@bitkyc08/opencodex 2.67.0 → 2.68.0

package/src/adapters/kiro-retry.ts

@@ -14,6 +14,7 @@ import {
   retryBackoffDelayMs,
   sleepWithAbort,
 } from "../lib/upstream-retry";
+import { releaseProviderRequestSlot, sendTrackingRequestSlot, type ProviderRequestSlot } from "../providers/request-pacing";
 
 const RESET_ATTEMPTS = 3;
 const RESET_RETRY_BASE_MS = 150;
@@ -29,6 +30,7 @@ const ENDPOINT_ERROR_MARKERS = [
   "unsupported endpoint",
 ];
 const CONNECT_ERROR_CODES = new Set(["ENOTFOUND", "EAI_AGAIN", "ECONNREFUSED", "ENETUNREACH", "EHOSTUNREACH"]);
+type KiroFetchContext = AdapterFetchContext & { allowGatewayRotation?: boolean };
 
 interface KiroThrottleProbe {
   token: symbol;
@@ -165,33 +167,54 @@ async function fetchWithResetRecovery(
   let lastError: unknown;
   for (let attempt = 0; attempt < RESET_ATTEMPTS; attempt++) {
     if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
-    // Every physical send is admitted, not just the adapter entry. Kiro nests a throttle loop
-    // over this ladder and can run the ladder twice per throttle round, so counting one entry
-    // as one send hid up to eighteen upstream requests from the per-request cap (#4546).
-    const decision = ctx.sendBudget?.reserveDispatch({ sendClass: "transient", targetKey: url });
-    if (decision && (!decision.allowed || !decision.permit.use())) {
-      throw new SendBudgetExhaustedError(url);
-    }
-    // Reported after admission and before dispatch, so a refused send is never counted and an
-    // admitted one is counted exactly once whichever way the fetch below settles.
-    notePhysicalSend(attempt > 0);
+    const executor = (ctx.executor ?? globalThis.fetch) as typeof globalThis.fetch & {
+      waitForPacing?: (signal?: AbortSignal) => Promise<ProviderRequestSlot | void>;
+      unpacedFetch?: typeof globalThis.fetch;
+    };
+    const slot = (await executor.waitForPacing?.(ctx.abortSignal)) || undefined;
     try {
-      const headers = new Headers(request.headers);
-      const recovered = attempt > 0;
-      if (recovered) headers.set("connection", "close");
-      return await fetchWithAttemptDeadline(url, {
-        method: request.method,
-        headers,
-        body: request.body,
-        ...(recovered ? { keepalive: false } : {}),
-      }, timeoutMs, ctx.abortSignal, ctx.stream);
-    } catch (error) {
-      if (ctx.abortSignal?.aborted || !isConnectionResetError(error) || attempt === RESET_ATTEMPTS - 1) throw error;
-      lastError = error;
-      await sleepWithAbort(retryBackoffDelayMs(attempt, {
-        baseDelayMs: RESET_RETRY_BASE_MS,
-        maxDelayMs: RESET_RETRY_MAX_MS,
-      }), ctx.abortSignal);
+      if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
+      // Every physical send is admitted, not just the adapter entry. Kiro nests a throttle loop
+      // over this ladder and can run the ladder twice per throttle round, so counting one entry
+      // as one send hid up to eighteen upstream requests from the per-request cap (#4546).
+      const decision = ctx.sendBudget?.reserveDispatch({ sendClass: "transient", targetKey: url });
+      if (decision && (!decision.allowed || !decision.permit.use())) {
+        throw new SendBudgetExhaustedError(url);
+      }
+      // Reported after admission and before dispatch, so a refused send is never counted and an
+      // admitted one is counted exactly once whichever way the fetch below settles.
+      notePhysicalSend(attempt > 0);
+      try {
+        const headers = new Headers(request.headers);
+        const recovered = attempt > 0;
+        if (recovered) headers.set("connection", "close");
+        return await sendTrackingRequestSlot(slot, () => fetchWithAttemptDeadline(url, {
+          method: request.method,
+          headers,
+          body: request.body,
+          ...(recovered ? { keepalive: false } : {}),
+        }, timeoutMs, ctx.abortSignal, ctx.stream, (async (input, init) => {
+          try {
+            return await (executor.unpacedFetch ?? executor)(input, init);
+          } catch (error) {
+            if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
+            const signal = init?.signal;
+            if (signal?.aborted && signal.reason instanceof Error && signal.reason.name === "TimeoutError") {
+              throw signal.reason;
+            }
+            throw error;
+          }
+        }) as typeof globalThis.fetch));
+      } catch (error) {
+        if (ctx.abortSignal?.aborted || !isConnectionResetError(error) || attempt === RESET_ATTEMPTS - 1) throw error;
+        lastError = error;
+        await sleepWithAbort(retryBackoffDelayMs(attempt, {
+          baseDelayMs: RESET_RETRY_BASE_MS,
+          maxDelayMs: RESET_RETRY_MAX_MS,
+        }), ctx.abortSignal);
+      }
+    } finally {
+      releaseProviderRequestSlot(slot);
     }
   }
   throw lastError ?? new Error("Kiro fetch failed");
@@ -217,7 +240,7 @@ async function inspectEndpointHttpFailure(
   return { response: rebuilt, fallback: ENDPOINT_ERROR_MARKERS.some(marker => text.includes(marker)) };
 }
 
-async function normalizeFinalKiroHttpError(res: Response, signal?: AbortSignal): Promise<Response> {
+export async function normalizeFinalKiroHttpError(res: Response, signal?: AbortSignal): Promise<Response> {
   return normalizeUpstreamHttpErrorResponse(res, {
     signal,
     formatMessage: payloadText => safeKiroHttpErrorMessage(res.status, res.headers, payloadText),
@@ -255,19 +278,28 @@ async function inspectKiroThrottle(
 
 async function fetchKiroAttempt(
   request: AdapterRequest,
-  ctx: AdapterFetchContext,
+  ctx: KiroFetchContext,
   timeoutMs: number,
   notePhysicalSend: (reset: boolean) => void,
 ): Promise<Response> {
-  const legacy = legacyUrl(request.url);
+  const plannedUrl = request.url;
+  const legacy = legacyUrl(plannedUrl);
   let response: Response;
   try {
-    response = await fetchWithResetRecovery(request, request.url, ctx, timeoutMs, notePhysicalSend);
+    response = await fetchWithResetRecovery(request, plannedUrl, ctx, timeoutMs, notePhysicalSend);
   } catch (error) {
     if (!legacy || !endpointConnectFailure(error)) throw error;
     return fetchWithResetRecovery(request, legacy, ctx, timeoutMs, notePhysicalSend);
   }
 
+  if (!response.ok && (response.status === 502 || response.status === 503 || response.status === 504)) {
+    const baseUrl = response.url || request.url || plannedUrl;
+    const alternate = ctx.allowGatewayRotation === false ? undefined : legacyUrl(baseUrl);
+    if (alternate) {
+      cancelResponseBodyBestEffort(response);
+      return fetchWithResetRecovery(request, alternate, ctx, timeoutMs, notePhysicalSend);
+    }
+  }
   if (legacy && !response.ok) {
     const inspected = await inspectEndpointHttpFailure(response, ctx.abortSignal);
     response = inspected.response;
@@ -284,7 +316,7 @@ async function fetchKiroAttempt(
  * throttle recovery. The shared probe starts only after a 429, so healthy parallel traffic remains
  * parallel while a throttled account cannot burn every caller's independent retry budget (#532).
  */
-export async function fetchKiroWithRetry(request: AdapterRequest, ctx: AdapterFetchContext = {}): Promise<Response> {
+export async function fetchKiroWithRetry(request: AdapterRequest, ctx: KiroFetchContext = {}): Promise<Response> {
   const timeoutMs = ctx.timeoutMs ?? 200_000;
   let probeToken: symbol | undefined;
   // One ordinal sequence for the whole call, across the throttle loop, the endpoint fallback
@@ -307,6 +339,10 @@ export async function fetchKiroWithRetry(request: AdapterRequest, ctx: AdapterFe
 
       const response = await fetchKiroAttempt(request, ctx, timeoutMs, notePhysicalSend);
       const throttle = await inspectKiroThrottle(response, ctx.abortSignal);
+      if (throttle && ctx.kiroPreferAccountFailover) {
+        releaseKiroThrottleProbe(probeToken);
+        return throttle.response;
+      }
       if (!throttle || !throttle.transient) {
         releaseKiroThrottleProbe(probeToken);
         const finalResponse = throttle?.response ?? response;
@@ -334,6 +370,10 @@ export async function fetchKiroWithRetry(request: AdapterRequest, ctx: AdapterFe
     throw new Error("Kiro throttle retry loop exhausted without a response");
   } catch (error) {
     releaseKiroThrottleProbe(probeToken);
+    if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
+    if (error instanceof Error && error.name === "TimeoutError") {
+      return new Response("Kiro upstream gateway timeout", { status: 504 });
+    }
     throw error;
   }
 }

package/src/adapters/openai-chat/deepseek-artifact-schema.ts

@@ -0,0 +1,45 @@
+import type { OcxProviderConfig } from "../../types";
+
+export function isDeepseekArtifactTarget(provider: OcxProviderConfig, name: string, namespace?: string): boolean {
+  if (name !== "Artifact" || namespace) return false;
+  try {
+    return new URL(provider.baseUrl).hostname === "api.deepseek.com";
+  } catch {
+    return false;
+  }
+}
+
+const NAME_BAGS = new Set(["properties", "$defs", "definitions", "patternProperties", "dependentSchemas"]);
+const SCHEMA_CHILDREN = new Set(["items", "additionalProperties", "additionalItems", "allOf", "oneOf", "not", "if", "then", "else", "contains", "propertyNames", "prefixItems", "unevaluatedItems", "unevaluatedProperties"]);
+
+/** DeepSeek rejects Artifact regex/union constraints. Relax them only on this built-in tool.
+ * Walk schema positions, preserving property names and literal defaults/examples verbatim.
+ * An explicit stack avoids recursion on caller-controlled schema nesting.
+ */
+export function relaxDeepseekArtifactSchema(schema: unknown): unknown {
+  let result: unknown;
+  const pending: Array<{ value: unknown; names?: boolean; assign: (value: unknown) => void }> = [
+    { value: schema, assign: value => { result = value; } },
+  ];
+  while (pending.length) {
+    const { value, names, assign } = pending.pop()!;
+    if (!value || typeof value !== "object") { assign(value); continue; }
+    if (Array.isArray(value)) {
+      const out: unknown[] = new Array(value.length);
+      assign(out);
+      value.forEach((child, index) => pending.push({ value: child, assign: next => { out[index] = next; } }));
+      continue;
+    }
+    const out: Record<string, unknown> = Object.create(null);
+    assign(out);
+    for (const [key, child] of Object.entries(value)) {
+      if (!names && (key === "pattern" || key === "anyOf")) continue;
+      if (names || NAME_BAGS.has(key) || SCHEMA_CHILDREN.has(key)) {
+        pending.push({ value: child, names: !names && NAME_BAGS.has(key), assign: next => { out[key] = next; } });
+      } else {
+        out[key] = child;
+      }
+    }
+  }
+  return result;
+}

package/src/adapters/openai-chat/messages.ts

@@ -7,6 +7,7 @@ import { EMPTY_TOOL_OUTPUT_ANNOTATION, isWhitespaceOnlyTextPartArray } from "../
 import { identifyRoutedModel } from "../identity";
 import { buildNonOpenAIToolCatalogNudgeForTools, shouldInjectNonOpenAIToolCatalogNudge } from "../tool-catalog-nudge";
 import { peekReasoningForCall } from "../../responses/reasoning-replay-cache";
+import type { ClaudeThinkingProjection } from "../../lib/claude-request-projection";
 import { inlineDocumentDataUrl } from "../../responses/inline-document";
 import type { OcxAssistantMessage, OcxContentPart, OcxParsedRequest, OcxProviderConfig, OcxTextContent, OcxThinkingContent, OcxToolCall } from "../../types";
 import { modelInList, namespacedToolName } from "../../types";
@@ -61,10 +62,36 @@ export function toolResultImageChatParts(content: string | OcxContentPart[]): un
   return parts;
 }
 
+/**
+ * Whether this wire serializes a replayed thinking block for the given model.
+ *
+ * The single source of truth for that question on the Chat wire: the assistant branch below uses
+ * it to decide `reasoning_content`, and the Messages ingress uses it to decide how much of a
+ * prompt is worth counting. Two copies of this rule would drift, and the count would then
+ * describe a body this adapter does not send.
+ */
+export function openAIChatSerializesThinking(
+  provider: OcxProviderConfig,
+  modelId: string,
+): ClaudeThinkingProjection {
+  return {
+    text: modelInList(provider.preserveReasoningContentModels, modelId),
+    // The wire has no `signature` field — base64 replay tokens are Anthropic-wire-only.
+    signature: false,
+    // A `redacted_thinking` block is opaque provider data with no Chat representation: the
+    // assistant branch below reads only `type: "thinking"` parts, so the encrypted form is
+    // dropped whatever the preserve list says.
+    redacted: false,
+  };
+}
+
 export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderConfig): unknown[] {
   const out: unknown[] = [];
   const { context, options } = parsed;
   const replayCacheScope = parsed._reasoningReplayScope;
+  // One question, one answer for the whole conversion: does this wire carry replayed thinking
+  // back for this model? Asked once so a long history cannot pay for it per message.
+  const wireSerializesThinking = openAIChatSerializesThinking(provider, parsed.modelId).text;
 
   interface PendingToolCall { id: string; name: string }
   let pendingToolCalls: PendingToolCall[] = [];
@@ -225,7 +252,7 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
         if (
           reasoningContent.length === 0
           && (toolCalls.length > 0 || thinkingParts.length > 0)
-          && modelInList(provider.preserveReasoningContentModels, parsed.modelId)
+          && wireSerializesThinking
         ) {
           const cached = toolCalls
             .map(tc => (tc.id ? peekReasoningForCall(tc.id, replayCacheScope) : undefined))
@@ -248,7 +275,7 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
             reasoningContent = " ";
           }
         }
-        if (reasoningContent.length > 0 && modelInList(provider.preserveReasoningContentModels, parsed.modelId)) {
+        if (reasoningContent.length > 0 && wireSerializesThinking) {
           // MiniMax's interleaved-thinking contract requires the structured
           // reasoning_details array back on the next turn; a reasoning_content
           // string is the native-format pass-back the docs mark unsupported.
@@ -302,7 +329,7 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
           flushPendingToolCalls();
           const name = safeToolName(msg.toolName);
           const cachedReasoning =
-            toolCallId && modelInList(provider.preserveReasoningContentModels, parsed.modelId)
+            toolCallId && wireSerializesThinking
               ? peekReasoningForCall(toolCallId, replayCacheScope)
               : undefined;
           // Same fallback as the main-assistant path: never emit a bare orphan
@@ -316,7 +343,7 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
           // falsy hit as a miss so the placeholder still fires.
           const orphanReasoning =
             cachedReasoning
-            || (modelInList(provider.preserveReasoningContentModels, parsed.modelId)
+            || (wireSerializesThinking
               && modelInList(provider.requiresReasoningPlaceholderModels ?? provider.preserveReasoningContentModels, parsed.modelId)
               ? " "
               : undefined);

package/src/adapters/openai-chat/serialized-tool-call-content.ts

@@ -46,6 +46,7 @@ export interface StructuredToolCallReference {
   names: ReadonlySet<string>;
   argumentsText: string;
   freeformTool?: FreeformToolIdentity;
+  recoveredParameterWrapper?: boolean;
 }
 
 const BLOCK_HEADER = /<tool_call>\s*<function=([^>\r\n]+)>/y;
@@ -222,6 +223,7 @@ function deferredContinuationBreak(text: string, context: TextContext): RegExp |
  * original order.
  */
 export class SerializedToolCallContentBuffer {
+  releasedAnswerText = false;
   private text = "";
   private bytes = 0;
   private hasOpenTag = false;
@@ -235,6 +237,12 @@ export class SerializedToolCallContentBuffer {
 
   constructor(private readonly budget: TranslatorBudget) {}
 
+  /** Remembers visible text released before a later structured call can be reconciled. */
+  private observeText(events: AdapterEvent[]): AdapterEvent[] {
+    if (events.some(event => event.type === "text_delta" && event.text.trim() !== "")) this.releasedAnswerText = true;
+    return events;
+  }
+
   /** Measures an append exactly even when the runtime prices isolated UTF-16 surrogates differently. */
   private appendedByteLength(delta: string): number {
     let bytes = Buffer.byteLength(delta);
@@ -324,16 +332,16 @@ export class SerializedToolCallContentBuffer {
       // A delta that alone passes the bound is delivered as text rather than retained.
       if (Buffer.byteLength(delta) > MAX_HELD_BYTES) {
         this.context = contextAfter(delta, this.context);
-        return [...released, ...textEvents(delta)];
+        return this.observeText([...released, ...textEvents(delta)]);
       }
-      return [...released, ...textEvents(this.ingest(delta))];
+      return this.observeText([...released, ...textEvents(this.ingest(delta))]);
     }
     const text = this.ingest(delta);
     // Checked after ingest too: one delta can open a block and already carry more than a bound.
     if (this.hasOpenTag && (this.bytes > MAX_HELD_BYTES || (this.sawCloser && !this.openAfterCloser && this.trailingProseChars > MAX_TRAILING_CHARS))) {
-      return [...textEvents(text), ...this.drain([])];
+      return this.observeText([...textEvents(text), ...this.drain([])]);
     }
-    return textEvents(text);
+    return this.observeText(textEvents(text));
   }
 
   /** Exposes held text as evidence for narrowly repairing duplicated argument prefixes. */
@@ -386,7 +394,7 @@ export class SerializedToolCallContentBuffer {
     this.context = contextAfter(this.text, this.context);
     this.queued = [];
     this.replace("", false);
-    return out;
+    return this.observeText(out);
   }
 
   /** Text-only drain for callers that never queued an event. */
@@ -475,7 +483,10 @@ function duplicatedSerializedToolCallRanges(
     const body = freeformBody(call.body);
     return structuredCalls.some(structured => {
       const input = structured.names.has(call.name) ? inputFromArguments(structured.argumentsText, structured.freeformTool) : undefined;
-      return input !== undefined && freeformBody(input) === body;
+      if (input === undefined) return false;
+      const normalized = freeformBody(input);
+      return normalized === body || (structured.recoveredParameterWrapper === true
+        && body.startsWith("<parameter=") && normalized === freeformBody(body.slice("<parameter=".length)));
     });
   });
 }
@@ -578,14 +589,48 @@ export interface StructuredToolCallInput {
 export function reconcileStructuredToolCalls(
   calls: readonly StructuredToolCallInput[],
   serializedText: string,
+  recoverEmptyMiMoFreeformInput = false,
 ): StructuredToolCallReference[] {
-  const references = calls.map(call => {
+  const references: StructuredToolCallReference[] = calls.map(call => {
     const names = new Set([call.wireName, call.restoredName]);
     return { names, freeformTool: call.freeformTool, argumentsText: repairArgumentsDuplicatedBesideSerializedCall(call.argumentsText, names, serializedText) };
   });
+  if (recoverEmptyMiMoFreeformInput && calls.length === 1 && calls[0]!.freeformTool
+      && emptyObjectArguments(references[0]!.argumentsText)) {
+    // A standalone MiMo block and one empty call to the exact wire tool provide the only
+    // unambiguous recovery shape. Prose before/after it or another call keeps text inert.
+    const blocks = callsIn(serializedText);
+    if (blocks.length === 1 && serializedText.slice(0, blocks[0]!.start).trim() === ""
+        && serializedText.slice(blocks[0]!.end).trim() === "") {
+      const block = blocks[0]!;
+      const wrappedBody = freeformBody(block.body);
+      // MiMo can put the freeform input after a malformed `<parameter=` opener.
+      const hasParameterOpener = wrappedBody.startsWith("<parameter=");
+      const body = hasParameterOpener
+        ? freeformBody(wrappedBody.slice("<parameter=".length)) : wrappedBody;
+      if (block.name === calls[0]!.wireName && body.trim() !== ""
+          && !/(?:^|\n)<tool_call>\s*<function=[^>\r\n]+>/.test(block.body)
+          && !(hasParameterOpener && /^<parameter=[A-Za-z_$][\w$.-]*>/.test(wrappedBody))
+          && !body.includes("<parameter=") && !body.includes("</parameter>")) {
+        references[0] = { ...references[0]!, argumentsText: JSON.stringify({ input: body }),
+          recoveredParameterWrapper: hasParameterOpener };
+      }
+    }
+  }
   return reduceUnambiguousDoubledInput(references, serializedText);
 }
 
+/** An empty JSON object means the structured freeform call supplied no input. */
+function emptyObjectArguments(text: string): boolean {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
+      && Object.keys(parsed).length === 0;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Applies the doubled-input reduction across the batch. The doubled shape is valid JSON, so the
  * prefix repair returns it untouched, and the reduction only ever rewrites a call the repair left

package/src/adapters/openai-chat/tool-call-id-remint.ts

@@ -0,0 +1,65 @@
+import { isConformingToolCallId, MAX_TOOL_CALL_ID_LENGTH } from "../tool-call-id";
+import type { OcxMessage } from "../../types";
+
+/**
+ * Remint a tool-call id the client's history already carries.
+ *
+ * Some upstreams mint tool-call ids deterministically per RESPONSE rather than per call: the same
+ * `call-0-0` on every turn of a conversation. Anthropic's wire requires `tool_use.id` to identify
+ * one call, and a client that has already stored that id for an earlier call cannot pair the new
+ * result to the new call — it drops one of them, the turn becomes an assistant message whose
+ * tool call has no result, and the model re-issues the same call forever.
+ *
+ * The first occurrence of an id is emitted byte-identical, so prompt-cache keys, reasoning-replay
+ * lookups, and every upstream that already mints unique ids stay untouched. Only a repeat — against
+ * the history the caller seeded, or against a call already emitted in this response — is rewritten,
+ * to the smallest unused suffix that still fits Anthropic's id bound.
+ */
+export function createToolCallIdReminter(reservedIds: Iterable<string>): (rawId: string) => string {
+  const occupied = new Set(reservedIds);
+  return rawId => {
+    if (!occupied.has(rawId)) {
+      occupied.add(rawId);
+      return rawId;
+    }
+    // A non-conforming source is sanitized, never dropped: the wire still needs an id, and the
+    // occupied check below covers a sanitized form that now equals some other call's id.
+    const base = isConformingToolCallId(rawId) ? rawId : rawId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    for (let n = 2; ; n++) {
+      // Hyphen, not underscore: an id that extends another id as `<earlier>_<digits>` is parsed by
+      // at least one client as a batch sub-call of `<earlier>`, which pairs the second call's
+      // result to the first call. A `-<n>` suffix is in the same id family without that reading.
+      const suffix = `-${n}`;
+      const candidate = base.slice(0, Math.max(1, MAX_TOOL_CALL_ID_LENGTH - suffix.length)) + suffix;
+      if (!occupied.has(candidate)) {
+        occupied.add(candidate);
+        return candidate;
+      }
+    }
+  };
+}
+
+/**
+ * Tool-call ids the client's own history has already fixed: every assistant tool call it kept, plus
+ * every tool result that answered one. A response repeating any of them is the collision this
+ * module exists for.
+ *
+ * Read from the client's history rather than from earlier responses because the client is the
+ * authority on uniqueness here: it is the side that drops duplicates, so the proxy cannot observe
+ * the ids it discarded — a dropped id only ever exists as the absence it caused. A Messages client
+ * sends the whole conversation on every turn, which is why one turn's history is a complete picture
+ * of the ids that may not be reused.
+ */
+export function reservedToolCallIdsFromHistory(messages: readonly OcxMessage[]): Set<string> {
+  const ids = new Set<string>();
+  for (const message of messages) {
+    if (message.role === "assistant") {
+      for (const part of message.content) {
+        if (part.type === "toolCall") ids.add(part.id);
+      }
+      continue;
+    }
+    if (message.role === "toolResult") ids.add(message.toolCallId);
+  }
+  return ids;
+}

package/src/adapters/openai-chat/tool-schema.ts

@@ -1,3 +1,4 @@
+import { isDeepseekArtifactTarget, relaxDeepseekArtifactSchema } from "./deepseek-artifact-schema";
 import { isNativeOpenAIChatTarget } from "./wire";
 import { createOpenAIChatToolNameRegistry, type OpenAIChatToolNameRegistry } from "./tool-name-registry";
 import { isXaiSchemaTarget, lookupLocalJsonPointer, normalizeXaiToolParameters } from "../xai-tool-schema";
@@ -548,7 +549,10 @@ export function toolsToChatFormat(
       : moonshotTarget
         ? normalizeMoonshotToolParameters(t.parameters, moonshotInlineByteBudget)
         : ensureRootObjectType(t.parameters);
-    const parameters = stripUnicodePropertyPatterns(stripResponsesOnlyEncryptedMarker(normalized));
+    const deepseekArtifact = isDeepseekArtifactTarget(provider, t.name, t.namespace);
+    const parameters = stripUnicodePropertyPatterns(stripResponsesOnlyEncryptedMarker(
+      deepseekArtifact ? relaxDeepseekArtifactSchema(normalized) : normalized,
+    ));
 
     if (parameters === undefined) return [];
     return [{
@@ -557,7 +561,7 @@ export function toolsToChatFormat(
         name: registry.alias(t),
         ...(t.description ? { description: t.description } : {}),
         parameters,
-        ...(t.strict !== undefined ? { strict: t.strict } : {}),
+        ...(t.strict !== undefined && !deepseekArtifact ? { strict: t.strict } : {}),
       },
     }];
   });

package/src/adapters/openai-chat.ts

@@ -340,7 +340,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           }
         }
         // Held markup is released only now, as one batch per response: the doubled-input repair needs every call.
-        const references = reconcileStructuredToolCalls(calls.map(call => ({ wireName: call.name, restoredName: toolNames.restore(call.name), argumentsText: call.args, freeformTool: freeformTools.get(call.name) })), toolCallContent.current());
+        const references = reconcileStructuredToolCalls(calls.map(call => ({ wireName: call.name, restoredName: toolNames.restore(call.name), argumentsText: call.args, freeformTool: freeformTools.get(call.name) })), toolCallContent.current(), !toolCallContent.releasedAnswerText && /(?:^|[/-])mimo-v2(?:\.|$)/i.test(lastRequestedModelId ?? ""));
         calls.forEach((call, index) => { call.args = references[index]!.argumentsText; });
         yield* toolCallContent.drain(references);
         for (const call of calls) {
@@ -803,7 +803,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
             events.push({ type: "tool_call_start", id, name: toolNames.restore(name) }, delta, { type: "tool_call_end" });
           }
         }
-        const references = reconcileStructuredToolCalls(structuredCalls, answerText);
+        const references = reconcileStructuredToolCalls(structuredCalls, answerText, /(?:^|[/-])mimo-v2(?:\.|$)/i.test(lastRequestedModelId ?? ""));
         structuredCalls.forEach((call, index) => { call.delta.arguments = references[index]!.argumentsText; });
         reconcileSerializedToolCallEvents(events, contentStart, contentEnd, references, budget);
         const stopReason = stopReasonFor(choice.finish_reason);

package/src/adapters/openai-responses/muse-tool-choice.ts

@@ -0,0 +1,31 @@
+import { isPlainObject } from "./internal";
+
+export class MuseToolChoiceCompatibilityError extends Error {
+  constructor() {
+    super("This tool_choice cannot be preserved for Meta Responses; use auto or none.");
+    this.name = "MuseToolChoiceCompatibilityError";
+  }
+}
+
+function selectorKind(choice: unknown): "auto" | "none" {
+  if (choice === undefined || choice === "auto") return "auto";
+  if (choice === "none") return "none";
+  throw new MuseToolChoiceCompatibilityError();
+}
+
+export function normalizeMuseToolChoice(body: unknown, originalChoice: unknown): unknown {
+  const originalKind = selectorKind(originalChoice);
+  const effectiveKind = selectorKind(isPlainObject(body) ? body.tool_choice : undefined);
+  if (originalKind !== "none" && effectiveKind !== "none") return body;
+  if (!isPlainObject(body)) return body;
+
+  const input = Array.isArray(body.input)
+    ? body.input.filter(item => !isPlainObject(item) || item.type !== "additional_tools")
+    : body.input;
+  const {
+    tool_choice: _toolChoice,
+    parallel_tool_calls: _parallelToolCalls,
+    ...rest
+  } = body;
+  return { ...rest, tools: [], ...(input !== body.input ? { input } : {}) };
+}

package/src/adapters/openai-responses/passthrough.ts

@@ -44,6 +44,7 @@ import { applyTierDecisionToResponsesBody, normalizeCanonicalForwardContinuation
 import { normalizeImageGenClientTools, preferConfiguredHostedTools } from "./image-gen";
 import { stripMuseSparkUnsupportedWebSearchFields, stripOpenAiOnlyWebSearchFields } from "./web-search";
 import { observeOutbound } from "../../usage/cache-diagnostic";
+import { normalizeMuseToolChoice } from "./muse-tool-choice";
 
 /**
  * Identifies DeepSeek's strict Responses replay contract: tool-bearing continuations need
@@ -411,8 +412,9 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         outBody = rewritten.body;
         convertedRoutedNamespaceToolAliases = rewritten.aliases;
         // Preserve xAI's cached-only fail-closed semantics and image-search mapping before the
-        // generic capability fallback removes the private OpenAI fields.
-        outBody = normalizeXaiResponsesWebSearch(outBody, provider);
+        // generic capability fallback removes the private OpenAI fields. Grok relayed through
+        // OpenCode Go speaks the same dialect, which the final model id and URL identify.
+        outBody = normalizeXaiResponsesWebSearch(outBody, provider, { modelId: parsed.modelId, responseUrl: url });
         outBody = injectXaiResponsesXSearch(outBody, provider, parsed._replayPrefixLen);
         // xAI and explicitly classified compatible gateways reject these OpenAI web_search
         // extensions. Keep them for OpenAI API-key traffic and unclassified gateways.
@@ -494,7 +496,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         parsed.modelId,
       );
       // Normalize the wire model before deriving model-dependent transport metadata.
-      const finalBody =
+      let finalBody =
         provider.modelSuffixBracketStrip
           && unnormalizedBody !== null
           && typeof unnormalizedBody === "object"
@@ -502,6 +504,10 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
           && typeof (unnormalizedBody as { model?: unknown }).model === "string"
           ? { ...(unnormalizedBody as Record<string, unknown>), model: stripBracketedModelSuffix((unnormalizedBody as { model: string }).model) }
           : unnormalizedBody;
+      if (isMetaAiResponsesDestination(url)) {
+        const originalChoice = isPlainObject(parsed._rawBody) ? parsed._rawBody.tool_choice : undefined;
+        finalBody = normalizeMuseToolChoice(finalBody, originalChoice);
+      }
       if (isCanonicalOpenAiForwardProvider(provider)) {
         const routingHeaders = new Headers(headers);
         applyCodexRoutingHint(routingHeaders, finalBody);

package/src/adapters/opencode-go-additional-tools.ts

@@ -2,22 +2,31 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
+/**
+ * True only for the exact OpenCode Go Responses resource. Lookalike hosts, other Zen paths,
+ * credentials, queries, fragments and unparsable URLs are all excluded, so a custom provider
+ * that merely resembles Go never inherits a Go-specific body rewrite.
+ */
+export function isOpenCodeGoResponsesUrl(responseUrl: string): boolean {
+  let destination: URL;
+  try {
+    destination = new URL(responseUrl);
+  } catch {
+    return false;
+  }
+  return destination.origin === "https://opencode.ai"
+    && destination.pathname === "/zen/go/v1/responses"
+    && !destination.username && !destination.password
+    && !destination.href.includes("?") && !destination.href.includes("#");
+}
+
 /** Console Go accepts public tools but rejects the private additional_tools input wrapper. */
 export function normalizeOpenCodeGoAdditionalTools(
   body: unknown,
   responseUrl: string,
   replayPrefixLength = 0,
 ): unknown {
-  let destination: URL;
-  try {
-    destination = new URL(responseUrl);
-  } catch {
-    return body;
-  }
-  if (destination.origin !== "https://opencode.ai"
-    || destination.pathname !== "/zen/go/v1/responses"
-    || destination.username || destination.password
-    || destination.href.includes("?") || destination.href.includes("#")) return body;
+  if (!isOpenCodeGoResponsesUrl(responseUrl)) return body;
   if (!isRecord(body) || !Array.isArray(body.input)) return body;
   // Do not replace a malformed top-level catalog with a partial promoted one.
   if (body.tools !== undefined && !Array.isArray(body.tools)) return body;