Method launch

packages/agent-core/src/agent/turn/index.ts:155–198

(input: readonly ContentPart[], origin: PromptOrigin)

  }

  private launch(input: readonly ContentPart[], origin: PromptOrigin): number | null {
    if (this.activeTurn) {
      this.agent.emitEvent({
        type: 'error',
        ...makeErrorPayload(
          'turn.agent_busy',
          `Cannot launch a new turn while another turn (ID ${this.turnId}) is active`,
          { details: { turnId: this.turnId } },
        ),
      });
      return null;
    }

    // While a manual/SDK compaction holds the context, defer the launch instead
    // of rejecting it: buffer the input and replay it from `onCompactionFinished`
    // once compaction's full lifecycle (summary + reinjection) completes. The
    // deferred turn's eventual `turn.started` lets PromptService associate the
    // pending prompt, so a prompt submitted mid-compaction completes normally
    // rather than getting stuck "running". (Auto compaction runs inside an active
    // turn, so the `activeTurn` check above already covers it.)
    if (this.agent.fullCompaction.isCompacting) {
      this.steerBuffer.push({ input, origin });
      return null;
    }

    // Per-turn setup (telemetry, usage window, `turn.started`, appending the
    // prompt) now lives in `runOneTurn`, so a goal-driven run emits a clean
    // start/end pair per continuation turn rather than one mega-turn.
    const turnId = this.allocateTurnId();
    const controller = new AbortController();
    const promise = this.turnWorker(turnId, input, origin, controller.signal);
    const firstRequest = createControlledPromise<void>();
    this.activeTurn = {
      turnId,
      controller,
      promise,
      firstRequest,
    };

    void firstRequest.catch(() => undefined);
    void promise.then(firstRequest.reject, firstRequest.reject);

    return turnId;
  }

  /** Allocates the next monotonic turn id. */
  private allocateTurnId(): number {