pi-freeflow 1.36.0 → 1.36.1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 1.36.1
+
+### Patch Changes
+
+- Fix tool calls being rejected as invalid JSON on every model, and tool names coming back under a name the host never registered.
+
+  - A tool whose arguments arrived carrying the tail of the previous call is now repaired for **every** tool, not only tools declaring a nested object or array. The most-used tool, the shell command tool, declares nothing but scalars, so it was never repaired at all — the call was rejected and the turn looped on the same broken payload.
+  - Buffered tool arguments are released when a stream ends without its normal ending event, instead of being dropped: a truncated stream used to deliver a call with no arguments at all.
+  - The tool-name restore now runs on the Cline and OVH lanes too. Those lanes send a renamed tool upstream but never took it back, so a client received a call for a tool it does not have.
+  - A caller that declares both file-pattern and semantic-search tools now keeps both. The two share a name across hosts but are different tools, and collapsing them handed the model one tool under the other's shape.
+  - A truncated number is refused rather than completed, and an inner object is never promoted over the wrapper that declares it.
+  - A non-streaming answer from the Kilo lane is repaired like a streamed one.
+  - The free tier is the only lane that renames a tool now. The other lanes carry
+    the caller's own names in both directions, so the host dispatches natively
+    instead of waiting for a name that never comes back.
+  - Tools that declare an optional value as "value or nothing" are repaired
+    again. Both hosts describe optional settings that way when a tool is declared
+    strictly, and reading that as "always send it" silently switched repair off
+    for the shell command tool — the one that matters most.
+  - A model answering an optional setting with the word "none" as text, instead of
+    leaving it empty, is now corrected rather than rejected. Affects roughly one
+    model in nine.
+  - A streamed Anthropic-format answer is now repaired and mapped like the other
+    two formats. It was forwarded untouched.
+  - A stream that ends without an answer says so, instead of reporting an empty
+    successful one.
+
 ## 1.36.0
 
 ### Minor Changes

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-freeflow",
   "type": "module",
-  "version": "1.36.0",
+  "version": "1.36.1",
   "description": "Thin provider for OMP/Pi — model list + dumb relay proxy + log; host pi-ai owns thinking/normalization",
   "main": "extensions/index.ts",
   "types": "src/index.ts",

package/src/opencode-fingerprint.ts

@@ -557,8 +557,11 @@ export function enforceOpencodeFingerprint(
  const injected = missing.filter((n) => !ompLike || n === "edit");
  const injectedReal = ompLike ? missing.filter((n) => n !== "edit") : [];
 
+ // Zen alone asks for a rename: its free-tier gate looks for the sextet name
+ // `glob`, so a Pi caller that sent `find` needs it renamed into that slot.
+ // Every other lane accepts the caller's own names untouched.
  if (Array.isArray(body.tools)) {
-  body.tools = translateToolsForPath(body.tools, pathname);
+  body.tools = translateToolsForPath(body.tools, pathname, { forFingerprint: true });
  }
 
  const before = Array.isArray(body.tools) ? body.tools.length : 0;
@@ -881,10 +884,14 @@ export function sseToResponsesJson(
   }
  } catch { }
 
+ // Nothing in the stream carried a response object: the upstream turn ended
+ // without one. Report that honestly — a `completed` answer with zero output
+ // reads to the host as "the model chose to say nothing", which is a
+ // different (and wrong) claim than "the stream was cut".
  return {
   id: "resp_fallback",
   object: "response",
-  status: "completed",
+  status: "incomplete",
   output: [],
  };
 }
@@ -895,8 +902,11 @@ export function sseToResponsesJson(
  * never see tool_use: stray placeholder input folds to text, matching the
  * SSE aggregator fallback below. Ids ride verbatim; `input` is repaired
  * against the caller's declared schema when the emitted shape cannot be right.
+ *
+ * Exported so the streaming cloak applies these identical rules to a `message`
+ * frame that arrives mid-stream, instead of forwarding it verbatim.
  */
-function cloakMessagesContent(
+export function cloakMessagesContent(
  msg: unknown,
  callerHadTools: boolean,
  caseRestore?: CaseRestoreMap,
@@ -1089,7 +1099,79 @@ export function convertSseToJson(
    return JSON.stringify(sseToMessagesJson(trimmed, callerHadTools, caseRestore, findGlob, injected, argSchemas));
   }
   return JSON.stringify(sseToChatCompletionJson(trimmed, callerHadTools, caseRestore, findGlob, injected, argSchemas));
+ } catch (error) {
+  // Every caller has already committed to `content-type: application/json`
+  // by the time this runs, so handing back the raw SSE bytes would deliver a
+  // parse error with no diagnosis. Say what happened, and keep the payload
+  // reachable under `raw` so nothing is silently destroyed.
+  return JSON.stringify({
+   error: {
+    message: "upstream stream could not be aggregated into a JSON answer",
+    detail: String(error).slice(0, 300),
+    raw: sseText.slice(0, 2000),
+   },
+  });
+ }
+}
+
+/**
+ * Repair the tool calls inside an already-JSON answer body.
+ *
+ * A lane that passes the caller's `stream` through untouched (Kilo) answers a
+ * non-streaming caller with a plain `chat.completion` / `response` object, not
+ * SSE. The SSE aggregators above never see that body, so the malformed
+ * arguments reached the host unrepaired on exactly the requests that asked for
+ * no stream. Repairs each call in place and re-serializes only when something
+ * actually changed, so a well-formed answer keeps its byte-identical body.
+ * Returns the input string untouched when it is not JSON or has no tool calls.
+ */
+export function repairJsonToolArguments(
+ bodyText: string,
+ pathname: string,
+ argSchemas: ReadonlyMap<string, Record<string, unknown>> | undefined,
+): string {
+ if (argSchemas === undefined || argSchemas.size === 0 || !bodyText.trimStart().startsWith("{")) return bodyText;
+ let parsed: unknown;
+ try {
+  parsed = JSON.parse(bodyText);
  } catch {
-  return sseText;
+  return bodyText;
+ }
+ if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return bodyText;
+ const body = parsed as Record<string, unknown>;
+ let changed = false;
+ const repairCall = (name: string, args: string): string => {
+  const repaired = repairToolArguments(name, args, argSchemas);
+  if (repaired !== args) changed = true;
+  return repaired;
+ };
+ if (pathname.endsWith("/responses")) {
+  const output = body.output;
+  if (!Array.isArray(output)) return bodyText;
+  for (const item of output) {
+   if (item === null || typeof item !== "object" || Array.isArray(item)) continue;
+   const rec = item as Record<string, unknown>;
+   if (rec.type !== "function_call" || typeof rec.name !== "string" || typeof rec.arguments !== "string") continue;
+   rec.arguments = repairCall(rec.name, rec.arguments);
+  }
+ } else {
+  const choices = body.choices;
+  if (!Array.isArray(choices)) return bodyText;
+  for (const choice of choices) {
+   if (choice === null || typeof choice !== "object" || Array.isArray(choice)) continue;
+   const message = (choice as Record<string, unknown>).message;
+   if (message === null || typeof message !== "object" || Array.isArray(message)) continue;
+   const calls = (message as Record<string, unknown>).tool_calls;
+   if (!Array.isArray(calls)) continue;
+   for (const call of calls) {
+    if (call === null || typeof call !== "object" || Array.isArray(call)) continue;
+    const fn = (call as Record<string, unknown>).function;
+    if (fn === null || typeof fn !== "object" || Array.isArray(fn)) continue;
+    const fnRec = fn as Record<string, unknown>;
+    if (typeof fnRec.name !== "string" || typeof fnRec.arguments !== "string") continue;
+    fnRec.arguments = repairCall(fnRec.name, fnRec.arguments);
+   }
+  }
  }
+ return changed ? JSON.stringify(body) : bodyText;
 }

package/src/proxy.ts

@@ -35,11 +35,12 @@ import {
 } from "./config.ts";
 
 import {
- convertSseToJson,
- enforceOpencodeFingerprint,
- sseToChatCompletionJson,
- type CaseRestoreMap,
- type FindGlobRestore,
+	convertSseToJson,
+	enforceOpencodeFingerprint,
+	repairJsonToolArguments,
+	sseToChatCompletionJson,
+	type CaseRestoreMap,
+	type FindGlobRestore,
 } from "./opencode-fingerprint.ts";
 import { isDebugEnabled, log } from "./logger.ts";
 import { getModelUpstream, isClineModel, isOvhModel, KILO_MODEL_IDS, MODEL_MAP, ovhUpstreamModelId, resolveCanonicalModelId } from "./models.ts";
@@ -47,10 +48,12 @@ import { ClineAuthError, refreshClineToken, toApiKey } from "./cline-device-auth
 import { rollChat } from "./cline-accounts.ts";
 import { fetchWithSystemCA } from "./system-ca-fetch.ts";
 import {
- chatResponsesJsonFromChatCompletion,
- chatResponsesSseFromChatCompletion,
- chatBodyFromResponsesBody,
- translateToolsForPath,
+	buildFindGlobRestore,
+	chatBodyFromResponsesBody,
+	chatResponsesJsonFromChatCompletion,
+	chatResponsesSseFromChatCompletion,
+	restoreToolNameForCaller,
+	translateToolsForPath,
 } from "./tool-translation.ts";
 import { buildArgRepairSchemas } from "./tool-args.ts";
 // normalize removed — host pi-ai already normalizes thinking/reasoning before proxy
@@ -271,6 +274,10 @@ async function handleClineRequest(opts: {
  // Cline bypasses the fingerprint, but its arguments still malform the same
  // way: capture the caller's own schemas before translation for repair.
  const argSchemas = buildArgRepairSchemas(Array.isArray(parsedBody.tools) ? parsedBody.tools : []);
+ // Translation renames the caller's `find` to `glob` upstream and folds any
+ // name the upstream shape forbids; without this map the answer returns under
+ // a name Pi never registered.
+ const findGlob = buildFindGlobRestore(Array.isArray(parsedBody.tools) ? parsedBody.tools : []);
  chatBody.stream = true;
  let upstreamRes: Response;
  let limitHint: ClineLimitHint | undefined;
@@ -334,8 +341,8 @@ async function handleClineRequest(opts: {
    req,
    reqId,
    "direct",
-   argSchemas.size > 0
-    ? { callerHadTools: true, argSchemas, pathname: "/v1/chat/completions" }
+   findGlob.renamedFindToGlob || findGlob.renamed !== undefined || argSchemas.size > 0
+    ? { callerHadTools: true, argSchemas, findGlob, pathname: "/v1/chat/completions" }
     : undefined,
   );
   return;
@@ -352,7 +359,7 @@ async function handleClineRequest(opts: {
   return;
  }
  if (!responsesRequest) {
-  const data = convertSseToJson(sseText, pathname, true, undefined, undefined, undefined, argSchemas);
+ const data = convertSseToJson(sseText, pathname, true, undefined, findGlob, undefined, argSchemas);
   if (!res.headersSent) {
    res.writeHead(upstreamRes.status, { "content-type": "application/json" });
    res.end(data);
@@ -361,7 +368,7 @@ async function handleClineRequest(opts: {
   }
   return;
  }
- const chat = sseToChatCompletionJson(sseText, true, undefined, undefined, undefined, argSchemas);
+ const chat = sseToChatCompletionJson(sseText, true, undefined, findGlob, undefined, argSchemas);
  const resp = chatResponsesJsonFromChatCompletion(chat, model);
  if (clientRequestedStream) {
   if (!res.headersSent) {
@@ -423,6 +430,10 @@ async function handleOvhRequest(opts: {
  // Bypassing the fingerprint does not exempt OVH from malformed tool
  // arguments: capture the caller's own schemas before translation for repair.
  const argSchemas = buildArgRepairSchemas(Array.isArray(parsedBody.tools) ? parsedBody.tools : []);
+ // Translation renames the caller's `find` to `glob` upstream and folds any
+ // name the upstream shape forbids; without this map the answer returns under
+ // a name Pi never registered.
+ const findGlob = buildFindGlobRestore(Array.isArray(parsedBody.tools) ? parsedBody.tools : []);
  chatBody.stream = true;
  // Header-wait timeout + client-disconnect abort, cleared once headers arrive
  // so a long stream is not killed at the timeout ceiling.
@@ -501,8 +512,8 @@ async function handleOvhRequest(opts: {
    req,
    reqId,
    "direct",
-   argSchemas.size > 0
-    ? { callerHadTools: true, argSchemas, pathname: "/v1/chat/completions" }
+   findGlob.renamedFindToGlob || findGlob.renamed !== undefined || argSchemas.size > 0
+    ? { callerHadTools: true, argSchemas, findGlob, pathname: "/v1/chat/completions" }
     : undefined,
   );
   return;
@@ -519,7 +530,7 @@ async function handleOvhRequest(opts: {
   return;
  }
  if (!responsesRequest) {
-  const data = convertSseToJson(sseText, pathname, true, undefined, undefined, undefined, argSchemas);
+ const data = convertSseToJson(sseText, pathname, true, undefined, findGlob, undefined, argSchemas);
   if (!res.headersSent) {
    res.writeHead(upstreamRes.status, { "content-type": "application/json" });
    res.end(data);
@@ -528,7 +539,7 @@ async function handleOvhRequest(opts: {
   }
   return;
  }
- const chat = sseToChatCompletionJson(sseText, true, undefined, undefined, undefined, argSchemas);
+ const chat = sseToChatCompletionJson(sseText, true, undefined, findGlob, undefined, argSchemas);
  const resp = chatResponsesJsonFromChatCompletion(chat, requestedModel);
  if (clientRequestedStream) {
   if (!res.headersSent) {
@@ -1382,7 +1393,11 @@ export function startProxy(
      } else {
       let rawText = await response.text();
       if (response.ok && kiloArgSchemas.size > 0) {
+       // Kilo passes `stream` through verbatim, so a non-streaming caller gets
+       // a plain JSON body: the SSE aggregator is a no-op on it, and the JSON
+       // repair is what actually applies here.
        rawText = convertSseToJson(rawText, target.pathname, true, undefined, undefined, undefined, kiloArgSchemas);
+       rawText = repairJsonToolArguments(rawText, target.pathname, kiloArgSchemas);
       }
       const data = withRateLimitHint(response.status, rawText);
       const ct = response.headers.get("content-type") || "application/json";

package/src/stream-pipe.ts

@@ -15,7 +15,7 @@ import {
  WATCHDOG_SSE_MIN_SAMPLES,
  WATCHDOG_SSE_WINDOW,
 } from "./config.ts";
-import type { CaseRestoreMap, FindGlobRestore } from "./opencode-fingerprint.ts";
+import { cloakMessagesContent, type CaseRestoreMap, type FindGlobRestore } from "./opencode-fingerprint.ts";
 import { restoreToolNameForCaller } from "./tool-translation.ts";
 import { repairToolArguments } from "./tool-args.ts";
 
@@ -211,6 +211,52 @@ export function createSseStreamCloakState(): SseStreamCloakState {
  };
 }
 
+/**
+ * Emit every tool call still holding buffered arguments, then clear the
+ * buffers. The fragments were withheld so the packet could be judged whole
+ * (see {@link SseStreamCloakState}); the terminal event that normally releases
+ * them never arrived when upstream cut the stream without one, and without
+ * this the client would receive a tool call whose `arguments` were deleted and
+ * never re-emitted. Repaired exactly as the terminal path repairs.
+ *
+ * Shape follows the pathname: Chat re-emits one `tool_calls` delta, Anthropic
+ * one `input_json_delta` per open block. Responses carries whole arguments on
+ * its `.done` event and buffers nothing, so it has nothing to flush.
+ * Returns null when nothing is buffered.
+ */
+export function flushBufferedToolArgs(
+ state: SseStreamCloakState,
+ cloak: StreamCloakOptions,
+): string | null {
+ if (state.messagesArgsByIndex.size > 0) {
+  const blocks: string[] = [];
+  for (const [index, args] of state.messagesArgsByIndex) {
+   const name = state.messagesNameByIndex.get(index) ?? "";
+   blocks.push(
+    `event: content_block_delta\ndata: ${JSON.stringify({
+     type: "content_block_delta",
+     index,
+     delta: { type: "input_json_delta", partial_json: repairToolArguments(name, args, cloak.argSchemas) },
+    })}\n\n`,
+   );
+  }
+  state.messagesArgsByIndex.clear();
+  state.messagesNameByIndex.clear();
+  return blocks.join("");
+ }
+ if (state.chatArgsByIndex.size === 0) return null;
+ const calls: unknown[] = [];
+ for (const [index, args] of state.chatArgsByIndex) {
+  const name = state.chatNameByIndex.get(index);
+  if (name === undefined) continue;
+  calls.push({ index, type: "function", function: { name, arguments: repairToolArguments(name, args, cloak.argSchemas) } });
+ }
+ state.chatArgsByIndex.clear();
+ state.chatNameByIndex.clear();
+ if (calls.length === 0) return null;
+ return `data: ${JSON.stringify({ object: "chat.completion.chunk", choices: [{ index: 0, delta: { tool_calls: calls } }] })}\n\n`;
+}
+
 /**
  * True when the stream needs no rewrite and must flow byte-identical:
  * nothing injected, no casing to restore, no find->glob rename, and the
@@ -656,6 +702,27 @@ function rewriteMessagesBlock(
   const stopBlock = emitSseBlock(event, JSON.stringify(parsed), hadEventPrefix);
   return `${emitSseBlock("content_block_delta", JSON.stringify(flushed), false)}\n\n${stopBlock}`;
  }
+ // A `message` frame carries a whole finished message mid-stream. It needs the
+ // same treatment the aggregate path gives it — injected tool_use dropped,
+ // caller names restored, inputs repaired — otherwise a placeholder call leaks
+ // downstream and a malformed one reaches the host unrepaired. Any block still
+ // buffering arguments is completed first so nothing is orphaned.
+ if (type === "message") {
+  const flushed = flushBufferedToolArgs(state, cloak);
+  cloakMessagesContent(parsed.message ?? parsed, cloak.callerHadTools, cloak.caseRestore, cloak.findGlob, cloak.injected, cloak.argSchemas);
+  if (flushed === null) return emitSseBlock(event, JSON.stringify(parsed), hadEventPrefix);
+  return `${flushed}${emitSseBlock(event, JSON.stringify(parsed), hadEventPrefix)}`;
+ }
+ // A tool_use block still holding buffered arguments is completed HERE, while
+ // its own event order is intact: `message_delta` / `message_stop` close the
+ // message, so the recovered `input_json_delta` has to precede them. (An
+ // end-of-stream flush would emit it after `message_stop`, where a strict
+ // Anthropic client has already closed the message.)
+ if (type === "message_delta" || type === "message_stop") {
+  const flushed = flushBufferedToolArgs(state, cloak);
+  if (flushed === null) return block;
+  return `${flushed}${emitSseBlock(event, JSON.stringify(parsed), hadEventPrefix)}`;
+ }
  return block;
 }
 
@@ -1099,6 +1166,15 @@ export function pipeUpstreamStream(
     }
    }
   }
+ // Buffered tool arguments are released on the call's terminal event, which a
+ // cut stream never sends. Flush them here: the client already saw the call
+ // announced, so it must receive the arguments too rather than a name with no
+ // payload. Runs before the terminal-marker decision and before the re-fire
+ // offer, because a rescue regenerates the turn and would double the calls.
+ if (cloakState && cloak) {
+  const flushed = flushBufferedToolArgs(cloakState, cloak);
+  if (flushed !== null) forwardText(flushed);
+ }
   if (hasTerminalEvent) recordOnce(false);
   const elapsed = ((Date.now() - startAt) / 1000).toFixed(1);
   if (!hasTerminalEvent && totalChunks > 0) {
@@ -1140,6 +1216,14 @@ export function pipeUpstreamStream(
   // inject a terminal nor end res — the replacement stream owns the turn now.
   if (refirePending) return;
   try {
+  // Same obligation as the clean-end flush: the client already saw the call
+  // announced, so its buffered arguments must still arrive before the turn is
+  // terminated — and before the re-fire offer, since a rescue regenerates the
+  // turn and would double the calls.
+  if (cloakState && cloak) {
+   const flushed = flushBufferedToolArgs(cloakState, cloak);
+   if (flushed !== null) forwardText(flushed);
+  }
    if (!hasTerminalEvent && totalChunks > 0) {
     if (clientAborted || upstreamEnded) {
      // Client disconnect teardown or post-end cleanup — the relay

package/src/tool-args.ts

@@ -9,9 +9,12 @@
  * `items: { item: [...] }`. Sibling free models invented whole vocabularies
  * (`phases` / `name` / `tasks`) the schema never declared.
  *
- * Two families are mechanically decidable from the CALLER's own declared
+ * Three families are mechanically decidable from the CALLER's own declared
  * schema, and this module repairs exactly those:
  *
+ * - Prefix-glue salvage: an argument string carrying the tail of the previous
+ *   call in front of the caller's own object is recovered (see parseArguments).
+ *
  * - Envelope unwrap: a declared array that arrives wrapped in a single-key
  *   object (`items: { item: [...] }`) is unwrapped.
  * - JSON-string decode: a declared object/array that arrives as a JSON string
@@ -38,6 +41,14 @@ import { canonicalizeTool } from "./tool-translation.ts";
 /** Bound on recursive repair/validation; real host schemas nest 3-4 deep. */
 const MAX_DEPTH = 8;
 
+/**
+ * Text ending in a bare numeric literal (`"timeout":18`, `"n":1.`, `"n":1e`).
+ * A complete JSON value is never followed by a digit, so this can only be a
+ * literal the model was still writing when the stream cut — see
+ * {@link appendClosers}.
+ */
+const CUT_NUMBER_TAIL = /[\d.eE+-]$/;
+
 /** Declared JSON Schema type, tolerating union types like ["array","null"]. */
 function schemaType(schema: Record<string, unknown>): string {
   const declared = schema.type;
@@ -49,10 +60,47 @@ function schemaType(schema: Record<string, unknown>): string {
   return "";
 }
 
-/** A schema property worth repairing: it holds an object or an array. */
-function structuralProperty(schema: Record<string, unknown>): boolean {
-  const type = schemaType(schema);
-  return type === "object" || type === "array";
+
+/**
+ * Does a value already satisfy the declared schema? Type, then required keys,
+ * then each present property recursively. A present property the schema does
+ * not declare is ignored (never fails): hosts decide their own extras policy,
+ * and this only gates whether a promotion is safe.
+ *
+ * Deliberately reads five keywords — `type`, `enum`, `properties`, `items`,
+ * `required` — and nothing else. `minItems`, `minLength`, `pattern`,
+ * `additionalProperties` and `strict` are NOT enforced, on purpose: this
+ * function only decides whether to hand the repaired value to the host, and
+ * the host validates the same keywords itself. A payload that violates
+ * `minItems` is rejected by the host whether or not the repair accepted it, so
+ * enforcing it here could only ever DISABLE a repair that would have been
+ * accepted downstream — strictly worse, never better. The trade-off this does
+ * leave: repair never rescues a call whose only fault is a constraint like
+ * `minItems`, because the shape was never the problem.
+ */
+/**
+ * Is this property allowed to be absent?
+ *
+ * Both hosts rewrite a tool's schema for strict mode by listing EVERY property
+ * key in `required` and wrapping each optional one in
+ * `anyOf: [<schema>, { type: "null" }]` (OMP: packages/ai CONSTRAINTS.md:34-49;
+ * Pi: core/constrained-sampling.ts:118-123). So "required" there does not mean
+ * "must be present" — it means "must be addressable". Reading it literally made
+ * this gate refuse every well-formed call on a strict tool, which silently
+ * disabled the whole repair for `bash` and the strict edit modes: the glued
+ * payload the host rejects is exactly the one this module exists to fix.
+ */
+function isNullableProperty(prop: unknown): boolean {
+	if (prop === null || typeof prop !== "object" || Array.isArray(prop)) return false;
+	const rec = prop as Record<string, unknown>;
+	if (Array.isArray(rec.type)) return (rec.type as unknown[]).includes("null");
+	const anyOf = rec.anyOf;
+	if (Array.isArray(anyOf)) {
+	for (const branch of anyOf) {
+		if (branch !== null && typeof branch === "object" && !Array.isArray(branch) && (branch as Record<string, unknown>).type === "null") return true;
+	}
+	}
+	return false;
 }
 
 /**
@@ -60,38 +108,74 @@ function structuralProperty(schema: Record<string, unknown>): boolean {
  * then each present property recursively. A present property the schema does
  * not declare is ignored (never fails): hosts decide their own extras policy,
  * and this only gates whether a promotion is safe.
+ *
+ * Deliberately reads `type`, `enum`, `properties`, `items`, `required` — and
+ * nothing else. `minItems`, `minLength`, `pattern`, `additionalProperties` and
+ * `strict` are NOT enforced, on purpose: this function only decides whether to
+ * hand the repaired value to the host, and the host validates the same
+ * keywords itself. A payload that violates `minItems` is rejected by the host
+ * whether or not the repair accepted it, so enforcing it here could only ever
+ * DISABLE a repair the host would otherwise have accepted — strictly worse,
+ * never better. The trade-off this leaves: repair never rescues a call whose
+ * only fault is a constraint like `minItems`, because the shape was never the
+ * problem.
  */
 function matchesSchema(value: unknown, schema: Record<string, unknown>, depth: number): boolean {
-  if (depth > MAX_DEPTH) return false;
-  const type = schemaType(schema);
-  if (type === "array") {
-   if (!Array.isArray(value)) return false;
-   const items = schema.items;
-   if (items === null || typeof items !== "object" || Array.isArray(items)) return true;
-   return value.every((element) => matchesSchema(element, items as Record<string, unknown>, depth + 1));
-  }
-  if (type === "object") {
-   if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-   const rec = value as Record<string, unknown>;
-   if (Array.isArray(schema.required)) {
-    for (const key of schema.required) {
-     if (typeof key === "string" && !(key in rec)) return false;
-    }
-   }
-   const props = schema.properties;
-   if (props === null || typeof props !== "object" || Array.isArray(props)) return true;
-   for (const [key, entry] of Object.entries(rec)) {
-    const propSchema = (props as Record<string, unknown>)[key];
-    if (propSchema === null || typeof propSchema !== "object" || Array.isArray(propSchema)) continue;
-    if (!matchesSchema(entry, propSchema as Record<string, unknown>, depth + 1)) return false;
+ if (depth > MAX_DEPTH) return false;
+ const type = schemaType(schema);
+ if (type === "array") {
+  if (!Array.isArray(value)) return false;
+  const items = schema.items;
+  if (items === null || typeof items !== "object" || Array.isArray(items)) return true;
+  return value.every((element) => matchesSchema(element, items as Record<string, unknown>, depth + 1));
+ }
+ if (type === "object") {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const rec = value as Record<string, unknown>;
+  const props = schema.properties;
+  const declared = props !== null && typeof props === "object" && !Array.isArray(props) ? (props as Record<string, unknown>) : null;
+  if (Array.isArray(schema.required)) {
+   for (const key of schema.required) {
+    if (typeof key !== "string" || key in rec) continue;
+    // Strict-mode hosts list every key here and mark the optional ones nullable,
+    // so a nullable key that is absent is correct, not a violation.
+    if (declared !== null && isNullableProperty(declared[key])) continue;
+    return false;
    }
-   return true;
   }
-  if (type === "string") return typeof value === "string";
-  if (type === "number") return typeof value === "number" && Number.isFinite(value);
-  if (type === "boolean") return typeof value === "boolean";
-  if (Array.isArray(schema.enum)) return schema.enum.some((member) => member === value);
+  if (declared === null) return true;
+  for (const [key, entry] of Object.entries(rec)) {
+   const propSchema = declared[key];
+   if (propSchema === null || typeof propSchema !== "object" || Array.isArray(propSchema)) continue;
+   if (!matchesSchema(entry, propSchema as Record<string, unknown>, depth + 1)) return false;
+  }
   return true;
+ }
+ if (type === "string") return typeof value === "string";
+ if (type === "number") return typeof value === "number" && Number.isFinite(value);
+ if (type === "boolean") return typeof value === "boolean";
+ if (Array.isArray(schema.enum)) return schema.enum.some((member) => member === value);
+ return true;
+}
+
+/** The spellings free models use for "no value" when the slot is nullable. */
+const NULL_SENTINELS = new Set(["null", "none", "undefined", "nil", "n/a"]);
+
+function isNullSentinel(text: string): boolean {
+	return NULL_SENTINELS.has(text.trim().toLowerCase());
+}
+
+/** The non-null branch of a nullable declaration, or null when it is not one. */
+function nonNullBranch(prop: Record<string, unknown>): Record<string, unknown> | null {
+	const anyOf = prop.anyOf;
+	if (!Array.isArray(anyOf)) return null;
+	for (const branch of anyOf) {
+		if (branch === null || typeof branch !== "object" || Array.isArray(branch)) continue;
+		const rec = branch as Record<string, unknown>;
+		if (rec.type === "null") continue;
+		return rec;
+	}
+	return null;
 }
 
 /**
@@ -164,6 +248,24 @@ function repairValue(
     out[key] = entry;
     continue;
    }
+   // A strict host makes optional keys `anyOf: [T, null]`, and free models
+   // routinely answer that slot with the SENTINEL AS TEXT — `"timeout":"null"`,
+   // `"pty":"None"` (measured across 4 of 37 catalog models). The host rejects
+   // the call because a string is not a number and not null.
+   //
+   // Restricted to non-string inner types on purpose: when T is `string`,
+   // `"null"` could be a genuine value and rewriting it would destroy data.
+   // With T = number/boolean/object/array the property can never legitimately
+   // hold a bare string, so collapsing a null sentinel loses nothing and makes
+   // the call one the host accepts.
+   if (typeof entry === "string" && isNullSentinel(entry)) {
+    const nonNull = nonNullBranch(propSchema as Record<string, unknown>);
+    if (nonNull !== null && schemaType(nonNull) !== "string") {
+     out[key] = null;
+     changed = true;
+     continue;
+    }
+   }
    const repaired = repairValue(entry, propSchema as Record<string, unknown>, depth + 1);
    if (repaired.changed) changed = true;
    out[key] = repaired.value;
@@ -318,28 +420,29 @@ function promoteStringArray(
 
 /**
  * Per-request map of caller tool name (lowercased) to the schema its
- * arguments are repaired against. Only tools whose parameters declare at least
- * one object or array property are kept: those are the only ones a repair can
- * act on, and an empty map means the request streams byte-identically.
+ * arguments are repaired against. Every tool that declares object parameters
+ * is kept, NOT only those with an object/array property: the prefix-glue
+ * salvage in {@link parseArguments} needs only the caller's own schema to
+ * confirm the recovered object, and it fires most often on scalar-only tools.
+ * `bash` is the live case — OMP's `bashSchemaBase` declares only `command`,
+ * `timeout`, `cwd`, `pty` (reference/oh-my-pi tools/bash.ts:327), so a
+ * structural-only filter left the most-used tool unrepairable and the host
+ * rejected the glued payload outright.
  *
  * Keyed by CALLER name, which is what arrives downstream after the casing and
  * find->glob restores. Injected fingerprint placeholders are absent by
  * construction, so they are never repaired.
  */
 export function buildArgRepairSchemas(tools: unknown[]): Map<string, Record<string, unknown>> {
-  const schemas = new Map<string, Record<string, unknown>>();
-  for (const tool of tools) {
-   const canon = canonicalizeTool(tool);
-   if (canon === null) continue;
-   const props = canon.parameters.properties;
-   if (props === null || typeof props !== "object" || Array.isArray(props)) continue;
-   const hasStructural = Object.values(props as Record<string, unknown>).some(
-    (prop) => prop !== null && typeof prop === "object" && !Array.isArray(prop) && structuralProperty(prop as Record<string, unknown>),
-   );
-   if (!hasStructural) continue;
-   schemas.set(canon.name.trim().toLowerCase(), canon.parameters);
-  }
-  return schemas;
+ const schemas = new Map<string, Record<string, unknown>>();
+ for (const tool of tools) {
+  const canon = canonicalizeTool(tool);
+  if (canon === null) continue;
+  const props = canon.parameters.properties;
+  if (props === null || typeof props !== "object" || Array.isArray(props)) continue;
+  schemas.set(canon.name.trim().toLowerCase(), canon.parameters);
+ }
+ return schemas;
 }
 
 
@@ -374,8 +477,13 @@ function parseArguments(argsJson: string): { value: Record<string, unknown>; sal
   } catch {
     // fall through to the salvage scan
   }
- for (let i = argsJson.indexOf("{"); i !== -1; i = argsJson.indexOf("{", i + 1)) {
-  const candidate = argsJson.slice(i);
+ // Only a brace that OPENS a top-level object can start the caller's call: a
+ // brace nested inside an already-unterminated object belongs to that outer
+ // object, so promoting it would drop the declared key that wraps it
+ // (`{"opts":{"a":1` must not salvage to `{"a":1}`).
+ for (const start of topLevelObjectStarts(argsJson)) {
+  const candidate = argsJson.slice(start);
+  const i = start;
   // Two shapes to try, in order: the candidate as written, then the candidate
   // with its missing closers appended. The closer is only offered at the FIRST
   // brace and only when something precedes it — that fragment is the evidence
@@ -395,7 +503,35 @@ function parseArguments(argsJson: string): { value: Record<string, unknown>; sal
    }
   }
  }
-  return undefined;
+ return undefined;
+}
+
+/**
+ * Offsets of every `{` that could open the caller's own object.
+ *
+ * Depth counts braces only, clamped at zero, and deliberately ignores string
+ * state. The junk in front is itself a cut fragment: it usually ends
+ * mid-string (`…/freelane-proxy"`), so string tracking would classify the whole
+ * real call as "inside a string" and find no start at all — which is exactly
+ * the live failure this scan has to recover from.
+ *
+ * A nested brace is a candidate only when no key precedes it: `{"opts":{"a":1}`
+ * must NOT promote its inner `{"a":1}` (a `:` sits between, so the outer
+ * object is a real one and its declared key would be dropped), while the
+ * observed prefix junk `}{` must still reach the real call that follows it.
+ */
+function topLevelObjectStarts(text: string): number[] {
+ const starts: number[] = [];
+ const openAt: number[] = [];
+ for (let i = 0; i < text.length; i++) {
+  if (text[i] === "{") {
+   if (openAt.length === 0 || !text.slice(openAt[openAt.length - 1] + 1, i).includes(":")) starts.push(i);
+   openAt.push(i);
+   continue;
+  }
+  if (text[i] === "}" && openAt.length > 0) openAt.pop();
+ }
+ return starts;
 }
 
 /**
@@ -404,11 +540,15 @@ function parseArguments(argsJson: string): { value: Record<string, unknown>; sal
  *
  * Only ever called on a candidate that starts at a `{` preceded by a fragment
  * of the previous call, and only when the candidate's own contents already
- * end cleanly. Two refusals keep this honest:
+ * end cleanly. Three refusals keep this honest:
  *
  * - Cut inside a string literal (an unterminated `"`) returns undefined. The
  *   value itself is incomplete, so any closing brace would silently shorten
  *   it — and these arguments carry shell commands.
+ * - Cut inside a number literal returns undefined. `{"timeout":18` may have
+ *   been `180`, `18.5`, or `18`; completing it hands the host a confident wrong
+ *   value with nothing to signal the guess. (`timeout` is a declared number on
+ *   both hosts' `bash`.)
  * - Nothing left open returns undefined, so a well-formed candidate never
  *   reaches this path.
  *
@@ -433,6 +573,8 @@ function appendClosers(text: string): string | undefined {
  }
  // Inside a string at the end: the value was cut mid-token, so refuse.
  if (inString || open.length === 0) return undefined;
+ // A bare number at the end is a cut literal (`18` of `180`), so refuse.
+ if (CUT_NUMBER_TAIL.test(text)) return undefined;
  return text + open.reverse().join("");
 }
 /**

package/src/tool-translation.ts

@@ -53,7 +53,17 @@ export const PI_TOOL_NAMES = [
  "ls",
 ] as const;
 
-/** OMP host built-ins: BUILTIN_TOOL_NAMES in reference/oh-my-pi packages/coding-agent/src/tools/builtin-names.ts plus browser/computer */
+/**
+ * OMP host built-ins: BUILTIN_TOOL_NAMES in
+ * reference/oh-my-pi/packages/coding-agent/src/tools/builtin-names.ts, plus
+ * browser/computer (real top-level tools in the same checkout) and `hub`.
+ *
+ * `find` here is OMP's semantic search (reference/oh-my-pi
+ * tools/jfind/index.ts:54), NOT Pi's file finder: they are different tools
+ * with different schemas, and both are declared together whenever the session
+ * enables it. That is why the translator renames `find` to `glob` only when the
+ * caller left the `glob` slot empty — see translateToolsForPath.
+ */
 export const OMP_TOOL_NAMES = [
  "read",
  "bash",
@@ -62,15 +72,20 @@ export const OMP_TOOL_NAMES = [
  "ast_edit",
  "ask",
  "debug",
+ "ida",
  "eval",
  "github",
  "glob",
  "grep",
+ "find",
  "lsp",
  "checkpoint",
  "rewind",
+ "context_notes",
+ "new_context",
  "security_scan",
  "task",
+ "wait",
  "hub",
  "todo",
  "web_search",
@@ -180,13 +195,20 @@ export const OMP_CALLER_MARKERS = ["ask", "task", "todo", "hub", "lsp"] as const
 
 /**
  * True when a lowercased caller-tool name set looks like OMP: any of
- * ask/task/todo/hub/lsp present, or glob present without find (Pi sends find,
- * OMP sends glob). Case-insensitive; pass already-lowercased names.
+ * ask/task/todo/hub/lsp present, or `glob` present at all.
+ *
+ * `glob` alone is the discriminator because Pi has no such tool (its file
+ * finder is `find`, reference/pi core/tools/index.ts:95) while OMP declares
+ * both. The old test was "glob without find", which assumed `find` was
+ * Pi-exclusive; OMP ships a semantic `find` too (reference/oh-my-pi
+ * tools/jfind/index.ts:54), so an OMP read-only session carrying glob+find was
+ * classified as Pi and its fingerprint slots came back as non-executable
+ * placeholders. Case-insensitive; pass already-lowercased names.
  */
 export function isOmpLikeCaller(lowerNames: Iterable<string>): boolean {
  const set = lowerNames instanceof Set ? lowerNames : new Set(lowerNames);
  for (const m of OMP_CALLER_MARKERS) if (set.has(m)) return true;
- return set.has("glob") && !set.has("find");
+ return set.has("glob");
 }
 
 export interface CanonicalTool {
@@ -385,8 +407,14 @@ export function sanitizeUpstreamToolName(name: string, taken: ReadonlySet<string
 }
 /** Inspect the original caller tools (pre-translate) for the rewrite cases. */
 export function buildFindGlobRestore(callerTools: unknown[]): FindGlobRestore {
-	let sawFind = false;
-	let sawGlob = false;
+	// Same rule as translateToolsForPath: the find->glob rename fires only when
+	// the caller left the `glob` slot empty. OMP declares both real tools, so
+	// there the rename must not happen and `find` must keep its own name.
+	const callerDeclaresGlob = callerTools.some((tool) => {
+		const canon = canonicalizeTool(tool);
+		return canon !== null && canon.name.trim().toLowerCase() === "glob";
+	});
+	const nameFor = (name: string): string => (callerDeclaresGlob ? name.trim() : upstreamToolNameFor(name));
 	const renamed: Record<string, string> = {};
 	// Same first-seen-wins order and case rules as translateToolsForPath, so
 	// the recorded map keys match the names that actually reach upstream.
@@ -395,25 +423,28 @@ export function buildFindGlobRestore(callerTools: unknown[]): FindGlobRestore {
 		const canon = canonicalizeTool(tool);
 		if (!canon) continue;
 		const callerName = canon.name;
-		if (isFindToolName(callerName)) sawFind = true;
-		else if (callerName.trim().toLowerCase() === "glob") sawGlob = true;
+		const upstreamName = nameFor(callerName);
 		// Mirrors translateToolsForPath: dedup on the lowercased
 		// pre-sanitization name (a collapsed duplicate never reaches upstream),
 		// then sanitize with the caller's casing intact.
-		const dedupKey = upstreamToolNameFor(callerName).toLowerCase();
+		const dedupKey = upstreamName.toLowerCase();
 		if (seen.has(dedupKey)) continue;
 		seen.add(dedupKey);
-		const sanitized = sanitizeUpstreamToolName(upstreamToolNameFor(callerName), seen);
+		const sanitized = sanitizeUpstreamToolName(upstreamName, seen);
 		if (sanitized.toLowerCase() !== dedupKey) seen.add(sanitized.toLowerCase());
 		// Only character-folding rewrites belong in the sanitized map. The
-		// find->glob rename is a collision case with its own flag: when the
-		// caller also sent `glob`, upstream `glob` really is the caller's glob,
-		// so recording it here would misroute a genuine call.
+		// find->glob rename is a single-name fallback, so a name that came in
+		// as `find` must not be recorded here: upstream `glob` may be the
+		// caller's own glob.
 		if (sanitized !== callerName && !isFindToolName(callerName)) {
 			renamed[sanitized.toLowerCase()] = callerName;
 		}
 	}
-	const restored: FindGlobRestore = { renamedFindToGlob: sawFind && !sawGlob, renamed };
+	const sawFind = callerTools.some((tool) => {
+		const canon = canonicalizeTool(tool);
+		return canon !== null && isFindToolName(canon.name);
+	});
+	const restored: FindGlobRestore = { renamedFindToGlob: sawFind && !callerDeclaresGlob, renamed };
 	return restored;
 }
 /**
@@ -489,22 +520,46 @@ function carryExtraFields(
  }
 }
 /**
- * Reshape a caller tool array for the target path. Tools already in the
- * target shape pass through verbatim (identical reference, every extra field
- * intact) except Pi `find`, which is renamed to `glob` even when the shape
- * already matches (new object, params/description verbatim). Function tools
- * in another shape are converted, carrying `description`/`parameters`/`strict`
- * verbatim plus every other top-level caller field except the
- * wire-shape-forbidden keys (`type`/`function` wrapper, `name`, `description`,
- * `parameters`/`input_schema`), which are remapped per target shape. Never
- * injects `additionalProperties`. Every other entry passes through verbatim.
- * Duplicates collapse first-seen-wins on the lowercased upstream name, so
- * `Bash` never duplicates `bash` and `find` collapses with `glob`.
- * Re-translating translated output adds zero tools. Never returns null entries.
+ * Reshape a caller tool array for the target path. Tools already in the target
+ * shape pass through verbatim (identical reference, every extra field intact).
+ * Function tools in another shape are converted, carrying
+ * `description`/`parameters`/`strict` verbatim plus every other top-level
+ * caller field except the wire-shape-forbidden keys (`type`/`function`
+ * wrapper, `name`, `description`, `parameters`/`input_schema`), which are
+ * remapped per target shape. Never injects `additionalProperties`. Every other
+ * entry passes through verbatim. Duplicates collapse first-seen-wins on the
+ * lowercased upstream name, so `Bash` never duplicates `bash`. Re-translating
+ * translated output adds zero tools. Never returns null entries.
  * `tool_choice` is never imposed here; use the retarget helpers to carry it.
+ *
+ * Names ride the caller's own unless `forFingerprint` is set — that flag exists
+ * for the OpenCode free tier alone, whose gate expects the sextet name `glob`
+ * and therefore needs Pi's `find` renamed into it. On every other lane the
+ * rename is pure loss: the upstream would have accepted `find`, and the host
+ * gets `find` back and dispatches it natively.
  */
-export function translateToolsForPath(tools: unknown[], pathname: string): Record<string, unknown>[] {
+export function translateToolsForPath(tools: unknown[], pathname: string, opts?: { forFingerprint?: boolean }): Record<string, unknown>[] {
  const api = apiForPathname(pathname);
+ // Only the OpenCode free tier needs a tool renamed: its gate looks for a
+ // sextet whose `glob` slot Pi's `find` can fill. Every other upstream accepts
+ // the caller's own names, so on those lanes the name rides verbatim in BOTH
+ // directions and the host dispatches it natively — nothing to translate, and
+ // nothing to restore.
+ //
+ // Even on the fingerprint lane the rename is skipped when the caller declared
+ // `glob` itself: OMP declares both `glob` (file patterns) and `find`
+ // (semantic search, reference/oh-my-pi tools/jfind/index.ts:54), and renaming
+ // there would collapse two real tools into one under the other's schema.
+ let callerDeclaresGlob = false;
+ for (const tool of tools) {
+  const canon = canonicalizeTool(tool);
+  if (canon && canon.name.trim().toLowerCase() === "glob") {
+   callerDeclaresGlob = true;
+   break;
+  }
+ }
+ const renameFind = opts?.forFingerprint === true && !callerDeclaresGlob;
+ const upstreamNameFor = (name: string): string => (renameFind ? upstreamToolNameFor(name) : name.trim());
  const seen = new Set<string>();
  const out: Record<string, unknown>[] = [];
  for (const tool of tools) {
@@ -517,15 +572,16 @@ export function translateToolsForPath(tools: unknown[], pathname: string): Recor
    continue;
   }
  // Duplicate collapse stays first-seen-wins on the lowercased upstream name
- // (`Bash` never duplicates `bash`, `find` collapses with `glob`) and runs on
- // the pre-sanitization name: the emitted name keeps the caller's casing, and
- // the sanitizer only ever folds characters the upstream shape forbids.
- const dedupKey = upstreamToolNameFor(canon.name).toLowerCase();
+ // (`Bash` never duplicates `bash`, a Pi `find` still collapses with `glob`)
+ // and runs on the pre-sanitization name: the emitted name keeps the caller's
+ // casing, and the sanitizer only ever folds characters the upstream shape
+ // forbids.
+ const dedupKey = upstreamNameFor(canon.name).toLowerCase();
  if (seen.has(dedupKey)) continue;
  seen.add(dedupKey);
  // The find->glob rename and the name sanitization share one upstream name,
  // so a caller tool needing either is emitted under a single new name.
- const upstreamName = sanitizeUpstreamToolName(upstreamToolNameFor(canon.name), seen);
+ const upstreamName = sanitizeUpstreamToolName(upstreamNameFor(canon.name), seen);
  if (upstreamName.toLowerCase() !== dedupKey) seen.add(upstreamName.toLowerCase());
  const needsRename = upstreamName !== canon.name;
  if (!needsRename && alreadyTargetShape(rec, api)) {
@@ -535,60 +591,17 @@ export function translateToolsForPath(tools: unknown[], pathname: string): Recor
  const renamed: CanonicalTool = needsRename
   ? { ...canon, name: upstreamName }
   : canon;
-  const converted =
-   api === "responses"
-    ? toResponsesTool(renamed)
-    : api === "messages"
-     ? toAnthropicTool(renamed)
-     : toChatTool(renamed);
-  carryExtraFields(rec, converted);
-  out.push(converted);
+ const converted =
+  api === "responses"
+   ? toResponsesTool(renamed)
+   : api === "messages"
+    ? toAnthropicTool(renamed)
+    : toChatTool(renamed);
+ carryExtraFields(rec, converted);
+ out.push(converted);
  }
  return out;
 }
-/**
- * Inject the missing fingerprint tools into an already-translated tool array,
- * using the target path's shape. Idempotent and case-insensitive: `Bash`
- * satisfies `bash` and is never duplicated.
- * OMP-like callers (explicit `ompLike`, else auto-detected from the array via
- * {@link isOmpLikeCaller}) get REAL minimal executable definitions from
- * {@link OMP_FINGERPRINT_DEFS}; everyone else (Pi) keeps the empty COMPAT
- * placeholders. `edit` is always the COMPAT placeholder, even for OMP-like
- * callers — no static edit def executes on either host, so it must stay
- * cloaked downstream. Re-injecting injected output adds zero tools.
- */
-export function injectFingerprintTools(
- tools: Record<string, unknown>[],
- pathname: string,
- ompLike?: boolean,
-): Record<string, unknown>[] {
- const present = new Set<string>();
- for (const tool of tools) {
-  const canon = canonicalizeTool(tool);
-  if (canon) present.add(canon.name.trim().toLowerCase());
- }
- const omp = ompLike ?? isOmpLikeCaller(present);
- const api = apiForPathname(pathname);
- for (const name of OPENCODE_FINGERPRINT_TOOLS) {
-  if (present.has(name.toLowerCase())) continue;
-  const def = omp && name !== "edit" ? OMP_FINGERPRINT_DEFS[name] : null;
-  const canon: CanonicalTool = {
-   name,
-   description: def ? def.description : COMPAT_TOOL_DESCRIPTION,
-   parameters: def ? { ...(def.parameters as Record<string, unknown>) } : { type: "object", properties: {} },
-  };
-  tools.push(
-   api === "responses"
-    ? toResponsesTool(canon)
-    : api === "messages"
-     ? toAnthropicTool(canon)
-     : toChatTool(canon),
-  );
-  present.add(name.toLowerCase());
- }
- return tools;
-}
-
 /**
  * Responses <-> Chat body translation. Cline serves chat completions only, so
  * the responses body is reshaped to chat before the Cline branch sends it,
@@ -675,7 +688,10 @@ export function chatBodyFromResponsesBody(body: Record<string, unknown>): Record
  out.messages = messages;
  if (Array.isArray(body.tools)) out.tools = translateToolsForPath(body.tools, "/v1/chat/completions");
  if (body.tool_choice !== undefined) out.tool_choice = body.tool_choice;
- for (const key of ["temperature", "top_p", "max_tokens", "max_completion_tokens", "stop", "presence_penalty", "frequency_penalty", "seed", "user", "parallel_tool_calls", "response_format"] as const) {
+ // `max_output_tokens` is the Responses-native cap and is what a host actually
+ // sets on this path; without it here the cap silently vanished on the
+ // chat-only lanes and the model answered at its own default length.
+ for (const key of ["temperature", "top_p", "max_tokens", "max_completion_tokens", "max_output_tokens", "stop", "presence_penalty", "frequency_penalty", "seed", "user", "parallel_tool_calls", "response_format"] as const) {
   if (body[key] !== undefined) out[key] = body[key];
  }
  return out;