mixdog 0.9.36 → 0.9.37

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

@@ -3,20 +3,20 @@
  * Responses-API transport policy switch (OpenAI OAuth/direct + xAI/compat).
  *
  * One env knob, MIXDOG_OAI_TRANSPORT, selects among the transport modes:
- *   - 'ws-delta'  (DEFAULT): WS transport, refs-compatible delta ON.
+ *   - 'ws-delta'  WS-only transport, refs-compatible delta ON.
  *   - 'ws-full'   WS transport, delta OFF (always full frames).
  *   - 'http-sse'  force the HTTP/SSE transport directly (delta is WS-only, so
  *                 it stays off).
- *   - 'auto'      compatibility spelling for the default ws-delta route.
+ *   - 'auto'      WS-first route with HTTP/SSE fallback on websocket failure.
  *
- * No mode performs an implicit HTTP fallback: explicit modes pin their
- * transport. Delta is selected solely via MIXDOG_OAI_TRANSPORT=ws-delta
- * (or by leaving the env unset).
+ * Default/unset behaves like 'auto': prefer WS/delta for cache hotness, but
+ * fall back to HTTP/SSE after bounded websocket failures. Explicit ws-* modes
+ * pin WS for experiments; http-sse pins HTTP.
  */
 
 // Normalize the transport mode token. Underscores/spaces and a few common
 // spellings collapse to the canonical modes. Unknown/empty → null so the
-// caller falls back to the default 'ws-delta'.
+// caller falls back to the default 'auto'.
 export function _normalizeTransportMode(raw) {
     const v = String(raw || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
     switch (v) {
@@ -27,7 +27,7 @@ export function _normalizeTransportMode(raw) {
         case 'http-sse': case 'httpsse': case 'http': case 'sse': case 'http/sse':
             return 'http-sse';
         case 'auto':
-            return 'ws-delta';
+            return 'auto';
         default:
             return null;
     }
@@ -63,9 +63,9 @@ export const RESPONSES_TRANSPORT_CAPABILITIES = Object.freeze({
 export function _gateTransportMode(mode, caps) {
     let m = mode;
     // Delta unsupported → keep WS transport but force full frames.
-    if (m === 'ws-delta' && !caps.delta) m = 'ws-full';
+    if ((m === 'auto' || m === 'ws-delta') && !caps.delta) m = caps.ws ? 'ws-full' : (caps.http ? 'http-sse' : 'auto');
     // WS unsupported → prefer HTTP, else defer to auto.
-    if ((m === 'ws-full' || m === 'ws-delta') && !caps.ws) m = caps.http ? 'http-sse' : 'ws-delta';
+    if ((m === 'auto' || m === 'ws-full' || m === 'ws-delta') && !caps.ws) m = caps.http ? 'http-sse' : 'auto';
     // HTTP unsupported → prefer full-frame WS, else defer to auto.
     if (m === 'http-sse' && !caps.http) m = caps.ws ? 'ws-full' : 'auto';
     return m;
@@ -76,8 +76,8 @@ export function _gateTransportMode(mode, caps) {
  * per-provider capabilities.
  * @param {Record<string,string|undefined>} [env=process.env]
  * @param {{ws?:boolean,http?:boolean,delta?:boolean}} [capabilities=FULL_RESPONSES_TRANSPORT_CAPS]
- * @returns {{ mode: 'ws-full'|'ws-delta'|'http-sse',
- *             requestedMode: 'ws-full'|'ws-delta'|'http-sse',
+ * @returns {{ mode: 'auto'|'ws-full'|'ws-delta'|'http-sse',
+ *             requestedMode: 'auto'|'ws-full'|'ws-delta'|'http-sse',
  *             transport: 'auto'|'ws'|'http',
  *             allowHttpFallback: boolean,
  *             delta: { force: boolean, refs: boolean, optIn: boolean },
@@ -85,7 +85,7 @@ export function _gateTransportMode(mode, caps) {
  */
 export function resolveResponsesTransportPolicy(env = process.env, capabilities = FULL_RESPONSES_TRANSPORT_CAPS) {
     const caps = { ...FULL_RESPONSES_TRANSPORT_CAPS, ...(capabilities || {}) };
-    const requestedMode = _normalizeTransportMode(env?.MIXDOG_OAI_TRANSPORT) || 'ws-delta';
+    const requestedMode = _normalizeTransportMode(env?.MIXDOG_OAI_TRANSPORT) || 'auto';
     const mode = _gateTransportMode(requestedMode, caps);
     let transport;
     let delta;
@@ -98,6 +98,7 @@ export function resolveResponsesTransportPolicy(env = process.env, capabilities
             transport = 'ws';
             delta = DELTA_OFF;      // explicit full frames
             break;
+        case 'auto':
         case 'ws-delta':
             transport = 'ws';
             // Reachable only when caps.delta is true (else gated to ws-full).
@@ -112,9 +113,11 @@ export function resolveResponsesTransportPolicy(env = process.env, capabilities
         mode,
         requestedMode,
         transport,
-        // No mode performs an implicit HTTP fallback; explicit http-sse pins the
-        // HTTP transport instead. Kept as a field so existing callers gate off.
-        allowHttpFallback: false,
+        // Codex refs behavior: default/auto is WS-first but not WS-only. If the
+        // websocket path stalls/fails before emitting live output, callers may
+        // replay the request over HTTP/SSE. Explicit ws-* modes remain pinned
+        // for transport experiments; explicit http-sse bypasses WS entirely.
+        allowHttpFallback: requestedMode === 'auto' && caps.http,
         delta,
         capabilities: caps,
     };

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

@@ -195,8 +195,9 @@ const TRANSPORT_ONLY_FRAME_FIELDS = new Set(['stream', 'background']);
 // identical byte-for-byte: `type` always leads, then the body's codex
 // struct-order keys follow verbatim. A delta send passes previousResponseId
 // (inserted immediately before `input`, matching codex's refs position) and
-// inputOverride (the stripped tail); an empty instructions string is dropped
-// in that case because the server resolves it from previous_response_id.
+// inputOverride (the stripped tail); instructions are dropped whenever
+// previous_response_id is present because the server resolves them from the
+// chained response and rejects sending both fields together.
 // Full/warmup frames pass the body unchanged and keep every key in place.
 // omitTransportFields is used by wire-parity/prewarm helpers to drop stream/background.
 export function _buildResponseCreateFrame(body, { previousResponseId = null, inputOverride, omitTransportFields = false } = {}) {
@@ -214,6 +215,7 @@ export function _buildResponseCreateFrame(body, { previousResponseId = null, inp
     for (const key of Object.keys(src)) {
         if (omitTransportFields && TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
         if (key === 'instructions') {
+            if (previousResponseId != null) continue;
             const instr = src.instructions;
             if (typeof instr === 'string' && instr.length) frame.instructions = instr;
             continue;

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

@@ -23,9 +23,9 @@ import { makeInvalidToolArgsMarker } from './openai-compat-stream.mjs';
 import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';
 import {
     PROVIDER_WS_INTER_CHUNK_TIMEOUT_MS,
-    PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
     PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
     PROVIDER_WS_FIRST_MEANINGFUL_TIMEOUT_MS,
+    PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS,
     streamStalledError,
 } from '../stall-policy.mjs';
 import { customToolCallFromResponseItem } from './custom-tool-wire.mjs';
@@ -47,6 +47,10 @@ import {
     _isMaxOutputIncompleteReason,
     _httpStatusFromWsClose,
 } from './openai-ws-events.mjs';
+import {
+    createActiveToolItemTracker,
+    hasCompleteToolCall as sharedHasCompleteToolCall,
+} from './tool-stream-state.mjs';
 
 // Facade re-exports: the delta/matching helpers and usage/event helpers below
 // were extracted to openai-ws-delta.mjs / openai-ws-events.mjs (no behavior
@@ -258,10 +262,24 @@ export async function _streamResponse({
     const citations = [];
     const citationKeys = new Set();
     const pendingCalls = new Map();
+    // Active tool-item / alias tracking extracted to tool-stream-state.mjs.
+    // Keep the WS-local names bound to the tracker's Set + methods so the
+    // event-switch call sites (markActiveToolItem/clearActiveToolItem/
+    // activeToolItems.size) read unchanged.
+    const _toolTracker = createActiveToolItemTracker();
+    const activeToolItems = _toolTracker.items;
+    const markActiveToolItem = _toolTracker.mark;
+    const clearActiveToolItem = _toolTracker.clear;
     // Tool-work-in-flight flag: set the moment a function/custom tool call's
     // input starts streaming (before it lands in pendingCalls/toolCalls).
     // Gates partial-final SUCCESS so a stall mid tool-input never looks text-only.
     let _toolInFlight = false;
+    // Early tool-call settle latch. Set when a fully-formed tool call is
+    // available but the server never emits response.completed/response.done —
+    // we resolve successfully anyway and surface `closeSocket` so the pool
+    // discards (never reuses) the socket, which may still carry the missing
+    // terminal frames as orphans.
+    let _earlySettled = false;
     // Fix 2: cross-path name+args dedupe. A text-leaked synthetic and an
     // identical native function_call must fire onToolCall exactly once. Every
     // dispatch site routes through emitToolCallDedupe.
@@ -461,7 +479,13 @@ export async function _streamResponse({
     // only) trips a short, named terminal StreamStalledError instead of coasting
     // to the 300s inter-chunk cap / 30-min agent watchdog.
     let semanticIdleTimer = null;
-    const semanticIdleMs = PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS;
+    // WS gets its own shorter semantic-idle window. The shared SSE semantic
+    // timeout is intentionally near the 300s stall warning to protect Anthropic
+    // effort-mode "silent thinking"; using that value here lets a wedged WS
+    // request race the TUI 300s watchdog. Keep websocket stalls provider-owned:
+    // fail/retry/fallback here first, then let the TUI watchdog remain a final
+    // safety net only.
+    const semanticIdleMs = PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS;
     const semanticIdleEnabled = PROVIDER_SSE_IDLE_WATCHDOG_ENABLED && semanticIdleMs > 0;
     // First-meaningful-frame watchdog timer + one-shot latch. Armed alongside
     // the pre-stream watchdog; cleared exactly once by the first meaningful
@@ -575,6 +599,11 @@ export async function _streamResponse({
         const resetInterChunk = () => {
             if (interChunkTimer) clearTimeout(interChunkTimer);
             interChunkTimer = setTimeout(() => {
+                // Early settle: a complete tool call is already captured with no
+                // deferred salvage pending, so silence here is the missing
+                // response.completed/done — resolve with the tool call instead
+                // of a stall error the loop would retry.
+                if (settleEarlyOnToolCall('inter_chunk')) return;
                 if (process.env.MIXDOG_DEBUG_AGENT) {
                     process.stderr.write(`[agent-trace] ws-timeout kind=inter-chunk afterMs=${interChunkMs}\n`);
                 }
@@ -593,6 +622,11 @@ export async function _streamResponse({
             if (!semanticIdleEnabled) return;
             if (semanticIdleTimer) clearTimeout(semanticIdleTimer);
             semanticIdleTimer = setTimeout(() => {
+                // Early settle before treating tool-work silence as a stall: if
+                // a complete tool call is available and no deferred salvage
+                // remains, the turn result is already final even without
+                // response.completed/done.
+                if (settleEarlyOnToolCall('semantic_idle')) return;
                 traceWsTimeout('semantic_idle_timeout', semanticIdleMs);
                 terminalError = streamStalledError('Responses WS', semanticIdleMs, { emittedToolCall: !!midState?.emittedToolCall });
                 // Partial-final recovery: attach streamed partial state so
@@ -672,11 +706,43 @@ export async function _streamResponse({
                 // for the WS path (sendViaWebSocket spreads this result
                 // through to the provider caller unchanged).
                 ...(stopReason === 'length' && content.length > 0 ? { truncated: true } : {}),
+                // Early tool-call settle: tell the caller to drop (not pool)
+                // this socket. The server may still emit the skipped
+                // response.completed/done as orphan frames; reusing the socket
+                // would read them as the next request's stream and wedge it.
+                ...(_earlySettled ? { closeSocket: true } : {}),
                 incompleteReason: incompleteReason || undefined,
                 responseId: responseId || undefined,
                 serviceTier: responseServiceTier || undefined,
             });
         };
+        // Early tool-call settle guard. A fully-formed tool call (real call_id +
+        // name, not a deferred salvage placeholder) means the turn's actionable
+        // result is already complete. When the server then goes silent without
+        // response.completed/response.done, resolve successfully with that tool
+        // call rather than surfacing a stall error the loop gates out via
+        // pendingToolUse and retries. Returns true if it settled the stream.
+        const hasCompleteToolCall = () => sharedHasCompleteToolCall({
+            toolCalls,
+            pendingSize: pendingCalls.size,
+            activeSize: activeToolItems.size,
+            toolInFlight: _toolInFlight,
+        });
+        const settleEarlyOnToolCall = (reason) => {
+            if (done || terminalError) return false;
+            if (!hasCompleteToolCall()) return false;
+            _earlySettled = true;
+            // Treat as a normal completion for downstream state: we have the
+            // canonical tool call, only the terminal lifecycle frame is missing.
+            midState.sawCompleted = true;
+            midState.wsEarlySettle = reason;
+            done = true;
+            // Close and mark keep=false (via closeSocket in the resolve). The
+            // late/never response.completed cannot then leak onto a pooled reuse.
+            try { socket.close(4000, `early_settle_${reason}`); } catch {}
+            finish();
+            return true;
+        };
 
         messageHandler = (data) => {
             resetIdle();
@@ -759,14 +825,17 @@ export async function _streamResponse({
                     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 === 'custom_tool_call') {
+                        markActiveToolItem(event.item);
                         _toolInFlight = true;
                     } else if (event.item?.type === 'tool_search_call') {
+                        markActiveToolItem(event.item);
                         // Mark tool_search in-flight at item-added time, same
                         // as function_call/custom_tool_call above, so the
                         // semantic-idle stall gate's pendingToolUse never
@@ -780,11 +849,13 @@ export async function _streamResponse({
                     resetSemanticIdle();
                     break;
                 case 'response.function_call_arguments.delta':
+                    markActiveToolItem(null, event.item_id);
                     _toolInFlight = true;
                     try { onStreamDelta?.(); } catch {}
                     bumpSemanticIdle();
                     break;
                 case 'response.custom_tool_call_input.delta':
+                    markActiveToolItem(null, event.item_id);
                     _toolInFlight = true;
                     try { onStreamDelta?.(); } catch {}
                     bumpSemanticIdle();
@@ -819,6 +890,11 @@ export async function _streamResponse({
                         const call = { id: pending.callId, name: pending.name, arguments: args };
                         toolCalls.push(call);
                         emitToolCallDedupe(call);
+                        pendingCalls.delete(itemId);
+                        // Keep the function item active until output_item.done:
+                        // arguments.done completes args, but the lifecycle item
+                        // itself may still be followed by item.done/final frames.
+                        _toolInFlight = pendingCalls.size > 0 || activeToolItems.size > 0;
                     } else {
                         // Synthesizing a `tc_${Date.now()}` callId here would
                         // make the next turn fail to match the model's
@@ -850,11 +926,46 @@ export async function _streamResponse({
                     // server-side prompt cache prefix warm.
                     if (event.item?.type === 'reasoning') pushReasoningItem(event.item);
                     if (event.item?.type === 'web_search_call') pushWebSearchCall(event.item);
+                    if (event.item?.type === 'function_call') {
+                        const item = event.item;
+                        const itemId = item.id || '';
+                        const callId = item.call_id || '';
+                        const name = item.name || '';
+                        const argsText = typeof item.arguments === 'string' ? item.arguments : '';
+                        let args = {};
+                        if (argsText.trim() !== '') {
+                            try {
+                                args = JSON.parse(argsText);
+                            } catch (err) {
+                                args = makeInvalidToolArgsMarker(argsText, err instanceof Error ? err.message : String(err));
+                            }
+                        }
+                        const deferred = toolCalls.find((tc) => tc?._deferred && (!itemId || tc._pendingItemId === itemId));
+                        if (deferred && callId && name) {
+                            deferred.id = callId;
+                            deferred.name = name;
+                            deferred.arguments = deferred.arguments && Object.keys(deferred.arguments).length > 0 ? deferred.arguments : args;
+                            delete deferred._deferred;
+                            delete deferred._pendingItemId;
+                            emitToolCallDedupe(deferred);
+                        } else if (callId && name && !toolCalls.some((tc) => tc?.id === callId)) {
+                            const call = { id: callId, name, arguments: args };
+                            toolCalls.push(call);
+                            emitToolCallDedupe(call);
+                        }
+                        if (itemId) pendingCalls.delete(itemId);
+                        clearActiveToolItem(item, itemId);
+                        _toolInFlight = pendingCalls.size > 0 || activeToolItems.size > 0;
+                    }
                     if (event.item?.type === 'tool_search_call') {
                         pushToolSearchCall(event.item);
+                        clearActiveToolItem(event.item);
+                        _toolInFlight = pendingCalls.size > 0 || activeToolItems.size > 0;
                     }
                     if (event.item?.type === 'custom_tool_call') {
                         pushCustomToolCall(event.item);
+                        clearActiveToolItem(event.item);
+                        _toolInFlight = pendingCalls.size > 0 || activeToolItems.size > 0;
                     }
                     // Item-done is genuine lifecycle progress — reset semantic
                     // idle so latency before the next item/args does not stall.

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

@@ -24,6 +24,15 @@ const signatures = new Map();
 // strictly sequential at the registry level, independent of any caller gating,
 // so two different config signatures can never interleave their rebuilds.
 let _initChain = Promise.resolve();
+// Singleflight state layered on top of the serial chain. Under simultaneous
+// multi-agent launch, many callers hit initProviders() with a byte-identical
+// config. `_inFlightPromise`/`_inFlightSig` coalesce those onto the pending
+// init instead of queueing redundant clear()+rebuild passes behind it, and
+// `_lastAppliedSig` lets a repeat call short-circuit entirely once the chain
+// is idle. Differing signatures still serialize through _initChain as before.
+let _inFlightPromise = null;
+let _inFlightSig = null;
+let _lastAppliedSig = null;
 
 // Deterministic structural signature of a provider config. Recursively sorts
 // object keys so signature equality reflects config-value equality regardless
@@ -80,6 +89,16 @@ function instantiateProvider(name, Ctor, cfg) {
 }
 
 export async function initProviders(config) {
+    const sig = configSignature(config);
+    // Coalesce: an identical config is already mid-init — attach to it.
+    if (sig !== null && _inFlightPromise && _inFlightSig === sig) {
+        return _inFlightPromise;
+    }
+    // Fast path: chain idle and the live registry already reflects this exact
+    // config — nothing to tear down or rebuild.
+    if (sig !== null && !_inFlightPromise && _lastAppliedSig === sig) {
+        return;
+    }
     // Serialize ALL inits through a single chain so two different config
     // signatures can never run their clear()+rebuild concurrently, regardless
     // of caller-side gating (agent-tool gateOnPrior may release a queued init
@@ -87,7 +106,19 @@ export async function initProviders(config) {
     const run = () => _initProvidersUnsynchronized(config);
     const next = _initChain.then(run, run);
     _initChain = next.then(() => {}, () => {});
-    return next;
+    const settle = () => {
+        if (_inFlightPromise === tracked) {
+            _inFlightPromise = null;
+            _inFlightSig = null;
+        }
+    };
+    const tracked = next.then(
+        (v) => { _lastAppliedSig = sig; settle(); return v; },
+        (err) => { settle(); throw err; },
+    );
+    _inFlightSig = sig;
+    _inFlightPromise = tracked;
+    return tracked;
 }
 
 async function _initProvidersUnsynchronized(config) {
@@ -243,18 +274,23 @@ export function warmupCatalogs() {
 // context metadata stays on its own 24h TTL. Fire-and-forget: never awaited,
 // per-provider failures logged to stderr like warmupCatalogs.
 export function refreshProviderCatalogsOnStartup() {
+    const pending = [];
     for (const [name, provider] of providers) {
         const refreshFn = typeof provider?._refreshModelCache === 'function'
             ? () => provider._refreshModelCache()
             : (typeof provider?.listModels === 'function' ? () => provider.listModels() : null);
         if (!refreshFn) continue;
-        Promise.resolve()
+        pending.push(Promise.resolve()
             .then(() => refreshFn())
             .catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
                 process.stderr.write(`[provider:${name}] startup catalog refresh failed: ${msg}\n`);
-            });
+            }));
     }
+    // Returns a completion promise so callers can invalidate stale model
+    // caches once the fresh catalogs land. Still fire-and-forget: unawaited
+    // callers keep the previous nonblocking startup behavior.
+    return Promise.allSettled(pending);
 }
 
 // Force-refresh provider catalogs after an operator changes model/provider
@@ -262,6 +298,7 @@ export function refreshProviderCatalogsOnStartup() {
 // the shared LiteLLM metadata cache first so context/pricing metadata follows
 // newly released models without waiting for the next process restart.
 export function refreshCatalogs() {
+    const pending = [];
     const metadataReady = Promise.resolve()
         .then(() => refreshMetadataCatalog())
         .catch((err) => {
@@ -274,12 +311,14 @@ export function refreshCatalogs() {
             ? () => provider._refreshModelCache()
             : (typeof provider?.listModels === 'function' ? () => provider.listModels() : null);
         if (!refreshFn) continue;
-        Promise.resolve()
+        pending.push(Promise.resolve()
             .then(() => metadataReady)
             .then(() => refreshFn())
             .catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
                 process.stderr.write(`[provider:${name}] catalog refresh failed: ${msg}\n`);
-            });
+            }));
     }
+    // Completion promise: lets callers drop stale model caches after refresh.
+    return Promise.allSettled([metadataReady, ...pending]);
 }

package/src/runtime/agent/orchestrator/providers/tool-stream-state.mjs

@@ -0,0 +1,78 @@
+/**
+ * tool-stream-state.mjs — shared active tool-item / alias tracking and the
+ * complete-tool early-settle predicate for the OpenAI Responses stream
+ * consumers.
+ *
+ * Extracted verbatim (no behavior change) from openai-ws-stream.mjs, where the
+ * activeToolItems Set + activeToolAliases Map (id/call_id/fallback-key alias
+ * union) and the hasCompleteToolCall gate were WS-local closures. Kept as a
+ * plain factory + pure predicate so any Responses-shaped stream can reuse the
+ * same lifecycle-tracking semantics.
+ */
+
+/**
+ * Per-stream active tool-item tracker. Tracks in-flight function/custom/
+ * tool_search items by every key they surface under (id, call_id, and any
+ * fallback item_id from delta frames), unioning aliases so a mark under one key
+ * and a clear under another still resolve to the same item.
+ */
+export function createActiveToolItemTracker() {
+    const activeToolItems = new Set();
+    const activeToolAliases = new Map();
+    const activeToolKeys = (item, fallback = '') => {
+        const keys = [];
+        const add = (value) => {
+            const key = String(value || '');
+            if (key && !keys.includes(key)) keys.push(key);
+        };
+        add(fallback);
+        add(item?.id);
+        add(item?.call_id);
+        return keys;
+    };
+    const mark = (item, fallback = '') => {
+        const keys = new Set(activeToolKeys(item, fallback));
+        for (const key of [...keys]) {
+            const aliases = activeToolAliases.get(key);
+            if (aliases) for (const alias of aliases) keys.add(alias);
+        }
+        for (const key of keys) {
+            activeToolItems.add(key);
+            activeToolAliases.set(key, new Set(keys));
+        }
+    };
+    const clear = (item, fallback = '') => {
+        const keys = new Set(activeToolKeys(item, fallback));
+        for (const key of [...keys]) {
+            const aliases = activeToolAliases.get(key);
+            if (aliases) for (const alias of aliases) keys.add(alias);
+        }
+        for (const key of keys) {
+            activeToolItems.delete(key);
+            activeToolAliases.delete(key);
+        }
+    };
+    return {
+        items: activeToolItems,
+        aliases: activeToolAliases,
+        keys: activeToolKeys,
+        mark,
+        clear,
+    };
+}
+
+/**
+ * Early tool-call settle predicate. True only when a fully-formed tool call
+ * (real id + name, not a deferred salvage placeholder) is captured and no tool
+ * work is still in flight — pendingCalls drained, no active lifecycle item, and
+ * the in-flight latch cleared. Callers pass the current sizes/flag rather than
+ * the live collections so the check stays a pure snapshot.
+ */
+export function hasCompleteToolCall({ toolCalls, pendingSize, activeSize, toolInFlight }) {
+    return toolCalls.length > 0
+        && pendingSize === 0
+        && activeSize === 0
+        && toolInFlight !== true
+        && !toolCalls.some((t) => t && t._deferred)
+        && toolCalls.every((t) => t && t.id && t.name);
+}

package/src/runtime/agent/orchestrator/session/agent-loop.mjs

@@ -195,21 +195,32 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     const drainSteeringIntoMessages = (stage = 'mid-turn', options = {}) => {
         if (typeof opts.drainSteering !== 'function') return false;
         let steerMsgs = [];
-        try { steerMsgs = opts.drainSteering(sessionId) || []; }
+        try { steerMsgs = opts.drainSteering(sessionId, options) || []; }
         catch { steerMsgs = []; }
-        const merged = mergeSteeringEntries(steerMsgs);
-        if (!merged) return false;
+        const mergedMessages = [];
+        for (const entry of Array.isArray(steerMsgs) ? steerMsgs : []) {
+            const merged = mergeSteeringEntries([entry]);
+            if (merged) mergedMessages.push(merged);
+        }
+        if (mergedMessages.length === 0) return false;
         if (typeof options.beforeAppend === 'function') {
             try { options.beforeAppend(); } catch { /* best-effort hook */ }
         }
-        // Tag steering-origin user messages so provider lowering keeps them a
-        // distinct user turn (see anthropic-oauth foldUserTextIntoToolResultTail):
-        // human/TUI steering must stay attributed as user input, never folded
-        // into a preceding tool_result where it reads as tool output.
-        messages.push({ role: 'user', content: merged.content, meta: { source: 'steering' } });
-        try { opts.onSteerMessage?.(merged.text || steeringContentText(merged.content)); } catch {}
+        let totalCount = 0;
+        let totalTextLen = 0;
+        for (const merged of mergedMessages) {
+            // Tag steering-origin user messages so provider lowering keeps them
+            // distinct from preceding tool results. Keep each queued command as
+            // its own user turn, matching Claude Code queued_command attachment
+            // semantics instead of collapsing priority/mode buckets together.
+            messages.push({ role: 'user', content: merged.content, meta: { source: 'steering' } });
+            const text = merged.text || steeringContentText(merged.content);
+            totalCount += Number(merged.count) || 1;
+            totalTextLen += String(text || '').length;
+            try { opts.onSteerMessage?.(text); } catch {}
+        }
         if (sessionId) {
-            try { process.stderr.write(`[steer] sess=${sessionId} injected ${stage} user message (merged=${merged.count} len=${String(merged.text || '').length})\n`); } catch {}
+            try { process.stderr.write(`[steer] sess=${sessionId} injected ${stage} user message(s) (merged=${totalCount} len=${totalTextLen})\n`); } catch {}
         }
         return true;
     };
@@ -259,6 +270,15 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // the loop as an explicit empty termination instead.
     let _emptyNudgeStreak = 0;
     const EMPTY_NUDGE_MAX = 3;
+    // Claude Code parity: queued prompt/task notifications are attached after a
+    // tool batch, before the continuation provider send. Normal batches drain
+    // up to 'next'; a Sleep-like tool grants a 'later' flush.
+    let _toolBatchJustCompleted = false;
+    let _lastToolBatchHadSleep = false;
+    const isSleepLikeToolCall = (call) => {
+        const name = String(call?.name || call?.toolName || call?.function?.name || '').toLowerCase();
+        return name === 'sleep' || name.endsWith('/sleep') || name.endsWith('.sleep');
+    };
     // Completion-first steering ladder controller. Owns the (cumulative) level-1
     // fire count, the all-read-only / serial-single / same-file-grep streaks,
     // and the level-2 latch. Threaded via live getters so it reads the loop's
@@ -336,11 +356,19 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 });
             } catch { /* best-effort */ }
         }
-        // Drain queued steering/prompts BEFORE the
-        // pre-send compact check. The compact decision must see the exact
-        // message set that the next provider.send would receive, including
-        // tool results plus any queued user input/notifications.
-        drainSteeringIntoMessages('pre-send');
+        // Drain queued steering/prompts BEFORE the pre-send compact check, but
+        // only immediately after a tool batch has completed. This mirrors
+        // Claude Code's query.ts queued_command attachment drain: queued entries
+        // are attached after tool results are appended and before the recursive
+        // continuation, not on arbitrary non-tool continuations (empty nudges,
+        // iteration-cap final text turns, etc.).
+        if (_toolBatchJustCompleted) {
+            drainSteeringIntoMessages('pre-send', {
+                maxPriority: _lastToolBatchHadSleep ? 'later' : 'next',
+            });
+            _toolBatchJustCompleted = false;
+            _lastToolBatchHadSleep = false;
+        }
         ({
             iterations,
             lastUsage,
@@ -442,16 +470,23 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         // the stateless contract for providers that don't use continuation).
         providerState = response?.providerState ?? undefined;
         iterations = nextIteration;
-        // Payload byte estimate serializes the FULL messages+tools array —
-        // only pay that cost when verbose loop tracing is actually enabled
-        // (traceAgentLoop is a no-op otherwise).
-        if (process.env.MIXDOG_AGENT_TRACE_VERBOSE === '1') {
+        // Loop trace has two modes (both no-op on provider behavior):
+        //   VERBOSE=1 → full row; pay the FULL messages+tools payload byte
+        //               estimate (serializes the whole array).
+        //   TIMING=1  → send-latency attribution only; skip the payload
+        //               estimate so measuring send_ms does not itself add
+        //               serialization cost during high-fanout bench runs.
+        const _traceVerbose = process.env.MIXDOG_AGENT_TRACE_VERBOSE === '1';
+        if (_traceVerbose || process.env.MIXDOG_AGENT_TRACE_TIMING === '1') {
             traceAgentLoop({
                 sessionId,
                 iteration: iterations,
                 sendMs: Date.now() - sendStartedAt,
                 messageCount: Array.isArray(messages) ? messages.length : 0,
-                bodyBytesEst: estimateProviderPayloadBytes(messages, model, sendTools),
+                bodyBytesEst: _traceVerbose
+                    ? estimateProviderPayloadBytes(messages, model, sendTools)
+                    : undefined,
+                agent: sessionAgent || null,
             });
         }
         // Accumulate usage across iterations — every billable slot, not just
@@ -556,17 +591,6 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             const isHidden = HIDDEN_AGENT_NAMES.has(sessionAgent);
             const stopReason = response.stopReason ?? response.stop_reason ?? null;
             const isIncompleteStop = stopReason && INCOMPLETE_STOP_REASONS.has(stopReason);
-            // A user/schedule notification can arrive while provider.send() is
-            // returning a terminal no-tool response. Drain once before accepting
-            // it as final so the queued input is handled in the same active turn
-            // instead of waiting for post-turn TUI drain. If the model already
-            // produced assistant text, persist that as an intermediate assistant
-            // message before appending the steered user message.
-            if (drainSteeringIntoMessages('final-pre-send', {
-                beforeAppend: () => pushIntermediateAssistantResponse(response),
-            })) {
-                continue;
-            }
             if (!hasContent && !isHidden) {
                 _emptyNudgeStreak += 1;
                 if (_emptyNudgeStreak > EMPTY_NUDGE_MAX) {
@@ -662,6 +686,8 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             pushToolResultMessage, throwIfAborted,
             repeatFailLimit: REPEAT_FAIL_LIMIT,
         }));
+        _toolBatchJustCompleted = true;
+        _lastToolBatchHadSleep = calls.some(isSleepLikeToolCall);
     }
     // Classify WHY the loop ended so agent-tool can promote an empty/abnormal
     // finish to an explicit Lead-facing error instead of a silent empty