mixdog 1.2.2 → 1.2.4

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

@@ -8,6 +8,7 @@ import { typedStatusFrom } from '../../retry-classifier.mjs';
 import {
   endTurnFromEvent,
   incompleteReasonFromEvent,
+  isIncompleteToolItem,
   isMaxOutputIncompleteReason,
 } from '../../lib/responses-terminal-fields.mjs';
 import { applyErrorContract, markContentFilter } from '../../openai-error-contract.mjs';
@@ -36,6 +37,13 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
   const absorbCompletedOutput = (output) => {
     let reported = false;
     for (const item of output) {
+      if (isIncompleteToolItem(item)) {
+        state.toolTracker.mark(item);
+        state.toolInFlight = true;
+        meaningful('tool');
+        reported = true;
+        continue;
+      }
       items.pushResponseItem(item);
       if (item.type === 'message') {
         if (text.absorbCompletedMessage(item)) reported = true;
@@ -101,26 +109,41 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
       }
       throw err;
     }
+    for (const item of event.response?.output || []) {
+      if (isIncompleteToolItem(item)) {
+        state.toolTracker.mark(item);
+        state.toolInFlight = true;
+      }
+    }
     if (toolInputPending(state)) {
-      const err = outcome.stampToolSafety(new Error(`${state.label} ${frame} (max_output_tokens) with tool call in flight`));
+      // Same carried state as the WS path: text (leak-guard tail flushed),
+      // the calls already complete and dispatched, model and billed usage.
+      text.flushLeak();
+      const err = outcome.stampToolSafety(
+        new Error(`${state.label} ${frame} (max_output_tokens) with tool call in flight`)
+      );
+      outcome.attachStreamPartial(err);
       err.streamStalled = true;
       err.pendingToolUse = true;
-      err.partialContent = state.content;
-      err.partialModel = state.model || undefined;
+      err.incompleteReason = reason;
       if (state.usage) err.partialUsage = state.usage;
       throw err;
     }
     state.completed = true;
     state.stopReason = 'length';
+    state.incompleteReason = reason;
   };
 
   const onDone = (event) => {
-    if (!event.response || event.response.status === 'completed') {
-      if (event.response) absorbTerminalResponse(event.response);
+    if (!event.response) {
       state.completed = true;
       // Terminal success frame for streams that never emit a separate
       // response.completed — same optional end_turn.
       setEndTurn(event);
+    } else if (event.response.status === 'completed') {
+      // Same terminal as response.completed: usage, end_turn and the output
+      // bundle reconciled through the same deduplicated collectors.
+      onCompleted(event);
     } else if (event.response.status === 'failed') {
       const msg = event.response?.error?.message || 'response.done failed';
       const err = new Error(`${state.label} response.done failed: ${msg}`);

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

@@ -42,6 +42,16 @@ export function createResponseEvents({ state, items, text, outcome, meaningful,
       case 'response.function_call_arguments.done':
         output.onFunctionCallArgumentsDone(event);
         break;
+      // Refusal text is collected for the typed refusal result, never relayed
+      // as visible answer text.
+      case 'response.refusal.delta':
+        state.refusals.delta(event);
+        meaningful('semantic');
+        break;
+      case 'response.refusal.done':
+        state.refusals.done(event);
+        meaningful('semantic');
+        break;
       case 'response.output_item.done':
         output.onOutputItemDone(event.item || {});
         break;

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

@@ -5,7 +5,12 @@
  * pending function_call completion.
  */
 import { makeInvalidToolArgsMarker } from '../lib/openai-tool-args.mjs';
-import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from '../custom-tool-wire.mjs';
+import {
+  customToolCallFromResponseItem,
+  nativeToolSearchCallFromArguments,
+  qualifiedToolCallName,
+  withToolCallNamespace,
+} from '../custom-tool-wire.mjs';
 
 // Completed function_call.arguments parse for the OpenAI Responses stream.
 // A function_call item arrives only on a completion/done signal, so a
@@ -37,7 +42,7 @@ export function createResponseItems({ state, onToolCall }) {
     if (!call?.id) return;
     if (state.emittedToolCallIds.has(call.id)) return;
     state.emittedToolCallIds.add(call.id);
-    if (!state.toolDedupe.shouldDispatch(call.name, call.arguments, call.id)) return;
+    if (!state.toolDedupe.shouldDispatch(qualifiedToolCallName(call), call.arguments, call.id)) return;
     state.emittedToolCall = true;
     try {
       onToolCall?.(call);
@@ -77,6 +82,8 @@ export function createResponseItems({ state, onToolCall }) {
   };
   const 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 || state.toolCalls.some((t) => t.id === callId)) return;
     let args = {};
@@ -104,6 +111,7 @@ export function createResponseItems({ state, onToolCall }) {
   const completePendingCall = (tc, item) => {
     if (!tc.id && item.call_id) tc.id = item.call_id;
     if (!tc.name && item.name) tc.name = item.name;
+    withToolCallNamespace(tc, item);
     if (tc.id && tc.name) {
       delete tc._pendingItemId;
       emitToolCall(tc);
@@ -119,11 +127,14 @@ export function createResponseItems({ state, onToolCall }) {
     if (tc) {
       completePendingCall(tc, item);
     } else if (item.call_id && item.name) {
-      const call = {
-        id: item.call_id,
-        name: item.name,
-        arguments: parseJsonObject(item.arguments),
-      };
+      const call = withToolCallNamespace(
+        {
+          id: item.call_id,
+          name: item.name,
+          arguments: parseJsonObject(item.arguments),
+        },
+        item
+      );
       state.toolCalls.push(call);
       emitToolCall(call);
     }

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-outcome.mjs

@@ -9,6 +9,7 @@ import { dedupeToolCallList } from '../lib/leaked-toolcall.mjs';
 import { _displayCodexModel } from '../openai-codex-model.mjs';
 import { createProviderReplay } from '../lib/provider-replay.mjs';
 import { createResponseStamps } from './response-stamps.mjs';
+import { refusalResultFields } from '../openai-ws-response-state/refusals.mjs';
 
 export function createResponseOutcome({ state }) {
   const { stampToolSafety, stampOutcome, stallPartial, stampStreamError, attachStreamPartial, endedEarlyError } =
@@ -74,6 +75,7 @@ export function createResponseOutcome({ state }) {
       webSearchCalls: state.webSearchCalls.length ? state.webSearchCalls : undefined,
       usage: state.usage || undefined,
       stopReason: state.stopReason || undefined,
+      incompleteReason: state.incompleteReason || undefined,
       // Only present when the terminal frame carried the wire field.
       ...(typeof state.endTurn === 'boolean' ? { endTurn: state.endTurn } : {}),
       // Text-only max-output cutoff (status:'incomplete'/reason=max_output_tokens
@@ -83,6 +85,8 @@ export function createResponseOutcome({ state }) {
       ...(state.stopReason === 'length' && state.content.length > 0 ? { truncated: true } : {}),
       responseId: state.responseId || undefined,
       serviceTier: state.serviceTier || undefined,
+      // A refused turn: typed stop reason and the refusal text.
+      ...refusalResultFields(state.refusals, state.content),
     };
   };
 

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

@@ -7,6 +7,7 @@
  */
 import { createActiveToolItemTracker } from '../tool-stream-state.mjs';
 import { createToolCallDedupe } from '../lib/leaked-toolcall.mjs';
+import { createRefusals } from '../openai-ws-response-state/refusals.mjs';
 
 export function createResponseState(label) {
   return {
@@ -31,8 +32,12 @@ export function createResponseState(label) {
     citationKeys: new Set(),
     webSearchCalls: [],
     webSearchCallKeys: new Set(),
+    // Refusal parts (streamed and final), folded into one typed refusal.
+    refusals: createRefusals(),
     completed: false,
     stopReason: null,
+    // Why a max-output cutoff completed the turn (response.incomplete_details).
+    incompleteReason: null,
     // Normalized wire `end_turn` from the terminal frame; undefined unless the
     // server actually supplied a boolean.
     endTurn: undefined,

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/text-relay.mjs

@@ -97,10 +97,18 @@ export function createTextRelay({ state, body, onTextDelta, meaningful, emitTool
   };
   const absorbCompletedMessage = (item) => {
     let reported = false;
+    // Decided once per message item (as the WS completed-item fold does), so
+    // every content part of an item with no streamed text is absorbed rather
+    // than only the first one that fills `state.content`.
+    const absorbText = !state.content;
     for (const part of item.content || []) {
-      if (!state.content && part.type === 'output_text' && absorbCompletedText(part)) reported = true;
+      if (absorbText && part.type === 'output_text' && absorbCompletedText(part)) reported = true;
       if (part.type === 'output_text') pushOutputTextAnnotations(part, state.citations, state.citationKeys);
     }
+    if (state.refusals.absorbMessage(item)) {
+      meaningful('semantic');
+      reported = true;
+    }
     return reported;
   };
 

package/src/runtime/agent/orchestrator/providers/openai-model-capabilities.mjs

@@ -0,0 +1,80 @@
+// Public OpenAI API model capabilities for Responses request construction.
+// Catalog metadata decides where it declares a capability; otherwise the
+// documented model-family rules below apply. The Codex (openai-oauth) route is
+// separate: its backend serves only current GPT-5.x models and keeps its own
+// defaults, so none of these gates apply to it.
+//   reasoning:    https://developers.openai.com/api/docs/guides/reasoning/
+//   tool_search:  https://developers.openai.com/api/docs/guides/tools-tool-search/ (gpt-5.4 and later)
+//   cache:        https://developers.openai.com/api/docs/guides/prompt-caching/
+import { getModelMetadataSync } from '../../../shared/llm/model-catalog.mjs';
+
+const SNAPSHOT_SUFFIX = /-\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.
+export function openAiCatalogMeta(model) {
+  const id = modelId(model);
+  for (const candidate of new Set([id, id.replace(SNAPSHOT_SUFFIX, '')])) {
+    const meta = candidate ? getModelMetadataSync(candidate, 'openai') : null;
+    if (meta) return meta;
+  }
+  return null;
+}
+
+// gpt-5.4 -> [5, 4]; gpt-6-astra -> [6, 0]; non-GPT ids -> null.
+// A bare multi-digit major with no minor or family suffix (gpt-60) is not a
+// generation id.
+function gptVersion(id) {
+  const m = /^gpt-(\d+)(?:\.(\d+))?(?=-|$)/.exec(id);
+  if (!m || (m[1].length > 1 && m[2] === undefined && m[0] === id)) return null;
+  return [Number(m[1]), Number(m[2] || 0)];
+}
+const atLeast = (version, major, minor) =>
+  Boolean(version) && (version[0] > major || (version[0] === major && version[1] >= minor));
+
+// Reasoning models: the o-series and GPT-5 and later (gpt-5-chat-latest is the
+// non-reasoning chat snapshot).
+export function openAiPublicSupportsReasoning(model) {
+  const flag = openAiCatalogMeta(model)?.supportsReasoning;
+  if (typeof flag === 'boolean') return flag;
+  const id = modelId(model);
+  if (/^gpt-5-chat/.test(id)) return false;
+  return /^o\d/.test(id) || atLeast(gptVersion(id), 5, 0);
+}
+
+// text.verbosity is documented for GPT-5 and later.
+export function openAiPublicSupportsVerbosity(model) {
+  return atLeast(gptVersion(modelId(model)), 5, 0);
+}
+
+// Native tool_search: Responses API gpt-5.4 and later.
+export function openAiPublicSupportsToolSearch(model) {
+  return atLeast(gptVersion(modelId(model)), 5, 4);
+}
+
+// GPT-5.6 and later take prompt_cache_options.ttl instead of prompt_cache_retention.
+export function openAiUsesPromptCacheOptions(model) {
+  return atLeast(gptVersion(modelId(model)), 5, 6);
+}
+
+// Documented extended (24h) prompt_cache_retention list; dated snapshots read
+// as their alias.
+const EXTENDED_RETENTION = new Set([
+  'gpt-5.5',
+  'gpt-5.5-pro',
+  'gpt-5.4',
+  'gpt-5.2',
+  'gpt-5.1-codex-max',
+  'gpt-5.1',
+  'gpt-5.1-codex',
+  'gpt-5.1-codex-mini',
+  'gpt-5.1-chat-latest',
+  'gpt-5',
+  'gpt-5-codex',
+  'gpt-4.1',
+]);
+export function openAiSupportsExtendedRetention(model) {
+  const id = modelId(model);
+  return EXTENDED_RETENTION.has(id) || EXTENDED_RETENTION.has(id.replace(SNAPSHOT_SUFFIX, ''));
+}

package/src/runtime/agent/orchestrator/providers/openai-oauth-dispatch.mjs

@@ -102,7 +102,9 @@ export function createOpenAiOAuthDispatch({
     for (const [key, expiresAt] of provider._httpFallbackUntilByPoolKey) {
       if (!(expiresAt > now)) provider._httpFallbackUntilByPoolKey.delete(key);
     }
-    return (provider._httpFallbackUntilByPoolKey.get(poolKey) || 0) > now;
+    // A forked transport scope follows its session's switch; it records its own.
+    const sessionUntil = opts.sessionId ? provider._httpFallbackUntilByPoolKey.get(opts.sessionId) || 0 : 0;
+    return Math.max(provider._httpFallbackUntilByPoolKey.get(poolKey) || 0, sessionUntil) > now;
   };
   const markStickyHttpFallback = () => {
     if (!poolKey) return;

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

@@ -20,6 +20,8 @@ import { httpLabel } from './openai-error-contract.mjs';
 import { openHttpSseResponse } from './openai-http-sse-request.mjs';
 import { createHttpSseWatchdogs } from './openai-http-sse-watchdogs.mjs';
 import { createHttpSseResponseState } from './openai-http-sse-response-state.mjs';
+import { codexUserAgent, codexVersionHeader } from './codex-client-meta.mjs';
+import { _codexBetaFeatures } from './openai-ws-headers.mjs';
 export { _envFlag };
 
 function _sseEventsFromBuffer(buffer) {
@@ -73,6 +75,11 @@ export function _buildOpenAIHttpFallbackHeaders({
     originator: CODEX_OAUTH_ORIGINATOR,
     'chatgpt-account-id': auth.account_id || '',
     'x-client-request-id': randomBytes(16).toString('hex'),
+    // Codex identity shared with the WS handshake (build_responses_headers);
+    // WS-only OpenAI-Beta value stays HTTP-specific above.
+    'User-Agent': codexUserAgent(),
+    version: codexVersionHeader(),
+    'x-codex-beta-features': _codexBetaFeatures(),
   };
   if (cacheKey && !statelessConversation) {
     const sid = String(cacheKey);

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

@@ -152,6 +152,11 @@ export class OpenAIOAuthProvider {
     return this.tokens;
   }
 
+  /** Drop a disposed transport scope's sticky transport record. */
+  releaseTransportScope(scope) {
+    this._httpFallbackUntilByPoolKey.delete(scope);
+  }
+
   send(messages, model, tools, sendOpts) {
     return withEffortConfigurationFallback('openai-oauth', model, sendOpts || {}, (opts) =>
       this._sendOnce(messages, model, tools, opts)
@@ -207,7 +212,8 @@ export class OpenAIOAuthProvider {
     // session. cacheKey is body.prompt_cache_key and affects prompt-cache
     // routing only; Codex handshake identity comes from sendOpts and remains
     // independent so a future cache-lane policy cannot merge conversations.
-    const poolKey = opts.sessionId || null;
+    // A forked request runs in its own transport scope (transport-scope.mjs).
+    const poolKey = opts.transportScope || opts.sessionId || null;
     const cacheKey = body.prompt_cache_key || resolveProviderCacheKey(opts, 'openai-oauth');
     const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;
     const sendWs = typeof opts._sendViaWebSocketFn === 'function' ? opts._sendViaWebSocketFn : sendViaWebSocket;

package/src/runtime/agent/orchestrator/providers/openai-responses-input.mjs

@@ -9,8 +9,30 @@ import {
   isCustomToolCallRecord,
   nativeToolSearchCallInput,
   nativeToolSearchOutputInput,
+  toolCallNamespace,
 } from './custom-tool-wire.mjs';
 
+// A call record that carries a Responses namespace replays it beside `name`.
+const namespaceField = (call) => {
+  const namespace = toolCallNamespace(call);
+  return namespace ? { namespace } : {};
+};
+
+// A replayed native tool_search item for a model that has no tool_search tool:
+// a client call becomes the load_tool function call (its output is lowered
+// from the tool message), server-executed calls and outputs are dropped.
+function withoutNativeToolSearch(item) {
+  if (item?.type === 'tool_search_output') return null;
+  if (item?.type !== 'tool_search_call') return item;
+  if (item.execution === 'server' || !item.call_id) return null;
+  return {
+    type: 'function_call',
+    call_id: item.call_id,
+    name: 'load_tool',
+    arguments: typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments ?? {}),
+  };
+}
+
 /**
  * One tool result → its wire item. Which item depends on how the call was
  * lowered: a custom tool answers with custom_tool_call_output, a native
@@ -18,16 +40,13 @@ import {
  * media, since that item carries no text field), everything else with
  * function_call_output.
  */
-function pushToolResult(
-  m,
-  { out, pendingToolMedia, pendingToolLoads, customToolCallNameById, nativeSearchCalls, opts }
-) {
-  const { output, mediaContent } = splitToolContentForOpenAIResponses(m.content);
-  if (customToolCallNameById.has(m.toolCallId || '')) {
+function pushToolResult(m, { out, pendingToolMedia, pendingToolLoads, customToolCallIds, nativeSearchCalls, opts }) {
+  const { output, mediaContent } = (opts.splitToolContent || splitToolContentForOpenAIResponses)(m.content);
+  if (customToolCallIds.has(m.toolCallId || '')) {
+    // Documented custom_tool_call_output shape: call_id + output (+ id).
     out.push({
       type: 'custom_tool_call_output',
       call_id: m.toolCallId || '',
-      name: customToolCallNameById.get(m.toolCallId || '') || undefined,
       output,
     });
     if (mediaContent) pendingToolMedia.push(...mediaContent);
@@ -54,7 +73,8 @@ function pushToolResult(
   // A function result (e.g. Skill) cannot carry schemas. Tools it already
   // loaded ride a runtime load_tool pair emitted after the batch's outputs;
   // only a result from another native family falls back to a load hint.
-  const loadedNames = (m.nativeToolSearch?.openaiTools || []).map((tool) => tool.name);
+  const loadedNames =
+    opts.nativeToolSearch === false ? [] : (m.nativeToolSearch?.openaiTools || []).map((tool) => tool.name);
   const loadOutput = loadedNames.length
     ? nativeToolSearchOutputInput(m, opts.nativeToolSearchProvider || 'openai-oauth')
     : null;
@@ -85,18 +105,21 @@ function pushToolResult(
  * lowered as a custom tool or a native search call so the matching result
  * lowers the same way.
  */
-function pushAssistantToolCalls(toolCalls, { out, customToolCallNameById, nativeSearchCalls }) {
+function pushAssistantToolCalls(toolCalls, { out, customToolCallIds, nativeSearchCalls, nativeToolSearch }) {
   for (const tc of toolCalls) {
-    const nativeSearchCall = nativeToolSearchCallInput(tc);
+    // A model without native tool_search replays its load_tool call as the
+    // plain function call it was declared as.
+    const nativeSearchCall = nativeToolSearch ? nativeToolSearchCallInput(tc) : null;
     if (nativeSearchCall) {
       nativeSearchCalls.set(tc.id, nativeSearchCall);
       out.push(nativeSearchCall);
     } else if (isCustomToolCallRecord(tc)) {
-      if (tc.id) customToolCallNameById.set(tc.id, tc.name || '');
+      if (tc.id) customToolCallIds.add(tc.id);
       out.push({
         type: 'custom_tool_call',
         call_id: tc.id,
         name: tc.name,
+        ...namespaceField(tc),
         input: customToolInputFromArguments(tc.name, tc.arguments),
       });
     } else {
@@ -104,20 +127,41 @@ function pushAssistantToolCalls(toolCalls, { out, customToolCallNameById, native
         type: 'function_call',
         call_id: tc.id,
         name: tc.name === 'tool_search' ? 'load_tool' : tc.name,
+        ...namespaceField(tc),
         arguments: JSON.stringify(tc.arguments),
       });
     }
   }
 }
 
+/**
+ * Messages → Responses input items, native-aware. Defaults are the first-party
+ * OpenAI lowering. Gateways that speak the same item types opt in through:
+ *  - `replayProvider`: the providerReplay owner tag accepted for ordered
+ *    replay (default 'openai-responses'); any other owner is never replayed.
+ *  - `replayOwnedReasoning`: keep reasoning items of an accepted ordered
+ *    replay even when `replayEncryptedReasoning` (flattened message
+ *    reasoning) is off.
+ *  - `reasoningByMessageIndex`: same-owner reasoning from provider state,
+ *    injected before the message at that index (or after the last one).
+ *  - `includeSystem`, `nativePdf`, `splitToolContent`, `startIndex`: the
+ *    gateway's system/media/continuation handling.
+ */
 export function convertMessagesToResponsesInput(messages, opts = {}) {
   const out = [];
   const pendingToolMedia = [];
   const pendingToolLoads = [];
-  const customToolCallNameById = new Map();
+  const customToolCallIds = new Set();
   const nativeSearchCalls = new Map();
   const replayEncryptedReasoning = opts.replayEncryptedReasoning === true;
   const wireParity = opts.codexWireParity === true;
+  const replayOwner = opts.replayProvider || 'openai-responses';
+  const replayOwnedReasoning = opts.replayOwnedReasoning ?? replayEncryptedReasoning;
+  // Native tool_search is a per-model capability (gpt-5.4 and later on the
+  // public API); every other caller keeps it.
+  const nativeToolSearch = opts.nativeToolSearch !== false;
+  const nativePdf = opts.nativePdf;
+  const contentOpts = (role) => (nativePdf === undefined ? { role } : { role, nativePdf });
   const wireMessage = (role, content, phase) => ({
     ...(wireParity ? { type: 'message' } : {}),
     role,
@@ -158,11 +202,12 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
     out.push(wireMessage('user', pendingToolMedia.splice(0)));
   };
   const effortUpdates = responsesEffortUpdates(opts.effortProjection);
-  for (const m of messages) {
-    if (!m || m.role === 'system') continue;
+  for (let messageIndex = opts.startIndex || 0; messageIndex < messages.length; messageIndex += 1) {
+    const m = messages[messageIndex];
+    if (!m || (m.role === 'system' && opts.includeSystem !== true)) continue;
     const updates = effortUpdates.before(m);
     if (m.role === 'tool') {
-      pushToolResult(m, { out, pendingToolMedia, pendingToolLoads, customToolCallNameById, nativeSearchCalls, opts });
+      pushToolResult(m, { out, pendingToolMedia, pendingToolLoads, customToolCallIds, nativeSearchCalls, opts });
       continue;
     }
     flushToolMedia();
@@ -171,14 +216,14 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
     // reasoning is explicitly disabled. Never replay another provider's data.
     const orderedReplay =
       m.role === 'assistant'
-        ? providerReplayItems(m, 'openai-responses')?.filter(
-            (item) => replayEncryptedReasoning || item?.type !== 'reasoning'
-          )
+        ? providerReplayItems(m, replayOwner)?.filter((item) => replayOwnedReasoning || item?.type !== 'reasoning')
         : undefined;
     if (orderedReplay?.length) {
-      for (const item of orderedReplay) {
+      for (const replayItem of orderedReplay) {
+        const item = nativeToolSearch ? replayItem : withoutNativeToolSearch(replayItem);
+        if (!item) continue;
         if (item?.type === 'custom_tool_call' && item.call_id) {
-          customToolCallNameById.set(item.call_id, item.name || '');
+          customToolCallIds.add(item.call_id);
         }
         if (item?.type === 'tool_search_call' && item.call_id) {
           nativeSearchCalls.set(item.call_id, item);
@@ -187,27 +232,30 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
       }
       continue;
     }
+    if (opts.reasoningByMessageIndex?.has(messageIndex)) out.push(...opts.reasoningByMessageIndex.get(messageIndex));
     pushReasoningItems(m, 'before');
     if (m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length) {
       // Legacy sessions may have only flattened messages and reasoning.
       if (m.content)
         out.push(
-          wireMessage('assistant', normalizeContentForOpenAIResponses(m.content, { role: 'assistant' }), m.phase)
+          wireMessage('assistant', normalizeContentForOpenAIResponses(m.content, contentOpts('assistant')), m.phase)
         );
       pushReasoningItems(m, 'after');
-      pushAssistantToolCalls(m.toolCalls, { out, customToolCallNameById, nativeSearchCalls });
+      pushAssistantToolCalls(m.toolCalls, { out, customToolCallIds, nativeSearchCalls, nativeToolSearch });
       continue;
     }
     out.push(
       wireMessage(
-        m.role === 'assistant' ? 'assistant' : 'user',
-        normalizeContentForOpenAIResponses(m.content, { role: m.role }),
+        m.role === 'assistant' || m.role === 'system' ? m.role : 'user',
+        normalizeContentForOpenAIResponses(m.role === 'system' ? m.content || '' : m.content, contentOpts(m.role)),
         m.phase
       )
     );
     pushReasoningItems(m, 'after');
   }
   flushToolMedia();
+  if (opts.reasoningByMessageIndex?.has(messages.length))
+    out.push(...opts.reasoningByMessageIndex.get(messages.length));
   out.push(...effortUpdates.end());
   // Wire-level pairing guard: replay envelopes can carry a call whose
   // result never committed (cancel/abort). The provider hard-rejects the