@bitkyc08/opencodex 2.64.0 → 2.65.0

package/src/adapters/openai-chat.ts

@@ -45,6 +45,7 @@ import { messagesToChatFormat } from "./openai-chat/messages";
 import { withOpenAIChatToolNames } from "./openai-chat/tool-name-registry";
 import { openAIChatTransport, stripBracketedModelSuffix } from "./openai-chat/wire";
 import { toolChoiceToChatFormat, toolsToChatFormatForProvider } from "./openai-chat/tool-schema";
+import { reconcileSerializedToolCallEvents, reconcileStructuredToolCall, reconcileStructuredToolCalls, SerializedToolCallContentBuffer } from "./openai-chat/serialized-tool-call-content";
 
 export { stripBracketedModelSuffix } from "./openai-chat/wire";
 export { buildOpenAIChatPassthroughRequest } from "./openai-chat/passthrough";
@@ -143,7 +144,9 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         if (parsed.options.topP !== undefined && !modelInList(provider.noTopPModels, parsed.modelId)) {
           body.top_p = parsed.options.topP;
         }
-        if (parsed.options.stopSequences !== undefined) body.stop = parsed.options.stopSequences;
+        if (parsed.options.stopSequences !== undefined && !modelInList(provider.noStopModels, parsed.modelId)) {
+          body.stop = parsed.options.stopSequences;
+        }
         const reasoningDisabled = modelInList(provider.noReasoningModels, parsed.modelId);
         const reasoningEffort = mapReasoningEffort(provider, parsed.modelId, parsed.options.reasoning);
         const explicitReasoning = applyExplicitChatReasoningWirePolicy({
@@ -299,6 +302,8 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         sawArgumentsString: boolean;
       }
       const pendingToolCalls: PendingToolCall[] = [];
+      const toolCallContent = new SerializedToolCallContentBuffer(budget);
+      const heldText = (): AdapterEvent[] => toolCallContent.drain([]);
       let toolCallSeq = 0;
       const closeToolCalls = (): PendingToolCall[] => {
         const calls = [...pendingToolCalls];
@@ -310,7 +315,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         pendingToolCalls.length > 0 && pendingToolCalls.every(call => {
           if (call.name.trim().length === 0 || !call.sawArgumentsString || call.args.length === 0) return false;
           try {
-            const parsed = JSON.parse(call.args) as unknown;
+            const parsed = JSON.parse(reconcileStructuredToolCall(call.name, toolNames.restore(call.name), call.args, toolCallContent.current()).argumentsText) as unknown;
             return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
           } catch {
             return false;
@@ -320,7 +325,8 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       // stops the turn instead of emitting an unusable call. `closeToolCalls()` runs first,
       // so budget reservations are released for every pending call even on the early return.
       const flushToolCalls = function* (): Generator<AdapterEvent, "continue" | "terminate"> {
-        for (const call of closeToolCalls()) {
+        const calls = closeToolCalls();
+        for (const call of calls) {
           // Ingest already proved `name` is a string; the typeof guard keeps this branch
           // total so a future ingest change cannot turn a malformed name into a throw.
           if (typeof call.name !== "string" || call.name.trim().length === 0) {
@@ -328,9 +334,14 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
               hadId: call.id.length > 0,
               argsBytes: call.argsBytes,
             });
-            yield unnamedToolCallEvent(pendingUsage);
-            return "terminate";
+            return yield* terminateWithError(unnamedToolCallEvent(pendingUsage));
           }
+        }
+        // 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 })), toolCallContent.current());
+        calls.forEach((call, index) => { call.args = references[index]!.argumentsText; });
+        yield* toolCallContent.drain(references);
+        for (const call of calls) {
           if (!call.id) call.id = `call_${++toolCallSeq}`;
           yield { type: "tool_call_start", id: call.id, name: toolNames.restore(call.name) };
           if (call.args.length > 0) yield { type: "tool_call_delta", arguments: call.args };
@@ -342,6 +353,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         event: Extract<AdapterEvent, { type: "error" }>,
       ): Generator<AdapterEvent, "terminate"> {
         closeToolCalls();
+        yield* heldText(); // Pending tools are not dispatched, so held text stays visible.
         yield event;
         return "terminate";
       };
@@ -360,7 +372,13 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       // <think> blocks, which would otherwise render as the answer. Passthrough unless opted in.
       const inlineThink = createInlineThinkContentSplitter(provider.inlineThinkTagModels, lastRequestedModelId, budget);
       const emitContent = function* (events: AdapterEvent[]): Generator<AdapterEvent> {
-        for (const event of events) { if (event.type === "text_delta") sawUserFacingOutput = true; yield event; }
+        for (const event of events) {
+          // Any other event keeps its place behind held text instead of overtaking it.
+          if (event.type !== "text_delta") { yield* toolCallContent.hold(event); continue; }
+          sawUserFacingOutput = true;
+          const released = toolCallContent.ingestStreaming(event.text);
+          yield* released.length > 0 ? released : [{ type: "heartbeat" } as AdapterEvent];
+        }
       };
 
       const handleDataLine = function* (line: string): Generator<AdapterEvent, "continue" | "terminate"> {
@@ -381,8 +399,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           parsed = JSON.parse(payload);
         } catch {
           tierMetadata?.markResponseUnparseable();
-          yield { type: "error", message: "malformed upstream SSE data frame" };
-          return "terminate";
+          return yield* terminateWithError({ type: "error", message: "malformed upstream SSE data frame" });
         }
         if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return "continue";
         const chunk = parsed as Record<string, unknown>;
@@ -423,11 +440,11 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           if (detailSegments.length > 0) {
             for (const segment of detailSegments) {
               const reasoningDelta = reasoningDetailTracker.ingest(segment);
-              if (reasoningDelta !== null) yield { type: "reasoning_raw_delta", text: reasoningDelta };
+              if (reasoningDelta !== null) yield* toolCallContent.hold({ type: "reasoning_raw_delta", text: reasoningDelta });
             }
           } else {
             const reasoningText = reasoningTextFrom(delta);
-            if (reasoningText !== undefined) yield { type: "reasoning_raw_delta", text: reasoningText };
+            if (reasoningText !== undefined) yield* toolCallContent.hold({ type: "reasoning_raw_delta", text: reasoningText });
           }
           if (typeof delta.content === "string" && delta.content.length > 0) {
             yield* emitContent(inlineThink.feed(delta.content));
@@ -630,7 +647,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
             hadUsage: pendingUsage !== undefined,
             pendingToolCalls: pendingToolCalls.length,
           });
-          yield { type: "error", message: "upstream stream ended mid tool call without a terminal signal — possible truncation" };
+          yield* terminateWithError({ type: "error", message: "upstream stream ended mid tool call without a terminal signal — possible truncation" });
           return;
         }
         if (!sawFinish && !sawUserFacingOutput) {
@@ -638,13 +655,15 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
             finishReason: finishReason ?? null,
             hadUsage: pendingUsage !== undefined,
           });
-          yield { type: "error", message: "upstream stream ended without a terminal signal ([DONE] or finish_reason) — possible truncation" };
+          yield* terminateWithError({ type: "error", message: "upstream stream ended without a terminal signal ([DONE] or finish_reason) — possible truncation" });
           return;
         }
         if ((yield* flushToolCalls()) === "terminate") return;
         const stopReason = stopReasonFor(finishReason);
         yield { type: "done", usage: pendingUsage, ...(stopReason ? { stopReason } : {}) };
       } catch (error) {
+        closeToolCalls();
+        yield* heldText();
         if (isTranslatorBudgetExceededError(error)
           || (error instanceof Error && (error.cause as { code?: unknown } | undefined)?.code === "translation_buffer_limit")) {
           yield {
@@ -662,6 +681,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         budget.releaseRetained(bufferBytes, { kind: "live_transient" });
         reasoningDetailTracker.release();
         inlineThink.dispose();
+        toolCallContent.dispose();
         closeToolCalls();
         reader.releaseLock();
       }
@@ -748,7 +768,12 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           if (segments.length > 0) reasoningText = segments.map(s => s.text).join("");
         }
         if (reasoningText !== undefined) events.push({ type: "reasoning_raw_delta", text: reasoningText });
+        const contentStart = events.length;
         if (typeof msg.content === "string") events.push(...splitInlineThinkContent(provider.inlineThinkTagModels, lastRequestedModelId, budget, msg.content));
+        const contentEnd = events.length;
+        const answerText = events.slice(contentStart).map(event => (event.type === "text_delta" ? event.text : "")).join("");
+        // Each call holds the delta event it emitted, so the batch repair sets its arguments later.
+        const structuredCalls: { wireName: string; restoredName: string; argumentsText: string; delta: Extract<AdapterEvent, { type: "tool_call_delta" }> }[] = [];
         const rawToolCalls = msg.tool_calls;
         if (rawToolCalls !== undefined && rawToolCalls !== null) {
           if (!Array.isArray(rawToolCalls)) {
@@ -771,11 +796,14 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
               logInvalidToolCalls("response", rawToolCalls);
               return [invalidToolCallsEvent(rawToolCalls, "response", usage)];
             }
-            events.push({ type: "tool_call_start", id, name: toolNames.restore(name) });
-            events.push({ type: "tool_call_delta", arguments: args });
-            events.push({ type: "tool_call_end" });
+            const delta: Extract<AdapterEvent, { type: "tool_call_delta" }> = { type: "tool_call_delta", arguments: args };
+            structuredCalls.push({ wireName: name, restoredName: toolNames.restore(name), argumentsText: args, delta });
+            events.push({ type: "tool_call_start", id, name: toolNames.restore(name) }, delta, { type: "tool_call_end" });
           }
         }
+        const references = reconcileStructuredToolCalls(structuredCalls, answerText);
+        structuredCalls.forEach((call, index) => { call.delta.arguments = references[index]!.argumentsText; });
+        reconcileSerializedToolCallEvents(events, contentStart, contentEnd, references, budget);
         const stopReason = stopReasonFor(choice.finish_reason);
         events.push({
           type: "done",

package/src/adapters/openai-responses/canonical-forward.ts

@@ -64,20 +64,27 @@ export function stripStatefulResponsesParams(body: unknown): unknown {
 }
 
 /**
- * Remove top-level parameters the ChatGPT backend (`authMode: "forward"`) rejects
- * with `{"detail":"Unsupported parameter: …"}` (strict allowlist). Codex CLI never
+ * Remove top-level parameters a forward destination rejects with
+ * `{"detail":"Unsupported parameter: …"}` (strict allowlist). Codex CLI never
  * sends these — it controls output length via `reasoning.effort` — but third-party
  * Responses API clients (GJC, SDK wrappers) include `max_output_tokens` per the
- * public spec. `metadata` is likewise absent from the allowlist. No-op when the
- * body carries neither field, keeping the common Codex path allocation-free.
+ * public spec. No-op when the body carries none of the dropped fields, keeping the
+ * common Codex path allocation-free.
+ *
+ * The canonical ChatGPT backend rejects `metadata`, so the forwarding path removes it on every
+ * forward route for compatibility.
+ * `max_output_tokens` does not: it is the caller's cost cap on the turn, and a
+ * self-hosted or third-party gateway may honour it — dropping it there silently
+ * removes the cap. Only the canonical ChatGPT backend rejects it outright, so only
+ * `canonical` callers strip it.
  */
-export function stripUnsupportedForwardParams(body: unknown): unknown {
+export function stripUnsupportedForwardParams(body: unknown, canonical: boolean): unknown {
   if (!isPlainObject(body)) return body;
-  const hasMot = Object.prototype.hasOwnProperty.call(body, "max_output_tokens");
-  const hasMeta = Object.prototype.hasOwnProperty.call(body, "metadata");
-  if (!hasMot && !hasMeta) return body;
-  const { max_output_tokens: _mot, metadata: _meta, ...rest } = body;
-  return rest;
+  const drop = canonical ? (["metadata", "max_output_tokens"] as const) : (["metadata"] as const);
+  if (!drop.some(key => Object.hasOwn(body, key))) return body;
+  const next: Record<string, unknown> = { ...body };
+  for (const key of drop) delete next[key];
+  return next;
 }
 
 /** Sampling controls the canonical ChatGPT backend rejects; other forward gateways accept them. */

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

@@ -1,4 +1,5 @@
 import { normalizeRoutedAgentMessages } from "../routed-agent-messages";
+import { nameRoutedIdentity, repairIdentityInResponsesBody, stripRoutedIdentity } from "../identity";
 import { stripBracketedModelSuffix } from "../openai-chat";
 import { normalizeOpenCodeGoAdditionalTools } from "../opencode-go-additional-tools";
 import { isXaiResponsesDestination } from "../../providers/xai-transport";
@@ -33,7 +34,7 @@ import {
   createAdapterTierMetadata,
 } from "../../providers/fastwire";
 import { dropResponsesReasoningInputItems, mapRoutedResponsesReasoningEffort, normalizeConfiguredReasoningSummaryDelivery, sanitizeReasoningInputContent, stripDisabledReasoningSummaries, stripDisabledVerbosity, stripUnsupportedReasoningSummaryDelivery } from "./reasoning";
-import { scrubOcxCompactionItems, stripCanonicalOnlyToolFields, stripCanonicalOnlyTopLevelFields, stripInternalChatMessageMetadataPassthrough, stripInvalidItemIds, stripItemIdsWhenUnstored } from "./request-strips";
+import { scrubOcxCompactionItems, stripCanonicalOnlyToolFields, stripCanonicalOnlyTopLevelFields, stripInternalChatMessageMetadataPassthrough, stripInvalidItemIds, stripItemIdsWhenUnstored, stripRejectedSamplingParams } from "./request-strips";
 import { stripCanonicalForwardPromptCacheOptions, stripDeprecatedPromptCacheRetention } from "./prompt-cache";
 import { isPlainObject } from "./internal";
 import { normalizeToolSchemas, promoteClientLoadedTools, stripUnsupportedHostedTools } from "./tool-schema";
@@ -268,6 +269,17 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       if (!forward) outBody = normalizeRoutedAgentMessages(outBody, {
         allowStringContent: isXaiResponsesDestination(provider),
       });
+      // #5217: a sub-agent inherits the parent session's instruction block, so the identity
+      // sentence this proxy generated for the PARENT's model rides along to a worker running a
+      // different one. On a routed destination it is renamed to that destination — including the
+      // model-neutral catalog sentence, which this adapter never names itself; on a native/forward
+      // destination our sentence is dropped, because Codex's own identity wording (sent in the
+      // client's model_switch block) is the correct one there. Text the proxy did not generate —
+      // user turns, tool output, fenced code, provider-native blocks — is untouched.
+      outBody = repairIdentityInResponsesBody(
+        outBody,
+        forward ? stripRoutedIdentity : (text: string) => nameRoutedIdentity(text, parsed.modelId),
+      );
       outBody = mapRoutedResponsesReasoningEffort(outBody, provider, parsed.modelId);
       // stripPreviousResponseId() intentionally returns its input on a no-op. Detach before the
       // tier write so a force-fast/default decision can never mutate parsed._rawBody.
@@ -312,9 +324,11 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         outBody = normalizeResponsesToolResultAdjacency(outBody);
       }
       if (forward) {
-        outBody = stripUnsupportedForwardParams(outBody);
-        // Only the canonical ChatGPT backend rejects the retired field; a self-hosted or
-        // third-party forward gateway may still accept it, so this must not be widened.
+        // `metadata` is stripped on every forward route for compatibility with the canonical backend.
+        // `max_output_tokens` is stripped only when this provider is the canonical backend.
+        outBody = stripUnsupportedForwardParams(outBody, isCanonicalOpenAiForwardProvider(provider));
+        // Only the canonical ChatGPT backend rejects the canonical-only fields below; a self-hosted
+        // or third-party forward gateway may accept them, so this guard must not be widened.
         if (isCanonicalOpenAiForwardProvider(provider)) {
           outBody = stripCanonicalForwardSamplingParams(outBody);
           outBody = stripDeprecatedPromptCacheRetention(outBody, parsed.modelId);
@@ -323,6 +337,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
           outBody = normalizeCanonicalForwardContinuationEnvelope(outBody);
         }
       } else {
+        outBody = stripRejectedSamplingParams(outBody, provider, parsed.modelId);
         outBody = preferConfiguredHostedTools(
           outBody,
           provider,

package/src/adapters/openai-responses/request-strips.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { COMPACT_PROMPT, compactionItemToText, decodeCompactionSummary, isCompactionItemType } from "../../responses/compaction";
 import { debugProviderDiagnostic } from "../../lib/debug";
+import { modelInList } from "../../types";
 import { isPlainObject } from "./internal";
 import { activateDeferredTool } from "./tool-schema";
 import { stripOpenAiOnlyWebSearchFields } from "./web-search";
@@ -165,6 +166,30 @@ export function stripCanonicalOnlyTopLevelFields(body: unknown): unknown {
   return next;
 }
 
+/**
+ * Sampling fields a model on the provider's `noStopModels` / `noPenaltyModels` list rejects on
+ * every wire. Claude inbound translates `stop_sequences` into a Responses `stop`
+ * (`src/claude/inbound.ts`), and a direct Responses caller can send penalties. Some listed models
+ * only have the Responses wire (xAI grok-4.20-multi-agent-0309 answers Chat Completions with 400),
+ * so the Chat adapter's omission cannot cover them. Returns the input unchanged when nothing is
+ * removed, so the caller-owned raw body is never mutated.
+ */
+export function stripRejectedSamplingParams(
+  body: unknown,
+  provider: { noStopModels?: string[]; noPenaltyModels?: string[] },
+  modelId: string,
+): unknown {
+  if (!isPlainObject(body)) return body;
+  const dropStop = Object.hasOwn(body, "stop") && modelInList(provider.noStopModels, modelId);
+  const penalties = ["presence_penalty", "frequency_penalty"].filter(field => Object.hasOwn(body, field));
+  const dropPenalties = penalties.length > 0 && modelInList(provider.noPenaltyModels, modelId);
+  if (!dropStop && !dropPenalties) return body;
+  const next = { ...body };
+  if (dropStop) delete next.stop;
+  if (dropPenalties) for (const field of penalties) delete next[field];
+  return next;
+}
+
 /**
  * When `store` is false, the upstream API does not persist response items. Any item ID
  * forwarded in `input` is then interpreted as a reference to a stored item that does not

package/src/adapters/openai-responses/web-search.ts

@@ -68,6 +68,10 @@ export function stripOpenAiOnlyWebSearchFields(body: unknown): unknown {
  * same-shaped successor to 1.2 on the same Zen wire, and an equality check would
  * have let a Codex-emitted `web_search` body reach the
  * gateway and come back 400 for every request the moment 1.3 was selected.
+ *
+ * This list gates the two Zen destinations only. Zen serves nothing but the Contributor
+ * tiers there, so the id is a proxy for "this gateway"; the direct Meta host below serves
+ * a non-Contributor default and is gated by destination instead.
  */
 const MUSE_SPARK_WEB_SEARCH_STRICT_MODELS = new Set([
   "muse-spark-1.3-contributor",
@@ -76,10 +80,21 @@ const MUSE_SPARK_WEB_SEARCH_STRICT_MODELS = new Set([
   "muse-spark-1.2-contributor-free",
 ]);
 
+/**
+ * Direct Meta Muse / Meta Model Responses. Its refusal is a gateway schema rule applied
+ * before inference, so it holds for every Muse model Meta serves — including the default
+ * `muse-spark-1.3`, which no Contributor-shaped list contains. Gating that host on model
+ * membership sent `search_content_types` through on every Codex `web_search` turn and 400ed
+ * the whole request. Same reading as the 64-char tool-name rewrite in
+ * `src/responses/muse-tool-name-alias.ts`, which is host-scoped and deliberately not
+ * model-gated for this reason.
+ */
+const MUSE_SPARK_STRICT_ANY_MODEL_DESTINATION = "https://api.meta.ai/v1/responses";
+
 const MUSE_SPARK_WEB_SEARCH_STRICT_RESPONSE_URLS = new Set([
   "https://opencode.ai/zen/v1/responses",
   "https://opencode.ai/zen/go/v1/responses",
-  "https://api.meta.ai/v1/responses",
+  MUSE_SPARK_STRICT_ANY_MODEL_DESTINATION,
 ]);
 
 const MUSE_SPARK_UNSUPPORTED_WEB_SEARCH_FIELDS = [
@@ -94,7 +109,8 @@ const MUSE_SPARK_UNSUPPORTED_WEB_SEARCH_FIELDS = [
  * malformed, credentialed, or parameterized destinations keep their original body
  * instead of assuming this gateway contract. Keep the rejected names together so a
  * newly identified field is a one-line compatibility update rather than another
- * bespoke rewrite.
+ * bespoke rewrite. The destination is the whole predicate on direct Meta; the Zen
+ * wires additionally require a known Contributor id.
  */
 export function stripMuseSparkUnsupportedWebSearchFields(
   body: unknown,
@@ -102,8 +118,6 @@ export function stripMuseSparkUnsupportedWebSearchFields(
   responseUrl: string,
 ): unknown {
   if (!isPlainObject(body)) return body;
-  if (typeof modelId !== "string") return body;
-  if (!MUSE_SPARK_WEB_SEARCH_STRICT_MODELS.has(modelId.trim().toLowerCase())) return body;
   let destination: string;
   try {
     const url = new URL(responseUrl);
@@ -113,6 +127,10 @@ export function stripMuseSparkUnsupportedWebSearchFields(
     return body;
   }
   if (!MUSE_SPARK_WEB_SEARCH_STRICT_RESPONSE_URLS.has(destination)) return body;
+  if (
+    destination !== MUSE_SPARK_STRICT_ANY_MODEL_DESTINATION
+    && (typeof modelId !== "string" || !MUSE_SPARK_WEB_SEARCH_STRICT_MODELS.has(modelId.trim().toLowerCase()))
+  ) return body;
 
   const rewriteTools = (tools: unknown[]): { tools: unknown[]; changed: boolean } => {
     let changed = false;

package/src/adapters/qoder/profiles.ts

@@ -3,6 +3,8 @@ import { clearCodingAgentBinaryCache, resolveProfileByBaseUrl, type CodingAgentP
 /** Official Qoder CLI profile. Region variants are separate profiles and credentials. */
 export interface QoderProfile extends CodingAgentProviderProfile {
   family: "qoder";
+  /** Required for this family: the CLI is driven with a personal access token. */
+  tokenEnv: string;
 }
 
 export const QODER_GLOBAL_PROFILE: QoderProfile = {

package/src/adapters/registry.ts

@@ -1,6 +1,7 @@
 import { createAnthropicAdapter } from "./anthropic";
 import { createAzureAdapter } from "./azure";
 import type { ProviderAdapter } from "./base";
+import { createClaudeCliAdapter } from "./claude-cli/adapter";
 import { withClinePassDeepSeekV4ToolReplayCompatibility } from "./cline-pass-deepseek-v4-tool-replay";
 import { createCodeBuddyAdapter } from "./codebuddy/adapter";
 import { createQoderAdapter } from "./qoder/adapter";
@@ -138,6 +139,13 @@ export const ADAPTER_REGISTRY = {
     contractParent: "codebuddy",
     create: (provider: OcxProviderConfig, _context: AdapterFactoryContext) => createQoderAdapter(provider),
   },
+  "claude-cli": {
+    // Claude Code speaks the same stream-json contract this repo already parses for CodeBuddy and
+    // Qoder, so the contract is inherited rather than restated. The family owns its args and env,
+    // and the CLI owns the credential: the adapter stores and injects none.
+    contractParent: "codebuddy",
+    create: (provider: OcxProviderConfig, _context: AdapterFactoryContext) => createClaudeCliAdapter(provider),
+  },
 } as const satisfies Record<string, AdapterDefinition>;
 
 export type AdapterId = keyof typeof ADAPTER_REGISTRY;

package/src/adapters/run-turn-queue.ts

@@ -152,6 +152,7 @@ async function* replay(
 
 export async function preflightAdapterEvents(
   source: AsyncIterable<AdapterEvent>,
+  classifyFirstEvent?: (event: AdapterEvent) => Extract<AdapterEvent, { type: "error" }> | undefined,
 ): Promise<AdapterEventPreflight> {
   const iterator = source[Symbol.asyncIterator]();
   const buffered: AdapterEvent[] = [];
@@ -165,6 +166,12 @@ export async function preflightAdapterEvents(
       if (buffered.length > PREFLIGHT_HEARTBEAT_RETAIN_LIMIT) buffered.shift();
       continue;
     }
+    const classifiedError = replayUnsafe ? undefined : classifyFirstEvent?.(next.value);
+    if (classifiedError) {
+      buffered.push(classifiedError);
+      await iterator.return?.();
+      return { stream: replay(buffered, iterator), error: classifiedError, empty: false, replayUnsafe };
+    }
     buffered.push(next.value);
     if (next.value.type === "error") {
       await iterator.return?.();

package/src/bridge/response-json.ts

@@ -45,6 +45,7 @@ import { adapterFailureFromEvent, emptyChunks, joinChunks, responsesUsage, toolC
 import type { OutputItem, StringChunks } from "./internal";
 import { bridgeToResponsesSSE } from "./sse";
 
+/** Build a buffered Responses result within a caller-owned or temporary translator budget. */
 export function buildResponseJSON(
   events: AdapterEvent[],
   modelId: string,
@@ -68,13 +69,14 @@ export function buildResponseJSON(
   }
 }
 
+/** Fold adapter events into a Responses result while enforcing the requested tool boundary. */
 function buildResponseJSONWithBudget(
   events: AdapterEvent[],
   modelId: string,
   options?: {
     hideThinkingSummary?: boolean;
     toolNsMap?: Map<string, { namespace: string; name: string; freeform?: true }>;
-    /** Request-visible tool names. When present, an upstream call outside this set fails closed. */
+    /** Request-visible tool names. Required for client calls when enforcement is explicitly enabled. */
     declaredToolNames?: ReadonlySet<string>;
     /** See `bridgeToResponsesSSE`: enforcement is separate from normalization (#4735). */
     enforceDeclaredToolNames?: boolean;
@@ -443,9 +445,9 @@ function buildResponseJSONWithBudget(
         flushToolCall();
         const effectiveName = normalizeDeclaredToolName(e.name, options?.declaredToolNames);
         if (
-          options?.declaredToolNames
-          && options.enforceDeclaredToolNames !== false
-          && !options.declaredToolNames.has(effectiveName)
+          (options?.enforceDeclaredToolNames === true || options?.declaredToolNames != null)
+          && options?.enforceDeclaredToolNames !== false
+          && !options?.declaredToolNames?.has(effectiveName)
         ) {
           errorEvent = {
             type: "error",

package/src/bridge/sse.ts

@@ -61,6 +61,7 @@ function responseError(status: number, type: string, message: string): OcxErrorP
 
 export type ResponsesTerminalStatus = "completed" | "failed" | "incomplete";
 
+/** Stream adapter events as Responses frames, applying tool authorization before relaying calls. */
 export function bridgeToResponsesSSE(
   events: AsyncIterable<AdapterEvent>,
   modelId: string,
@@ -92,13 +93,14 @@ export function bridgeToResponsesSSE(
      * from this callback instead of re-parsing the bridged SSE.
      */
     onUsage?: (usage: OcxUsage | undefined) => void;
-    /** Request-visible tool names. When present, an upstream call outside this set fails closed. */
+    /** Request-visible tool names. Required for client calls when enforcement is explicitly enabled. */
     declaredToolNames?: ReadonlySet<string>;
     /**
      * Whether `declaredToolNames` is an authorization boundary this proxy enforces, or only the
      * catalog used to normalize provider-invented names back to declared ones.
      *
-     * Defaults to enforcing. The chat and Anthropic inbound wires set it false: those specs make
+     * Defaults to enforcing when a catalog is supplied. Explicit true also fails closed when the
+     * catalog is absent. The chat and Anthropic inbound wires set it false: those specs make
      * the server relay a tool call and leave execution or refusal to the client's own runner, and
      * harnesses on them legitimately defer part of their catalog (#4735).
      *
@@ -1010,9 +1012,9 @@ export function bridgeToResponsesSSE(
               const mapped = toolNsMap?.get(effectiveName);
               const realName = mapped?.name ?? effectiveName;
               if (
-                options?.declaredToolNames
-                && options.enforceDeclaredToolNames !== false
-                && !options.declaredToolNames.has(effectiveName)
+                (options?.enforceDeclaredToolNames === true || options?.declaredToolNames != null)
+                && options?.enforceDeclaredToolNames !== false
+                && !options?.declaredToolNames?.has(effectiveName)
               ) {
                 const failure = responseError(
                   502,