tinker-agent 1.9.0 → 1.11.0

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",

package/src/cli/public-config-contract.ts

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { rgPath } from "@vscode/ripgrep";
+import { parseModelApi, type ModelApi } from "../model/model-api";
 
 export type PublicConfigValueKind = "non-empty-string" | "positive-integer" | "boolean";
 
@@ -39,6 +40,16 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     section: "model",
     description: "Model name used when model profiles are not configured.",
   }),
+  publicField({
+    name: "TINKER_API",
+    valueKind: "non-empty-string",
+    requiredIn: "never",
+    appliesIn: "env-mode",
+    defaultValue: "chat-completions",
+    secret: false,
+    section: "model",
+    description: 'Model API adapter: "chat-completions" or "responses".',
+  }),
   publicField({
     name: "TINKER_BASE_URL",
     valueKind: "non-empty-string",
@@ -46,7 +57,8 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     appliesIn: "env-mode",
     secret: false,
     section: "model",
-    description: "OpenAI-compatible Chat Completions API base URL.",
+    description:
+      "OpenAI-compatible API root URL; do not append /chat/completions or /responses.",
   }),
   publicField({
     name: "TINKER_API_KEY",
@@ -84,7 +96,8 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     defaultValue: false,
     secret: false,
     section: "model",
-    description: "Include provider reasoning content in the model response mapping.",
+    description:
+      "Replay provider reasoning_content in Chat Completions history; ignored by Responses.",
   }),
   publicField({
     name: "TINKER_STREAM",
@@ -94,7 +107,7 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     defaultValue: true,
     secret: false,
     section: "model",
-    description: "Use streaming Chat Completions transport.",
+    description: "Use streaming transport for the selected model API.",
   }),
   publicField({
     name: "TINKER_WEBFETCH_REFINE_MODEL",
@@ -229,7 +242,11 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
 
 export type ModelProfileField = {
   readonly name: string;
-  readonly valueKind: PublicConfigValueKind | "input-modalities" | "token-estimator";
+  readonly valueKind:
+    | PublicConfigValueKind
+    | "input-modalities"
+    | "reasoning"
+    | "token-estimator";
   readonly required: boolean;
   readonly defaultValue?: string | number | boolean | readonly string[];
   readonly secret: boolean;
@@ -248,12 +265,21 @@ export const MODEL_PROFILE_FIELDS = Object.freeze([
     secret: false,
     description: "Provider model name.",
   }),
+  profileField({
+    name: "api",
+    valueKind: "non-empty-string",
+    required: false,
+    defaultValue: "chat-completions",
+    secret: false,
+    description: 'Model API adapter: "chat-completions" or "responses".',
+  }),
   profileField({
     name: "apiBase",
     valueKind: "non-empty-string",
     required: true,
     secret: false,
-    description: "OpenAI-compatible API base URL.",
+    description:
+      "OpenAI-compatible API root URL; do not append /chat/completions or /responses.",
   }),
   profileField({
     name: "apiKey",
@@ -277,13 +303,22 @@ export const MODEL_PROFILE_FIELDS = Object.freeze([
     description:
       "Maximum output-token count supported by the model; must not exceed contextWindowTokens.",
   }),
+  profileField({
+    name: "reasoning",
+    valueKind: "reasoning",
+    required: false,
+    secret: false,
+    description:
+      "Provider-specific reasoning efforts and the default for each new session runtime.",
+  }),
   profileField({
     name: "includeReasoningContent",
     valueKind: "boolean",
     required: false,
     defaultValue: false,
     secret: false,
-    description: "Include provider reasoning content in response mapping.",
+    description:
+      "Replay provider reasoning_content in Chat Completions history; ignored by Responses.",
   }),
   profileField({
     name: "stream",
@@ -291,7 +326,7 @@ export const MODEL_PROFILE_FIELDS = Object.freeze([
     required: false,
     defaultValue: true,
     secret: false,
-    description: "Use streaming Chat Completions transport.",
+    description: "Use streaming transport for the selected model API.",
   }),
   profileField({
     name: "inputModalities",
@@ -311,6 +346,35 @@ export const MODEL_PROFILE_FIELDS = Object.freeze([
   }),
 ]);
 
+export type ModelReasoningField = {
+  readonly name: string;
+  readonly valueKind: "non-empty-string" | "non-empty-string-array";
+  readonly required: true;
+  readonly secret: false;
+  readonly description: string;
+};
+
+function reasoningField<const T extends ModelReasoningField>(field: T): Readonly<T> {
+  return Object.freeze(field);
+}
+
+export const MODEL_REASONING_FIELDS = Object.freeze([
+  reasoningField({
+    name: "supportedEfforts",
+    valueKind: "non-empty-string-array",
+    required: true,
+    secret: false,
+    description: "Provider-supported effort values exposed by the /reasoning command.",
+  }),
+  reasoningField({
+    name: "defaultEffort",
+    valueKind: "non-empty-string",
+    required: true,
+    secret: false,
+    description: "Effort used whenever a session runtime is created or reopened.",
+  }),
+]);
+
 export type ModelTokenEstimatorField = {
   readonly name: string;
   readonly valueKind: PublicConfigValueKind | "literal-string" | "literal-number";
@@ -502,6 +566,7 @@ export type ParsedPublicEnvironment =
   | (ParsedCommonEnvironment & {
       readonly mode: "env";
       readonly modelName: string;
+      readonly api: ModelApi;
       readonly apiBase: string;
       readonly apiKey: string;
       readonly contextWindowTokens: number;
@@ -615,6 +680,7 @@ export function parsePublicEnvironment(
     ...common,
     mode,
     modelName,
+    api: parseModelApi(requiredStringValue(values, "TINKER_API"), "TINKER_API"),
     apiBase: requiredStringValue(values, "TINKER_BASE_URL"),
     apiKey: requiredStringValue(values, "TINKER_API_KEY"),
     contextWindowTokens: requiredNumberValue(values, "TINKER_CONTEXT_WINDOW_TOKENS"),

package/src/cli/run-runner.ts

@@ -16,6 +16,7 @@ import {
   createWebFetchRefiner,
   RUNTIME_INSTRUCTIONS,
 } from "./runner-dependencies";
+import { createReasoningEffortController } from "../model/reasoning-effort";
 import type { PublicToolingConfig } from "./public-config-contract";
 import { realpath } from "node:fs/promises";
 import { loadSkillCatalog } from "../skills/skill-loader";
@@ -51,10 +52,12 @@ export async function runOneShot(
       runtimeInstructions: RUNTIME_INSTRUCTIONS(workspaceRoot),
       projectInstructions,
     });
+    const reasoningEffort = createReasoningEffortController(config.reasoning);
     const modelClient = createRunnerModelClient(
       config,
       options.modelClient,
       options.env,
+      reasoningEffort,
     );
     session = await createRuntimeSession({
       selection: { mode: "new", sessionId: config.sessionId },
@@ -72,7 +75,7 @@ export async function runOneShot(
       presentationSinks: [new StdoutEventPrinter(stdout, stderr)],
       persistence:
         options.eventLogPath === false ? false : { eventLogPath: options.eventLogPath },
-      webFetchRefiner: createWebFetchRefiner(config, options.env),
+      webFetchRefiner: createWebFetchRefiner(config, options.env, reasoningEffort),
       toolingConfig: options.tooling,
       bashGuard: {
         mode: config.bashGuardMode,

package/src/cli/runner-dependencies.ts

@@ -2,6 +2,11 @@ import { renderRecallRetirementContract } from "../context/recall-retirement-con
 import { FakeModelClient } from "../model/fake-model-client";
 import type { ModelClient } from "../model/model-client";
 import { OpenAIChatModelClient } from "../model/openai-chat-model-client";
+import { OpenAIResponsesModelClient } from "../model/openai-responses-model-client";
+import {
+  createReasoningEffortController,
+  type ReasoningEffortController,
+} from "../model/reasoning-effort";
 import { createModelRefiner, type Refiner } from "../tools/web-fetch/refiner";
 import type { RunnerConfig } from "./config";
 
@@ -53,6 +58,8 @@ export function createModelClient(
   config: Pick<
     RunnerConfig,
     | "modelName"
+    | "api"
+    | "reasoning"
     | "includeReasoningContent"
     | "stream"
     | "contextBudget"
@@ -62,13 +69,19 @@ export function createModelClient(
     | "tokenEstimator"
   >,
   env: NodeJS.ProcessEnv = process.env,
+  reasoningEffort?: ReasoningEffortController,
 ): ModelClient {
+  const activeReasoningEffort =
+    reasoningEffort ?? createReasoningEffortController(config.reasoning);
   const fakeMode = env.TINKER_TEST_FAKE_MODEL;
   if (fakeMode !== undefined && fakeMode !== "") {
     return new FakeModelClient(fakeMode, {
       model: config.modelName,
       contextBudget: config.contextBudget,
       inputModalities: config.inputModalities,
+      ...(activeReasoningEffort === undefined
+        ? {}
+        : { reasoningEffort: activeReasoningEffort }),
       ...(config.tokenEstimator === undefined
         ? {}
         : { tokenEstimator: config.tokenEstimator }),
@@ -79,17 +92,26 @@ export function createModelClient(
     });
   }
 
-  return new OpenAIChatModelClient({
+  const common = {
     apiKey: config.apiKey,
     baseURL: config.apiBase,
-    includeReasoningContent: config.includeReasoningContent,
     model: config.modelName,
     stream: config.stream,
     contextBudget: config.contextBudget,
     inputModalities: config.inputModalities,
+    ...(activeReasoningEffort === undefined
+      ? {}
+      : { reasoningEffort: activeReasoningEffort }),
     ...(config.tokenEstimator === undefined
       ? {}
       : { tokenEstimator: config.tokenEstimator }),
+  };
+  if (config.api === "responses") {
+    return new OpenAIResponsesModelClient(common);
+  }
+  return new OpenAIChatModelClient({
+    ...common,
+    includeReasoningContent: config.includeReasoningContent,
   });
 }
 
@@ -97,16 +119,18 @@ export function createRunnerModelClient(
   config: Parameters<typeof createModelClient>[0],
   injected?: ModelClient,
   env?: NodeJS.ProcessEnv,
+  reasoningEffort?: ReasoningEffortController,
 ): ModelClient {
-  return injected ?? createModelClient(config, env);
+  return injected ?? createModelClient(config, env, reasoningEffort);
 }
 
 export function createWebFetchRefiner(
   config: Parameters<typeof createModelClient>[0],
   env?: NodeJS.ProcessEnv,
+  reasoningEffort?: ReasoningEffortController,
 ): Refiner {
   return createModelRefiner({
-    createModelClient: () => createModelClient(config, env),
+    createModelClient: () => createModelClient(config, env, reasoningEffort),
     contextBudget: config.contextBudget,
   });
 }

package/src/cli/tui-memory.ts

@@ -37,8 +37,12 @@ export async function initializeTuiMemory(input: {
         return createModelClient(
           {
             modelName: profile.model,
+            api: profile.api,
             apiKey: profile.apiKey,
             apiBase: profile.apiBase,
+            ...(profile.reasoning === undefined
+              ? {}
+              : { reasoning: profile.reasoning }),
             includeReasoningContent: profile.includeReasoningContent,
             stream: profile.stream,
             contextBudget: memoryConfig.contextBudget,

package/src/cli/tui-runner.tsx

@@ -48,6 +48,7 @@ import { createWorkspaceFileLister } from "../tui/workspace-file-search";
 import { clipboardWriterForEnvironment } from "../tui/clipboard";
 import { initializeTuiMemory } from "./tui-memory";
 import { prepareShikiHighlighter } from "../tui/shiki-highlighter";
+import { createReasoningEffortController } from "../model/reasoning-effort";
 
 export type RunTuiOptions = {
   readonly publicConfig: ResolvedPublicConfig;
@@ -82,10 +83,12 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
       sessionId: SessionId,
       sink: EventSink & AssistantTextDeltaSink,
     ): Promise<RuntimeSession> => {
+      const reasoningEffort = createReasoningEffortController(sessionConfig.reasoning);
       const modelClient = createRunnerModelClient(
         sessionConfig,
         undefined,
         options.env,
+        reasoningEffort,
       );
       const projectInstructions = await loadProjectInstructions(workspaceRoot);
       const skillCatalog = await loadSkillCatalog({ workspaceRoot });
@@ -107,7 +110,11 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
         skillCatalog,
         presentationSinks: [sink],
         assistantTextDeltaSink: sink,
-        webFetchRefiner: createWebFetchRefiner(sessionConfig, options.env),
+        webFetchRefiner: createWebFetchRefiner(
+          sessionConfig,
+          options.env,
+          reasoningEffort,
+        ),
         toolingConfig: options.publicConfig.tooling,
         enableTurnUndo: true,
         bashGuard: {

package/src/context/context-automation-policy.ts

@@ -1,5 +1,5 @@
 import { stableJsonStringify, sha256 } from "../model/model-request-preflight";
-import { RECALL_TOOL_DEFINITION } from "../tools/recall";
+import { RECALL_TOOL_DEFINITIONS } from "../tools/recall";
 import type { ToolDefinition } from "../tools/types";
 import type { StoredContextSurfaceV8 } from "./context-surface";
 import {
@@ -17,26 +17,26 @@ export const I4_ACTIVE_RECALL_QUALIFICATION = Object.freeze({
   policyVersion: "active-recall-qualification-policy-v1",
   policySha256: "77ca611594d4e9b7b5a597a3a33e35fcaaffae284dc2ac9953ce9a63cce1c009",
   positiveReportSha256:
-    "ef84dfee3fdefd7bbf1be2f1641bccc4a1aa06874b22172fecc03dfa2db840d6",
+    "e827e5e94171328bb2dd7fcaeff91881f04bdfc78361a45e2548da323229b02a",
   negativeReportSha256:
-    "c991980ae2824102174315c9b25c1e4affdbbd22aac320e1a254f2702ba3d1b4",
+    "ed379843aee0f193f398a4dff9a18ed338f0edab2cbaf9b628d0dfc402d925a4",
   resolvedModel: "deepseek-v4-flash",
   recallContractVersion: CURRENT_RECALL_RETIREMENT_CONTRACT_VERSION,
   recallContractSha256:
-    "c75108d351ed3223928ebeb52c7258a6f95033287a8e560fb5b2efff8e084c9b",
+    "3b6d1a452efea1db5920eb13542571b038667ef4f635551bea375bda6562a39f",
   recallToolDefinitionSha256:
-    "60caf87f313ea35e74e278ab8b30337cc8af1cc83d82d957a73857a764f3e3d9",
+    "e63ada7cdf9591d1e933cf5e190ea30586e02bbf73aeb5e648db449d75aae009",
   metrics: Object.freeze({
-    fullHistoryTaskSuccessRate: 1,
-    swapOnlyTaskSuccessRate: 1,
-    recallOnlyTaskSuccessRate: 0.9667,
-    recallOnlyActiveRecallRate: 0.9667,
-    recallOnlySearchGetSuccessRate: 0.3,
-    minimumCounterfactualGroupTaskSuccessRate: 0.8333,
-    invalidRecallCallsPerRecallOnlyTrial: 0.0333,
+    fullHistoryTaskSuccessRate: 0.9667,
+    swapOnlyTaskSuccessRate: 0.9667,
+    recallOnlyTaskSuccessRate: 1,
+    recallOnlyActiveRecallRate: 1,
+    recallOnlySearchGetSuccessRate: 0.3333,
+    minimumCounterfactualGroupTaskSuccessRate: 1,
+    invalidRecallCallsPerRecallOnlyTrial: 0,
     negativeUnnecessaryRecallRate: 0,
-    recallOnlyTokenRatioToFullHistory: 1.1555,
-    recallOnlyLatencyRatioToFullHistory: 1.365,
+    recallOnlyTokenRatioToFullHistory: 1.3739,
+    recallOnlyLatencyRatioToFullHistory: 1.207,
   }),
   passed: true,
 } as const);
@@ -80,13 +80,14 @@ export function selectContextAutomation(
   ) {
     return disabled("recall_contract_mismatch");
   }
-  const recall = input.surface.toolDefinitions.find(
-    (definition) => definition.name === "Recall",
+  const recallTools = input.surface.toolDefinitions.filter(
+    (definition) =>
+      definition.name === "RecallSearch" || definition.name === "RecallGet",
   );
   if (
-    recall === undefined ||
-    toolDefinitionHash(recall) !== evidence.recallToolDefinitionSha256 ||
-    toolDefinitionHash(RECALL_TOOL_DEFINITION) !== evidence.recallToolDefinitionSha256
+    recallTools.length !== 2 ||
+    toolDefinitionsHash(recallTools) !== evidence.recallToolDefinitionSha256 ||
+    toolDefinitionsHash(RECALL_TOOL_DEFINITIONS) !== evidence.recallToolDefinitionSha256
   ) {
     return disabled("recall_tool_mismatch");
   }
@@ -116,6 +117,6 @@ function disabled(
   });
 }
 
-function toolDefinitionHash(definition: ToolDefinition): string {
-  return sha256(stableJsonStringify(definition));
+function toolDefinitionsHash(definitions: readonly ToolDefinition[]): string {
+  return sha256(stableJsonStringify(definitions));
 }