tinker-agent 1.9.0 → 1.11.0

package/src/agent/runtime-session.ts

@@ -93,6 +93,7 @@ import { FatalAgentTurnError, runAgent, type RunAgentInput } from "./loop";
 import {
   AdmissionStaleError,
   SessionLedgerWriteError,
+  type AgentTurnLedger,
   type AdmissionBaseToken,
   type SessionLedger,
 } from "./session-ledger";
@@ -114,6 +115,7 @@ import {
   type ContextAutomationDecision,
 } from "../context/context-automation-policy";
 import type { SkillCatalogSnapshot } from "../skills/skill-loader";
+import type { ReasoningEffortSnapshot } from "../model/reasoning-effort";
 import {
   activeSkillManifestEntry,
   createSkillCatalogSnapshot,
@@ -137,6 +139,18 @@ export type AcceptedTurn = {
   readonly completion: Promise<RunAgentResult>;
 };
 
+export type PromptSchedulerSnapshot = {
+  readonly state: "idle" | "running";
+  readonly activeTurnId?: TurnIdentity["turnId"];
+  readonly pendingCount: number;
+};
+
+export type QueueFollowUpResult = {
+  readonly kind: "queued";
+  readonly pendingCount: number;
+  readonly activeTurnId?: TurnIdentity["turnId"];
+};
+
 export type SessionDisposeReason =
   | { type: "oneshot_complete" }
   | { type: "tui_exit" }
@@ -151,6 +165,9 @@ export type RuntimeSession = {
   skills(): RuntimeSkillsSnapshot;
   mcp(): McpInventorySnapshot;
   supportsImageInput(): boolean;
+  reasoningEffort(): ReasoningEffortSnapshot | undefined;
+  setReasoningEffort(effort: string): ReasoningEffortSnapshot;
+  resetReasoningEffort(): ReasoningEffortSnapshot;
   importImage(
     sourcePath: string,
     signal: AbortSignal,
@@ -162,6 +179,9 @@ export type RuntimeSession = {
   ): Promise<void>;
   admitTurn(input: ExecuteTurnInput): Promise<AcceptedTurn>;
   executeTurn(input: ExecuteTurnInput): Promise<RunAgentResult>;
+  promptScheduler(): PromptSchedulerSnapshot;
+  subscribePromptScheduler(listener: () => void): () => void;
+  queueFollowUp(userMessage: UserMessage): QueueFollowUpResult;
   compactContext(): Promise<ContextCompactionResult>;
   retireContext(): Promise<ContextRetirementResult>;
   undoLatestFileMutationTurn(): Promise<TurnUndoResult>;
@@ -217,6 +237,15 @@ export type RuntimeSessionContext = {
     iteration: IterationIdentity;
     built: BuiltContextRequest;
   }): void;
+  maintainContextAfterIteration?(input: {
+    turn: TurnIdentity;
+    consumedThroughOrdinal: number;
+    ledger: AgentTurnLedger;
+  }): Promise<void>;
+  applyQueuedSteering?(input: {
+    turn: TurnIdentity;
+    ledger: AgentTurnLedger;
+  }): Promise<number>;
 };
 
 export type ContextSurfaceRefreshSummary = {
@@ -344,10 +373,18 @@ type RuntimeSessionState =
   | "disposed";
 
 type ActiveTurn = {
+  turn: TurnIdentity;
   controller: AbortController;
   completion: Promise<RunAgentResult>;
 };
 
+type QueuedPrompt = {
+  readonly userMessage: UserMessage;
+};
+
+const MAX_QUEUED_PROMPTS = 8;
+const MAX_QUEUED_PROMPT_TEXT_BYTES = 64 * 1024;
+
 type ActiveAdmission = {
   controller: AbortController;
   settled: Promise<void>;
@@ -405,6 +442,13 @@ class DefaultRuntimeSession implements RuntimeSession {
   private ledger?: SessionLedger;
   private activeAdmission?: ActiveAdmission;
   private activeTurn?: ActiveTurn;
+  private executionChainRunning = false;
+  private readonly queuedPrompts: QueuedPrompt[] = [];
+  private promptSchedulerSnapshot: PromptSchedulerSnapshot = Object.freeze({
+    state: "idle",
+    pendingCount: 0,
+  });
+  private readonly promptSchedulerListeners = new Set<() => void>();
   private activeContextRevision?: Promise<
     ContextCompactionResult | ContextRetirementResult
   >;
@@ -482,6 +526,9 @@ class DefaultRuntimeSession implements RuntimeSession {
       onToolCompletionsCommitted: (completion) =>
         this.onToolCompletionsCommitted(completion),
       prepareModelDispatch: (dispatch) => this.prepareModelDispatch(dispatch),
+      maintainContextAfterIteration: (maintenance) =>
+        this.performActiveTurnContextMaintenance(maintenance),
+      applyQueuedSteering: (steering) => this.applyQueuedSteering(steering),
     };
   }
 
@@ -965,6 +1012,36 @@ class DefaultRuntimeSession implements RuntimeSession {
     return this.input.modelClient.inputModalities?.includes("image") === true;
   }
 
+  reasoningEffort(): ReasoningEffortSnapshot | undefined {
+    return this.input.modelClient.reasoningEffort?.snapshot();
+  }
+
+  setReasoningEffort(effort: string): ReasoningEffortSnapshot {
+    if (this.state !== "ready" || this.activeTurn !== undefined) {
+      throw new Error(
+        `Cannot change reasoning effort while RuntimeSession is ${this.state}.`,
+      );
+    }
+    const reasoningEffort = this.input.modelClient.reasoningEffort;
+    if (reasoningEffort === undefined) {
+      throw new Error("Current model profile does not configure reasoning effort.");
+    }
+    return reasoningEffort.set(effort);
+  }
+
+  resetReasoningEffort(): ReasoningEffortSnapshot {
+    if (this.state !== "ready" || this.activeTurn !== undefined) {
+      throw new Error(
+        `Cannot change reasoning effort while RuntimeSession is ${this.state}.`,
+      );
+    }
+    const reasoningEffort = this.input.modelClient.reasoningEffort;
+    if (reasoningEffort === undefined) {
+      throw new Error("Current model profile does not configure reasoning effort.");
+    }
+    return reasoningEffort.reset();
+  }
+
   bashGuard(): BashGuardSnapshot {
     return this.bashGuardSnapshot;
   }
@@ -1467,11 +1544,71 @@ class DefaultRuntimeSession implements RuntimeSession {
     }
   }
 
+  promptScheduler(): PromptSchedulerSnapshot {
+    return this.promptSchedulerSnapshot;
+  }
+
+  subscribePromptScheduler(listener: () => void): () => void {
+    this.promptSchedulerListeners.add(listener);
+    return () => this.promptSchedulerListeners.delete(listener);
+  }
+
+  queueFollowUp(userMessage: UserMessage): QueueFollowUpResult {
+    if (!this.executionChainRunning) {
+      throw new Error("Cannot queue a follow-up while no execution chain is running.");
+    }
+    validateUserMessage(userMessage);
+    if (userMessage.attachments !== undefined) {
+      throw new Error("Active-turn follow-ups do not support image attachments.");
+    }
+    if (this.queuedPrompts.length >= MAX_QUEUED_PROMPTS) {
+      throw new Error(`At most ${MAX_QUEUED_PROMPTS} follow-ups may be queued.`);
+    }
+    const queuedBytes = this.queuedPrompts.reduce(
+      (total, entry) => total + Buffer.byteLength(entry.userMessage.content, "utf8"),
+      0,
+    );
+    const nextBytes = Buffer.byteLength(userMessage.content, "utf8");
+    if (queuedBytes + nextBytes > MAX_QUEUED_PROMPT_TEXT_BYTES) {
+      throw new Error("Queued follow-ups exceed the 64 KiB text limit.");
+    }
+    this.queuedPrompts.push({
+      userMessage: Object.freeze({ ...userMessage }),
+    });
+    this.notifyPromptScheduler();
+    return Object.freeze({
+      kind: "queued",
+      pendingCount: this.queuedPrompts.length,
+      ...(this.activeTurn === undefined
+        ? {}
+        : { activeTurnId: this.activeTurn.turn.turnId }),
+    });
+  }
+
   async executeTurn(input: ExecuteTurnInput): Promise<RunAgentResult> {
     return (await this.admitTurn(input)).completion;
   }
 
   async admitTurn(input: ExecuteTurnInput): Promise<AcceptedTurn> {
+    if (this.executionChainRunning) {
+      throw new Error(
+        `Cannot execute a turn while RuntimeSession is ${this.state}; a prompt chain is already executing.`,
+      );
+    }
+    this.executionChainRunning = true;
+    this.notifyPromptScheduler();
+    try {
+      const accepted = await this.admitSingleTurn(input);
+      const completion = this.continueExecutionChain(accepted.completion, input.signal);
+      return Object.freeze({ ...accepted, completion });
+    } catch (error) {
+      this.executionChainRunning = false;
+      this.notifyPromptScheduler();
+      throw error;
+    }
+  }
+
+  private async admitSingleTurn(input: ExecuteTurnInput): Promise<AcceptedTurn> {
     if (this.state !== "ready") {
       throw new Error(`Cannot execute a turn while RuntimeSession is ${this.state}.`);
     }
@@ -1544,7 +1681,8 @@ class DefaultRuntimeSession implements RuntimeSession {
           usage: admissionSnapshot,
         },
       });
-      this.activeTurn = { controller, completion };
+      this.activeTurn = { turn, controller, completion };
+      this.notifyPromptScheduler();
       return Object.freeze({
         turnId: turn.turnId,
         userMessage: input.userMessage,
@@ -1566,6 +1704,79 @@ class DefaultRuntimeSession implements RuntimeSession {
     }
   }
 
+  private async continueExecutionChain(
+    initialCompletion: Promise<RunAgentResult>,
+    signal: AbortSignal,
+  ): Promise<RunAgentResult> {
+    let completion = initialCompletion;
+    let finalResult: RunAgentResult;
+    try {
+      for (;;) {
+        finalResult = await completion;
+        if (finalResult.status !== "completed" || this.queuedPrompts.length === 0) {
+          return finalResult;
+        }
+        const next = this.queuedPrompts[0];
+        if (next === undefined) {
+          return finalResult;
+        }
+        const accepted = await this.admitSingleTurn({
+          userMessage: next.userMessage,
+          signal,
+        });
+        this.queuedPrompts.shift();
+        this.notifyPromptScheduler();
+        completion = accepted.completion;
+      }
+    } finally {
+      this.queuedPrompts.splice(0);
+      this.executionChainRunning = false;
+      this.notifyPromptScheduler();
+    }
+  }
+
+  private notifyPromptScheduler(): void {
+    this.promptSchedulerSnapshot = Object.freeze({
+      state: this.executionChainRunning ? "running" : "idle",
+      ...(this.activeTurn === undefined
+        ? {}
+        : { activeTurnId: this.activeTurn.turn.turnId }),
+      pendingCount: this.queuedPrompts.length,
+    });
+    for (const listener of this.promptSchedulerListeners) listener();
+  }
+
+  private async applyQueuedSteering(input: {
+    turn: TurnIdentity;
+    ledger: AgentTurnLedger;
+  }): Promise<number> {
+    if (this.activeTurn?.turn.turnId !== input.turn.turnId) {
+      throw new Error("Cannot apply steering outside the active turn.");
+    }
+    if (this.queuedPrompts.length === 0) return 0;
+    const drained = this.queuedPrompts.splice(0);
+    const records = input.ledger.appendSteeringUserMessages(
+      drained.map((entry) => entry.userMessage),
+    );
+    this.notifyPromptScheduler();
+    for (let index = 0; index < records.length; index += 1) {
+      const record = records[index];
+      const queued = drained[index];
+      if (record === undefined || queued === undefined) {
+        throw new Error("Steering ledger result did not match the drained queue.");
+      }
+      await this.append({
+        type: "turn.steering.applied",
+        ...input.turn,
+        data: {
+          userPrompt: projectUserMessage(queued.userMessage),
+          ordinal: record.ordinal,
+        },
+      });
+    }
+    return records.length;
+  }
+
   private settleAdmission(admission: ActiveAdmission): void {
     if (this.activeAdmission !== admission) {
       throw new Error("Runtime admission ownership was lost.");
@@ -1796,6 +2007,8 @@ class DefaultRuntimeSession implements RuntimeSession {
   canSwitchSession(): boolean {
     return (
       this.state === "ready" &&
+      !this.executionChainRunning &&
+      this.queuedPrompts.length === 0 &&
       this.activeTurn === undefined &&
       (this.tooling?.taskManager
         .listBackgroundTasks()
@@ -1983,6 +2196,7 @@ class DefaultRuntimeSession implements RuntimeSession {
     } finally {
       removeExternalAbortListener();
       this.activeTurn = undefined;
+      this.notifyPromptScheduler();
       this.pendingAutomaticContextMaintenance = false;
       if (this.state === "executing") {
         this.state = "ready";
@@ -2016,6 +2230,129 @@ class DefaultRuntimeSession implements RuntimeSession {
     }
   }
 
+  private async performActiveTurnContextMaintenance(input: {
+    turn: TurnIdentity;
+    consumedThroughOrdinal: number;
+    ledger: AgentTurnLedger;
+  }): Promise<void> {
+    const automation = this.requireContextAutomation();
+    if (!automation.automaticSwapOnly) return;
+    if (this.state !== "executing") {
+      throw new Error(
+        `Cannot maintain active-turn context while RuntimeSession is ${this.state}.`,
+      );
+    }
+    const manager = this.requireContextManager();
+    const usage = manager.measureCurrent(input.turn.turnId, input.ledger);
+    if (usage.pressure === "normal") return;
+
+    const qualificationId = requireAutomationQualificationId(automation);
+    const compactionTrigger = {
+      kind: "runtime_pressure",
+      activeTurn: {
+        turnId: input.turn.turnId,
+        consumedThroughOrdinal: input.consumedThroughOrdinal,
+      },
+    } as const;
+    this.pendingAutomaticContextMaintenance = false;
+    this.state = "maintaining_context";
+    try {
+      await this.append({
+        type: "context.revision.started",
+        sessionId: this.sessionId,
+        data: {
+          strategy: "swap",
+          reason: "runtime_pressure",
+          policyVersion: "swap-only-v1",
+          rendererFormat: "swap-observation-v1",
+          qualificationId,
+        },
+      });
+      let swap: ContextCompactionResult;
+      try {
+        swap = await manager.compact(compactionTrigger, input.ledger);
+        await this.append({
+          type: "context.revision.finished",
+          sessionId: this.sessionId,
+          data: contextRevisionFinishedData(swap, "runtime_pressure", qualificationId),
+        });
+      } catch (error) {
+        const failure = automaticContextFailure(error, "compaction");
+        await this.append({
+          type: "context.revision.failed",
+          sessionId: this.sessionId,
+          data: {
+            strategy: "swap",
+            reason: "runtime_pressure",
+            stage: failure.stage,
+            errorCode: boundedContextErrorCode(failure.code),
+            error: `Automatic context compaction failed at ${failure.stage}.`,
+            qualificationId,
+          },
+        }).catch(() => undefined);
+        if (failure.fatal) throw error;
+        return;
+      }
+
+      if (
+        !automation.automaticPrefixRetirement ||
+        !automaticSwapNeedsRetirement(swap)
+      ) {
+        return;
+      }
+
+      await this.append({
+        type: "context.revision.started",
+        sessionId: this.sessionId,
+        data: {
+          strategy: "retire_prefix",
+          reason: "runtime_pressure",
+          policyVersion: "recall-first-retirement-v1",
+          baseRevisionNumber: this.store.loadContextSnapshot().revision.revisionNumber,
+          qualificationId,
+        },
+      });
+      try {
+        const retirement = await manager.retirePrefix(
+          {
+            kind: "runtime_pressure",
+            activeTurnId: input.turn.turnId,
+          },
+          input.ledger,
+        );
+        await this.append({
+          type: "context.revision.finished",
+          sessionId: this.sessionId,
+          data: contextRetirementFinishedData(
+            retirement,
+            "runtime_pressure",
+            qualificationId,
+          ),
+        });
+      } catch (error) {
+        const failure = automaticContextFailure(error, "retirement");
+        await this.append({
+          type: "context.revision.failed",
+          sessionId: this.sessionId,
+          data: {
+            strategy: "retire_prefix",
+            reason: "runtime_pressure",
+            stage: failure.stage,
+            errorCode: boundedContextErrorCode(failure.code),
+            error: `Automatic context retirement failed at ${failure.stage}.`,
+            committed: failure.committed,
+            qualificationId,
+          },
+        }).catch(() => undefined);
+        if (failure.fatal) throw error;
+      }
+    } finally {
+      if (this.state === "maintaining_context") {
+        this.state = "executing";
+      }
+    }
+  }
+
   private notifyCompletedTurn(turn: TurnIdentity): void {
     const hook = this.input.completedTurnHook;
     if (hook === undefined) {
@@ -2233,6 +2570,9 @@ class DefaultRuntimeSession implements RuntimeSession {
     }
 
     this.state = "disposing";
+    this.queuedPrompts.splice(0);
+    this.executionChainRunning = false;
+    this.notifyPromptScheduler();
     const errors: unknown[] = this.faultCause === undefined ? [] : [this.faultCause];
     const activeAdmission = this.activeAdmission;
     if (activeAdmission !== undefined) {

package/src/agent/session-ledger.ts

@@ -100,6 +100,9 @@ export type PendingLedgerTurn = {
 };
 
 export type AgentTurnLedger = {
+  appendSteeringUserMessages(
+    messages: readonly UserMessage[],
+  ): readonly CanonicalMessageRecord[];
   appendAssistant(input: {
     iteration: IterationIdentity;
     message: AssistantMessage;
@@ -111,6 +114,7 @@ export type AgentTurnLedger = {
     completions: readonly ToolCompletionInput[],
   ): readonly CommittedToolCompletion[];
   buildModelRequest(tools: readonly ToolDefinition[]): BuiltContextRequest;
+  activateContextSnapshot(snapshot: StoredContextSnapshotV8): void;
 };
 
 export type CommittedToolCompletion = {
@@ -128,6 +132,13 @@ export type LedgerMutation =
       admissionBase?: AdmissionBaseToken;
       next: ProtocolContextView;
     }
+  | {
+      kind: "append_steering_users";
+      turn: TurnIdentity;
+      frames: readonly ProtocolFrame[];
+      messages: readonly CanonicalMessageRecord[];
+      next: ProtocolContextView;
+    }
   | {
       kind: "append_assistant";
       iteration: IterationIdentity;
@@ -188,9 +199,9 @@ export class InMemorySessionLedger implements SessionLedger {
   private readonly validator = new ContextProtocolValidator();
   private readonly contextBuilder: ContextBuilder;
   private readonly revisionCompiler: ContextRevisionCompiler;
-  private readonly revision: StoredContextRevisionV8;
-  private readonly surface: StoredContextSurfaceV8;
-  private readonly activeOverrides: readonly StoredContextOverrideV8[];
+  private revision: StoredContextRevisionV8;
+  private surface: StoredContextSurfaceV8;
+  private activeOverrides: readonly StoredContextOverrideV8[];
   private readonly clock: () => string;
 
   constructor(private readonly input: CreateInMemorySessionLedgerInput) {
@@ -354,6 +365,20 @@ export class InMemorySessionLedger implements SessionLedger {
     return this.view.messages.length;
   }
 
+  activateContextSnapshot(snapshot: StoredContextSnapshotV8): void {
+    this.requireHealthy("activate a context snapshot");
+    if (
+      snapshot.meta.sessionId !== this.input.sessionId ||
+      stableJsonStringify(snapshot.canonical) !== stableJsonStringify(this.view)
+    ) {
+      throw new Error("Activated context snapshot does not match canonical history.");
+    }
+    this.revisionCompiler.compileActive(snapshot);
+    this.revision = snapshot.revision;
+    this.surface = snapshot.surface;
+    this.activeOverrides = snapshot.activeOverrides;
+  }
+
   snapshot(
     options: {
       fullIntegrity?: boolean;
@@ -381,6 +406,74 @@ export class InMemorySessionLedger implements SessionLedger {
     this.pending = undefined;
   }
 
+  appendSteeringUserMessages(
+    pending: InMemoryPendingLedgerTurn,
+    userMessages: readonly UserMessage[],
+  ): readonly CanonicalMessageRecord[] {
+    this.requirePending(pending, "append steering user messages");
+    this.assertNoOpenFrame();
+    if (userMessages.length === 0) {
+      return Object.freeze([]);
+    }
+    for (const userMessage of userMessages) {
+      validateUserMessage(userMessage);
+    }
+
+    const frames: ProtocolFrame[] = [];
+    const messages: CanonicalMessageRecord[] = [];
+    for (const userMessage of userMessages) {
+      const createdAt = this.clock();
+      const ordinal = this.view.messages.length + messages.length + 1;
+      const frameId = this.input.idFactory.createProtocolFrameId();
+      messages.push(
+        immutableRecord<CanonicalMessageRecord>({
+          messageId: this.input.idFactory.createMessageId(),
+          sessionId: this.input.sessionId,
+          frameId,
+          ordinal,
+          contentSha256: userMessageHash(userMessage),
+          createdAt,
+          role: "user",
+          turnId: pending.turn.turnId,
+          content: userMessage.content,
+          ...(userMessage.attachments === undefined
+            ? {}
+            : {
+                attachments: Object.freeze(
+                  immutableCanonicalClone(userMessage.attachments),
+                ),
+              }),
+          origin: "user",
+        }),
+      );
+      frames.push(
+        immutableRecord<ProtocolFrame>({
+          frameId,
+          sessionId: this.input.sessionId,
+          turnId: pending.turn.turnId,
+          kind: "user",
+          state: "closed",
+          firstOrdinal: ordinal,
+          lastOrdinal: ordinal,
+          createdAt,
+          closedAt: createdAt,
+        }),
+      );
+    }
+    const immutableFrames = Object.freeze(frames);
+    const immutableMessages = Object.freeze(messages);
+    const next = appendView(this.view, immutableFrames, immutableMessages, []);
+    this.validator.validate(next, { fullIntegrity: true });
+    this.commit({
+      kind: "append_steering_users",
+      turn: pending.turn,
+      frames: immutableFrames,
+      messages: immutableMessages,
+      next,
+    });
+    return immutableMessages;
+  }
+
   appendAssistant(
     pending: InMemoryPendingLedgerTurn,
     input: {
@@ -761,11 +854,15 @@ class InMemoryPendingLedgerTurn implements PendingLedgerTurn {
     readonly turn: TurnIdentity,
   ) {
     this.agent = {
+      appendSteeringUserMessages: (messages) =>
+        this.ledger.appendSteeringUserMessages(this, messages),
       appendAssistant: (input) => this.ledger.appendAssistant(this, input),
       assertCanExecuteTool: (call) => this.ledger.assertCanExecuteTool(this, call),
       commitToolCompletions: (completions) =>
         this.ledger.commitToolCompletions(this, completions),
       buildModelRequest: (tools) => this.ledger.buildTurnModelRequest(this, tools),
+      activateContextSnapshot: (snapshot) =>
+        this.ledger.activateContextSnapshot(snapshot),
     };
   }
 

package/src/cli/config.ts

@@ -6,6 +6,7 @@ import {
   type ModelContextBudget,
   type ModelContextProfile,
 } from "../model/model-context-profile";
+import type { ModelApi } from "../model/model-api";
 import {
   loadModelProfiles,
   persistDefaultProfile,
@@ -17,6 +18,7 @@ import {
   unknownProfileError,
 } from "./model-profiles";
 import type { MemoryEmbeddingConfig } from "../memory/contracts";
+import type { ReasoningEffortConfig } from "../model/reasoning-effort";
 import {
   parsePublicEnvironment,
   type ParsedPublicEnvironment,
@@ -27,9 +29,11 @@ export type RunnerConfig = {
   readonly sessionId: SessionId;
   readonly workspaceRoot: string;
   readonly modelName: string;
+  readonly api: ModelApi;
   readonly apiKey: string;
   readonly apiBase: string;
   readonly maxIterations: number;
+  readonly reasoning?: ReasoningEffortConfig;
   readonly includeReasoningContent: boolean;
   readonly stream: boolean;
   readonly contextProfile: ModelContextProfile;
@@ -166,10 +170,13 @@ function runnerConfigTemplateFromProfile(
   return Object.freeze({
     workspaceRoot: environment.workspaceRoot,
     modelName: profile.model,
+    api: profile.api,
     apiKey: profile.apiKey,
     apiBase: profile.apiBase,
     maxIterations: environment.maxIterations,
-    includeReasoningContent: profile.includeReasoningContent,
+    ...(profile.reasoning === undefined ? {} : { reasoning: profile.reasoning }),
+    includeReasoningContent:
+      profile.api === "chat-completions" && profile.includeReasoningContent,
     stream: profile.stream,
     contextProfile,
     contextBudget: deriveModelContextBudget(contextProfile),
@@ -193,10 +200,12 @@ function runnerConfigTemplateFromEnvironment(
   return Object.freeze({
     workspaceRoot: environment.workspaceRoot,
     modelName: environment.modelName,
+    api: environment.api,
     apiKey: environment.apiKey,
     apiBase: environment.apiBase,
     maxIterations: environment.maxIterations,
-    includeReasoningContent: environment.includeReasoningContent,
+    includeReasoningContent:
+      environment.api === "chat-completions" && environment.includeReasoningContent,
     stream: environment.stream,
     contextProfile,
     contextBudget: deriveModelContextBudget(contextProfile),