mixdog 0.9.95 → 0.9.97

package/src/runtime/agent/orchestrator/providers/stream-json-pool.mjs

@@ -0,0 +1,291 @@
+import { availableParallelism } from 'node:os';
+import { Worker } from 'node:worker_threads';
+import { currentProviderAdmissionOwner } from './admission-scheduler.mjs';
+
+const DEFAULT_MIN_BATCH_BYTES = 32 * 1024;
+
+function positiveInt(value, fallback) {
+    const parsed = Math.floor(Number(value));
+    return Number.isFinite(parsed) && parsed >= 1 ? parsed : fallback;
+}
+
+function configuredWorkerCount(env = process.env) {
+    const configured = Number(env.MIXDOG_PROVIDER_STREAM_WORKERS);
+    if (configured === 0) return 0;
+    if (Number.isFinite(configured) && configured > 0) return Math.floor(configured);
+    return Math.max(1, Math.min(4, availableParallelism() - 1));
+}
+
+function abortError(signal) {
+    return signal?.reason instanceof Error
+        ? signal.reason
+        : new Error(String(signal?.reason || 'provider stream parse canceled'));
+}
+
+function syntaxError(details) {
+    const error = new SyntaxError(String(details?.message || 'invalid JSON'));
+    error.name = String(details?.name || 'SyntaxError');
+    return error;
+}
+
+/**
+ * Reusable worker pool for the CPU part of provider SSE handling.
+ *
+ * Small deltas stay inline because a Worker round-trip costs more than parsing
+ * them. Large events and multi-event network chunks are parsed off the daemon
+ * event loop. Calls are never admission-capped: every request is posted
+ * immediately and workers consume their independent message queues.
+ */
+export function createStreamJsonPool({
+    maxWorkers = configuredWorkerCount(),
+    minBatchBytes = Number(process.env.MIXDOG_PROVIDER_STREAM_WORKER_MIN_BYTES)
+        || DEFAULT_MIN_BATCH_BYTES,
+    maxPendingBytes = (Number(process.env.MIXDOG_PROVIDER_STREAM_PENDING_MB) || 32)
+        * 1024 * 1024,
+    WorkerImpl = Worker,
+} = {}) {
+    const workerMax = Math.max(0, Math.floor(Number(maxWorkers) || 0));
+    const inlineBelowBytes = Math.max(0, Math.floor(Number(minBatchBytes) || 0));
+    const slots = [];
+    const ownerAffinities = new Map();
+    const waiting = [];
+    const pendingByteMax = Math.max(1024 * 1024, Math.floor(Number(maxPendingBytes) || 0));
+    let pendingBytes = 0;
+    let waitingBytes = 0;
+    let sequence = 0;
+    let closed = false;
+    const stats = {
+        inlineBatches: 0,
+        offloadedBatches: 0,
+        fallbackBatches: 0,
+        parsedBytes: 0,
+    };
+
+    function parseInline(payloads) {
+        return payloads.map((payload) => JSON.parse(payload));
+    }
+
+    function removeSlot(slot) {
+        const index = slots.indexOf(slot);
+        if (index >= 0) slots.splice(index, 1);
+        for (const [owner, assigned] of ownerAffinities) {
+            if (assigned === slot) ownerAffinities.delete(owner);
+        }
+    }
+
+    function failSlot(slot) {
+        if (slot.failed) return;
+        slot.failed = true;
+        removeSlot(slot);
+        for (const task of slot.tasks.values()) {
+            pendingBytes = Math.max(0, pendingBytes - task.bytes);
+            task.detach();
+            if (task.aborted) continue;
+            stats.fallbackBatches += 1;
+            try { task.resolve(parseInline(task.payloads)); }
+            catch (error) { task.reject(error); }
+        }
+        slot.tasks.clear();
+        try { slot.worker.terminate(); } catch {}
+        drainWaiting();
+    }
+
+    function createSlot() {
+        const worker = new WorkerImpl(new URL('./stream-json-worker.mjs', import.meta.url), {
+            execArgv: [],
+        });
+        worker.unref?.();
+        const slot = { worker, tasks: new Map(), failed: false };
+        worker.on('message', (message) => {
+            const task = slot.tasks.get(Number(message?.id));
+            if (!task) return;
+            slot.tasks.delete(Number(message.id));
+            pendingBytes = Math.max(0, pendingBytes - task.bytes);
+            task.detach();
+            if (task.aborted) return;
+            if (message?.ok === true) task.resolve(message.values);
+            else task.reject(syntaxError(message?.error));
+            drainWaiting();
+        });
+        worker.on('error', () => failSlot(slot));
+        worker.on('exit', () => {
+            if (!closed) failSlot(slot);
+            else removeSlot(slot);
+        });
+        slots.push(slot);
+        return slot;
+    }
+
+    function pickSlot(ownerKey) {
+        const ready = slots.filter((slot) => !slot.failed);
+        const owner = String(ownerKey || '').trim().slice(0, 240);
+        const assigned = owner ? ownerAffinities.get(owner) : null;
+        if (assigned && !assigned.failed) return assigned;
+        const least = ready.sort((left, right) => left.tasks.size - right.tasks.size)[0] || null;
+        const slot = ready.length < workerMax && (!least || least.tasks.size > 0)
+            ? createSlot()
+            : least || createSlot();
+        if (owner) {
+            ownerAffinities.set(owner, slot);
+            while (ownerAffinities.size > 4096) {
+                ownerAffinities.delete(ownerAffinities.keys().next().value);
+            }
+        }
+        return slot;
+    }
+
+    function removeWaiting(task) {
+        const index = waiting.indexOf(task);
+        if (index < 0) return false;
+        waiting.splice(index, 1);
+        waitingBytes = Math.max(0, waitingBytes - task.bytes);
+        return true;
+    }
+
+    function postTask(task) {
+        const slot = pickSlot(task.ownerKey);
+        task.slot = slot;
+        slot.tasks.set(task.id, task);
+        pendingBytes += task.bytes;
+        try {
+            slot.worker.postMessage({ id: task.id, payloads: task.payloads });
+        } catch {
+            slot.tasks.delete(task.id);
+            pendingBytes = Math.max(0, pendingBytes - task.bytes);
+            task.detach();
+            stats.fallbackBatches += 1;
+            try { task.resolve(parseInline(task.payloads)); }
+            catch (error) { task.reject(error); }
+            drainWaiting();
+        }
+    }
+
+    function drainWaiting() {
+        while (waiting.length > 0) {
+            const task = waiting[0];
+            if (pendingBytes > 0 && pendingBytes + task.bytes > pendingByteMax) return;
+            waiting.shift();
+            waitingBytes = Math.max(0, waitingBytes - task.bytes);
+            if (task.aborted) continue;
+            postTask(task);
+        }
+    }
+
+    function parseBatch(values, {
+        signal = null,
+        ownerKey = currentProviderAdmissionOwner(),
+    } = {}) {
+        const payloads = (Array.isArray(values) ? values : [values]).map((value) => String(value));
+        if (signal?.aborted) return Promise.reject(abortError(signal));
+        const bytes = payloads.reduce((sum, payload) => sum + Buffer.byteLength(payload), 0);
+        stats.parsedBytes += bytes;
+        if (workerMax === 0 || bytes < inlineBelowBytes) {
+            stats.inlineBatches += 1;
+            try { return Promise.resolve(parseInline(payloads)); }
+            catch (error) { return Promise.reject(error); }
+        }
+        if (closed) return Promise.reject(new Error('provider stream JSON pool is closed'));
+        if (bytes > pendingByteMax) {
+            const error = new Error(
+                `provider stream JSON batch exceeded ${pendingByteMax} bytes`,
+            );
+            error.code = 'ERESOURCEPRESSURE';
+            return Promise.reject(error);
+        }
+
+        const id = ++sequence;
+        stats.offloadedBatches += 1;
+        return new Promise((resolve, reject) => {
+            const task = {
+                id,
+                ownerKey,
+                bytes,
+                payloads,
+                resolve,
+                reject,
+                aborted: false,
+                onAbort: null,
+                detach() {
+                    if (!task.onAbort || !signal) return;
+                    try { signal.removeEventListener('abort', task.onAbort); } catch {}
+                    task.onAbort = null;
+                },
+            };
+            if (signal) {
+                task.onAbort = () => {
+                    if (task.aborted) return;
+                    task.aborted = true;
+                    task.detach();
+                    if (removeWaiting(task)) {
+                        reject(abortError(signal));
+                        return;
+                    }
+                    reject(abortError(signal));
+                };
+                signal.addEventListener('abort', task.onAbort, { once: true });
+            }
+            if (pendingBytes > 0 && pendingBytes + bytes > pendingByteMax) {
+                if (waitingBytes + bytes > pendingByteMax) {
+                    task.detach();
+                    const error = new Error(
+                        `provider stream JSON backlog exceeded ${pendingByteMax} bytes`,
+                    );
+                    error.code = 'ERESOURCEPRESSURE';
+                    reject(error);
+                    return;
+                }
+                waiting.push(task);
+                waitingBytes += bytes;
+                return;
+            }
+            postTask(task);
+        });
+    }
+
+    async function close(reason = 'provider stream JSON pool closed') {
+        if (closed) return;
+        closed = true;
+        const error = new Error(reason);
+        for (const task of waiting.splice(0)) {
+            task.detach();
+            if (!task.aborted) task.reject(error);
+        }
+        waitingBytes = 0;
+        const workers = [];
+        for (const slot of slots.splice(0)) {
+            for (const task of slot.tasks.values()) {
+                task.detach();
+                if (!task.aborted) task.reject(error);
+            }
+            slot.tasks.clear();
+            workers.push(Promise.resolve(slot.worker.terminate()).catch(() => {}));
+        }
+        ownerAffinities.clear();
+        await Promise.all(workers);
+    }
+
+    function snapshot() {
+        return {
+            workers: slots.filter((slot) => !slot.failed).length,
+            workerMax,
+            activeBatches: slots.reduce((sum, slot) => sum + slot.tasks.size, 0),
+            pendingBytes,
+            waitingBatches: waiting.length,
+            waitingBytes,
+            maxPendingBytes: pendingByteMax,
+            ownerAffinities: ownerAffinities.size,
+            inlineBatches: stats.inlineBatches,
+            offloadedBatches: stats.offloadedBatches,
+            fallbackBatches: stats.fallbackBatches,
+            parsedBytes: stats.parsedBytes,
+        };
+    }
+
+    return { parseBatch, close, snapshot };
+}
+
+export const providerStreamJsonPool = createStreamJsonPool();
+export const parseProviderJsonBatch = (payloads, options) =>
+    providerStreamJsonPool.parseBatch(payloads, options);
+export const providerStreamJsonSnapshot = () => providerStreamJsonPool.snapshot();
+export const closeProviderStreamJsonPool = (reason) => providerStreamJsonPool.close(reason);

package/src/runtime/agent/orchestrator/providers/stream-json-worker.mjs

@@ -0,0 +1,21 @@
+import { parentPort } from 'node:worker_threads';
+
+if (!parentPort) throw new Error('provider stream JSON worker requires parentPort');
+
+parentPort.on('message', (message) => {
+    const id = Number(message?.id);
+    const payloads = Array.isArray(message?.payloads) ? message.payloads : [];
+    try {
+        const values = payloads.map((payload) => JSON.parse(String(payload)));
+        parentPort.postMessage({ id, ok: true, values });
+    } catch (error) {
+        parentPort.postMessage({
+            id,
+            ok: false,
+            error: {
+                name: String(error?.name || 'SyntaxError'),
+                message: String(error?.message || error || 'invalid JSON'),
+            },
+        });
+    }
+});

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

@@ -30,7 +30,7 @@ import {
 } from './loop/tool-classify.mjs';
 import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
 import { runRecallFastTrackCompact } from './loop/recall-fasttrack.mjs';
-import { executeTool, _scopedCacheOutcomeForCall } from './loop/tool-exec.mjs';
+import { executeTool, _scopedCacheOutcomeForCall, resolveLiveToolCwd } from './loop/tool-exec.mjs';
 
 // classifyResultKind is imported from result-classification.mjs at the top of
 // this file; import it from there directly rather than via this module.
@@ -403,23 +403,26 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // Continuations since the last executed tool batch — bounds the text-only
     // continuation runaway (see PROVIDER_CONTINUATION_NO_TOOL_LIMIT).
     let _continuationsSinceToolBatch = 0;
-    // Loop-level transport replays consumed this ask (see send-with-recovery
-    // TRANSPORT_RETRY_MAX): bounded per turn, reset only with a fresh ask.
+    // Loop-level transport replays consumed since the last SUCCESSFUL send
+    // (see send-with-recovery TRANSPORT_RETRY_MAX). Reference parity: codex
+    // starts each sampling request at retries=0 (and resets on transport
+    // fallback), cc's withRetry budget is per request, opencode schedules
+    // retries per stream call. A per-ask budget instead let one early blip in
+    // a long turn leave every later iteration with zero replays.
     let _transportRetriesUsed = 0;
     // 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 _lastToolBatchEndedAt = 0;
     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');
     };
-    // Tool execution must use the session cwd even when the caller omitted the
-    // legacy positional cwd argument. Agent workers always carry their cwd on
-    // sessionRef; falling through to pwd()/process.cwd() resolves relatives
-    // against the host/plugin root instead of the worker workspace.
-    cwd = cwd || sessionRef?.cwd || undefined;
+    // sessionRef.cwd is the live SSOT. The legacy positional cwd is only the
+    // turn-start snapshot and becomes stale after an in-turn cwd tool call.
+    cwd = resolveLiveToolCwd(cwd, sessionRef);
     // Staged pre-cap warnings + one true hard stop. The ONLY count-based
     // forced termination is the hard cap at maxLoopIterations (default 200):
     // a genuine runaway guard. Before it, staged warnings fire at 50%/75%/90%
@@ -440,6 +443,10 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             Math.floor(maxLoopIterations * 0.9),
         ];
     while (true) {
+        // A cwd tool call updates sessionRef in place. Refresh before building
+        // this iteration's eager dispatcher and cache keys so every following
+        // tool family, including apply_patch, observes the new write root.
+        cwd = resolveLiveToolCwd(cwd, sessionRef);
         const _iterT0 = Date.now();
         throwIfAborted();
         if (iterations >= maxLoopIterations) {
@@ -457,7 +464,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 // non-empty final so callers never see an empty response.
                 if (response && !String(response.content || '').trim()) {
                     response.content = sessionAgent === 'explorer'
-                        ? 'EXPLORATION_FAILED'
+                        ? 'EXPLORATION_FAILED [iteration-cap] — explorer hit its tool-turn cap with zero anchors; retry once with changed tokens or a narrower root'
                         : '[iteration cap reached before final text]';
                     if (Array.isArray(response.toolCalls)) response.toolCalls = [];
                 }
@@ -632,6 +639,10 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 return result;
             };
         const sendStartedAt = Date.now();
+        const preSendMs = sendStartedAt - _iterT0;
+        const toolResumeMs = _lastToolBatchEndedAt
+            ? sendStartedAt - _lastToolBatchEndedAt
+            : null;
         try { opts.onProviderSendStarted?.(); } catch {}
         const _sendResult = await runWithProviderRequestToolsScope(
             requestToolScope,
@@ -659,6 +670,10 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         opts.onToolCall = undefined;
         delete opts.cacheBreakIntent;
         contextOverflowRetryUsed = false;
+        // A completed send ends the outage this budget was covering; the next
+        // iteration is a fresh request and must get the full replay budget
+        // again (mirrors contextOverflowRetryUsed above).
+        _transportRetriesUsed = 0;
         // Capture opaque state for the next turn only when the provider
         // explicitly returned the field. Absence means "no update"; an own
         // property with null/undefined means "clear".
@@ -679,6 +694,8 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 sessionId,
                 iteration: iterations,
                 sendMs: Date.now() - sendStartedAt,
+                preSendMs,
+                toolResumeMs,
                 messageCount: Array.isArray(messages) ? messages.length : 0,
                 bodyBytesEst: _traceVerbose
                     ? estimateProviderPayloadBytes(messages, model, sendTools)
@@ -1050,15 +1067,24 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         }));
         // Settle the stop hook on the batch that actually executed.
         _toolFailureStopHook.endBatch(_callsToExecute);
+        const _toolsEndedAt = Date.now();
+        try {
+            opts.onToolPhaseCompleted?.({
+                iteration: nextIteration,
+                calls: _callsToExecute.length,
+                elapsedMs: _toolsEndedAt - _toolsT0,
+            });
+        } catch {}
         // Loop-phase timing (diagnostics): where non-model time goes per
         // iteration — presend (repair/compact/snapshot), send (provider
         // round-trip incl. streaming), tools (batch execution). Gated by the
         // same env as [turn-timing] so bench runs opt in via -AgentEnv.
         if (process.env.MIXDOG_TURN_TIMING === '1') {
             try {
-                process.stderr.write(`[loop-timing] iter=${nextIteration} presend=${sendStartedAt - _iterT0}ms send=${_sendEndedAt - sendStartedAt}ms tools=${Date.now() - _toolsT0}ms calls=${_callsToExecute.length}\n`);
+                process.stderr.write(`[loop-timing] iter=${nextIteration} presend=${preSendMs}ms send=${_sendEndedAt - sendStartedAt}ms tools=${_toolsEndedAt - _toolsT0}ms calls=${_callsToExecute.length}\n`);
             } catch { /* diagnostics only */ }
         }
+        _lastToolBatchEndedAt = _toolsEndedAt;
         _toolBatchJustCompleted = true;
         _continuationsSinceToolBatch = 0;
         _lastToolBatchHadSleep = _callsToExecute.some(isSleepLikeToolCall);

package/src/runtime/agent/orchestrator/session/compact.mjs

@@ -53,4 +53,4 @@ export {
 export {
     semanticCompactMessages,
     recallFastTrackCompactMessages,
-} from './compact/engine.mjs';
+} from './compact/runner.mjs';

package/src/runtime/agent/orchestrator/session/eager-dispatch.mjs

@@ -1,13 +1,19 @@
 // Eager tool-dispatch controller, extracted from agent-loop.mjs. Owns the
 // per-turn pending promise map, the intra-turn in-flight signature set, and
-// the mutation epoch. Read-only calls may start while the provider is still
-// streaming. Side-effect calls stream-start too until the first apply_patch
-// appears in the stream (they are definitively in segment 0); after that they
-// wait for their segment bounded by apply_patch barriers. Patches execute
-// serially as barriers, so a failed patch can skip every later side effect.
+// the mutation epoch. Every valid call dispatches while the provider is still
+// streaming. Calls execute in parallel except that shell after apply_patch
+// waits for every earlier patch in the turn; results are collected later in
+// call order.
 import { normalizeToolEnvelope } from './tool-envelope.mjs';
 import { isInvalidToolArgsMarker } from '../providers/openai-compat-stream.mjs';
-import { _intraTurnSig, _isMutationTool, _isOrderedGateSkippable, _isReadTool, _isScopedCacheableTool, _stripMcpPrefix } from './loop/tool-classify.mjs';
+import {
+    _intraTurnSig,
+    _isMutationTool,
+    _isReadTool,
+    _isScopedCacheableTool,
+    _isShellTool,
+    _stripMcpPrefix,
+} from './loop/tool-classify.mjs';
 import { tryReadCached, tryScopedToolCached } from './read-dedup.mjs';
 import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
 import { executeTool } from './loop/tool-exec.mjs';
@@ -20,6 +26,10 @@ export function createEagerDispatcher({
     executeToolFn = executeTool,
 }) {
         const pending = new Map();
+        // Cumulative settlement barrier for patches already emitted in this
+        // assistant turn. Patches remain path-parallel with each other; only a
+        // later shell waits, so validation cannot observe pre-patch files.
+        let patchBarrier = Promise.resolve();
         // Streaming-time intra-turn dedup. When the LLM emits two
         // tool_use blocks with identical (name, args) signatures in
         // sequence, the provider's onToolCall fires for both BEFORE
@@ -40,11 +50,6 @@ export function createEagerDispatcher({
         // resets at the turn boundary without leaking across getIterations().
         const _eagerInFlightSigs = new Map();
         const epoch = { mutation: 0 };
-        // True once an apply_patch tool_use has been seen in THIS turn's
-        // stream. Before that, every side-effect call streamed so far sits
-        // before the first patch in call order (segment 0), so it may start
-        // immediately — a patch that arrives later cannot gate an EARLIER call.
-        let _streamSeenMutation = false;
         const startEagerTool = (call) => {
             if (!call?.id || pending.has(call.id) || !isParallelDispatchable(call.name)) return null;
             // Never eager-execute a call whose arguments failed to parse
@@ -97,9 +102,11 @@ export function createEagerDispatcher({
             // this call there, never start it eagerly here.
             if (preDispatchDenyForSession(sessionRef, call, toolKind) !== null) return null;
             const entry = { startedAt: Date.now(), endedAt: null, mutationEpoch: epoch.mutation };
+            const precedingPatches = _isShellTool(call.name) ? patchBarrier : null;
             if (_dedupEligible) _eagerInFlightSigs.set(_sig, call.id);
             entry.promise = (async () => {
                 try {
+                    if (precedingPatches) await precedingPatches;
                     await opts.beforeToolExecution?.();
                     return { ok: true, value: await executeToolFn(call.name, call.arguments, cwd, sessionId, sessionRef, { toolCallId: call.id, signal, notifyFn: opts.notifyFn, toolApprovalHook: opts.onToolApproval, iteration: getNextIteration(), deferShellCwdCommit: true }) };
                 } catch (error) {
@@ -159,24 +166,17 @@ export function createEagerDispatcher({
                     return settled;
                 });
             pending.set(call.id, entry);
+            if (_isMutationTool(call.name)) {
+                const currentPatch = entry.promise;
+                patchBarrier = Promise.allSettled([patchBarrier, currentPatch]).then(() => undefined);
+            }
             return entry;
         };
         const startEagerRun = (calls, startIndex, dupSet) => {
-            const _nextOrderedMutationIndex = calls.findIndex(
-                (call, index) => index >= startIndex && _isMutationTool(call?.name),
-            );
             for (let j = startIndex; j < calls.length; j += 1) {
                 const call = calls[j];
-                // Side effects may eager-start in the current segment but not
-                // across the next apply_patch barrier. Known read-only work
-                // may cross it and is protected by mutation-epoch re-execution.
                 if (!call?.id || !isParallelDispatchable(call.name)) continue;
                 if (dupSet && dupSet.has(call.id)) continue;
-                if (
-                    _nextOrderedMutationIndex >= 0
-                    && j >= _nextOrderedMutationIndex
-                    && _isOrderedGateSkippable(call.name)
-                ) continue;
                 // A null return here is NOT a state barrier. It means a
                 // non-barrier stub — intra-turn in-flight dup, repeat-failure /
                 // cross-turn dedup, pre-dispatch-deny, invalid-args, or a cache
@@ -187,17 +187,6 @@ export function createEagerDispatcher({
             }
         };
         const onToolCall = (call) => {
-            if (_isMutationTool(call?.name)) {
-                _streamSeenMutation = true;
-                return;
-            }
-            // Declared read-only calls always overlap streaming (epoch guard
-            // re-executes them if a later patch lands). Side-effect calls may
-            // stream-start only while NO apply_patch has streamed yet: their
-            // call-order position is already fixed before the first barrier,
-            // matching exactly what startEagerRun would do post-batch. Once a
-            // patch has streamed, later side effects wait for their segment.
-            if (!isEagerDispatchable(call?.name, tools) && _streamSeenMutation) return;
             startEagerTool(call);
         };
     return { pending, epoch, startEagerTool, startEagerRun, onToolCall };

package/src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs

@@ -71,6 +71,19 @@ export function isLoopbackHttpUrl(value) {
  */
 export function routeWebFetchCall(call) {
     if (call?.name !== 'web_fetch') return call;
+    // A JSON-stringified array ('["https://a","https://b"]') is a common
+    // provider serialisation artifact. Parse it back into real URLs so the
+    // fetch surface routes and validates them instead of rejecting the call.
+    const rawUrl = call?.arguments?.url;
+    if (typeof rawUrl === 'string' && /^\s*\[/.test(rawUrl)) {
+        try {
+            const parsed = JSON.parse(rawUrl);
+            if (Array.isArray(parsed) && parsed.length > 0
+                && parsed.every((item) => typeof item === 'string' && item.trim())) {
+                call.arguments.url = parsed.map((item) => item.trim());
+            }
+        } catch { /* leave the original value for the downstream validator */ }
+    }
     const urls = callUrls(call);
     if (!urls.length) return call;
     if (urls.every(isLoopbackHttpUrl)) call.name = 'local_fetch';

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

@@ -28,8 +28,8 @@ export function isOutputLimitStopReason(reason) {
 // NOT a completed assistant turn even when it holds final-looking text: the
 // provider explicitly stated it intends to keep sampling inside the SAME user
 // turn. Two structured shapes are honored:
-//   - `endTurn === false` (Codex/Responses `end_turn=false`; see
-//     codex-rs/core/src/session/turn.rs Completed{ end_turn } → needs_follow_up)
+//   - `endTurn === false` (Responses `end_turn=false` on the completed frame,
+//     which means the turn needs a follow-up)
 //   - Anthropic `stop_reason: 'pause_turn'` (server-side pause; the turn is
 //     resumed by replaying the transcript unchanged)
 // Structural only — no lexical/progress-text heuristic is consulted, and a

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

@@ -15,30 +15,6 @@ export function _isMutationTool(name) {
     const n = _stripMcpPrefix(name);
     return n === 'apply_patch';
 }
-// Side-effect-free read-only tools that may eager-start across an upcoming
-// apply_patch barrier and may keep running after an earlier patch fails.
-// Everything NOT in this set waits for its side-effect segment and is skipped
-// after a failed patch. Kept separate from _isMutationTool, which stays
-// apply_patch-only for epoch counting.
-const ORDERED_GATE_SAFE_READONLY_TOOLS = new Set([
-    'read',
-    'find',
-    'glob',
-    'list',
-    'grep',
-    'code_graph',
-    'explore',
-    'search',
-    'web_fetch',
-]);
-// True when a LATER call in a batch must be skipped because an earlier ordered
-// mutation (apply_patch) already failed. Conservative: only the known
-// side-effect-free read-only tools above keep running; shell, write tools, and
-// unknown MCP tools are skipped so they cannot act on unchanged/partially
-// changed state.
-export function _isOrderedGateSkippable(name) {
-    return !ORDERED_GATE_SAFE_READONLY_TOOLS.has(_stripMcpPrefix(name));
-}
 const SCOPED_CACHEABLE_TOOLS = new Set([
     'code_graph',
     'grep',