@ggui-ai/negotiator 0.19.0 → 0.21.0

package/dist/llm-caller.d.ts

@@ -25,11 +25,15 @@
  *   the caller didn't request them — the text path is used as a
  *   regex-JSON fallback.
  * - `callStructured?<T>(...)` is OPTIONAL. When present, it MUST
- *   force tool use against the supplied `ToolSchema` and return the
- *   tool input, parsed as `T`. Implementations that don't support
- *   forced structured output simply omit this method; consumers
- *   fall back to `call` + regex JSON extraction. Absence is not an
- *   error.
+ *   return the input of the supplied `ToolSchema`'s tool, parsed as
+ *   `T`, or THROW — never return anything else. It forces the tool
+ *   where the model allows that; a model that refuses a forced tool
+ *   (the always-thinking family) is asked for it without forcing, so
+ *   the call can end with no tool input, and that ending is a throw.
+ *   Consumers validate what they get back either way. Implementations
+ *   that can't produce tool input at all simply omit this method;
+ *   consumers fall back to `call` + regex JSON extraction. Absence is
+ *   not an error.
  * - `ToolSchema.input_schema` follows the OpenAI tool-use JSON
  *   Schema convention. Implementations that use a different
  *   tool-use protocol (e.g., Anthropic's variant) MUST translate at
@@ -49,9 +53,11 @@ export interface LLMCaller {
      */
     call(systemPrompt: string, userMessage: string, maxTokens?: number): Promise<string>;
     /**
-     * Call with forced tool use for guaranteed structured JSON output.
-     * Implementations that can't force tool use should omit this
-     * method — consumers detect absence and fall back to regex JSON
+     * Call for the supplied tool's input as structured JSON — forced
+     * where the model allows it, requested otherwise; throws when the
+     * turn ends without it (see the normative semantics above).
+     * Implementations that can't produce tool input at all should omit
+     * this method — consumers detect absence and fall back to regex JSON
      * extraction on the text path.
      */
     callStructured?<T>(systemPrompt: string, userMessage: string, tool: ToolSchema, maxTokens?: number): Promise<T>;

package/dist/llm-caller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"llm-caller.d.ts","sourceRoot":"","sources":["../src/llm-caller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,6DAA6D;AAC7D,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC;AAED,uFAAuF;AACvF,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,IAAI,CACF,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAAC;IAEnB;;;;;OAKG;IACH,cAAc,CAAC,CAAC,CAAC,EACf,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,UAAU,EAChB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,CAAC,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,CAAC;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}
+{"version":3,"file":"llm-caller.d.ts","sourceRoot":"","sources":["../src/llm-caller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,6DAA6D;AAC7D,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC;AAED,uFAAuF;AACvF,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,IAAI,CACF,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAAC;IAEnB;;;;;;;OAOG;IACH,cAAc,CAAC,CAAC,CAAC,EACf,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,UAAU,EAChB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,CAAC,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,CAAC;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/llm-caller.js

@@ -25,11 +25,15 @@
  *   the caller didn't request them — the text path is used as a
  *   regex-JSON fallback.
  * - `callStructured?<T>(...)` is OPTIONAL. When present, it MUST
- *   force tool use against the supplied `ToolSchema` and return the
- *   tool input, parsed as `T`. Implementations that don't support
- *   forced structured output simply omit this method; consumers
- *   fall back to `call` + regex JSON extraction. Absence is not an
- *   error.
+ *   return the input of the supplied `ToolSchema`'s tool, parsed as
+ *   `T`, or THROW — never return anything else. It forces the tool
+ *   where the model allows that; a model that refuses a forced tool
+ *   (the always-thinking family) is asked for it without forcing, so
+ *   the call can end with no tool input, and that ending is a throw.
+ *   Consumers validate what they get back either way. Implementations
+ *   that can't produce tool input at all simply omit this method;
+ *   consumers fall back to `call` + regex JSON extraction. Absence is
+ *   not an error.
  * - `ToolSchema.input_schema` follows the OpenAI tool-use JSON
  *   Schema convention. Implementations that use a different
  *   tool-use protocol (e.g., Anthropic's variant) MUST translate at

package/dist/rerank-eval/run-probe-cli.js

@@ -14,79 +14,9 @@
  *
  * Eval-only — not exported from the package index.
  */
-import { readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { resolve as pathResolve } from 'node:path';
 import { runProbe, formatReport } from './run-probe.js';
-const ANTHROPIC_API = 'https://api.anthropic.com/v1/messages';
+import { buildAnthropicLlmCaller, getTokenUsage, resolveAnthropicKey, } from '../synth-bench/cli-llm.js';
 const DEFAULT_MODEL = 'claude-haiku-4-5';
-function resolveAnthropicKey() {
-    const envKey = process.env['ANTHROPIC_API_KEY'];
-    if (envKey && envKey.length > 0)
-        return envKey;
-    const credsPath = pathResolve(homedir(), '.ggui', 'credentials.json');
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(credsPath, 'utf8'));
-    }
-    catch (err) {
-        throw new Error(`probe-rerank: could not read ${credsPath} (${err instanceof Error ? err.message : String(err)}). Set ANTHROPIC_API_KEY env var or run \`ggui auth set anthropic\`.`);
-    }
-    const key = parsed.apps?.global?.anthropic;
-    if (typeof key !== 'string' || key.length === 0) {
-        throw new Error(`probe-rerank: no anthropic key found at apps.global.anthropic in ${credsPath}.`);
-    }
-    return key;
-}
-let totalInputTokens = 0;
-let totalOutputTokens = 0;
-function buildAnthropicLlmCaller(apiKey, model) {
-    return {
-        async call() {
-            throw new Error('probe-cli: text-mode not exercised — use callStructured');
-        },
-        async callStructured(systemPrompt, userMessage, tool, maxTokens) {
-            const body = {
-                model,
-                max_tokens: maxTokens ?? 1024,
-                system: systemPrompt,
-                messages: [{ role: 'user', content: userMessage }],
-                tools: [
-                    {
-                        name: tool.name,
-                        description: tool.description,
-                        input_schema: tool.input_schema,
-                    },
-                ],
-                tool_choice: { type: 'tool', name: tool.name },
-            };
-            const res = await fetch(ANTHROPIC_API, {
-                method: 'POST',
-                headers: {
-                    'content-type': 'application/json',
-                    'x-api-key': apiKey,
-                    'anthropic-version': '2023-06-01',
-                },
-                body: JSON.stringify(body),
-            });
-            const json = (await res.json());
-            if (!res.ok) {
-                const errType = json.error?.type ?? 'unknown';
-                const errMsg = json.error?.message ?? `HTTP ${res.status}`;
-                throw new Error(`anthropic ${errType}: ${errMsg}`);
-            }
-            if (json.usage) {
-                totalInputTokens += json.usage.input_tokens ?? 0;
-                totalOutputTokens += json.usage.output_tokens ?? 0;
-            }
-            const toolBlock = json.content?.find((b) => b.type === 'tool_use');
-            if (!toolBlock || toolBlock.input === undefined) {
-                throw new Error(`anthropic: no tool_use block in response (stop_reason=${json.stop_reason ?? 'unknown'})`);
-            }
-            return toolBlock.input;
-        },
-    };
-}
 function parseArgs(argv) {
     let limit;
     let threshold;
@@ -116,7 +46,7 @@ const HAIKU_4_5_PRICE_INPUT_PER_TOKEN = 1.0 / 1_000_000;
 const HAIKU_4_5_PRICE_OUTPUT_PER_TOKEN = 5.0 / 1_000_000;
 async function main() {
     const args = parseArgs(process.argv.slice(2));
-    const apiKey = resolveAnthropicKey();
+    const apiKey = resolveAnthropicKey('probe-rerank');
     const llm = buildAnthropicLlmCaller(apiKey, args.model);
     process.stdout.write(`probe: model=${args.model}\n\n`);
     const report = await runProbe({ llm }, {
@@ -132,11 +62,12 @@ async function main() {
     process.stdout.write('\n');
     process.stdout.write(formatReport(report));
     process.stdout.write('\n\n');
-    const totalCost = totalInputTokens * HAIKU_4_5_PRICE_INPUT_PER_TOKEN +
-        totalOutputTokens * HAIKU_4_5_PRICE_OUTPUT_PER_TOKEN;
+    const usage = getTokenUsage();
+    const totalCost = usage.input * HAIKU_4_5_PRICE_INPUT_PER_TOKEN +
+        usage.output * HAIKU_4_5_PRICE_OUTPUT_PER_TOKEN;
     const callsMade = report.outcomes.filter((o) => !/short-circuited/.test(o.decision.reason)).length;
     const costPerCall = callsMade === 0 ? 0 : totalCost / callsMade;
-    process.stdout.write(`Tokens:         input=${totalInputTokens} · output=${totalOutputTokens}\n`);
+    process.stdout.write(`Tokens:         input=${usage.input} · output=${usage.output}\n`);
     process.stdout.write(`Cost:           total=$${totalCost.toFixed(4)} · per-call=$${costPerCall.toFixed(4)}\n`);
     process.stdout.write(`  G4 cost ≤ $0.002/call →  ${costPerCall <= 0.002 ? 'PASS' : 'FAIL'} ($${costPerCall.toFixed(4)})\n`);
 }

package/dist/synth-bench/cli-llm.d.ts

@@ -16,5 +16,10 @@ export declare function getTokenUsage(): {
     readonly input: number;
     readonly output: number;
 };
+/**
+ * The dev caller the synth benches and the rerank probe CLI share
+ * (Haiku-pinned by default; every CLI takes `--model`). Text mode is not
+ * exercised — every consumer uses `callStructured`.
+ */
 export declare function buildAnthropicLlmCaller(apiKey: string, model: string): LLMCaller;
 //# sourceMappingURL=cli-llm.d.ts.map

package/dist/synth-bench/cli-llm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-llm.d.ts","sourceRoot":"","sources":["../../src/synth-bench/cli-llm.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,kBAAkB,CAAC;AAI9D,oFAAoF;AACpF,eAAO,MAAM,aAAa,qBAAqB,CAAC;AAEhD,mEAAmE;AACnE,eAAO,MAAM,+BAA+B,QAAkB,CAAC;AAC/D,eAAO,MAAM,gCAAgC,QAAkB,CAAC;AAMhE;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAmB9D;AAmBD;oDACoD;AACpD,wBAAgB,aAAa,IAAI;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAEA;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,SAAS,CA2DX"}
+{"version":3,"file":"cli-llm.d.ts","sourceRoot":"","sources":["../../src/synth-bench/cli-llm.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,kBAAkB,CAAC;AAK9D,oFAAoF;AACpF,eAAO,MAAM,aAAa,qBAAqB,CAAC;AAEhD,mEAAmE;AACnE,eAAO,MAAM,+BAA+B,QAAkB,CAAC;AAC/D,eAAO,MAAM,gCAAgC,QAAkB,CAAC;AAMhE;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAmB9D;AAmBD;oDACoD;AACpD,wBAAgB,aAAa,IAAI;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAEA;AAUD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,SAAS,CAyEX"}

package/dist/synth-bench/cli-llm.js

@@ -8,6 +8,7 @@
 import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve as pathResolve } from 'node:path';
+import { anthropicRejectsForcedToolChoice } from '@ggui-ai/protocol';
 const ANTHROPIC_API = 'https://api.anthropic.com/v1/messages';
 /** Default bench model — the model the `ui-gen-default` seed generator declares. */
 export const DEFAULT_MODEL = 'claude-haiku-4-5';
@@ -44,20 +45,44 @@ let totalOutputTokens = 0;
 export function getTokenUsage() {
     return { input: totalInputTokens, output: totalOutputTokens };
 }
+/**
+ * Thinking budget added to the caller's answer budget for a model that
+ * refuses a forced tool (ggui#1264). Same value and reason as the
+ * negotiator's production caller in `@ggui-ai/mcp-server`; the three
+ * copies are consolidated under ggui#1271.
+ */
+const ALWAYS_THINKING_HEADROOM_TOKENS = 16_000;
+/**
+ * The dev caller the synth benches and the rerank probe CLI share
+ * (Haiku-pinned by default; every CLI takes `--model`). Text mode is not
+ * exercised — every consumer uses `callStructured`.
+ */
 export function buildAnthropicLlmCaller(apiKey, model) {
     return {
         async call() {
-            throw new Error('synth-bench: text-mode not exercised — synth uses callStructured');
+            throw new Error('negotiator dev caller: text-mode not exercised — use callStructured');
         },
         async callStructured(systemPrompt, userMessage, tool, maxTokens) {
             // `temperature` deprecated on Haiku 4.5+ — Anthropic rejects with
-            // HTTP 400. `tool_choice: { type: 'tool', name }` below already
-            // binds output to the input_schema; residual stochasticity stays
-            // bounded via canonical-key normalization downstream.
+            // HTTP 400. Residual stochasticity stays bounded via canonical-key
+            // normalization downstream.
+            //
+            // ggui#1264 — a forced `tool_choice` only where the model accepts
+            // one. The always-thinking models (`@ggui-ai/protocol`
+            // `anthropicRejectsForcedToolChoice`) 400 on it, so they get
+            // `auto` + at most one call + the tool named in the system prompt,
+            // and thinking headroom on top of the answer budget (their thinking
+            // counts against `max_tokens` and comes first).
+            const refusesForcedTool = anthropicRejectsForcedToolChoice(model);
+            const answerBudget = maxTokens ?? 1024;
             const body = {
                 model,
-                max_tokens: maxTokens ?? 1024,
-                system: systemPrompt,
+                max_tokens: refusesForcedTool
+                    ? answerBudget + ALWAYS_THINKING_HEADROOM_TOKENS
+                    : answerBudget,
+                system: refusesForcedTool
+                    ? `${systemPrompt}\n\nAnswer by calling the \`${tool.name}\` tool exactly once. Do not answer in text.`
+                    : systemPrompt,
                 messages: [{ role: 'user', content: userMessage }],
                 tools: [
                     {
@@ -66,7 +91,9 @@ export function buildAnthropicLlmCaller(apiKey, model) {
                         input_schema: tool.input_schema,
                     },
                 ],
-                tool_choice: { type: 'tool', name: tool.name },
+                tool_choice: refusesForcedTool
+                    ? { type: 'auto', disable_parallel_tool_use: true }
+                    : { type: 'tool', name: tool.name },
             };
             const res = await fetch(ANTHROPIC_API, {
                 method: 'POST',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ggui-ai/negotiator",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "Contract-synthesis + match-judge engine for ggui's handshake. Synthesizes or repairs a conforming DataContract from an agent's draft, judges blueprint-match candidates for reuse, and validates contract structure + novelty — the primitives composed by decideHandshake in @ggui-ai/mcp-server-handlers. Deployment-agnostic: concrete embedding and vector-store bindings plug in via the storage interfaces from @ggui-ai/mcp-server-core.",
   "license": "Apache-2.0",
   "keywords": [
@@ -47,8 +47,8 @@
     }
   },
   "dependencies": {
-    "@ggui-ai/mcp-server-core": "0.19.0",
-    "@ggui-ai/protocol": "0.19.0"
+    "@ggui-ai/protocol": "0.21.0",
+    "@ggui-ai/mcp-server-core": "0.21.0"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/llm-caller.ts

@@ -25,11 +25,15 @@
  *   the caller didn't request them — the text path is used as a
  *   regex-JSON fallback.
  * - `callStructured?<T>(...)` is OPTIONAL. When present, it MUST
- *   force tool use against the supplied `ToolSchema` and return the
- *   tool input, parsed as `T`. Implementations that don't support
- *   forced structured output simply omit this method; consumers
- *   fall back to `call` + regex JSON extraction. Absence is not an
- *   error.
+ *   return the input of the supplied `ToolSchema`'s tool, parsed as
+ *   `T`, or THROW — never return anything else. It forces the tool
+ *   where the model allows that; a model that refuses a forced tool
+ *   (the always-thinking family) is asked for it without forcing, so
+ *   the call can end with no tool input, and that ending is a throw.
+ *   Consumers validate what they get back either way. Implementations
+ *   that can't produce tool input at all simply omit this method;
+ *   consumers fall back to `call` + regex JSON extraction. Absence is
+ *   not an error.
  * - `ToolSchema.input_schema` follows the OpenAI tool-use JSON
  *   Schema convention. Implementations that use a different
  *   tool-use protocol (e.g., Anthropic's variant) MUST translate at
@@ -56,9 +60,11 @@ export interface LLMCaller {
   ): Promise<string>;
 
   /**
-   * Call with forced tool use for guaranteed structured JSON output.
-   * Implementations that can't force tool use should omit this
-   * method — consumers detect absence and fall back to regex JSON
+   * Call for the supplied tool's input as structured JSON — forced
+   * where the model allows it, requested otherwise; throws when the
+   * turn ends without it (see the normative semantics above).
+   * Implementations that can't produce tool input at all should omit
+   * this method — consumers detect absence and fall back to regex JSON
    * extraction on the text path.
    */
   callStructured?<T>(

package/src/rerank-eval/run-probe-cli.ts

@@ -14,112 +14,15 @@
  *
  * Eval-only — not exported from the package index.
  */
-import { readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { resolve as pathResolve } from 'node:path';
 import { runProbe, formatReport } from './run-probe.js';
-import type { LLMCaller, ToolSchema } from '../llm-caller.js';
+import {
+  buildAnthropicLlmCaller,
+  getTokenUsage,
+  resolveAnthropicKey,
+} from '../synth-bench/cli-llm.js';
 
-const ANTHROPIC_API = 'https://api.anthropic.com/v1/messages';
 const DEFAULT_MODEL = 'claude-haiku-4-5';
 
-interface CredsFile {
-  apps?: { global?: { anthropic?: string } };
-}
-
-function resolveAnthropicKey(): string {
-  const envKey = process.env['ANTHROPIC_API_KEY'];
-  if (envKey && envKey.length > 0) return envKey;
-  const credsPath = pathResolve(homedir(), '.ggui', 'credentials.json');
-  let parsed: CredsFile;
-  try {
-    parsed = JSON.parse(readFileSync(credsPath, 'utf8')) as CredsFile;
-  } catch (err) {
-    throw new Error(
-      `probe-rerank: could not read ${credsPath} (${err instanceof Error ? err.message : String(err)}). Set ANTHROPIC_API_KEY env var or run \`ggui auth set anthropic\`.`,
-    );
-  }
-  const key = parsed.apps?.global?.anthropic;
-  if (typeof key !== 'string' || key.length === 0) {
-    throw new Error(
-      `probe-rerank: no anthropic key found at apps.global.anthropic in ${credsPath}.`,
-    );
-  }
-  return key;
-}
-
-interface AnthropicContentBlock {
-  type: string;
-  name?: string;
-  input?: unknown;
-  text?: string;
-}
-
-interface AnthropicResponse {
-  content?: AnthropicContentBlock[];
-  usage?: { input_tokens?: number; output_tokens?: number };
-  stop_reason?: string;
-  error?: { type?: string; message?: string };
-}
-
-let totalInputTokens = 0;
-let totalOutputTokens = 0;
-
-function buildAnthropicLlmCaller(apiKey: string, model: string): LLMCaller {
-  return {
-    async call(): Promise<string> {
-      throw new Error('probe-cli: text-mode not exercised — use callStructured');
-    },
-    async callStructured<T>(
-      systemPrompt: string,
-      userMessage: string,
-      tool: ToolSchema,
-      maxTokens?: number,
-    ): Promise<T> {
-      const body = {
-        model,
-        max_tokens: maxTokens ?? 1024,
-        system: systemPrompt,
-        messages: [{ role: 'user', content: userMessage }],
-        tools: [
-          {
-            name: tool.name,
-            description: tool.description,
-            input_schema: tool.input_schema,
-          },
-        ],
-        tool_choice: { type: 'tool', name: tool.name },
-      };
-      const res = await fetch(ANTHROPIC_API, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'x-api-key': apiKey,
-          'anthropic-version': '2023-06-01',
-        },
-        body: JSON.stringify(body),
-      });
-      const json = (await res.json()) as AnthropicResponse;
-      if (!res.ok) {
-        const errType = json.error?.type ?? 'unknown';
-        const errMsg = json.error?.message ?? `HTTP ${res.status}`;
-        throw new Error(`anthropic ${errType}: ${errMsg}`);
-      }
-      if (json.usage) {
-        totalInputTokens += json.usage.input_tokens ?? 0;
-        totalOutputTokens += json.usage.output_tokens ?? 0;
-      }
-      const toolBlock = json.content?.find((b) => b.type === 'tool_use');
-      if (!toolBlock || toolBlock.input === undefined) {
-        throw new Error(
-          `anthropic: no tool_use block in response (stop_reason=${json.stop_reason ?? 'unknown'})`,
-        );
-      }
-      return toolBlock.input as T;
-    },
-  };
-}
-
 function parseArgs(argv: readonly string[]): { limit?: number; threshold?: number; model: string } {
   let limit: number | undefined;
   let threshold: number | undefined;
@@ -147,7 +50,7 @@ const HAIKU_4_5_PRICE_OUTPUT_PER_TOKEN = 5.0 / 1_000_000;
 
 async function main(): Promise<void> {
   const args = parseArgs(process.argv.slice(2));
-  const apiKey = resolveAnthropicKey();
+  const apiKey = resolveAnthropicKey('probe-rerank');
   const llm = buildAnthropicLlmCaller(apiKey, args.model);
 
   process.stdout.write(`probe: model=${args.model}\n\n`);
@@ -171,15 +74,16 @@ async function main(): Promise<void> {
   process.stdout.write(formatReport(report));
   process.stdout.write('\n\n');
 
+  const usage = getTokenUsage();
   const totalCost =
-    totalInputTokens * HAIKU_4_5_PRICE_INPUT_PER_TOKEN +
-    totalOutputTokens * HAIKU_4_5_PRICE_OUTPUT_PER_TOKEN;
+    usage.input * HAIKU_4_5_PRICE_INPUT_PER_TOKEN +
+    usage.output * HAIKU_4_5_PRICE_OUTPUT_PER_TOKEN;
   const callsMade = report.outcomes.filter(
     (o) => !/short-circuited/.test(o.decision.reason),
   ).length;
   const costPerCall = callsMade === 0 ? 0 : totalCost / callsMade;
   process.stdout.write(
-    `Tokens:         input=${totalInputTokens} · output=${totalOutputTokens}\n`,
+    `Tokens:         input=${usage.input} · output=${usage.output}\n`,
   );
   process.stdout.write(
     `Cost:           total=$${totalCost.toFixed(4)} · per-call=$${costPerCall.toFixed(4)}\n`,

package/src/synth-bench/cli-llm.ts

@@ -9,6 +9,7 @@ import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve as pathResolve } from 'node:path';
 import type { LLMCaller, ToolSchema } from '../llm-caller.js';
+import { anthropicRejectsForcedToolChoice } from '@ggui-ai/protocol';
 
 const ANTHROPIC_API = 'https://api.anthropic.com/v1/messages';
 
@@ -75,6 +76,19 @@ export function getTokenUsage(): {
   return { input: totalInputTokens, output: totalOutputTokens };
 }
 
+/**
+ * Thinking budget added to the caller's answer budget for a model that
+ * refuses a forced tool (ggui#1264). Same value and reason as the
+ * negotiator's production caller in `@ggui-ai/mcp-server`; the three
+ * copies are consolidated under ggui#1271.
+ */
+const ALWAYS_THINKING_HEADROOM_TOKENS = 16_000;
+
+/**
+ * The dev caller the synth benches and the rerank probe CLI share
+ * (Haiku-pinned by default; every CLI takes `--model`). Text mode is not
+ * exercised — every consumer uses `callStructured`.
+ */
 export function buildAnthropicLlmCaller(
   apiKey: string,
   model: string,
@@ -82,7 +96,7 @@ export function buildAnthropicLlmCaller(
   return {
     async call(): Promise<string> {
       throw new Error(
-        'synth-bench: text-mode not exercised — synth uses callStructured',
+        'negotiator dev caller: text-mode not exercised — use callStructured',
       );
     },
     async callStructured<T>(
@@ -92,13 +106,25 @@ export function buildAnthropicLlmCaller(
       maxTokens?: number,
     ): Promise<T> {
       // `temperature` deprecated on Haiku 4.5+ — Anthropic rejects with
-      // HTTP 400. `tool_choice: { type: 'tool', name }` below already
-      // binds output to the input_schema; residual stochasticity stays
-      // bounded via canonical-key normalization downstream.
+      // HTTP 400. Residual stochasticity stays bounded via canonical-key
+      // normalization downstream.
+      //
+      // ggui#1264 — a forced `tool_choice` only where the model accepts
+      // one. The always-thinking models (`@ggui-ai/protocol`
+      // `anthropicRejectsForcedToolChoice`) 400 on it, so they get
+      // `auto` + at most one call + the tool named in the system prompt,
+      // and thinking headroom on top of the answer budget (their thinking
+      // counts against `max_tokens` and comes first).
+      const refusesForcedTool = anthropicRejectsForcedToolChoice(model);
+      const answerBudget = maxTokens ?? 1024;
       const body = {
         model,
-        max_tokens: maxTokens ?? 1024,
-        system: systemPrompt,
+        max_tokens: refusesForcedTool
+          ? answerBudget + ALWAYS_THINKING_HEADROOM_TOKENS
+          : answerBudget,
+        system: refusesForcedTool
+          ? `${systemPrompt}\n\nAnswer by calling the \`${tool.name}\` tool exactly once. Do not answer in text.`
+          : systemPrompt,
         messages: [{ role: 'user', content: userMessage }],
         tools: [
           {
@@ -107,7 +133,9 @@ export function buildAnthropicLlmCaller(
             input_schema: tool.input_schema,
           },
         ],
-        tool_choice: { type: 'tool', name: tool.name },
+        tool_choice: refusesForcedTool
+          ? { type: 'auto', disable_parallel_tool_use: true }
+          : { type: 'tool', name: tool.name },
       };
       const res = await fetch(ANTHROPIC_API, {
         method: 'POST',