mixdog 0.9.36 → 0.9.38

package/src/rules/shared/01-tool.md

@@ -16,9 +16,13 @@
   error origin, ...) and send them as ONE `query[]` call — facets run in
   parallel. Never fan out rephrasings of the same target; on
   EXPLORATION_FAILED, retry once with changed tokens.
-- Verified paths = user-provided or tool-returned. Guessed/unknown path →
-  `find`/`glob`/`explore` first; ENOENT → `find` basename, never retry a guess
-  or invent absolute paths outside the project.
+- Verified = user-provided, tool-returned, or the session project cwd itself.
+  Unscoped grep/glob/list from the project root needs NO find hop; find only
+  resolves a genuinely guessed path-name fragment, and it rides the SAME turn
+  as independent probes (unscoped grep, code_graph) — never a solo
+  path-verification turn. ENOENT → `find` basename, never retry a guess; don't
+  mask a miss with a guessed glob scope (path "." + `src/**`) or an invented
+  absolute path, but plain project-root searches are fine.
 - Retrieval stops when evidence covers the deliverable: single-answer tasks
   end at the first sufficient anchor; enumeration tasks (review, audit) end
   when the stated scope is covered. Never re-verify a hit already on screen;

package/src/runtime/agent/orchestrator/agent-trace-format.mjs

@@ -21,15 +21,22 @@ const MIXDOG_SLOW_TOOL_TRACE_NAMES = new Set(
         .filter(Boolean)
 );
 
-function traceAgentLoop({ sessionId, iteration, sendMs, messageCount, bodyBytesEst }) {
-    if (process.env.MIXDOG_AGENT_TRACE_VERBOSE !== '1') return;
+function traceAgentLoop({ sessionId, iteration, sendMs, messageCount, bodyBytesEst, agent = null }) {
+    // Two emit modes, no behavior change either way:
+    //   VERBOSE=1 → full loop row incl. body_bytes_est (payload serialized).
+    //   TIMING=1  → lightweight send-latency attribution for high-fanout
+    //               benches; bodyBytesEst is skipped upstream so measuring
+    //               the send does not perturb it (body_bytes_est → null).
+    if (process.env.MIXDOG_AGENT_TRACE_VERBOSE !== '1'
+        && process.env.MIXDOG_AGENT_TRACE_TIMING !== '1') return;
     appendAgentTrace({
         sessionId,
         iteration,
         kind: 'loop',
+        agent: agent || null,
         send_ms: sendMs,
         message_count: messageCount,
-        body_bytes_est: bodyBytesEst,
+        body_bytes_est: bodyBytesEst ?? null,
     });
 }
 
@@ -206,6 +213,11 @@ function _redactLogText(text) {
 
 function classifyToolFailure(resultText, toolName) {
     const text = String(resultText ?? '').toLowerCase();
+    if (/\[shell-tool-failed\]/i.test(String(resultText ?? ''))) return 'tool-call/failure';
+    if (/\[shell-run-failed\]/i.test(String(resultText ?? ''))) {
+        if (/timeout|timed out|aborted|interrupted/.test(text)) return 'timeout/abort';
+        return 'command-exit';
+    }
     if (/requires either|invalid arguments|unknown parameter|must be|schema|expected|required|old_string is .*>=/.test(text)) return 'schema/args';
     if (/not in allow-list|not allowed/.test(text)) return 'permission';
     if (String(toolName || '') === 'shell' || /^\s*\[exit code:\s*\d+\]/i.test(String(resultText ?? ''))) return 'command-exit';

package/src/runtime/agent/orchestrator/config.mjs

@@ -46,7 +46,7 @@ export const MAINTENANCE_SLOTS = Object.freeze(['explore', 'memory']);
 export const PROFILE_LANGUAGES = Object.freeze([
     { id: 'system', label: 'System (locale)', prompt: null },
     { id: 'en', label: 'English', prompt: 'English' },
-    { id: 'ko', label: '한국어', prompt: 'Korean (한국어)' },
+    { id: 'ko', label: 'Korean', prompt: 'Korean' },
     { id: 'ja', label: '日本語', prompt: 'Japanese (日本語)' },
     { id: 'zh-Hans', label: '中文（简体）', prompt: 'Simplified Chinese (简体中文)' },
     { id: 'zh-Hant', label: '中文（繁體）', prompt: 'Traditional Chinese (繁體中文)' },

package/src/runtime/agent/orchestrator/dispatch-persist.mjs

@@ -372,6 +372,27 @@ export function recoverPending(dataDir, notifyFn, { sessionId, priorSessionId, c
         const entry = map[handle] || {};
         const tool = entry.tool || 'dispatch';
         const queries = Array.isArray(entry.queries) ? entry.queries : [];
+        // Determine the true owner session for this entry. A scoped recovery
+        // may have matched purely on clientHostPid (not on the owner session
+        // id); in that case we must NOT stamp the reconnecting filter session's
+        // id onto another session's abort — that injects an old-session abort
+        // into the wrong resumed session. Deliver to the true owner session, or
+        // leave the entry persisted when it carries no owner session to target.
+        const cid = entry.callerSessionId != null && String(entry.callerSessionId)
+          ? String(entry.callerSessionId)
+          : null;
+        const ownerMatch = cid != null && (cid === filterSid || (priorSid != null && cid === priorSid));
+        if (scoped && !ownerMatch && cid == null) {
+          // hostPid-only match with no owner session id — cannot target a
+          // session safely. Leave persisted for a correctly-scoped recovery.
+          continue;
+        }
+        // Owner match → prefer the reconnecting filter session id (the owner's
+        // new session). When only priorSessionId matched and no current
+        // sessionId was supplied, filterSid is null — keep the entry's known
+        // owner `cid` for stamping/ack scoping rather than dropping it.
+        // Non-owner matches (hostPid-only) always stamp the entry's true owner.
+        const stampSid = (ownerMatch && filterSid) ? filterSid : cid;
         // Single recovery mode: the worker was in flight at restart. Emit the
         // Aborted boilerplate so the Lead can retry. Completed result bodies are
         // never persisted, so there is nothing to replay here.
@@ -383,21 +404,23 @@ export function recoverPending(dataDir, notifyFn, { sessionId, priorSessionId, c
           dispatch_id: handle,
           tool,
           error: String(isError),
-          ...(filterSid
-            ? { caller_session_id: filterSid }
-            : (entry.callerSessionId ? { caller_session_id: entry.callerSessionId } : {})),
+          ...(stampSid ? { caller_session_id: stampSid } : {}),
           ...(filterHostPid > 0
             ? { client_host_pid: String(filterHostPid) }
             : (entry.clientHostPid > 0 ? { client_host_pid: String(entry.clientHostPid) } : {})),
           instruction: `Earlier ${tool} dispatch (${handle}) was aborted by a plugin restart. Retry if the answer is still needed.`,
         };
         try { process.stderr.write(`[dispatch-persist] recover handle=${handle} tool=${tool} kind=abort\n`); } catch { /* best-effort */ }
-        // Entry remains on disk until notifyFn resolves.  A crash between
-        // fire and ack is safe: the entry survives and recoverPending re-fires
-        // it on the next restart.  Only clear AFTER ack to prevent silent loss.
+        // Entry remains on disk until notifyFn settles as DELIVERED. Matching
+        // notifyToolCompletion settlement semantics (tool-execution-contract),
+        // only an explicit `false`/`0` resolve counts as undelivered and keeps
+        // the entry for retry; any other resolve (including `undefined`/void
+        // from a delivered notifyFn) removes it — otherwise it re-fires until
+        // TTL. A crash between fire and ack is likewise safe: the entry survives
+        // and recoverPending re-fires it on the next restart.
         try {
-          Promise.resolve(notifyFn(content, meta)).then(() => {
-            removePending(dataDir, handle);
+          Promise.resolve(notifyFn(content, meta)).then((ok) => {
+            if (ok !== false && ok !== 0) removePending(dataDir, handle);
           }).catch(() => { /* best-effort — entry stays for next recoverPending */ });
         } catch { /* best-effort */ }
       }

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

@@ -411,6 +411,14 @@ export async function beginOAuthLogin() {
     };
     const url = buildUrl(OAUTH_REDIRECT_URI);
     const manualUrl = buildUrl(OAUTH_MANUAL_REDIRECT_URI);
+    const openLoginUrl = async (targetUrl, label = 'login') => {
+        try {
+            const { openInBrowser } = await import('../../../shared/open-url.mjs');
+            openInBrowser(targetUrl.toString());
+        } catch (err) {
+            process.stderr.write(`[anthropic-oauth] browser open failed for ${label} URL: ${String(err?.message || err).slice(0, 200)}\n`);
+        }
+    };
 
     let server = null;
     let timeout = null;
@@ -454,14 +462,12 @@ export async function beginOAuthLogin() {
         timeout = setTimeout(() => finish(null), OAUTH_LOGIN_TIMEOUT_MS);
         server.listen(OAUTH_CALLBACK_PORT, OAUTH_CALLBACK_HOST, async () => {
             process.stderr.write(`\n[anthropic-oauth] Open this URL to log in with Claude:\n${url.toString()}\n\nIf the localhost callback cannot complete, open this manual URL and paste the shown code#state:\n${manualUrl.toString()}\n\n`);
-            try {
-                const { openInBrowser } = await import('../../../shared/open-url.mjs');
-                openInBrowser(url.toString());
-            } catch (err) {
-                process.stderr.write(`[anthropic-oauth] browser open failed: ${String(err?.message || err).slice(0, 200)}\n`);
-            }
+            await openLoginUrl(url, 'callback');
+        });
+        server.on('error', async (err) => {
+            process.stderr.write(`\n[anthropic-oauth] localhost callback unavailable on ${OAUTH_CALLBACK_HOST}:${OAUTH_CALLBACK_PORT}: ${err?.message || err}\n[anthropic-oauth] Opening manual login URL instead. Paste the shown code#state:\n${manualUrl.toString()}\n\n`);
+            await openLoginUrl(manualUrl, 'manual');
         });
-        server.on('error', (err) => finish(null, new Error(`[anthropic-oauth] callback server failed on ${OAUTH_CALLBACK_HOST}:${OAUTH_CALLBACK_PORT}: ${err?.message || err}`)));
     });
 
     return {

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