tinker-agent 1.9.0 → 1.10.1

package/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable user-facing changes to Tinker are documented here. The project follo
 
 ## [Unreleased]
 
+## [1.10.1] - 2026-08-15
+
+### Added
+
+- Add an OpenAI Responses API adapter selectable per model profile, including
+  stateless request mapping, streaming, reasoning output, tool calls, image
+  input, token estimation, and compatible encrypted reasoning items.
+- Add per-profile reasoning effort configuration and a session-runtime
+  `/reasoning` control. The TUI displays the active effort, and `Ctrl+R` cycles
+  through supported efforts in profile order without changing configuration or
+  canonical history.
+- Add a model provider configuration guide with ready-to-adapt examples for
+  OpenAI, Kimi K3, and Zhipu GLM-5.2.
+
+### Changed
+
+- Split historical session retrieval into `RecallSearch` and `RecallGet`, so the
+  agent can locate relevant history before retrieving exact bounded content.
+- Track active-turn tool-output consumption when maintaining context, allowing
+  already-consumed observations to be compacted safely during long-running
+  turns.
+- Bound Bash and background-task output previews while preserving complete
+  output in log files for paginated inspection.
+
 ## [1.9.0] - 2026-08-04
 
 ### Added
@@ -175,7 +199,8 @@ All notable user-facing changes to Tinker are documented here. The project follo
 - First formal npm release under the `tinker-agent` package name with the `tinker`
   executable.
 
-[Unreleased]: https://github.com/ishowshao/tinker/compare/v1.9.0...HEAD
+[Unreleased]: https://github.com/ishowshao/tinker/compare/v1.10.1...HEAD
+[1.10.1]: https://github.com/ishowshao/tinker/releases/tag/v1.10.1
 [1.9.0]: https://github.com/ishowshao/tinker/releases/tag/v1.9.0
 [1.8.0]: https://github.com/ishowshao/tinker/releases/tag/v1.8.0
 [1.7.0]: https://github.com/ishowshao/tinker/releases/tag/v1.7.0

package/README.md

@@ -140,12 +140,13 @@ are required. Boolean environment values accept case-insensitive `true/false`,
 | --- | --- | --- | --- | --- | --- | --- | --- |
 | `TINKER_MODELS` | Model | All modes | No | Non-empty string | — | No | Optional model profiles JSON path. Relative paths resolve from the process cwd. |
 | `TINKER_MODEL` | Model | Env mode | Env mode | Non-empty string | — | No | Model name used when model profiles are not configured. |
-| `TINKER_BASE_URL` | Model | Env mode | Env mode | Non-empty string | — | No | OpenAI-compatible Chat Completions API base URL. |
+| `TINKER_API` | Model | Env mode | No | Non-empty string | `"chat-completions"` | No | Model API adapter: "chat-completions" or "responses". |
+| `TINKER_BASE_URL` | Model | Env mode | Env mode | Non-empty string | — | No | OpenAI-compatible API root URL; do not append /chat/completions or /responses. |
 | `TINKER_API_KEY` | Model | Env mode | Env mode | Non-empty string | — | Yes | API credential for the configured model endpoint. |
 | `TINKER_CONTEXT_WINDOW_TOKENS` | Model | Env mode | Env mode | Positive integer | — | No | Model context-window size in tokens. |
 | `TINKER_MAX_SUPPORTED_OUTPUT_TOKENS` | Model | Env mode | Env mode | Positive integer | — | No | Maximum output-token count supported by the model; must not exceed the context window. |
-| `TINKER_INCLUDE_REASONING_CONTENT` | Model | Env mode | No | Boolean | `false` | No | Include provider reasoning content in the model response mapping. |
-| `TINKER_STREAM` | Model | Env mode | No | Boolean | `true` | No | Use streaming Chat Completions transport. |
+| `TINKER_INCLUDE_REASONING_CONTENT` | Model | Env mode | No | Boolean | `false` | No | Replay provider reasoning_content in Chat Completions history; ignored by Responses. |
+| `TINKER_STREAM` | Model | Env mode | No | Boolean | `true` | No | Use streaming transport for the selected model API. |
 | `TINKER_WEBFETCH_REFINE_MODEL` | Model | Env mode | No | Non-empty string | — | No | Optional WebFetch refiner model; currently must match TINKER_MODEL. |
 | `TINKER_WORKSPACE` | Workspace | All modes | No | Non-empty string | Process cwd | No | Workspace path. Relative paths resolve from the process cwd. |
 | `TINKER_MAX_ITERATIONS` | Workspace | All modes | No | Positive integer | `512` | No | Maximum agent-loop iterations per turn. |
@@ -174,21 +175,36 @@ switch to another profile. If `TINKER_MODELS` is not set, Tinker falls back to
 the individual `TINKER_*` environment variables. A configured profiles file must
 exist and be valid; Tinker does not silently fall back when it cannot be loaded.
 
+For provider-specific examples and guidance on API adapters, model capabilities,
+reasoning efforts, and context limits, see the
+[`.tinker/models.json` provider configuration guide](docs/models-json-provider-guide.md).
+
 <!-- BEGIN GENERATED: MODEL PROFILE FIELDS -->
 Profile fields:
 
 | Field | Required | Type / constraint | Default | Secret | Description |
 | --- | --- | --- | --- | --- | --- |
 | `model` | Yes | Non-empty string | — | No | Provider model name. |
-| `apiBase` | Yes | Non-empty string | — | No | OpenAI-compatible API base URL. |
+| `api` | No | Non-empty string | `"chat-completions"` | No | Model API adapter: "chat-completions" or "responses". |
+| `apiBase` | Yes | Non-empty string | — | No | OpenAI-compatible API root URL; do not append /chat/completions or /responses. |
 | `apiKey` | Yes | Non-empty string | — | Yes | API credential for this profile. |
 | `contextWindowTokens` | Yes | Positive integer | — | No | Model context-window size in tokens. |
 | `maxSupportedOutputTokens` | Yes | Positive integer | — | No | Maximum output-token count supported by the model; must not exceed contextWindowTokens. |
-| `includeReasoningContent` | No | JSON boolean | `false` | No | Include provider reasoning content in response mapping. |
-| `stream` | No | JSON boolean | `true` | No | Use streaming Chat Completions transport. |
+| `reasoning` | No | Object | — | No | Provider-specific reasoning efforts and the default for each new session runtime. |
+| `includeReasoningContent` | No | JSON boolean | `false` | No | Replay provider reasoning_content in Chat Completions history; ignored by Responses. |
+| `stream` | No | JSON boolean | `true` | No | Use streaming transport for the selected model API. |
 | `inputModalities` | No | Normalized modality array | `["text"]` | No | Accepted model input modalities; normalizes to ["text"] or ["text", "image"]. |
 | `tokenEstimator` | With image | Object | — | Yes | Independent token estimator required for image profiles. |
 
+`reasoning` fields:
+
+| Field | Type / constraint | Description |
+| --- | --- | --- |
+| `supportedEfforts` | Non-empty unique string array | Provider-supported effort values exposed by the /reasoning command. |
+| `defaultEffort` | Non-empty string listed above | Effort used whenever a session runtime is created or reopened. |
+
+The optional `reasoning` object declares provider-specific effort values. Efforts must be unique non-whitespace strings, `reset` is reserved by the TUI command, and `defaultEffort` must appear in `supportedEfforts`. Omitting `reasoning` sends no effort parameter and disables `/reasoning` for that profile.
+
 `tokenEstimator` fields:
 
 | Field | Type / constraint | Secret | Description |
@@ -212,6 +228,14 @@ Text-only profile example:
       "apiKey": "your-model-api-key",
       "contextWindowTokens": 128000,
       "maxSupportedOutputTokens": 8192,
+      "reasoning": {
+        "supportedEfforts": [
+          "low",
+          "medium",
+          "high"
+        ],
+        "defaultEffort": "medium"
+      },
       "includeReasoningContent": false,
       "stream": true,
       "inputModalities": [
@@ -234,6 +258,14 @@ Image-capable profile example:
       "apiKey": "your-model-api-key",
       "contextWindowTokens": 128000,
       "maxSupportedOutputTokens": 8192,
+      "reasoning": {
+        "supportedEfforts": [
+          "low",
+          "medium",
+          "high"
+        ],
+        "defaultEffort": "medium"
+      },
       "includeReasoningContent": false,
       "stream": true,
       "inputModalities": [
@@ -285,6 +317,14 @@ Atomic-memory profile example:
       "apiKey": "your-model-api-key",
       "contextWindowTokens": 128000,
       "maxSupportedOutputTokens": 8192,
+      "reasoning": {
+        "supportedEfforts": [
+          "low",
+          "medium",
+          "high"
+        ],
+        "defaultEffort": "medium"
+      },
       "includeReasoningContent": false,
       "stream": true,
       "inputModalities": [
@@ -307,6 +347,12 @@ Atomic-memory profile example:
 ```
 <!-- END GENERATED: MODEL PROFILE FIELDS -->
 
+Set `api` to `"responses"` to use the standard Responses API. Keep `apiBase`
+at the API root—such as `https://api.openai.com/v1`—because Tinker appends the
+`/responses` route. Responses requests use the stateless common subset
+(`store: false` with complete input history), so the same adapter works with
+OpenAI and compatible providers that do not implement stored response chaining.
+
 You can also select profiles explicitly for the TUI or one-shot command:
 
 ```bash
@@ -353,6 +399,7 @@ complete fixed policy and persistence contract.
 | `/view <path>` | View a local UTF-8 text file |
 | `/copy` | Copy the last response as Markdown |
 | `/model [profile-name]` | Switch model profile (new session) |
+| `/reasoning [effort\|reset]` | Show or change reasoning effort for this session runtime |
 | `/resume [session-id]` | Choose or resume a session |
 | `/session delete <session-id> --confirm` | Manage stored sessions |
 | `/quit` | Exit the TUI |
@@ -364,6 +411,17 @@ swaps eligible historical tool output, while `/compact retire` retires a complet
 cold prefix whose original history remains available through `Recall`. `/copy`
 copies the last completed assistant response as raw Markdown.
 
+Profiles that declare `reasoning` expose `/reasoning` as a session-runtime
+control. `/reasoning <effort>` temporarily selects one of the profile's
+`supportedEfforts`, and `/reasoning reset` restores `defaultEffort`. The
+selection is not written to configuration or canonical history: `/clear`,
+`/fork`, `/model`, `/resume`, and a TUI restart create a new runtime from the
+profile default. Responses requests send `reasoning.effort`; Chat Completions
+requests send `reasoning_effort`. Press `Ctrl+R` while the prompt is idle to cycle
+through `supportedEfforts` in profile order, wrapping from the last effort to the
+first. When configured, the TUI information line shows the live effort immediately
+after the model name, for example `gpt-5.6-sol max`.
+
 ### Project Custom Slash Commands
 
 The TUI loads optional project-scoped prompt aliases from `.tinker.json` in the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tinker-agent",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "A personal coding agent with an interactive TUI and one-shot CLI.",
   "license": "Apache-2.0",
   "type": "module",

package/src/agent/loop.ts

@@ -93,6 +93,7 @@ const MODEL_REQUEST_MAX_ATTEMPTS =
 
 export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
   let lastIteration: IterationIdentity | undefined;
+  let consumedThroughOrdinal = 1;
   const committedPrefixAuditor =
     input.committedPrefixAuditor ?? new CommittedPrefixAuditor();
 
@@ -154,6 +155,7 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       built,
       prepared,
       preflight,
+      consumedThroughOrdinal,
     });
     try {
       input.contextMeter.assertWithinBudget(preflight);
@@ -365,6 +367,7 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       },
     });
     const measured = input.contextMeter.recordProviderUsage(request, modelOutput);
+    consumedThroughOrdinal = built.canonical.messages.length;
     await input.runtimeSession.append({
       type: "context.usage.updated",
       ...iteration,
@@ -501,6 +504,11 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       data: { outcome: "continue", toolCallCount: toolCalls.length },
     });
     input.runtimeSession.finishIterationForContinuation(iteration);
+    await input.runtimeSession.maintainContextAfterIteration?.({
+      turn: input.turn,
+      consumedThroughOrdinal,
+      ledger: input.ledger,
+    });
   }
 
   if (lastIteration === undefined) {
@@ -520,6 +528,7 @@ async function runShadowPlanning(input: {
   built: BuiltContextRequest;
   prepared: PreparedModelRequest;
   preflight: ReturnType<ContextMeter["measure"]>;
+  consumedThroughOrdinal: number;
 }): Promise<void> {
   const shadowPlanning = input.input.shadowPlanning;
   if (shadowPlanning === undefined) {
@@ -547,6 +556,10 @@ async function runShadowPlanning(input: {
       tools: input.input.tools.definitions(),
       policy: swapOnlyPolicyV1,
       trigger: decision.trigger,
+      activeTurn: {
+        turnId: input.input.turn.turnId,
+        consumedThroughOrdinal: input.consumedThroughOrdinal,
+      },
       ...(decision.forcedTargetTokens === undefined
         ? {}
         : { forcedTargetTokens: decision.forcedTargetTokens }),

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,
@@ -151,6 +153,9 @@ export type RuntimeSession = {
   skills(): RuntimeSkillsSnapshot;
   mcp(): McpInventorySnapshot;
   supportsImageInput(): boolean;
+  reasoningEffort(): ReasoningEffortSnapshot | undefined;
+  setReasoningEffort(effort: string): ReasoningEffortSnapshot;
+  resetReasoningEffort(): ReasoningEffortSnapshot;
   importImage(
     sourcePath: string,
     signal: AbortSignal,
@@ -217,6 +222,11 @@ export type RuntimeSessionContext = {
     iteration: IterationIdentity;
     built: BuiltContextRequest;
   }): void;
+  maintainContextAfterIteration?(input: {
+    turn: TurnIdentity;
+    consumedThroughOrdinal: number;
+    ledger: AgentTurnLedger;
+  }): Promise<void>;
 };
 
 export type ContextSurfaceRefreshSummary = {
@@ -482,6 +492,8 @@ class DefaultRuntimeSession implements RuntimeSession {
       onToolCompletionsCommitted: (completion) =>
         this.onToolCompletionsCommitted(completion),
       prepareModelDispatch: (dispatch) => this.prepareModelDispatch(dispatch),
+      maintainContextAfterIteration: (maintenance) =>
+        this.performActiveTurnContextMaintenance(maintenance),
     };
   }
 
@@ -965,6 +977,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;
   }
@@ -2016,6 +2058,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) {

package/src/agent/session-ledger.ts

@@ -111,6 +111,7 @@ export type AgentTurnLedger = {
     completions: readonly ToolCompletionInput[],
   ): readonly CommittedToolCompletion[];
   buildModelRequest(tools: readonly ToolDefinition[]): BuiltContextRequest;
+  activateContextSnapshot(snapshot: StoredContextSnapshotV8): void;
 };
 
 export type CommittedToolCompletion = {
@@ -188,9 +189,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 +355,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;
@@ -766,6 +781,8 @@ class InMemoryPendingLedgerTurn implements PendingLedgerTurn {
       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),

package/src/cli/model-profiles.ts

@@ -3,24 +3,29 @@ import {
   createModelContextProfile,
   type ModelContextProfile,
 } from "../model/model-context-profile";
+import { parseModelApi, type ModelApi } from "../model/model-api";
 import {
   MEMORY_CONFIG_FIELDS,
   MEMORY_EMBEDDING_FIELDS,
   MODEL_PROFILE_FIELDS,
   MODEL_PROFILES_DOCUMENT_FIELDS,
+  MODEL_REASONING_FIELDS,
   MODEL_TOKEN_ESTIMATOR_FIELDS,
   type ModelTokenEstimatorKind,
   type ModelTokenEstimatorMaxRetries,
 } from "./public-config-contract";
 import type { MemoryEmbeddingConfig } from "../memory/contracts";
+import type { ReasoningEffortConfig } from "../model/reasoning-effort";
 
 export type ModelProfile = {
   readonly name: string;
   readonly model: string;
+  readonly api: ModelApi;
   readonly apiBase: string;
   readonly apiKey: string;
   readonly contextWindowTokens: number;
   readonly maxSupportedOutputTokens: number;
+  readonly reasoning?: ReasoningEffortConfig;
   readonly includeReasoningContent: boolean;
   readonly stream: boolean;
   readonly inputModalities: readonly ModelInputModality[];
@@ -249,6 +254,7 @@ function parseProfile(
   );
 
   const model = parseProfileString(value, "model", where);
+  const api = parseProfileApi(value, where);
   const apiBase = parseProfileString(value, "apiBase", where);
   const apiKey = parseProfileString(value, "apiKey", where);
 
@@ -263,6 +269,11 @@ function parseProfile(
     where,
   );
 
+  const reasoning =
+    value.reasoning === undefined
+      ? undefined
+      : parseReasoning(value.reasoning, `${where}: "reasoning"`);
+
   const includeReasoningContent = parseProfileBoolean(
     value,
     "includeReasoningContent",
@@ -292,10 +303,12 @@ function parseProfile(
   return Object.freeze({
     name: profileName,
     model,
+    api,
     apiBase,
     apiKey,
     contextWindowTokens,
     maxSupportedOutputTokens,
+    ...(reasoning === undefined ? {} : { reasoning }),
     includeReasoningContent,
     stream,
     inputModalities,
@@ -303,6 +316,45 @@ function parseProfile(
   });
 }
 
+function parseReasoning(value: unknown, where: string): ReasoningEffortConfig {
+  if (!isRecord(value)) {
+    throw new Error(`${where} must be an object.`);
+  }
+  assertKnownKeys(
+    value,
+    MODEL_REASONING_FIELDS.map((field) => field.name),
+    where,
+  );
+  if (!Array.isArray(value.supportedEfforts) || value.supportedEfforts.length === 0) {
+    throw new Error(`${where}.supportedEfforts must be a non-empty array.`);
+  }
+  const supportedEfforts = value.supportedEfforts.map((entry, index) => {
+    const effort = requireString(entry, `${where}.supportedEfforts[${index}]`);
+    if (effort !== effort.trim() || /\s/u.test(effort)) {
+      throw new Error(
+        `${where}.supportedEfforts[${index}] must not contain whitespace.`,
+      );
+    }
+    if (effort === "reset") {
+      throw new Error(
+        `${where}.supportedEfforts[${index}] must not use the reserved value "reset".`,
+      );
+    }
+    return effort;
+  });
+  if (new Set(supportedEfforts).size !== supportedEfforts.length) {
+    throw new Error(`${where}.supportedEfforts must not contain duplicates.`);
+  }
+  const defaultEffort = requireString(value.defaultEffort, `${where}.defaultEffort`);
+  if (!supportedEfforts.includes(defaultEffort)) {
+    throw new Error(`${where}.defaultEffort must be listed in supportedEfforts.`);
+  }
+  return Object.freeze({
+    supportedEfforts: Object.freeze(supportedEfforts),
+    defaultEffort,
+  });
+}
+
 function parseMemoryConfig(
   value: unknown,
   profiles: ReadonlyMap<string, ModelProfile>,
@@ -471,6 +523,12 @@ function parseProfileString(
   return requireString(value[name], `${where}: ${JSON.stringify(name)}`);
 }
 
+function parseProfileApi(value: Record<string, unknown>, where: string): ModelApi {
+  const field = modelProfileField("api");
+  const configured = value.api ?? field.defaultValue;
+  return parseModelApi(configured, `${where}: "api"`);
+}
+
 function parseProfilePositiveInteger(
   value: Record<string, unknown>,
   name: "contextWindowTokens" | "maxSupportedOutputTokens",