mixdog 1.2.2 → 1.2.4

package/src/runtime/agent/orchestrator/providers/openai-compat-wire.mjs

@@ -17,8 +17,11 @@ import {
 } from './media-normalization.mjs';
 import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from './custom-tool-wire.mjs';
 import { providerReplayItems } from './lib/provider-replay.mjs';
+import { acceptedWireTools } from './lib/claude-bridge-schema.mjs';
 import { ensureResponsesCallOutputs } from './lib/wire-pairing.mjs';
 import { responsesEffortUpdates } from './effort-configuration.mjs';
+import { convertMessagesToResponsesInput } from './openai-responses-input.mjs';
+import { COMPAT_REASONING_METADATA_KEY, contentWithThinkingChunk } from './openai-compat-reasoning-field.mjs';
 
 function positiveTokenInt(value) {
   const n = Number(value);
@@ -39,19 +42,23 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
   // strict providers (xai) reject unknown roles/types and would 400 the
   // request. Documented in v0.1.160 (GPT reasoning replay).
   //
-  // DeepSeek splits by model: thinking-mode models with tools REQUIRE the
-  // prior turn's `reasoning_content` echoed back (400 without it), while
-  // `deepseek-reasoner` REJECTS it with a 400. The caller decides per model
-  // through options.replaysReasoningContent — see
-  // deepseekReplaysReasoningContent below. xAI reasoning models preserve
-  // their official multi-turn shape and cache prefix stability when prior
-  // assistant reasoning_content is replayed; reasoning_effort itself remains
-  // caller/user-selected.
+  // DeepSeek thinking-mode models with tools REQUIRE the prior turn's
+  // `reasoning_content` echoed back (400 without it); without tools it is
+  // ignored, so the caller (options.replaysReasoningContent) always replays it.
+  // xAI reasoning models preserve their official multi-turn shape and cache
+  // prefix stability when prior assistant reasoning_content is replayed;
+  // reasoning_effort itself remains caller/user-selected.
   //
   // Custom providers pass options.customReplay (custom-reasoning.mjs replay
   // eligibility). When it is a boolean it alone decides; a replaying custom
   // endpoint also needs a non-empty reasoning_content on every assistant
   // tool-call turn, so missing/empty reasoning there is padded with " ".
+  //
+  // options.reasoningShape (openai-compat-reasoning-field.mjs) names the
+  // endpoint families with their own reasoning fields; they decide the resend
+  // key and win over the flags above. options.developerRole keeps the
+  // `developer` role for endpoints that document it; every other chat endpoint
+  // only knows `system`, so developer instructions go out as system messages.
   const customReplay = typeof options.customReplay === 'boolean' ? options.customReplay : null;
   const replaysReasoningContent = customReplay ?? (options.replaysReasoningContent === true || providerName === 'xai');
   const out = [];
@@ -62,8 +69,25 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
     const details = metadata?.reasoning_details ?? metadata?.reasoningDetails;
     return Array.isArray(details) && details.length ? details : null;
   };
+  const shape = options.reasoningShape || null;
+  // Receive and resend fields differ per endpoint family: the key a reply's
+  // reasoning arrived on is recorded in providerMetadata at receive time.
+  const receivedField = (message) => message?.providerMetadata?.[COMPAT_REASONING_METADATA_KEY]?.reasoningField;
+  const attachShapeReasoning = (msg, message, stored) => {
+    if (!stored) return;
+    if (shape.resend === 'same_key') {
+      msg[receivedField(message) === 'reasoning' ? 'reasoning' : 'reasoning_content'] = stored;
+    } else if (shape.resend === 'reasoning') {
+      // OpenRouter: reasoning_details replace the text when present.
+      if (!openRouterReasoningDetails(message)) msg.reasoning = stored;
+    } else if (shape.resend === 'content_chunks' && receivedField(message) === 'content_chunks') {
+      msg.content = contentWithThinkingChunk(msg.content, stored);
+    }
+  };
   const attachAssistantReasoning = (msg, message) => {
-    if (customReplay) {
+    if (shape) {
+      attachShapeReasoning(msg, message, typeof message.reasoningContent === 'string' ? message.reasoningContent : '');
+    } else if (customReplay) {
       const stored = typeof message.reasoningContent === 'string' ? message.reasoningContent : '';
       if (stored) msg.reasoning_content = stored;
       else if (Array.isArray(msg.tool_calls) && msg.tool_calls.length) msg.reasoning_content = ' ';
@@ -104,8 +128,12 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
       continue;
     }
     const msg = {
-      role: m.role,
-      content: normalizeContentForOpenAIChat(m.content, { role: m.role, nativePdf: options.nativePdf }),
+      role: m.role === 'developer' && options.developerRole !== true ? 'system' : m.role,
+      content: normalizeContentForOpenAIChat(m.content, {
+        role: m.role,
+        nativePdf: options.nativePdf,
+        cacheControl: options.cacheControl === true,
+      }),
     };
     out.push(m.role === 'assistant' ? attachAssistantReasoning(msg, m) : msg);
   }
@@ -113,18 +141,6 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
   return out;
 }
 
-// deepseek-reasoner returns 400 when `reasoning_content` appears in the input
-// messages; every other DeepSeek thinking model needs it back once tools are in
-// play. Unknown DeepSeek ids default to replaying: a missing echo breaks the
-// tool loop, while a stray field on a non-thinking model is ignored.
-export function deepseekReplaysReasoningContent(model) {
-  return !/reasoner/.test(
-    String(model || '')
-      .trim()
-      .toLowerCase()
-  );
-}
-
 export function toOpenAITools(tools) {
   return tools.map((t) => ({
     type: 'function',
@@ -146,9 +162,42 @@ function functionToolFromSessionTool(t, name = t?.name) {
   };
 }
 
-export function toResponsesTools(tools, options = {}) {
+// xAI hosts tool search itself (docs.x.ai progressive tool disclosure): a
+// `{type:'tool_search'}` server tool loads the definitions of function tools
+// marked `defer_loading: true`, and the server returns the search as
+// tool_search_call / tool_search_output items. The client loader (`load_tool`)
+// is therefore replaced by that one server tool; with deferred tools but no
+// loader the server tool is still added, or the deferred tools could never load.
+function toServerToolSearchTools(tools) {
+  let hasSearch = false;
+  let hasDeferred = false;
+  const out = tools.map((t) => {
+    if (t?.name === 'load_tool' || t?.name === 'tool_search') {
+      if (hasSearch) return null;
+      hasSearch = true;
+      return { type: 'tool_search' };
+    }
+    if (t?.deferLoading === true || t?.defer_loading === true) {
+      hasDeferred = true;
+      return { ...functionToolFromSessionTool(t), defer_loading: true };
+    }
+    return functionToolFromSessionTool(t);
+  });
+  if (hasDeferred && !hasSearch) out.push({ type: 'tool_search' });
+  return out.filter(Boolean);
+}
+
+export function toResponsesTools(allTools, options = {}) {
   const provider = String(options?.provider || '').toLowerCase();
+  // A Responses endpoint rejects the whole request for one invalid
+  // `parameters`; a tool broken even after lowering is left out and reported.
+  const tools = acceptedWireTools(allTools, 'openai', options?.onToolExcluded, `[${provider || 'responses'}] tool`);
+  if (options?.serverToolSearch === true) return toServerToolSearchTools(tools);
+  // A route pinned with verified native deferred tools declares the native
+  // client tool_search tool and marks deferred definitions `defer_loading`.
+  const nativeDeferred = options?.nativeDeferredTools === true;
   const allowNativeToolSearch =
+    nativeDeferred ||
     options?.nativeToolSearch === true ||
     (options?.nativeToolSearch !== false && (provider === 'openai' || provider === 'openai-oauth'));
   return tools.map((t) => {
@@ -170,6 +219,9 @@ export function toResponsesTools(tools, options = {}) {
     // tools (e.g. apply_patch) as ordinary function tools instead. Grammar
     // tools may carry no usable inputSchema, so fall back to a permissive
     // object schema so grok still registers a valid function tool.
+    if (nativeDeferred && (t?.deferLoading === true || t?.defer_loading === true)) {
+      return { ...functionToolFromSessionTool(t), defer_loading: true };
+    }
     return functionToolFromSessionTool(t);
   });
 }
@@ -237,7 +289,7 @@ export function parseResponsesToolCalls(response, label) {
     } else if (item?.type === 'custom_tool_call') {
       const call = customToolCallFromResponseItem(item);
       if (call) out.push(call);
-    } else if (item?.type === 'tool_search_call') {
+    } else if (item?.type === 'tool_search_call' && item.execution !== 'server') {
       const searchArgs =
         item.arguments && typeof item.arguments === 'object' && !Array.isArray(item.arguments)
           ? item.arguments
@@ -409,16 +461,41 @@ export function toXaiResponsesInput(messages, providerState, options = {}) {
     let history = [];
     if (Array.isArray(state?.encryptedReasoningHistory)) history = state.encryptedReasoningHistory;
     else if (Array.isArray(state?.encryptedReasoningItems)) {
-      history = [{ messageIndex: seen, items: state.encryptedReasoningItems }];
+      history = [{ messageIndex: seen, items: state.encryptedReasoningItems, owner: state.owner }];
     }
     for (const entry of history) {
       const index = Number(entry?.messageIndex);
       if (!Number.isInteger(index) || index < 0 || !Array.isArray(entry?.items)) continue;
+      // Owner-tagged reasoning (compat routes) never replays under another
+      // owner, even when a caller passes provider state across providers.
+      if (entry.owner !== undefined && entry.owner !== replayProvider) continue;
       const bucket = reasoningByMessageIndex.get(index) || [];
       bucket.push(...entry.items.map((item) => ({ ...item })));
       reasoningByMessageIndex.set(index, bucket);
     }
   }
+  if (options.nativeLowering === true) {
+    // Native-item-capable Responses routes share the first-party lowering:
+    // native tool_search / custom calls keep their own output type, and only
+    // this route's own replay tag and reasoning state are replayed.
+    return {
+      input: convertMessagesToResponsesInput(messages, {
+        startIndex,
+        includeSystem,
+        nativePdf: options.nativePdf,
+        replayProvider,
+        // Compat-owned tool_search payloads are tagged with the route name.
+        nativeToolSearchProvider: options.providerName,
+        replayOwnedReasoning: true,
+        reasoningByMessageIndex,
+        effortProjection: options.effortProjection,
+        splitToolContent: (content) => splitToolContentForXaiResponses(content, { nativePdf: options.nativePdf }),
+      }),
+      previousResponseId,
+      startIndex,
+      continuationResetReason: resetReason,
+    };
+  }
   const pendingToolMedia = [];
   const flushToolMedia = () => {
     if (!pendingToolMedia.length) return;

package/src/runtime/agent/orchestrator/providers/openai-compat-xai-send.mjs

@@ -5,6 +5,7 @@ import { consumeCompatResponsesStream } from './openai-compat-stream.mjs';
 import { PROVIDER_FIRST_BYTE_TIMEOUT_MS, createPassthroughSignal } from '../stall-policy.mjs';
 import {
   nativeResponsesTools,
+  resolveCompatMaxOutputTokens,
   toOpenAIMessages,
   toResponsesTools,
   toXaiResponsesInput,
@@ -26,17 +27,34 @@ import { applyCompatToolChoice, compatStreamRetryReporter } from './compat-reque
 import { envFlag as _envFlag } from '../../../shared/env.mjs';
 import { resolveResponsesTransportPolicy, RESPONSES_TRANSPORT_CAPABILITIES } from './openai-transport-policy.mjs';
 
+// Server-side tool search is strictly opt-in, from the provider's own config
+// (`xaiServerToolSearch`, shared by grok-oauth's inner xai provider) or the
+// request opts. Unset, every xAI request body is unchanged: deferred tools go
+// out as plain function tools and the client `load_tool` stays a function.
+// Server-executed search items replay through the owner-tagged providerReplay
+// envelope in either mode and are never dispatched locally.
+function xaiServerToolSearchEnabled(provider, opts) {
+  return (opts.xaiServerToolSearch ?? provider.config?.xaiServerToolSearch) === true;
+}
+
 // Tool list, parallel tool calls, tool choice and reasoning effort shared by
 // the HTTP/SSE and WebSocket Responses bodies.
 function applyXaiResponsesToolsAndEffort(params, { provider, tools, opts, useModel }) {
   const nativeTools = nativeResponsesTools(opts);
   if (tools?.length || nativeTools.length) {
-    params.tools = [...nativeTools, ...toResponsesTools(tools || [], { provider: 'xai' })];
+    const toolOptions = xaiServerToolSearchEnabled(provider, opts)
+      ? { provider: 'xai', serverToolSearch: true, onToolExcluded: opts.onToolExcluded }
+      : { provider: 'xai', onToolExcluded: opts.onToolExcluded };
+    params.tools = [...nativeTools, ...toResponsesTools(tools || [], toolOptions)];
   }
   // Explicit parallel tool calls, matching the OpenAI Responses
   // reference shape. Probe-verified accepted by api.x.ai (HTTP 200,
-  // 2026-08-16); absent, the service default decides per turn.
-  if (params.tools?.length) params.parallel_tool_calls = true;
+  // 2026-08-16); absent, the service default decides per turn. An explicit
+  // caller `parallelToolCalls:false` is honored (docs.x.ai function-calling).
+  if (params.tools?.length) params.parallel_tool_calls = opts.parallelToolCalls !== false;
+  // Caller output cap (docs.x.ai text best-practices): max_output_tokens.
+  const maxOutputTokens = resolveCompatMaxOutputTokens(opts);
+  if (maxOutputTokens) params.max_output_tokens = maxOutputTokens;
   applyCompatToolChoice(params, opts);
   const reasoningEffort = normalizeXaiReasoningEffort(
     opts.xaiReasoningEffort ??
@@ -201,7 +219,8 @@ export async function sendXaiResponsesWebSocket(provider, messages, useModel, to
     onTextDelta: typeof opts.onTextDelta === 'function' ? opts.onTextDelta : null,
     onStageChange: typeof opts.onStageChange === 'function' ? opts.onStageChange : null,
     externalSignal: signal,
-    poolKey: opts.sessionId || opts.session?.id || null,
+    // A forked request runs in its own transport scope (transport-scope.mjs).
+    poolKey: opts.transportScope || opts.sessionId || opts.session?.id || null,
     cacheKey: cacheRouting.key,
     iteration,
     useModel,

package/src/runtime/agent/orchestrator/providers/openai-compat-xai.mjs

@@ -235,13 +235,18 @@ export function useXaiResponsesApi(opts, config) {
 }
 
 export function useXaiResponsesWebSocket(opts, config) {
+  // A pinned route (grok-oauth's cli-chat-proxy) takes its transport from the
+  // config alone: the xAI WebSocket connector targets api.x.ai, so no request
+  // option or env override may carry the OAuth bearer there.
   const raw =
-    opts?.xaiResponsesTransport ??
-    opts?.xaiTransport ??
-    config?.responsesTransport ??
-    config?.transport ??
-    process.env.MIXDOG_XAI_RESPONSES_TRANSPORT ??
-    process.env.MIXDOG_XAI_TRANSPORT;
+    config?.transportPinned === true
+      ? config.responsesTransport
+      : (opts?.xaiResponsesTransport ??
+        opts?.xaiTransport ??
+        config?.responsesTransport ??
+        config?.transport ??
+        process.env.MIXDOG_XAI_RESPONSES_TRANSPORT ??
+        process.env.MIXDOG_XAI_TRANSPORT);
   // Reference xAI/Grok parity is HTTP/SSE. WebSocket remains available only
   // when a caller explicitly selects a WS transport.
   if (raw == null || raw === '') return false;

package/src/runtime/agent/orchestrator/providers/openai-compat.mjs

@@ -15,7 +15,12 @@ import {
 import { withEffortRejectionFallback } from './effort-rejection.mjs';
 import { applyCompatErrorContract } from './openai-compat-error-contract.mjs';
 import { sendCompatResponses } from './openai-compat-responses.mjs';
-import { COMPAT_RETRY_POLICY, COMPAT_RETRY_PROFILES, XAI_COMPAT_RETRY_POLICY } from './openai-compat-retry-profile.mjs';
+import {
+  COMPAT_RETRY_POLICY,
+  COMPAT_RETRY_PROFILES,
+  XAI_COMPAT_RETRY_POLICY,
+  compatFirstResponseBudget,
+} from './openai-compat-retry-profile.mjs';
 import { sendCompatChat, recoverCompatNonStreaming } from './openai-compat-chat-send.mjs';
 import { sendXaiResponses, sendXaiResponsesWebSocket } from './openai-compat-xai-send.mjs';
 import {
@@ -78,6 +83,9 @@ export class OpenAICompatProvider {
     this.config = config;
     this.baseURL = baseURL;
     this.apiKey = apiKey;
+    // Whether Chat content blocks keep their Anthropic-style `cache_control`
+    // (OpenRouter documents it); a gateway that does not ignores or rejects it.
+    this.chatCacheControl = (config.chatCacheControl ?? preset?.chatCacheControl) === true;
     // Merge caller-supplied headers (config.extraHeaders) over the preset's.
     // Used e.g. by grok-oauth to inject the Grok CLI client headers for the
     // grok-build proxy. Backward-compatible: providers that pass no
@@ -97,6 +105,11 @@ export class OpenAICompatProvider {
       }
     }
   }
+  // First-response budget of a chat profile with its own first-byte window;
+  // null keeps the agent watchdog default.
+  firstResponseBudget() {
+    return compatFirstResponseBudget(this.name, this.config?.chatProfile);
+  }
   get _preconnectFn() {
     return typeof this.config?.preconnectFn === 'function' ? this.config.preconnectFn : preconnect;
   }
@@ -256,7 +269,9 @@ export class OpenAICompatProvider {
     return fetchCompatModelItems(this);
   }
   async listModels() {
-    return listCompatModels(this);
+    // A failed /models request must surface; an empty list would be cached as
+    // a complete catalog by the shared catalog loader.
+    return listCompatModels(this, { throwOnError: true });
   }
   async isAvailable() {
     return isCompatProviderAvailable(this);

package/src/runtime/agent/orchestrator/providers/openai-direct-request.mjs

@@ -1,28 +1,20 @@
-import { getModelMetadataSync } from '../../../shared/llm/model-catalog.mjs';
+import {
+  openAiCatalogMeta,
+  openAiSupportsExtendedRetention,
+  openAiUsesPromptCacheOptions,
+} from './openai-model-capabilities.mjs';
 
-// Public Responses contracts are independent of the OAuth backend. Every
-// capability here comes from the model catalog (the service-tier price columns
-// and the cache-write rate), so a model the catalog lists works without an
-// edit. Only a model no catalog describes (cold install) falls back to the
-// documented ids known before the catalogs carried these columns.
-const SNAPSHOT_SUFFIX = /-\d{4}-\d{2}-\d{2}$/;
+// Public Responses contracts are independent of the OAuth backend. Service
+// tiers come from the model catalog (the service-tier price columns), so a
+// model the catalog lists works without an edit. Only a model no catalog
+// describes (cold install) falls back to the documented ids known before the
+// catalogs carried these columns.
 const PRE_CATALOG_GPT_56_PLUS =
   /^(?:gpt-6-(?:astra|sol|luna)|gpt-6\.1-sol|gpt-5\.6-(?:sol|terra|luna))(?:-\d{4}-\d{2}-\d{2})?$/;
 const PRE_CATALOG_EARLIER_FAST = /^gpt-5\.(?:5|4|4-mini)(?:-\d{4}|$)/;
 const PRE_CATALOG_ULTRAFAST = /^(?:gpt-6-astra|gpt-6\.1-sol)(?:-\d{4}-\d{2}-\d{2})?$/;
 const modelId = (model) => String(model?.id || model || '').trim();
 
-// The catalog metadata of one model. A dated snapshot reads as its undated
-// alias when only the alias is listed.
-function openAiCatalogMeta(model) {
-  const id = String(model?.id || model || '').trim();
-  for (const candidate of new Set([id, id.replace(SNAPSHOT_SUFFIX, '')])) {
-    const meta = candidate ? getModelMetadataSync(candidate, 'openai') : null;
-    if (meta) return meta;
-  }
-  return null;
-}
-
 export function openAiDirectSupportsFast(model) {
   const meta = openAiCatalogMeta(model);
   // The catalog's declaration (true or false) decides; a published Priority
@@ -40,13 +32,13 @@ export function openAiDirectSupportsUltrafast(model) {
   return PRE_CATALOG_ULTRAFAST.test(modelId(model));
 }
 
-// OpenAI bills prompt-cache writes from GPT-5.6 on, and exactly those models
-// take prompt_cache_options in place of prompt_cache_retention, so a published
-// cache-write rate selects the new form.
 // https://developers.openai.com/api/docs/guides/prompt-caching
+// GPT-5.6 and later: prompt_cache_options.ttl. Earlier models: 24h
+// prompt_cache_retention only on the documented extended-retention list;
+// every other model gets no lifetime field (never inferred from pricing).
 function promptCacheForm(model) {
-  const writeRate = openAiCatalogMeta(model)?.cacheWriteCostPerM > 0;
-  return writeRate || PRE_CATALOG_GPT_56_PLUS.test(modelId(model)) ? 'options' : 'retention';
+  if (openAiUsesPromptCacheOptions(model) || PRE_CATALOG_GPT_56_PLUS.test(modelId(model))) return 'options';
+  return openAiSupportsExtendedRetention(model) ? 'retention' : null;
 }
 
 export function applyOpenAIDirectCachePolicy(body, model, storeResponses) {

package/src/runtime/agent/orchestrator/providers/openai-http-sse-request.mjs

@@ -6,7 +6,16 @@
  * Returns an OK response whose body is ready to stream; every failure path
  * throws with the initial-response markers the retry classifier reads.
  */
+import { promisify } from 'node:util';
 import zlib from 'node:zlib';
+import {
+  REQ_COMPRESSION_MIN_BYTES,
+  compressBody,
+  createCompressionLatch,
+  hasContentEncoding,
+  resendIfEncodingRejected,
+  withContentEncoding,
+} from './lib/request-compression.mjs';
 import { traceAgentFetch } from '../agent-trace.mjs';
 import { PROVIDER_HTTP_RESPONSE_TIMEOUT_MS, createTimeoutSignal } from '../stall-policy.mjs';
 import { CODEX_REQUEST_RETRY_BACKOFF_MS, CODEX_RETRY_JITTER_RATIO } from './openai-retry-policy.mjs';
@@ -37,7 +46,6 @@ const OPENAI_REQUEST_RETRY_OPTS = Object.freeze({
   retryJitterRatio: CODEX_RETRY_JITTER_RATIO,
 });
 
-
 // Request-layer retry: 5xx and typed transport
 // failures only. 408 and 429 are NOT retried here; they surface to the outer
 // stream-retry layer, which owns their budget and honors Retry-After.
@@ -52,31 +60,29 @@ function isRetryableHttpFailure(err) {
 }
 // Request-body zstd gate. Namespace import: on Node runtimes without zlib
 // zstd bindings the named export would fail at module load, so the call site
-// typeof-guards zlib.zstdCompressSync instead.
-const OPENAI_REQ_ZSTD_MIN_BYTES = 8 * 1024;
-let _openaiReqZstdLatch = false;
-function _openaiReqZstdDisabled() {
-  return _openaiReqZstdLatch || process.env.MIXDOG_OPENAI_REQ_ZSTD === '0';
-}
-function _disableOpenaiReqZstd() {
-  _openaiReqZstdLatch = true;
-}
-function _zstdHeaders(headers, bodyForSend) {
-  return bodyForSend.encoding ? { ...headers, 'Content-Encoding': bodyForSend.encoding } : headers;
-}
+// typeof-guards zlib.zstdCompress instead.
+const _openaiReqZstdLatch = createCompressionLatch('MIXDOG_OPENAI_REQ_ZSTD');
+export const _resetOpenaiReqZstdLatchForTest = _openaiReqZstdLatch.reset;
 
 // Request-body zstd: compression is enabled for the codex backend on the
 // OpenAI provider — the server decompresses Content-Encoding: zstd.
-// openai-direct is excluded: only the codex backend is verified. Env
-// kill-switch plus a process-wide latch flipped on the first 400 seen on
-// a compressed request, which then replays that attempt uncompressed.
-function encodeRequestBody(auth, rawBytes) {
-  return auth?.type !== 'openai-direct' &&
-    !_openaiReqZstdDisabled() &&
-    typeof zlib.zstdCompressSync === 'function' &&
-    rawBytes.length >= OPENAI_REQ_ZSTD_MIN_BYTES
-    ? { bytes: zlib.zstdCompressSync(rawBytes), encoding: 'zstd' }
-    : { bytes: rawBytes, encoding: null };
+// openai-direct is excluded: only the codex backend is verified. Compression
+// runs on the libuv threadpool (zlib.zstdCompress, promisified) so it never
+// blocks the main thread; runtimes without the async zstd binding send plain.
+// Env kill-switch; the 400/415 resend + latch policy is shared
+// (lib/request-compression.mjs).
+async function encodeRequestBody(auth, headers, rawBytes) {
+  const plain = { bytes: rawBytes, encoding: null };
+  if (
+    auth?.type === 'openai-direct' ||
+    _openaiReqZstdLatch.disabled() ||
+    typeof zlib.zstdCompress !== 'function' ||
+    rawBytes.length < REQ_COMPRESSION_MIN_BYTES ||
+    hasContentEncoding(headers)
+  ) {
+    return plain;
+  }
+  return compressBody(rawBytes, promisify(zlib.zstdCompress), 'zstd');
 }
 
 async function postWithRetries({
@@ -91,15 +97,32 @@ async function postWithRetries({
   _sleepFn,
 }) {
   const label = httpLabel(auth);
-  let bodyForSend = encodeRequestBody(auth, rawBytes);
-  let response;
-  let httpError = null;
-  for (let attempt = 0; attempt <= CODEX_REQUEST_MAX_RETRIES; attempt++) {
+  const bodyForSend = await encodeRequestBody(auth, headers, rawBytes);
+  const fetchOnce = async (bytes, sendHeaders) => {
     const headerTimeout = createTimeoutSignal(
       totalTimeout.signal,
       PROVIDER_HTTP_RESPONSE_TIMEOUT_MS,
       `${label} initial response`
     );
+    try {
+      return await fetchFn(responsesUrl, {
+        method: 'POST',
+        headers: sendHeaders,
+        body: bytes,
+        signal: headerTimeout.signal,
+        dispatcher: getLlmDispatcher(),
+      });
+    } catch (err) {
+      throw headerTimeout.signal?.aborted && headerTimeout.signal.reason instanceof Error
+        ? headerTimeout.signal.reason
+        : err;
+    } finally {
+      headerTimeout.cleanup();
+    }
+  };
+  let response;
+  let httpError = null;
+  for (let attempt = 0; attempt <= CODEX_REQUEST_MAX_RETRIES; attempt++) {
     let requestError = null;
     try {
       // Keep the established stage name for consumers, while making each
@@ -113,32 +136,20 @@ async function postWithRetries({
           retry: attempt > 0,
         });
       } catch {}
-      response = await fetchFn(responsesUrl, {
-        method: 'POST',
-        headers: _zstdHeaders(headers, bodyForSend),
-        body: bodyForSend.bytes,
-        signal: headerTimeout.signal,
-        dispatcher: getLlmDispatcher(),
+      response = bodyForSend.encoding
+        ? await fetchOnce(bodyForSend.bytes, withContentEncoding(headers, bodyForSend.encoding))
+        : await fetchOnce(rawBytes, headers);
+      // Encoding rejection (400/415): resent uncompressed inside this attempt,
+      // so it never consumes a retry; the latch flips only if that succeeds.
+      response = await resendIfEncodingRejected({
+        response,
+        encoded: Boolean(bodyForSend.encoding),
+        resend: () => fetchOnce(rawBytes, headers),
+        latch: _openaiReqZstdLatch,
       });
     } catch (err) {
-      requestError =
-        headerTimeout.signal?.aborted && headerTimeout.signal.reason instanceof Error
-          ? headerTimeout.signal.reason
-          : err;
-    } finally {
-      headerTimeout.cleanup();
-    }
-
-    // zstd rejection fallback: a 400 on a compressed request latches
-    // compression OFF process-wide and replays this attempt uncompressed.
-    if (response && response.status === 400 && bodyForSend.encoding) {
-      _disableOpenaiReqZstd();
-      bodyForSend = { bytes: rawBytes, encoding: null };
-      await response.arrayBuffer().catch(() => {});
       response = undefined;
-      // The uncompressed replay is not a retry: it must not consume an attempt.
-      attempt--;
-      continue;
+      requestError = err;
     }
     // The error body is read exactly once, here, into the contract fields.
     httpError = null;
@@ -183,8 +194,9 @@ async function postWithRetries({
       // Uncapped for retryable errors; the attempt count is
       // the bound, and the abort signal cancels the wait.
       // The shared schedule carries a leading duplicate (withRetry convention).
-    const raw = OPENAI_REQUEST_RETRY_OPTS.backoffMs[attempt + 1];
-      const delayMs = retryAfterMsFromError(attemptFailure) ?? jitterDelayMs(raw, OPENAI_REQUEST_RETRY_OPTS.retryJitterRatio);
+      const raw = OPENAI_REQUEST_RETRY_OPTS.backoffMs[attempt + 1];
+      const delayMs =
+        retryAfterMsFromError(attemptFailure) ?? jitterDelayMs(raw, OPENAI_REQUEST_RETRY_OPTS.retryJitterRatio);
       emitProviderRetryStage(onStageChange, {
         attempt: attempt + 2,
         maxAttempts: CODEX_REQUEST_MAX_RETRIES + 1,

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-events/output-items.mjs

@@ -6,6 +6,8 @@
  */
 import { recomputeToolInFlight } from '../response-state.mjs';
 import { parseJsonObject } from '../response-items.mjs';
+import { withToolCallNamespace } from '../../custom-tool-wire.mjs';
+import { isIncompleteToolItem } from '../../lib/responses-terminal-fields.mjs';
 
 function outputItemKind(item) {
   if (item.type === 'reasoning') return 'reasoning';
@@ -19,10 +21,10 @@ export function createOutputItemEvents({ state, items, meaningful }) {
   const onOutputItemAdded = (item) => {
     if (item?.type === 'function_call') {
       toolTracker.mark(item);
-      state.pendingCalls.set(item.id || '', {
-        name: item.name || '',
-        callId: item.call_id || '',
-      });
+      state.pendingCalls.set(
+        item.id || '',
+        withToolCallNamespace({ name: item.name || '', callId: item.call_id || '' }, item)
+      );
       state.toolInFlight = true;
     } else if (item?.type === 'tool_search_call') {
       // Mark tool_search as in-flight the moment the item is added,
@@ -66,12 +68,15 @@ export function createOutputItemEvents({ state, items, meaningful }) {
       meaningful('tool');
       return;
     }
-    const call = {
-      id: pending?.callId || event.call_id || '',
-      name: pending?.name || event.name || '',
-      arguments: parseJsonObject(event.arguments),
-      _pendingItemId: itemId,
-    };
+    const call = withToolCallNamespace(
+      {
+        id: pending?.callId || event.call_id || '',
+        name: pending?.name || event.name || '',
+        arguments: parseJsonObject(event.arguments),
+        _pendingItemId: itemId,
+      },
+      pending
+    );
     state.toolCalls.push(call);
     if (call.id && call.name) {
       delete call._pendingItemId;
@@ -81,9 +86,17 @@ export function createOutputItemEvents({ state, items, meaningful }) {
   };
 
   const onOutputItemDone = (item) => {
+    if (isIncompleteToolItem(item)) {
+      // Server-truncated call: stays in flight, never collected or replayed.
+      toolTracker.mark(item);
+      state.toolInFlight = true;
+      meaningful('tool');
+      return;
+    }
     items.pushResponseItem(item);
     items.pushReasoningItem(item);
     items.pushWebSearchCall(item);
+    state.refusals.absorbMessage(item);
     if (item.type === 'function_call') {
       const tc = state.toolCalls.find((t) => t._pendingItemId === (item.id || ''));
       if (tc) items.completePendingCall(tc, item);