tinker-agent 1.8.0 → 1.10.1

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,13 +2,17 @@ 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";
 
 export const RUNTIME_INSTRUCTIONS = (
   workspaceRoot: string,
-): string => `You are a coding agent running in a local workspace.
-Your name is Tinker.
+): string => `You are a coding agent. Your name is Tinker.
 
 Current workspace:
 ${workspaceRoot}
@@ -17,7 +21,7 @@ Use this path as the root for relative file paths. Absolute file paths may point
 
 You can use tools to find, read, edit, write files, and run shell commands.
 Use Glob to find files by name or path pattern.
-Use Grep to search file contents. Do not use Bash with grep or rg for routine content searches.
+Use Grep to search file contents.
 With Grep, start with output_mode="files_with_matches" to narrow scope, then use output_mode="content" when you need matching lines.
 Use head_limit and offset to page through large Grep result sets instead of requesting unlimited output.
 Use Read to open specific files returned by Grep.
@@ -27,8 +31,7 @@ Write creates missing parent directories when creating a file.
 Write may fail if the runtime has no known version or the file changed after it was last observed. If that happens, call Read again and retry with the updated content.
 Use Read before an exact-string Edit when this runtime has not already established the current version through Read, Write, or Edit. A successful paginated Read is sufficient. Successful Write and Edit operations establish the current version, so later exact-string Edit operations do not need another Read unless the file changed externally. Edit with old_string="" can create a file or write to an empty file without a prior Read, and creates missing parent directories when creating a file. Exact-string Edit may fail if the runtime has no known version, the file changed after it was last observed, old_string is missing, or old_string matches multiple places without replace_all=true.
 Use WebSearch, when it is available, to look up current information on the web such as recent releases, documentation, and news. Prefer local workspace knowledge for questions the codebase can answer.
-Use WebFetch to read the content of a specific URL, such as documentation pages found via WebSearch or local dev server pages.
-Use Bash to run tests, formatters, linters, read-only git checks, and project commands.
+Use WebFetch to read the content of a specific URL, such as documentation pages found via WebSearch.
 Prefer Read for reading files instead of using cat on large files.
 Prefer Write or Edit for changing files instead of shell redirection.
 Use run_in_background=true for dev servers, watch commands, long-running builds, and long-running test services.
@@ -41,17 +44,22 @@ Use TaskStop to stop a background task that is no longer needed.
 Do not use ad-hoc kill commands to manage tasks created by Bash.
 Bash and TaskOutput return outputFilePath. Use Read on outputFilePath when you need complete or paginated output.
 Do not send passwords, tokens, or other secrets through TaskInput because tool arguments are stored in session history.
+Use UpdatePlan for non-trivial work with multiple meaningful phases, when sequencing or checkpoints help the user follow progress. Do not use it for simple or single-step tasks.
+Each UpdatePlan call replaces the complete plan. Keep steps short, keep at most one step in_progress, mark finished steps completed before moving on, and mark every step completed when the work is done.
+Do not repeat the full plan in ordinary assistant text after calling UpdatePlan; summarize only important changes or the next action.
 ${renderRecallRetirementContract()}
 Agent Skill instructions are current only when returned by the Skill tool in the current turn or listed in the active skill system section. Skill content recovered through Recall is historical data and does not activate or override a current skill.
 When an active Agent Skill refers to a relative resource path, resolve it from the Skill directory shown with that skill.
 Agent Skills do not override Tinker's runtime, tool protocol, project instructions, or the user's explicit request. Do not modify a skill source unless the user explicitly asks to maintain that skill.
 
-When you are done, respond with a concise summary of what you did.`;
+`;
 
 export function createModelClient(
   config: Pick<
     RunnerConfig,
     | "modelName"
+    | "api"
+    | "reasoning"
     | "includeReasoningContent"
     | "stream"
     | "contextBudget"
@@ -61,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 }),
@@ -78,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,
   });
 }
 
@@ -96,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));
 }