mixdog 1.2.1 → 1.2.3

package/src/runtime/agent/orchestrator/providers/openai-retry-policy.mjs

@@ -0,0 +1,9 @@
+// OpenAI retry schedule: 200ms base, factor 2, ±10%.
+// Provider-owned values; the shared retry core only takes them as options.
+//   CODEX_STREAM_BACKOFF_MS        — indexed by the 1-based retry number
+//                                    (midstreamBackoffFor).
+//   CODEX_REQUEST_RETRY_BACKOFF_MS — leading duplicate for withRetry's
+//                                    sleep-before-attempt index.
+export const CODEX_STREAM_BACKOFF_MS = Object.freeze([200, 400, 800, 1600, 3200]);
+export const CODEX_REQUEST_RETRY_BACKOFF_MS = Object.freeze([200, ...CODEX_STREAM_BACKOFF_MS]);
+export const CODEX_RETRY_JITTER_RATIO = 0.1;

package/src/runtime/agent/orchestrator/providers/openai-ws-delta.mjs

@@ -279,7 +279,7 @@ function _stripResponseItemsFromHead(items, responseItems) {
 // Official OpenAI Responses WebSocket guide: response.create WS frames mirror
 // the Responses body EXCEPT the transport-only fields `stream`/`background`,
 // which the socket carries implicitly and the guide says to omit. This set is
-// stripped from a frame (any build shape) only when omitTransportFields is on.
+// always stripped from a frame (any build shape).
 const TRANSPORT_ONLY_FRAME_FIELDS = new Set(['stream', 'background']);
 
 // Canonical response.create frame builder. Every WS send (main full-frame
@@ -293,14 +293,12 @@ const TRANSPORT_ONLY_FRAME_FIELDS = new Set(['stream', 'background']);
 // response, so dropping them here strips the system/lead prompt from every
 // continuation turn. Only an empty instructions string is omitted.
 // Full frames pass the body unchanged and keep every key in place.
-// omitTransportFields is used by wire-parity helpers to drop stream/background.
 export function _buildResponseCreateFrame(
   body,
-  { previousResponseId = null, inputOverride, omitTransportFields = false } = {}
+  { previousResponseId = null, inputOverride } = {}
 ) {
   const src = body && typeof body === 'object' ? body : {};
   if (previousResponseId == null && inputOverride === undefined) {
-    if (!omitTransportFields) return { type: 'response.create', ...src };
     const frame = { type: 'response.create' };
     for (const key of Object.keys(src)) {
       if (TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
@@ -310,7 +308,7 @@ export function _buildResponseCreateFrame(
   }
   const frame = { type: 'response.create' };
   for (const key of Object.keys(src)) {
-    if (omitTransportFields && TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
+    if (TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
     if (key === 'instructions') {
       const instr = src.instructions;
       if (typeof instr === 'string' && instr.length) frame.instructions = instr;
@@ -366,17 +364,10 @@ export function _computeDelta({ entry, body, traceProvider }) {
   if (!entry?.lastRequestSansInput || !entry.lastResponseId) {
     return { mode: 'full', reason: 'no_anchor', frame: buildFrame(body) };
   }
-  // Public OpenAI resolves previous_response_id out of its response STORE, so
-  // an anchor only exists when the anchored response was stored. store:false
-  // there — e.g. an explicit MIXDOG_OAI_STORE=0 opt-out on the openai-direct
-  // provider — makes a continuation frame fail with
-  // previous_response_not_found, so the opt-out degrades to full frames.
-  // openai-oauth/Codex (per-WS-session server state) and xAI (in-connection
-  // ZDR continuation with encrypted reasoning) both anchor without the store
-  // and are deliberately excluded from this gate.
-  if (traceProvider === 'openai-direct' && body?.store !== true) {
-    return { mode: 'full', reason: 'store_disabled', frame: buildFrame(body) };
-  }
+  // WebSocket mode keeps the latest response in a connection-local cache, so
+  // previous_response_id continues on the same socket even with store:false.
+  // If the server no longer has the anchor (previous_response_not_found), the
+  // caller recovers with a full-context frame.
   if (!deltaForce && !deltaRefs && !entry.turnState) {
     return { mode: 'full', reason: 'delta_missing_turn_state', frame: buildFrame(body) };
   }

package/src/runtime/agent/orchestrator/providers/openai-ws-handshake.mjs

@@ -9,6 +9,11 @@
 import { appendFileSync, chmodSync } from 'node:fs';
 import { errText } from '../../../shared/err-text.mjs';
 import { _cfCookieCapture, _formatRedactedHeaders } from './openai-ws-headers.mjs';
+import { httpResponseError } from './openai-error-contract.mjs';
+
+// Enough of the handshake body to parse a typed JSON error; diagnostics are
+// truncated separately by the error message.
+const HANDSHAKE_BODY_LIMIT = 16 * 1024;
 
 /** CF cookie jar refresh plus the opt-in upgrade-header dump. */
 export function captureHandshakeUpgrade(auth, res) {
@@ -85,7 +90,7 @@ export function attachHandshakeFailureHandlers({ socket, errLabel, openStart, is
     const status = res?.statusCode || 0;
     let body = '';
     res.on('data', (c) => {
-      if (body.length < 2048) body += c.toString('utf-8');
+      if (body.length < HANDSHAKE_BODY_LIMIT) body += c.toString('utf-8');
     });
     res.on('end', () => {
       if (process.env.MIXDOG_DEBUG_AGENT) {
@@ -96,13 +101,16 @@ export function attachHandshakeFailureHandlers({ socket, errLabel, openStart, is
       try {
         socket.terminate();
       } catch {}
-      settle(
-        false,
-        Object.assign(new Error(`${errLabel} handshake ${status}: ${body.slice(0, 200)}`), {
-          httpStatus: status,
-          httpBody: body,
-        })
-      );
+      // Status, headers and the parsed body ride on the error; only the
+      // message is truncated.
+      const err = httpResponseError({
+        label: `${errLabel} handshake`,
+        status,
+        headers: res.headers,
+        text: body,
+      });
+      err.httpBody = body;
+      settle(false, err);
     });
   });
 }

package/src/runtime/agent/orchestrator/providers/openai-ws-response-state/refusals.mjs

@@ -0,0 +1,60 @@
+// Refusal content of one Responses stream. The model's refusal arrives as
+// `response.refusal.delta` / `response.refusal.done` and as a
+// `{type:'refusal', refusal}` content part of the message item
+// (output_item.done and the terminal output bundle). Parts are keyed by item
+// id + content index so the streamed, item-done and terminal copies of one
+// part fold into one text; a full (done / final-part) text replaces the
+// accumulated deltas. Shared by the WS and HTTP/SSE collectors.
+export function createRefusals() {
+  const parts = new Map();
+  const keyOf = (itemId, contentIndex) => `${itemId || ''}:${Number.isInteger(contentIndex) ? contentIndex : 0}`;
+
+  return {
+    /** response.refusal.delta */
+    delta(event) {
+      if (typeof event?.delta !== 'string') return;
+      const key = keyOf(event.item_id, event.content_index);
+      parts.set(key, (parts.get(key) || '') + event.delta);
+    },
+    /** response.refusal.done */
+    done(event) {
+      if (typeof event?.refusal !== 'string') return;
+      parts.set(keyOf(event.item_id, event.content_index), event.refusal);
+    },
+    /** A message item's refusal parts. Returns whether it carried any. */
+    absorbMessage(item) {
+      if (item?.type !== 'message' || !Array.isArray(item.content)) return false;
+      let found = false;
+      item.content.forEach((part, index) => {
+        if (part?.type !== 'refusal' || typeof part.refusal !== 'string') return;
+        found = true;
+        // An id-less item cannot be matched to its streamed copy; the
+        // streamed text already stands for it.
+        if (!item.id && parts.size > 0) return;
+        parts.set(keyOf(item.id, index), part.refusal);
+      });
+      return found;
+    },
+    get seen() {
+      return parts.size > 0;
+    },
+    get text() {
+      return [...parts.values()].filter(Boolean).join('\n');
+    },
+  };
+}
+
+/** The typed stop reason of a refused turn (read by the agent loop). */
+export const REFUSAL_STOP_REASON = 'refusal';
+
+/** Result fields for a refused turn — the shared result shape:
+ *    stopReason: REFUSAL_STOP_REASON
+ *    refusal:    the refusal text (joined parts; may be '')
+ *    content:    the output_text, or the refusal text when there was none
+ *  so a refusal never reads as an empty successful answer. Empty object when
+ *  the response carried no refusal. */
+export function refusalResultFields(refusals, content) {
+  if (!refusals.seen) return {};
+  const refusal = refusals.text;
+  return { content: content || refusal, refusal, stopReason: REFUSAL_STOP_REASON };
+}

package/src/runtime/agent/orchestrator/providers/openai-ws-response-state/tool-calls.mjs

@@ -1,7 +1,12 @@
 import { makeInvalidToolArgsMarker } from '../lib/openai-tool-args.mjs';
 import { synthLeakedOpenAICall } from '../openai-compat-stream-common.mjs';
 import { createToolCallDedupe, dedupeToolCallList } from '../lib/leaked-toolcall.mjs';
-import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from '../custom-tool-wire.mjs';
+import {
+  customToolCallFromResponseItem,
+  nativeToolSearchCallFromArguments,
+  qualifiedToolCallName,
+  withToolCallNamespace,
+} from '../custom-tool-wire.mjs';
 import { createActiveToolItemTracker } from '../tool-stream-state.mjs';
 
 // tool_search_call.arguments parse. Module-scope (exported) for direct test
@@ -64,7 +69,7 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     } catch {}
   }
   function emit(call) {
-    if (!toolDedupe.shouldDispatch(call?.name, call?.arguments, call?.id)) return;
+    if (!toolDedupe.shouldDispatch(qualifiedToolCallName(call), call?.arguments, call?.id)) return;
     fire(call);
   }
   function settle() {
@@ -84,6 +89,8 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
   }
   function pushToolSearchCall(item) {
     if (item?.type !== 'tool_search_call') return;
+    // Server-executed search already ran inside the response; replay-only.
+    if (item.execution === 'server') return;
     const callId = item.call_id || item.id || '';
     if (!callId || toolCalls.some((call) => call.id === callId)) return;
     const call = nativeToolSearchCallFromArguments(callId, parseToolSearchArgs(item.arguments));
@@ -106,7 +113,10 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     const type = item?.type;
     if (type === 'function_call') {
       markStarted(item);
-      pendingCalls.set(item.id || '', { name: item.name || '', callId: item.call_id || '' });
+      pendingCalls.set(
+        item.id || '',
+        withToolCallNamespace({ name: item.name || '', callId: item.call_id || '' }, item)
+      );
     } else if (type === 'custom_tool_call' || type === 'tool_search_call') {
       // tool_search is marked in-flight at item-added time too, so the
       // semantic-idle stall gate's pendingToolUse never drops a mid-flight
@@ -134,7 +144,7 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
       argumentsText: event.arguments || JSON.stringify(args),
     });
     if (pending?.callId && pending?.name) {
-      const call = { id: pending.callId, name: pending.name, arguments: args };
+      const call = withToolCallNamespace({ id: pending.callId, name: pending.name, arguments: args }, pending);
       toolCalls.push(call);
       emit(call);
       pendingCalls.delete(itemId);
@@ -150,31 +160,45 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     // bundle. If salvage also fails the stream fails explicitly — masking the
     // gap with a synthetic id just shifts the failure one turn later under a
     // confusing "No tool output found for function call" error.
-    toolCalls.push({
-      id: pending?.callId || '',
-      name: pending?.name || '',
-      arguments: args,
-      _pendingItemId: itemId,
-      _deferred: true,
-    });
+    toolCalls.push(
+      withToolCallNamespace(
+        {
+          id: pending?.callId || '',
+          name: pending?.name || '',
+          arguments: args,
+          _pendingItemId: itemId,
+          _deferred: true,
+        },
+        pending
+      )
+    );
   }
 
-  /** response.output_item.done for a function_call item */
+  /** A complete function_call item (output_item.done, or the terminal
+   *  response output bundle) through the one deduplicated collector: it
+   *  resolves the deferred placeholder for its item (canonical call_id/name
+   *  from the item, missing ones kept from the placeholder), is skipped when
+   *  its call_id is already recorded, and is otherwise created and
+   *  dispatched — so a call present only in the terminal bundle still runs. */
   function completeFunctionCallItem(item) {
     const itemId = item.id || '';
     const callId = item.call_id || '';
     const name = item.name || '';
     const args = parseFunctionCallArgs(argsTextOf(item.arguments));
     const deferred = toolCalls.find((tc) => tc?._deferred && (!itemId || tc._pendingItemId === itemId));
-    if (deferred && callId && name) {
-      deferred.id = callId;
-      deferred.name = name;
-      deferred.arguments = deferred.arguments && Object.keys(deferred.arguments).length > 0 ? deferred.arguments : args;
-      delete deferred._deferred;
-      delete deferred._pendingItemId;
-      emit(deferred);
+    if (deferred) {
+      deferred.id = callId || deferred.id;
+      deferred.name = name || deferred.name;
+      withToolCallNamespace(deferred, item);
+      if (deferred.id && deferred.name) {
+        deferred.arguments =
+          deferred.arguments && Object.keys(deferred.arguments).length > 0 ? deferred.arguments : args;
+        delete deferred._deferred;
+        delete deferred._pendingItemId;
+        emit(deferred);
+      }
     } else if (callId && name && !toolCalls.some((tc) => tc?.id === callId)) {
-      const call = { id: callId, name, arguments: args };
+      const call = withToolCallNamespace({ id: callId, name, arguments: args }, item);
       toolCalls.push(call);
       emit(call);
     }
@@ -193,20 +217,6 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     settle();
   }
 
-  /** response.completed salvage: when arguments.done fired before (or
-   *  without) a matching output_item.added, the deferred placeholder has an
-   *  empty id/name; the bundle carries the canonical call_id/name. */
-  function salvageFunctionCall(item) {
-    const tc = toolCalls.find((t) => t._deferred && t._pendingItemId === (item.id || ''));
-    if (!tc) return;
-    if (!tc.id && item.call_id) tc.id = item.call_id;
-    if (!tc.name && item.name) tc.name = item.name;
-    if (tc.id && tc.name) {
-      delete tc._deferred;
-      delete tc._pendingItemId;
-      emit(tc);
-    }
-  }
 
   return {
     get calls() {
@@ -238,6 +248,12 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     completeFunctionCallItem,
     completeToolSearchItem,
     completeCustomToolItem,
-    salvageFunctionCall,
+    /** A server-truncated call item: kept in flight, never collected. */
+    holdIncompleteItem: markStarted,
+    // Terminal-bundle salvage (response.completed / success response.done):
+    // the same collector as output_item.done. When arguments.done fired
+    // before (or without) output_item.added, the deferred placeholder has an
+    // empty id/name and the bundle carries the canonical call_id/name.
+    salvageFunctionCall: completeFunctionCallItem,
   };
 }

package/src/runtime/agent/orchestrator/providers/openai-ws-response-state.mjs

@@ -13,6 +13,8 @@ import { createReplayItems } from './openai-ws-response-state/replay-items.mjs';
 import { createCitations } from './openai-ws-response-state/citations.mjs';
 import { createWsToolCalls } from './openai-ws-response-state/tool-calls.mjs';
 import { normalizeWsUsage } from './openai-ws-response-state/usage.mjs';
+import { createRefusals, refusalResultFields } from './openai-ws-response-state/refusals.mjs';
+import { isIncompleteToolItem } from './lib/responses-terminal-fields.mjs';
 
 export { parseToolSearchArgs } from './openai-ws-response-state/tool-calls.mjs';
 
@@ -37,6 +39,7 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
   const reasoningDeltas = { text: 0, summary: 0, other: 0 };
   const replayItems = createReplayItems();
   const citations = createCitations();
+  const refusals = createRefusals();
   const tools = createWsToolCalls({ onToolCall, midState, replayItems });
   const replayProvider = traceProvider === 'xai' ? 'xai-responses' : 'openai-responses';
   const progress = (kind) => {
@@ -49,6 +52,11 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
   // anything the per-item events never carried. Returns whether any progress
   // was reported.
   function salvageCompletedItem(item, relayFinalText) {
+    if (isIncompleteToolItem(item)) {
+      tools.holdIncompleteItem(item);
+      progress('tool');
+      return true;
+    }
     replayItems.push(item);
     let reported = false;
     if (item.type === 'message') {
@@ -64,6 +72,10 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
         }
         citations.pushOutputTextAnnotations(c);
       }
+      if (refusals.absorbMessage(item)) {
+        progress('semantic');
+        reported = true;
+      }
     }
     if (item.type === 'web_search_call') {
       citations.pushWebSearchCall(item);
@@ -146,10 +158,19 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
     noteToolInputDelta: tools.noteToolInputDelta,
     /** response.function_call_arguments.done */
     completeFunctionCallArguments: tools.completeFunctionCallArguments,
+    /** response.refusal.delta */
+    noteRefusalDelta: refusals.delta,
+    /** response.refusal.done */
+    noteRefusalDone: refusals.done,
     /** response.output_item.done. Returns the progress kind to report. */
     completeOutputItem(item) {
+      if (isIncompleteToolItem(item)) {
+        tools.holdIncompleteItem(item);
+        return 'tool';
+      }
       replayItems.push(item);
       const type = item?.type || '';
+      if (type === 'message') refusals.absorbMessage(item);
       // function_call / output_text already arrive via their dedicated
       // streaming events; `reasoning` carries encrypted_content that keeps the
       // openai-oauth server-side prompt cache prefix warm.
@@ -189,6 +210,13 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
       if (!responseId && response?.id) responseId = response.id;
       return usage;
     },
+    /** A cutoff frame's output bundle: call items the server truncated stay
+     *  in flight so the cutoff reads as a pending-tool turn. */
+    holdIncompleteBundleItems(response) {
+      for (const item of response?.output || []) {
+        if (isIncompleteToolItem(item)) tools.holdIncompleteItem(item);
+      }
+    },
     /** max_output_tokens maps cleanly to Anthropic's stop_reason=max_tokens. */
     markMaxOutputIncomplete(reason) {
       incompleteReason = reason;
@@ -227,6 +255,8 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
         ...(typeof endTurn === 'boolean' ? { endTurn } : {}),
         responseId: responseId || undefined,
         serviceTier: responseServiceTier || undefined,
+        // A refused turn: typed stop reason and the refusal text.
+        ...refusalResultFields(refusals, content),
       };
     },
   };

package/src/runtime/agent/orchestrator/providers/openai-ws-send-attempts/attempt-context.mjs

@@ -3,7 +3,6 @@
  * WS send, plus the surface/backoff primitives both failure resolvers use.
  */
 import { performance } from 'node:perf_hooks';
-import { retryAfterMsFromError } from '../retry-classifier.mjs';
 import { _sleepWithAbort, MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT, midstreamBackoffFor, tag } from './policy.mjs';
 
 export function createAttemptContext(deps) {
@@ -35,7 +34,7 @@ export function createAttemptContext(deps) {
   const backoff = async (retryNumber, err = null) => {
     const sleepStart = performance.now();
     try {
-      await _sleepWithAbort(retryAfterMsFromError(err) ?? midstreamBackoffFor(retryNumber), externalSignal, sleepFn);
+      await _sleepWithAbort(midstreamBackoffFor(retryNumber, err), externalSignal, sleepFn);
     } catch (sleepErr) {
       sendSpan.retryBackoffMs += performance.now() - sleepStart;
       sendSpan.emit('error');

package/src/runtime/agent/orchestrator/providers/openai-ws-send-attempts/policy.mjs

@@ -2,12 +2,13 @@
  * policy.mjs — the WS send retry budget, its backoff curves and the
  * classification wrappers shared by the handshake and stream resolvers.
  */
+import { CODEX_RETRY_JITTER_RATIO, CODEX_STREAM_BACKOFF_MS } from '../openai-retry-policy.mjs';
 import {
   classifyHandshakeError,
   classifyMidstreamError,
   isWsMessageTooBigClose,
-  jitterDelayMs,
   MIDSTREAM_RETRY_POLICY,
+  midstreamBackoffFor as sharedMidstreamBackoffFor,
   sleepWithAbort,
 } from '../retry-classifier.mjs';
 
@@ -15,23 +16,26 @@ import {
 // by connect/handshake and pre-output stream failures.
 export const MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT = MIDSTREAM_RETRY_POLICY.ws.transientCloseRetries;
 const MIDSTREAM_DEFAULT_RETRY_LIMIT = MIDSTREAM_RETRY_POLICY.ws.defaultRetries;
-// The reference client uses a 200ms base, factor 2, and symmetric ±10%
-// jitter for each of its five stream retries.
-const MIDSTREAM_BACKOFF_MS = Object.freeze([200, 400, 800, 1600, 3200]);
-const CODEX_RETRY_JITTER_RATIO = 0.1;
+// The stream retry schedule (200ms base, factor 2, ±10%) lives in
+// openai-retry-policy.mjs, shared with the HTTP request loop.
+// Advice-gated retry (OAuth and API-key WS alike): an overload and an untyped 429
+// retry only when the server gave advice.
+const ADVICE_GATES = Object.freeze({
+  overloadRetryRequiresAdvice: true,
+  generic429RetryRequiresAdvice: true,
+});
 // Policy object passed to the shared classifyMidstreamError for the WS path.
 const WS_MIDSTREAM_POLICY = {
   mode: 'ws',
   transientCloseRetries: MIDSTREAM_RETRY_POLICY.ws.transientCloseRetries,
   defaultRetries: MIDSTREAM_RETRY_POLICY.ws.defaultRetries,
+  ...ADVICE_GATES,
 };
 
 // Kept for the _acquireWithRetry test seam and non-Codex callers.
 // sendViaWebSocket deliberately invokes it with maxAttempts:1 so handshake
 // failures consume the same stream budget as pre-output disconnects.
 export const HANDSHAKE_MAX_ATTEMPTS = MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT + 1;
-const HANDSHAKE_BACKOFF_BASE_MS = 200;
-const HANDSHAKE_BACKOFF_CAP_MS = 3200;
 // These statuses are decisions made by the CURRENT attempt. They must never
 // be replaced by a stale transient from an earlier retry: auth recovery,
 // transport fallback, and Retry-After handling all depend on the live error.
@@ -47,8 +51,15 @@ export function _mustSurfaceCurrentAttempt(err, externalSignal) {
   );
 }
 
-export function _classifyHandshakeError(err, { retry429 = true } = {}) {
-  return classifyHandshakeError(err, { retry429 });
+export function _classifyHandshakeError(
+  err,
+  {
+    retry429 = true,
+    overloadRetryRequiresAdvice = ADVICE_GATES.overloadRetryRequiresAdvice,
+    generic429RetryRequiresAdvice = ADVICE_GATES.generic429RetryRequiresAdvice,
+  } = {}
+) {
+  return classifyHandshakeError(err, { retry429, overloadRetryRequiresAdvice, generic429RetryRequiresAdvice });
 }
 
 /**
@@ -103,15 +114,15 @@ export function midstreamRetryLimit(classifier) {
     : MIDSTREAM_DEFAULT_RETRY_LIMIT;
 }
 
-export function midstreamBackoffFor(retryNumber) {
-  const raw = MIDSTREAM_BACKOFF_MS[Math.min(Math.max(retryNumber, 1), MIDSTREAM_BACKOFF_MS.length) - 1];
-  return jitterDelayMs(raw, CODEX_RETRY_JITTER_RATIO);
+// Passing the failure makes server advice replace the step for retryable
+// kinds only (midstreamRetryDelayMs).
+export function midstreamBackoffFor(retryNumber, err = null) {
+  return sharedMidstreamBackoffFor(retryNumber, CODEX_STREAM_BACKOFF_MS, err, CODEX_RETRY_JITTER_RATIO);
 }
 
 export function _backoffFor(attempt) {
   // attempt is 1-based; exponential backoff is capped before jitter.
-  const raw = HANDSHAKE_BACKOFF_BASE_MS * (1 << (attempt - 1));
-  return jitterDelayMs(Math.min(raw, HANDSHAKE_BACKOFF_CAP_MS), CODEX_RETRY_JITTER_RATIO);
+  return midstreamBackoffFor(attempt);
 }
 
 export const _defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/src/runtime/agent/orchestrator/providers/openai-ws-stream/event-switch.mjs

@@ -88,6 +88,18 @@ export function createWsEventSwitch({ response, textRelay, watchdogs, midState,
         progress('tool');
         watchdogs.bumpSemantic();
         break;
+      // Refusal text is model output but never visible answer text: it is
+      // collected for the typed refusal result, not relayed live.
+      case 'response.refusal.delta':
+        response.noteRefusalDelta(event);
+        progress('semantic');
+        watchdogs.bumpSemantic();
+        break;
+      case 'response.refusal.done':
+        response.noteRefusalDone(event);
+        progress('semantic');
+        watchdogs.bumpSemantic();
+        break;
       case 'response.output_item.done': {
         const kind = response.completeOutputItem(event.item);
         // Item-done is genuine lifecycle progress — reset semantic idle so

package/src/runtime/agent/orchestrator/providers/openai-ws-stream/terminal-frames.mjs

@@ -27,11 +27,30 @@ export function createTerminalFrameHandlers({ response, textRelay, midState, err
 
   // Most incomplete reasons are real failures. max_output_tokens maps cleanly
   // to Anthropic's stop_reason=max_tokens; treating it as an error makes
-  // Claude retry the same over-budget turn.
+  // Claude retry the same over-budget turn — unless a tool call's input was
+  // still streaming: its arguments were truncated, so the cutoff is a
+  // stalled pending-tool turn (same guard as HTTP/SSE), never a clean length
+  // completion that would surface the partial call as successful.
   function settleIncomplete(event, label, options) {
     const usage = response.noteTerminal(event.response);
     const reasonStr = _incompleteReasonFromEvent(event);
     if (_isMaxOutputIncompleteReason(reasonStr)) {
+      response.holdIncompleteBundleItems(event.response);
+      if (response.pendingToolUse) {
+        const error = new Error(`${label} (max_output_tokens) with tool call in flight`);
+        try {
+          textRelay.flush();
+        } catch {
+          /* best-effort */
+        }
+        Object.assign(error, response.partialState());
+        error.streamStalled = true;
+        error.pendingToolUse = true;
+        error.incompleteReason = reasonStr;
+        if (usage) error.partialUsage = usage;
+        failWith(error, options);
+        return;
+      }
       response.markMaxOutputIncomplete(reasonStr);
       completeTurn();
       return;
@@ -105,11 +124,11 @@ export function createTerminalFrameHandlers({ response, textRelay, midState, err
       failWith(responseDoneStatusError(status, `${errLabel} response.done unexpected status`), { markDone: true });
       return;
     }
-    // Success-shaped response.done (status '' or 'completed') carries the
-    // same optional end_turn, and the response's usage.
-    response.noteTerminal(event.response);
-    response.setEndTurn(_endTurnFromEvent(event));
-    completeTurn();
+    // Success-shaped response.done (status '' or 'completed') is the same
+    // terminal as response.completed: usage, end_turn, and its output bundle
+    // reconciled through the same deduplicated collectors (calls that appear
+    // only in the bundle are created; unresolvable deferred calls fail).
+    onResponseCompleted(event);
   }
 
   function onResponseIncomplete(event) {

package/src/runtime/agent/orchestrator/providers/openai-ws-terminal.mjs

@@ -4,6 +4,7 @@
  * builder returns a tagged Error the stream loop stores as terminalError.
  */
 import { typedStatusFrom } from './retry-classifier.mjs';
+import { applyErrorContract, markContentFilter } from './openai-error-contract.mjs';
 import { _httpStatusFromWsClose } from './openai-ws-events.mjs';
 
 /** A server `event.error` on any frame. Same wire-error contract as
@@ -17,10 +18,9 @@ export function serverErrorEventError(error, event) {
   try {
     err.payload = error;
     err.responseFailed = event;
-    const typed = typedStatusFrom(error, event);
-    if (typed) err.httpStatus = typed;
     const code = error.code ?? error.type ?? null;
     if (typeof code === 'string' && code) err.providerErrorCode = code;
+    applyErrorContract(err, { status: typedStatusFrom(error, event), error, event });
   } catch {}
   return err;
 }
@@ -32,23 +32,27 @@ export function serverErrorEventError(error, event) {
 export function responseFailedError(event, { label, fallbackMessage, providerErrorCode = false }) {
   const msg = event.response?.error?.message || event.error?.message || event.message || fallbackMessage;
   const err = Object.assign(new Error(`${label}: ${msg}`), { responseFailed: event });
-  const typed = typedStatusFrom(event.response?.error, event.error, event);
-  if (typed) err.httpStatus = typed;
+  const detail = event.response?.error || event.error || null;
   if (providerErrorCode) {
-    const detail = event.response?.error || event.error || null;
     const code = detail?.code ?? detail?.type ?? null;
     if (typeof code === 'string' && code) err.providerErrorCode = code;
   }
-  return err;
+  return applyErrorContract(err, {
+    status: typedStatusFrom(event.response?.error, event.error, event),
+    error: detail,
+    event,
+  });
 }
 
 /** response.incomplete (or response.done status 'incomplete') for a reason
- *  other than max_output_tokens. */
+ *  other than max_output_tokens. A content_filter stop is a typed policy
+ *  refusal (code 'content_filter'), not an untyped failure. */
 export function responseIncompleteError(event, reasonStr, label) {
-  return Object.assign(new Error(`${label}: ${reasonStr}`), {
+  const err = Object.assign(new Error(`${label}: ${reasonStr}`), {
     responseIncomplete: event,
     incompleteReason: reasonStr,
   });
+  return markContentFilter(err, reasonStr);
 }
 
 /** response.done with a status that is neither completed, failed nor incomplete. */
@@ -63,11 +67,14 @@ export function errorFrameError(event, label) {
   const errMsg = String(event.message || event.error?.message || 'unknown');
   const err = new Error(`${label}: ${errMsg}`);
   err.responseFailed = event;
-  const typed = typedStatusFrom(event.error, event);
-  if (typed) err.httpStatus = typed;
   const code = event.error?.code ?? event.error?.type ?? event.code ?? null;
   if (typeof code === 'string' && code) err.providerErrorCode = code;
-  return err;
+  return applyErrorContract(err, {
+    status: typedStatusFrom(event.error, event),
+    code: typeof code === 'string' ? code : undefined,
+    error: event.error,
+    event,
+  });
 }
 
 /** The socket closed before a terminal frame. */