mixdog 0.9.35 → 0.9.37

package/src/runtime/agent/orchestrator/mcp/client.mjs

@@ -16,7 +16,7 @@ import { readServicePort, markServiceUnreachable, isConnRefuseError } from '../.
 const AUTO_DETECT_PORTS = {
     'mixdog-memory': { discovery: 'memory', dir: 'mixdog', file: 'active-instance.json', portField: 'memory_port', endpoint: '/mcp' },
 };
-const DEFAULT_MCP_CALL_TIMEOUT_MS = 0;
+const DEFAULT_MCP_CALL_TIMEOUT_MS = 120000;
 // Per-server STARTUP handshake budget (connect + listTools). Codex parity: 10s.
 export const DEFAULT_MCP_STARTUP_TIMEOUT_MS = 10000;
 // --- State ---
@@ -227,12 +227,12 @@ export async function executeMcpTool(name, args) {
     return capMcpOutput(text);
 }
 
-// MCP per-tool-call timeout. Disabled by default: external MCP tools can be
-// long-running, and replaying an arbitrary tool after a timeout can duplicate
-// side effects. Operators may opt in with MIXDOG_MCP_CALL_TIMEOUT_MS or a
-// per-server timeoutMs/callTimeoutMs config value. On expiry we close the
-// transport so the next dispatch reconnects fresh, but we do not retry the
-// timed-out call automatically.
+// MCP per-tool-call timeout. Default 2min: a hung/unresponsive MCP server
+// (e.g. a busy editor) must not stall a tool call indefinitely. Genuinely
+// long-running tools can raise/disable it via MIXDOG_MCP_CALL_TIMEOUT_MS or a
+// per-server timeoutMs/callTimeoutMs config value (0/off/none/false disables).
+// On expiry we close the transport so the next dispatch reconnects fresh, but
+// we do not retry the timed-out call automatically (avoids side-effect dupes).
 export function resolveMcpCallTimeoutMs(cfg = {}, env = process.env) {
     const raw = cfg?.timeoutMs ?? cfg?.timeout_ms ?? cfg?.callTimeoutMs ?? cfg?.call_timeout_ms
         ?? env?.MIXDOG_MCP_CALL_TIMEOUT_MS;

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

@@ -373,15 +373,15 @@ function toAnthropicMessages(messages) {
 
         if (m.role === 'tool') {
             const last = result[result.length - 1];
-            const refs = Array.isArray(m.nativeToolSearch?.toolReferences)
-                ? m.nativeToolSearch.toolReferences.map((name) => String(name || '').trim()).filter(Boolean)
-                : [];
+            // Do not replay native deferred-loader `tool_reference` blocks from
+            // prior turns. They are tied to the exact Anthropic deferred-tool
+            // request that produced them; after /model or provider switches the
+            // new request may not carry the matching deferred tool surface and
+            // Anthropic rejects the history as a request validation error.
             const block = {
                 type: 'tool_result',
                 tool_use_id: m.toolCallId || '',
-                content: refs.length
-                    ? refs.map((name) => ({ type: 'tool_reference', tool_name: name }))
-                    : normalizeContentForAnthropic(m.content),
+                content: normalizeContentForAnthropic(m.content),
             };
             if (last?.role === 'user' && Array.isArray(last.content)) {
                 last.content.push(block);

package/src/runtime/agent/orchestrator/providers/anthropic.mjs

@@ -376,15 +376,15 @@ function toAnthropicMessages(messages) {
         }
         if (m.role === 'tool') {
             const last = result[result.length - 1];
-            const refs = Array.isArray(m.nativeToolSearch?.toolReferences)
-                ? m.nativeToolSearch.toolReferences.map((name) => String(name || '').trim()).filter(Boolean)
-                : [];
+            // Do not replay native deferred-loader `tool_reference` blocks from
+            // prior turns. They are tied to the exact Anthropic deferred-tool
+            // request that produced them; after /model or provider switches the
+            // new request may not carry the matching deferred tool surface and
+            // Anthropic rejects the history as a request validation error.
             const block = {
                 type: 'tool_result',
                 tool_use_id: m.toolCallId || '',
-                content: refs.length
-                    ? refs.map((name) => ({ type: 'tool_reference', tool_name: name }))
-                    : normalizeContentForAnthropic(m.content),
+                content: normalizeContentForAnthropic(m.content),
             };
             if (last?.role === 'user' && Array.isArray(last.content)) {
                 last.content.push(block);

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -15,31 +15,61 @@ function pushUnique(list, value) {
     if (!list.includes(value)) list.push(value);
 }
 
+// Short-TTL memo. Under simultaneous multi-agent launch, buildDefaultConfig
+// and registry lazy-init call these probes in bursts; each probe does
+// synchronous existsSync + readFileSync disk work. Cache the boolean per key
+// for a brief window so one launch burst shares a single read instead of N.
+// Kept short so the registry's "re-probe on each getProvider miss" self-heal
+// (a credential file appearing/changing) is delayed by at most PROBE_TTL_MS.
+const PROBE_TTL_MS = 3000;
+const _probeCache = new Map();
+function memoProbe(key, compute) {
+    const hit = _probeCache.get(key);
+    const now = Date.now();
+    if (hit && now - hit.ts < PROBE_TTL_MS) return hit.value;
+    const value = compute();
+    _probeCache.set(key, { ts: now, value });
+    return value;
+}
+
 export function hasAnthropicOAuthCredentials() {
+  return memoProbe('anthropic-oauth', () => {
     const paths = [];
+    const candidates = [];
     pushUnique(paths, process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH);
     pushUnique(paths, ANTHROPIC_DEFAULT_CREDENTIALS_PATH);
     for (const path of paths) {
         const raw = readJsonIfExists(path);
         const oauth = raw?.claudeAiOauth;
-        if (oauth?.accessToken && Array.isArray(oauth.scopes) && oauth.scopes.includes('user:inference')) {
-            return true;
+        if (oauth?.accessToken) {
+            candidates.push({
+                accessToken: oauth.accessToken,
+                expiresAt: Number(oauth.expiresAt ?? oauth.expires_at) || 0,
+                scopes: Array.isArray(oauth.scopes) ? oauth.scopes : [],
+            });
         }
     }
-    return false;
+    if (!candidates.length) return false;
+    candidates.sort((a, b) => (Number(b.expiresAt) || 0) - (Number(a.expiresAt) || 0));
+    const chosen = candidates[0];
+    return !!(chosen.accessToken && Array.isArray(chosen.scopes) && chosen.scopes.includes('user:inference'));
+  });
 }
 
 export function hasOpenAIOAuthCredentials() {
+  return memoProbe('openai-oauth', () => {
     const paths = [join(resolvePluginData(), 'openai-oauth.json')];
     for (const path of paths) {
         const raw = readJsonIfExists(path);
-        const tokens = raw?.tokens || raw;
-        if (tokens?.access_token && tokens?.refresh_token) return true;
+        if (raw?.access_token && raw?.refresh_token) return true;
     }
     return false;
+  });
 }
 
 export function hasGrokOAuthCredentials() {
+  return memoProbe('grok-oauth', () => {
     const own = readJsonIfExists(join(resolvePluginData(), 'grok-oauth.json'));
     return !!(own?.access_token && own?.refresh_token);
+  });
 }

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

@@ -10,6 +10,7 @@ import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
 import { customToolCallFromResponseItem } from './custom-tool-wire.mjs';
 import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';
 import { randomBytes } from 'crypto';
+import { createActiveToolItemTracker } from './tool-stream-state.mjs';
 
 // Synthesize a native-shaped OpenAI tool call from a recovered leaked call.
 // Matches the `call_...` id scheme the native Responses/Chat paths use so the
@@ -554,14 +555,17 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
                     name: event.item.name || '',
                     callId: event.item.call_id || '',
                 });
+                state.toolTracker?.mark(event.item);
                 state.toolInFlight = true;
             } else if (event.item?.type === 'custom_tool_call') {
+                state.toolTracker?.mark(event.item);
                 state.toolInFlight = true;
             } else if (event.item?.type === 'tool_search_call') {
                 // Mark tool_search in-flight at item-added time, same as
                 // function_call/custom_tool_call above, so the stall-recovery
                 // pendingToolUse gate never drops a mid-flight tool_search
                 // before response.output_item.done pushes it.
+                state.toolTracker?.mark(event.item);
                 state.toolInFlight = true;
             }
             try { onStreamDelta?.(); } catch {}
@@ -569,6 +573,7 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
         case 'response.function_call_arguments.delta':
             // A tool call's args are streaming — mark tool work in-flight so a
             // mid-args stall is NEVER accepted as a text-only partial-final.
+            state.toolTracker?.mark(null, event.item_id);
             state.toolInFlight = true;
             try { onStreamDelta?.(); } catch {}
             break;
@@ -576,6 +581,7 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
             // Custom-tool input streams before output_item.done records the call
             // in pendingCalls; flag it so a mid-input stall gates out partial-
             // final success (otherwise a tool-bearing turn looks text-only).
+            state.toolTracker?.mark(null, event.item_id);
             state.toolInFlight = true;
             try { onStreamDelta?.(); } catch {}
             break;
@@ -616,10 +622,21 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
                     state.toolCalls.push(call);
                     emitCompatToolCallOnce(state, call, onToolCall);
                 }
+                // Drop the resolved function item from pendingCalls before
+                // recomputing toolInFlight — otherwise a completed call keeps
+                // pendingCalls.size > 0 and the latch never clears, so a later
+                // text-only stall stays wrongly gated as tool-bearing.
+                if (itemId) state.pendingCalls.delete(itemId);
+                state.toolTracker?.clear(item, itemId);
+                state.toolInFlight = state.pendingCalls.size > 0 || (state.toolTracker ? state.toolTracker.items.size > 0 : false);
             } else if (item.type === 'tool_search_call') {
                 pushToolSearchCall(item);
+                state.toolTracker?.clear(item, item.id || '');
+                state.toolInFlight = state.pendingCalls.size > 0 || (state.toolTracker ? state.toolTracker.items.size > 0 : false);
             } else if (item.type === 'custom_tool_call') {
                 pushCustomToolCall(item);
+                state.toolTracker?.clear(item, item.id || '');
+                state.toolInFlight = state.pendingCalls.size > 0 || (state.toolTracker ? state.toolTracker.items.size > 0 : false);
             }
             try { onStreamDelta?.(); } catch {}
             break;
@@ -746,6 +763,14 @@ export async function consumeCompatResponsesStream(stream, {
         pendingCalls: new Map(),
         emittedToolCallKeys: new Set(),
         emittedToolCall: false,
+        // Active tool-item / alias tracking shared with the WS + HTTP-SSE
+        // Responses streams (tool-stream-state.mjs): mark on output_item.added /
+        // arg-input deltas, clear on output_item.done. Unions id/call_id/item_id
+        // aliases so a mark under one key and a clear under another resolve to
+        // the same item — closes the custom-tool-input in-flight gap that a bare
+        // boolean toolInFlight latch could not (a mid-input stall now gates out
+        // text-only partial-final).
+        toolTracker: createActiveToolItemTracker(),
         completed: false,
         completedResponse: null,
         sawOutput: false,
@@ -823,6 +848,7 @@ export async function consumeCompatResponsesStream(stream, {
                     || leakedCalls.length > 0
                     || (state.pendingCalls && state.pendingCalls.size > 0)
                     || (Array.isArray(state.toolCalls) && state.toolCalls.length > 0)
+                    || (state.toolTracker && state.toolTracker.items.size > 0)
                     || state.toolInFlight === true;
                 err.partialModel = state.model || undefined;
             } catch { /* best-effort */ }
@@ -849,6 +875,7 @@ export async function consumeCompatResponsesStream(stream, {
                     || leakedCalls.length > 0
                     || (state.pendingCalls && state.pendingCalls.size > 0)
                     || (Array.isArray(state.toolCalls) && state.toolCalls.length > 0)
+                    || (state.toolTracker && state.toolTracker.items.size > 0)
                     || state.toolInFlight === true;
                 err.partialModel = state.model || undefined;
             } catch { /* best-effort */ }

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

@@ -105,11 +105,26 @@ export function toOpenAITools(tools) {
     }));
 }
 
-export function toResponsesTools(tools) {
+function functionToolFromSessionTool(t, name = t?.name) {
+    return {
+        type: 'function',
+        name,
+        description: t.description,
+        parameters: t.inputSchema || { type: 'object', additionalProperties: true },
+    };
+}
+
+export function toResponsesTools(tools, options = {}) {
+    const provider = String(options?.provider || '').toLowerCase();
+    const allowNativeToolSearch = options?.nativeToolSearch === true
+        || (options?.nativeToolSearch !== false && provider !== 'xai');
     return tools.map((t) => {
         // load_tool advertises as the OpenAI-native `tool_search` wire type
-        // (legacy 'tool_search' name still accepted for back-compat).
+        // (legacy 'tool_search' name still accepted for back-compat). xAI/Grok
+        // Responses rejects that OpenAI-only variant ("unknown variant
+        // 'tool_search'"), so serialize it as an ordinary function there.
         if (t?.name === 'load_tool' || t?.name === 'tool_search') {
+            if (!allowNativeToolSearch) return functionToolFromSessionTool(t, 'load_tool');
             return {
                 type: 'tool_search',
                 execution: 'client',
@@ -122,12 +137,7 @@ export function toResponsesTools(tools) {
         // 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.
-        return {
-            type: 'function',
-            name: t.name,
-            description: t.description,
-            parameters: t.inputSchema || { type: 'object', additionalProperties: true },
-        };
+        return functionToolFromSessionTool(t);
     });
 }
 
@@ -271,18 +281,10 @@ export function collectCompatResponseSearchSources(response) {
 
 export function toResponsesInputMessage(m, pendingToolMedia = null, customToolCallNameById = null) {
     if (m.role === 'tool') {
-        if (Array.isArray(m.nativeToolSearch?.openaiTools)) {
-            return {
-                type: 'tool_search_output',
-                call_id: m.toolCallId || '',
-                status: 'completed',
-                execution: 'client',
-                tools: m.nativeToolSearch.openaiTools,
-            };
-        }
         const { output, mediaContent } = splitToolContentForOpenAIResponses(m.content);
         // xai path: never emit `custom_tool_call_output` (the `custom` variant
-        // is rejected by grok). Replay prior tool outputs as the standard
+        // is rejected by grok). Replay prior tool outputs — including old
+        // native tool_search outputs after /model switches — as the standard
         // `function_call_output` item regardless of original native type.
         const item = {
             type: 'function_call_output',
@@ -296,25 +298,16 @@ export function toResponsesInputMessage(m, pendingToolMedia = null, customToolCa
         const items = [];
         if (m.content) items.push({ role: 'assistant', content: normalizeContentForOpenAIResponses(m.content, { role: 'assistant' }) });
         for (const tc of m.toolCalls) {
-            if (tc.nativeType === 'tool_search_call' || tc.name === 'load_tool' || tc.name === 'tool_search') {
-                items.push({
-                    type: 'tool_search_call',
-                    call_id: tc.id,
-                    execution: 'client',
-                    arguments: tc.arguments || {},
-                });
-            } else {
-                // xai path: prior native `custom_tool_call` history is replayed
-                // as a standard `function_call` (grok rejects the `custom`
-                // variant). tc.arguments already holds the recovered object
-                // form, so the same stringify path as regular calls applies.
-                items.push({
-                    type: 'function_call',
-                    call_id: tc.id,
-                    name: tc.name,
-                    arguments: JSON.stringify(tc.arguments || {}),
-                });
-            }
+            // xAI/Grok rejects OpenAI-only Responses variants such as
+            // `custom_tool_call` and `tool_search_call`, including when they
+            // appear in replayed history after a model switch. Replay all prior
+            // client tools as plain function calls.
+            items.push({
+                type: 'function_call',
+                call_id: tc.id,
+                name: tc.name === 'tool_search' ? 'load_tool' : tc.name,
+                arguments: JSON.stringify(tc.arguments || {}),
+            });
         }
         return items;
     }
@@ -351,6 +344,7 @@ export function toXaiResponsesInput(messages, providerState, options = {}) {
         startIndex = Math.max(0, Math.min(seen, messages.length));
         if (messages[startIndex]?.role === 'assistant') startIndex += 1;
     }
+    const dropToolHistory = !previousResponseId && (resetReason !== null || !state?.previousResponseId);
     const input = [];
     const pendingToolMedia = [];
     const customToolCallNameById = new Map();
@@ -361,6 +355,11 @@ export function toXaiResponsesInput(messages, providerState, options = {}) {
     for (const m of messages.slice(startIndex)) {
         if (!includeSystem && m.role === 'system') continue;
         if (m.role !== 'tool') flushToolMedia();
+        if (dropToolHistory && m.role === 'tool') continue;
+        if (dropToolHistory && m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length > 0) {
+            if (m.content) input.push({ role: 'assistant', content: normalizeContentForOpenAIResponses(m.content, { role: 'assistant' }) });
+            continue;
+        }
         const converted = toResponsesInputMessage(m, pendingToolMedia, customToolCallNameById);
         if (Array.isArray(converted)) input.push(...converted);
         else input.push(converted);

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

@@ -467,7 +467,7 @@ export class OpenAICompatProvider {
         };
         if (previousResponseId) params.previous_response_id = previousResponseId;
         const nativeTools = nativeResponsesTools(opts);
-        if (tools?.length || nativeTools.length) params.tools = [...nativeTools, ...toResponsesTools(tools || [])];
+        if (tools?.length || nativeTools.length) params.tools = [...nativeTools, ...toResponsesTools(tools || [], { provider: 'xai' })];
         // SSE transport: report 'requesting' until the stream opens, then
         // per-chunk onStreamDelta feeds the agent stall watchdog.
         try { opts.onStageChange?.('requesting'); } catch { /* heartbeat best-effort */ }
@@ -664,7 +664,7 @@ export class OpenAICompatProvider {
         // first response already anchors instructions for the continuation.
         else if (instructions) params.instructions = instructions;
         const nativeTools = nativeResponsesTools(opts);
-        if (tools?.length || nativeTools.length) params.tools = [...nativeTools, ...toResponsesTools(tools || [])];
+        if (tools?.length || nativeTools.length) params.tools = [...nativeTools, ...toResponsesTools(tools || [], { provider: 'xai' })];
         const reasoningEffort = normalizeXaiReasoningEffort(opts.xaiReasoningEffort
             ?? opts.effort
             ?? this.config?.reasoningEffort

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

@@ -26,6 +26,7 @@ import { makeInvalidToolArgsMarker } from './openai-compat-stream.mjs';
 import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';
 import { customToolCallFromResponseItem } from './custom-tool-wire.mjs';
 import { CODEX_OAUTH_ORIGINATOR, CODEX_RESPONSES_URL, _displayCodexModel } from './openai-oauth.mjs';
+import { createActiveToolItemTracker } from './tool-stream-state.mjs';
 
 // Public OpenAI Responses API endpoint for the api-key `openai` provider.
 // The openai-direct WS transport hits the same origin (openai-ws-pool
@@ -297,7 +298,15 @@ export async function sendViaHttpSse({
             try {
                 _streamAbortReason.partialContent = content;
                 _streamAbortReason.partialToolCalls = toolCalls.length ? toolCalls.slice() : undefined;
-                _streamAbortReason.pendingToolUse = pendingCalls.size > 0 || emittedToolCallIds.size > 0;
+                // Shared active tool-item tracker (tool-stream-state.mjs) closes
+                // the custom-tool gap: a stall mid custom_tool_call_input.delta
+                // never lands in pendingCalls, so without activeToolItems/_toolInFlight
+                // a tool-bearing turn would look text-only and be wrongly accepted
+                // as a partial-final.
+                _streamAbortReason.pendingToolUse = pendingCalls.size > 0
+                    || emittedToolCallIds.size > 0
+                    || activeToolItems.size > 0
+                    || _toolInFlight === true;
                 _streamAbortReason.partialModel = model || undefined;
             } catch { /* best-effort enrichment */ }
             try { reader.cancel(_streamAbortReason).catch(() => {}); } catch {}
@@ -313,6 +322,15 @@ export async function sendViaHttpSse({
     let ttftMs = null;
     const toolCalls = [];
     const pendingCalls = new Map();
+    // Active tool-item / alias tracking shared with the WS + compat Responses
+    // streams (tool-stream-state.mjs). Mark on output_item.added / arg-input
+    // deltas, clear on output_item.done; _toolInFlight latches tool work the
+    // moment a call's input starts streaming (before it lands in pendingCalls).
+    const _toolTracker = createActiveToolItemTracker();
+    const activeToolItems = _toolTracker.items;
+    const markActiveToolItem = _toolTracker.mark;
+    const clearActiveToolItem = _toolTracker.clear;
+    let _toolInFlight = false;
     const reasoningItems = [];
     const citations = [];
     const citationKeys = new Set();
@@ -486,10 +504,12 @@ export async function sendViaHttpSse({
                 break;
             case 'response.output_item.added':
                 if (event.item?.type === 'function_call') {
+                    markActiveToolItem(event.item);
                     pendingCalls.set(event.item.id || '', {
                         name: event.item.name || '',
                         callId: event.item.call_id || '',
                     });
+                    _toolInFlight = true;
                 } else if (event.item?.type === 'tool_search_call') {
                     // Mark tool_search as in-flight the moment the item is
                     // added, mirroring function_call above, so the semantic
@@ -506,9 +526,21 @@ export async function sendViaHttpSse({
                             kind: 'tool_search',
                         });
                     }
+                    markActiveToolItem(event.item);
+                    _toolInFlight = true;
+                } else if (event.item?.type === 'custom_tool_call') {
+                    // Custom tool calls surface no pendingCalls entry, so mark
+                    // the item active at added-time (mirroring function_call /
+                    // tool_search_call above). The later custom_tool_call_input.delta
+                    // still marks too, but a stall between added and the first
+                    // input delta must already read as pendingToolUse.
+                    markActiveToolItem(event.item);
+                    _toolInFlight = true;
                 }
                 break;
             case 'response.function_call_arguments.delta':
+                markActiveToolItem(null, event.item_id);
+                _toolInFlight = true;
                 meaningful();
                 break;
             case 'response.function_call_arguments.done': {
@@ -530,6 +562,8 @@ export async function sendViaHttpSse({
                 break;
             }
             case 'response.custom_tool_call_input.delta':
+                markActiveToolItem(null, event.item_id);
+                _toolInFlight = true;
                 meaningful();
                 break;
             case 'response.output_item.done': {
@@ -546,11 +580,23 @@ export async function sendViaHttpSse({
                             emitToolCall(tc);
                         }
                     }
+                    // Drop the resolved function item from pendingCalls before
+                    // recomputing _toolInFlight (mirrors tool_search_call below
+                    // and the compat path) — otherwise a completed call keeps
+                    // pendingCalls.size > 0 and the latch never clears, so a
+                    // later max-output cutoff is misread as a tool in flight.
+                    pendingCalls.delete(item.id || '');
+                    clearActiveToolItem(item, item.id || '');
+                    _toolInFlight = pendingCalls.size > 0 || activeToolItems.size > 0;
                 } else if (item.type === 'tool_search_call') {
                     pendingCalls.delete(item.id || '');
                     pushToolSearchCall(item);
+                    clearActiveToolItem(item, item.id || '');
+                    _toolInFlight = pendingCalls.size > 0 || activeToolItems.size > 0;
                 } else if (item.type === 'custom_tool_call') {
                     pushCustomToolCall(item);
+                    clearActiveToolItem(item, item.id || '');
+                    _toolInFlight = pendingCalls.size > 0 || activeToolItems.size > 0;
                     meaningful();
                 }
                 break;
@@ -636,6 +682,20 @@ export async function sendViaHttpSse({
                 } else if (event.response.status === 'incomplete') {
                     const reason = _incompleteReasonFromEvent(event);
                     if (_isMaxOutputIncompleteReason(reason)) {
+                        // Max-output cutoff with a function/custom/tool_search
+                        // still in flight means the tool arguments were
+                        // truncated — do NOT mark a clean completion (mirrors
+                        // the compat Responses path), or partial args surface as
+                        // a successful tool call. Throw a stream-stalled
+                        // pendingToolUse error so the loop gates/retries.
+                        if (pendingCalls.size > 0 || activeToolItems.size > 0 || _toolInFlight === true) {
+                            const err = _stampToolSafety(new Error('OpenAI OAuth HTTP fallback response.done incomplete (max_output_tokens) with tool call in flight'));
+                            err.streamStalled = true;
+                            err.pendingToolUse = true;
+                            err.partialContent = content;
+                            err.partialModel = model || undefined;
+                            throw err;
+                        }
                         completed = true;
                         stopReason = 'length';
                         break;
@@ -652,6 +712,17 @@ export async function sendViaHttpSse({
             case 'response.incomplete': {
                 const reason = _incompleteReasonFromEvent(event);
                 if (_isMaxOutputIncompleteReason(reason)) {
+                    // See response.done incomplete above: a max-output cutoff
+                    // while a tool is in flight is a truncated tool call, not a
+                    // clean length completion.
+                    if (pendingCalls.size > 0 || activeToolItems.size > 0 || _toolInFlight === true) {
+                        const err = _stampToolSafety(new Error('OpenAI OAuth HTTP fallback response.incomplete (max_output_tokens) with tool call in flight'));
+                        err.streamStalled = true;
+                        err.pendingToolUse = true;
+                        err.partialContent = content;
+                        err.partialModel = model || undefined;
+                        throw err;
+                    }
                     completed = true;
                     stopReason = 'length';
                     break;

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

@@ -895,7 +895,26 @@ export async function sendViaWebSocket({
                 // Delta opt-in still chains via entry.lastResponseId above.
             }
 
-            const delta = _computeDelta({ entry, body: requestBody, traceProvider });
+            // Warmup writes the same prefix with generate:false, but the first
+            // real response must still be a FULL generating frame. Reusing the
+            // warmup response_id here causes _buildResponseCreateFrame() to drop
+            // `instructions` (previous_response_id frames cannot carry them) and
+            // can also reduce the frame input to [] when the warmup input matches.
+            // That made first-turn lead/system rules effectively disappear
+            // ("who are you?" answered as a generic OpenAI assistant). Keep the
+            // warmup state for cache/trace, but compute the main frame as cold.
+            const deltaEntry = warmupResult
+                ? {
+                    ...entry,
+                    lastResponseId: null,
+                    lastRequestSansInput: null,
+                    lastRequestInput: null,
+                    lastResponseItems: null,
+                    lastInputLen: 0,
+                    lastInputPrefixHash: null,
+                }
+                : entry;
+            const delta = _computeDelta({ entry: deltaEntry, body: requestBody, traceProvider });
             ({ mode, frame } = delta);
             deltaReason = delta.reason || null;
             strippedResponseItems = delta.strippedResponseItems || 0;
@@ -1063,7 +1082,11 @@ export async function sendViaWebSocket({
         // own, so retaining the anchor cannot corrupt the cache — it only adds
         // a delta fast-path when the items DO match.
         const keepResponseChain = !!result.responseId;
-        const keepSocket = true;
+        // Normally the socket is pooled for reuse. But an early tool-call settle
+        // (result.closeSocket) means the stream resolved before
+        // response.completed/done arrived: the server may still emit those as
+        // orphan frames, so the socket must be discarded, not reused.
+        const keepSocket = !result.closeSocket;
 
         // Update cache state for the next iteration in this session. openai-oauth
         // keeps the previous response anchor even when the model emitted tool
@@ -1300,7 +1323,7 @@ export async function sendViaWebSocket({
         } catch {}
 
         releaseWebSocket({ entry, poolKey, keep: keepSocket });
-        const { responseId: _ignored, responseItems: _responseItemsIgnored, ...out } = result;
+        const { responseId: _ignored, responseItems: _responseItemsIgnored, closeSocket: _closeSocketIgnored, ...out } = result;
         if (includeResponseId && result.responseId) out.responseId = result.responseId;
         if (warmupResult) {
             try {

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

@@ -410,16 +410,6 @@ function convertMessagesToResponsesInput(messages, opts = {}) {
     for (const m of messages) {
         if (!m || m.role === 'system') continue;
         if (m.role === 'tool') {
-            if (Array.isArray(m.nativeToolSearch?.openaiTools)) {
-                out.push({
-                    type: 'tool_search_output',
-                    call_id: m.toolCallId || '',
-                    status: 'completed',
-                    execution: 'client',
-                    tools: m.nativeToolSearch.openaiTools,
-                });
-                continue;
-            }
             const { output, mediaContent } = splitToolContentForOpenAIResponses(m.content);
             if (customToolCallNameById.has(m.toolCallId || '')) {
                 out.push({
@@ -449,14 +439,7 @@ function convertMessagesToResponsesInput(messages, opts = {}) {
             // reasoning in `input` triggers "Duplicate item".
             if (m.content) out.push(wireMessage('assistant', normalizeContentForOpenAIResponses(m.content, { role: 'assistant' })));
             for (const tc of m.toolCalls) {
-                if (tc.nativeType === 'tool_search_call' || tc.name === 'load_tool' || tc.name === 'tool_search') {
-                    out.push({
-                        type: 'tool_search_call',
-                        call_id: tc.id,
-                        execution: 'client',
-                        arguments: tc.arguments || {},
-                    });
-                } else if (isCustomToolCallRecord(tc)) {
+                if (isCustomToolCallRecord(tc)) {
                     if (tc.id) customToolCallNameById.set(tc.id, tc.name || '');
                     out.push({
                         type: 'custom_tool_call',
@@ -468,7 +451,7 @@ function convertMessagesToResponsesInput(messages, opts = {}) {
                     out.push({
                         type: 'function_call',
                         call_id: tc.id,
-                        name: tc.name,
+                        name: tc.name === 'tool_search' ? 'load_tool' : tc.name,
                         arguments: JSON.stringify(tc.arguments),
                     });
                 }
@@ -487,8 +470,8 @@ function convertMessagesToResponsesInput(messages, opts = {}) {
 function toOpenAIResponsesTool(t) {
     if (t?.name === 'load_tool' || t?.name === 'tool_search') {
         return {
-            type: 'tool_search',
-            execution: 'client',
+            type: 'function',
+            name: 'load_tool',
             description: t.description,
             parameters: t.inputSchema,
         };
@@ -923,13 +906,14 @@ export class OpenAIOAuthProvider {
             useModel,
             displayModel: _displayCodexModel,
             forceFresh,
-            // Fast-fallback: when HTTP/SSE fallback is enabled, cap the WS
-            // handshake acquire loop at ONE attempt so a first
-            // acquire/first-byte failure aborts the remaining backoff retries
-            // and lets HTTP start immediately (skip-retries, no concurrent race
-            // → no double token spend). WS-only paths (fallback disabled) keep
-            // the full retry budget.
-            fastFallback: httpFallbackEnabled,
+            // Default refs-style recovery: keep using WS first. A transient
+            // first-byte / mid-stream stall closes the bad socket and retries on
+            // a fresh WS entry; only after the bounded WS retry budget is
+            // exhausted does openai-oauth fall back to HTTP/SSE. This preserves
+            // the hot WS/cache path for temporary blips while still preventing
+            // TUI-level hangs. Operators can opt into immediate HTTP fallback
+            // for diagnostics with MIXDOG_OPENAI_OAUTH_FAST_HTTP_FALLBACK=1.
+            fastFallback: httpFallbackEnabled && _envFlag('MIXDOG_OPENAI_OAUTH_FAST_HTTP_FALLBACK', false),
             // codex-parity prewarm (generate:false full frame on a fresh
             // socket, wire-verified 2026-07-03). DEFAULT ON: R19(off) vs
             // R20(on) A/B shows prewarm removes ALL early-session zero-cache