Method startTurn

packages/runtime/src/runtime-kernel.ts:648–722

(
    sessionId: string,
    input: UserMessageInput,
    options: TurnStartOptions = {},
  )

  }

  async *startTurn(
    sessionId: string,
    input: UserMessageInput,
    options: TurnStartOptions = {},
  ): AsyncIterable<SessionEvent> {
    if (this.pendingContinuationSessions.has(sessionId)) {
      throw new Error('Cannot start a turn while a runtime continuation is being claimed');
    }
    const execution = this.takeExecutionClaim(sessionId, options.execution);
    try {
      await this.enterExecutionClaim(execution);
      const header = await this.deps.store.readHeader(sessionId);
      let workspaceIdentity: string | undefined;
      if (this.deps.safeBoundaryResumeEnabled === true && this.deps.inspectContinuationSafety) {
        try {
          workspaceIdentity = (await this.deps.inspectContinuationSafety(sessionId))
            .workspaceIdentity;
        } catch {
          // A new turn remains usable without continuation metadata. Actual
          // continuation claims inspect the same facts strictly below.
        }
      }
      const run = new AgentRun({
        sessionId,
        header,
        userInput: input,
        runId: options.runId,
        userMessageId: options.userMessageId,
        durability: options.durability,
        store: this.deps.store,
        runStore: this.deps.runStore,
        runtimeEventStore: this.deps.runtimeEventStore,
        ...(runtimeToolBoundaryProtocol(this.deps, header)
          ? { toolBoundaryProtocol: runtimeToolBoundaryProtocol(this.deps, header) }
          : {}),
        repairRunRuntimeLedger: this.deps.repairRunRuntimeLedger,
        newId: this.deps.newId,
        now: this.deps.now,
        ...(workspaceIdentity ? { workspaceIdentity } : {}),
        hooks: {
          reserveRun: async (targetSessionId, nextHeader, activeRun) => {
            const active = await this.reserveParentRun(
              targetSessionId,
              nextHeader,
              activeRun,
              execution,
            );
            this.reserveExecutionClaim(execution, active, activeRun);
            return active;
          },
          unregisterRun: (active, activeRun) => this.unregisterParentRun(active, activeRun),
          updateHeader: (targetSessionId, patch) => this.updateHeader(targetSessionId, patch),
          updateStatus: (targetSessionId, status, blockedReason, ts) =>
            this.updateStatus(targetSessionId, status, blockedReason, ts),
          appendTurnState: (targetSessionId, turnId, status, lineage, options) =>
            this.appendTurnState(targetSessionId, turnId, status, lineage, options),
        },
      });