mixdog 0.9.95 → 0.9.97

package/src/runtime/agent/orchestrator/mcp/reconnect-singleflight.mjs

@@ -0,0 +1,23 @@
+export function createKeyedSingleflight() {
+    const pending = new Map();
+    return {
+        run(key, task) {
+            const lane = String(key || '');
+            const existing = pending.get(lane);
+            if (existing) return existing;
+            let tracked;
+            const promise = Promise.resolve().then(task);
+            tracked = promise.finally(() => {
+                if (pending.get(lane) === tracked) pending.delete(lane);
+            });
+            pending.set(lane, tracked);
+            return tracked;
+        },
+        has(key) {
+            return pending.has(String(key || ''));
+        },
+        get size() {
+            return pending.size;
+        },
+    };
+}

package/src/runtime/agent/orchestrator/providers/admission-scheduler.mjs

@@ -1,10 +1,9 @@
 import { createHash } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
-// Unbounded by design: provider requests must never serialize behind a local
-// concurrency cap. Rate-limit cooldowns below (server-mandated retry-after)
-// remain the only thing that parks/rejects requests; with an infinite limit
-// the adaptive halving/recovery below is inert.
+// Normal provider traffic is not concurrency-gated. Independent sessions and
+// accounts start immediately; a finite limit exists only when an operator
+// explicitly configures one, or after that account reports a real 429.
 export const PROVIDER_ACCOUNT_CONCURRENCY = Infinity;
 export const PROVIDER_ACCOUNT_MAX_QUEUE = 1024;
 // A cooldown longer than this is a quota-window block (subscription limit),
@@ -13,6 +12,21 @@ export const PROVIDER_ACCOUNT_MAX_QUEUE = 1024;
 export const PROVIDER_COOLDOWN_FAIL_FAST_MS = 60_000;
 const MAX_TIMEOUT_MS = 2_147_483_647;
 const currentAdmission = new AsyncLocalStorage();
+const PRIORITY_RANK = Object.freeze({
+    'user-blocking': 0,
+    'user-visible': 1,
+    'best-effort': 2,
+});
+
+function normalizePriority(value) {
+    const key = String(value || 'user-visible').toLowerCase();
+    return Object.hasOwn(PRIORITY_RANK, key) ? key : 'user-visible';
+}
+
+export function currentProviderAdmissionOwner() {
+    const active = currentAdmission.getStore();
+    return active?.ownerKey ? String(active.ownerKey) : null;
+}
 
 function abortError(signal, fallback = 'provider request canceled') {
     return signal?.reason instanceof Error
@@ -110,10 +124,10 @@ export class ProviderAdmissionScheduler {
         setTimer = setTimeout,
         clearTimer = clearTimeout,
     } = {}) {
-        this.concurrency = Math.min(
-            PROVIDER_ACCOUNT_CONCURRENCY,
-            Math.max(1, Math.floor(Number(concurrency) || PROVIDER_ACCOUNT_CONCURRENCY)),
-        );
+        const parsedConcurrency = Math.floor(Number(concurrency));
+        this.concurrency = Number.isFinite(parsedConcurrency) && parsedConcurrency >= 1
+            ? parsedConcurrency
+            : Infinity;
         this.maxQueue = configuredQueueBound(maxQueue);
         this.now = now;
         this.setTimer = setTimer;
@@ -160,7 +174,9 @@ export class ProviderAdmissionScheduler {
             limit: this.concurrency,
             cooldownUntil: 0,
             recoverySuccesses: 0,
+            recoveryTarget: null,
             cooldownTimer: null,
+            fairCursor: null,
         };
         if (!lane.adaptive || until <= lane.cooldownUntil) return false;
         this.lanes.set(laneKey, lane);
@@ -175,8 +191,15 @@ export class ProviderAdmissionScheduler {
         return true;
     }
 
-    run(key, task, { signal = null, onCooldownWait = null } = {}) {
+    run(key, task, {
+        signal = null,
+        onCooldownWait = null,
+        ownerKey = null,
+        priority = 'user-visible',
+    } = {}) {
         const laneKey = String(key || 'provider:default');
+        const owner = String(ownerKey || 'anonymous').trim().slice(0, 240) || 'anonymous';
+        const taskPriority = normalizePriority(priority);
         // Provider-local recovery may recursively call this.send(). It already
         // owns a slot, so reacquiring the same lane could deadlock a full wave.
         const current = this.context.getStore();
@@ -193,7 +216,9 @@ export class ProviderAdmissionScheduler {
             limit: this.concurrency,
             cooldownUntil: 0,
             recoverySuccesses: 0,
+            recoveryTarget: null,
             cooldownTimer: null,
+            fairCursor: null,
         };
         this.lanes.set(laneKey, lane);
         // Long cooldown = quota window. Fail fast with a visible error; short
@@ -206,7 +231,17 @@ export class ProviderAdmissionScheduler {
             return Promise.reject(new ProviderAdmissionQueueOverflowError(laneKey, this.maxQueue));
         }
         return new Promise((resolve, reject) => {
-            const item = { task, signal, resolve, reject, canceled: false, onAbort: null };
+            const item = {
+                task,
+                signal,
+                resolve,
+                reject,
+                canceled: false,
+                onAbort: null,
+                ownerKey: owner,
+                priority: taskPriority,
+                queuedAt: this.now(),
+            };
             if (signal) {
                 item.onAbort = () => {
                     if (item.started || item.canceled) return;
@@ -236,6 +271,28 @@ export class ProviderAdmissionScheduler {
         });
     }
 
+    _nextQueueIndex(lane) {
+        if (!lane.queue.length) return -1;
+        const bestRank = Math.min(...lane.queue.map((item) =>
+            PRIORITY_RANK[normalizePriority(item.priority)]));
+        const eligible = lane.queue
+            .map((item, index) => ({ item, index }))
+            .filter(({ item }) => PRIORITY_RANK[normalizePriority(item.priority)] === bestRank);
+        const owners = [];
+        for (const { item } of eligible) {
+            const owner = item.ownerKey || 'anonymous';
+            if (!owners.includes(owner)) owners.push(owner);
+        }
+        let selected = owners[0] || 'anonymous';
+        if (owners.length > 1) {
+            const prior = owners.indexOf(lane.fairCursor);
+            selected = owners[(prior + 1 + owners.length) % owners.length];
+        }
+        lane.fairCursor = selected;
+        return eligible.find(({ item }) => (item.ownerKey || 'anonymous') === selected)?.index
+            ?? eligible[0].index;
+    }
+
     _drain(key, lane) {
         if (lane.adaptive && lane.cooldownUntil > this.now()) {
             if (lane.cooldownUntil - this.now() > PROVIDER_COOLDOWN_FAIL_FAST_MS) {
@@ -245,7 +302,9 @@ export class ProviderAdmissionScheduler {
             return;
         }
         while (lane.active < lane.limit && lane.queue.length) {
-            const item = lane.queue.shift();
+            const index = this._nextQueueIndex(lane);
+            if (index < 0) break;
+            const [item] = lane.queue.splice(index, 1);
             if (item.canceled) {
                 this._detach(item);
                 continue;
@@ -268,7 +327,14 @@ export class ProviderAdmissionScheduler {
                 item.signal.addEventListener('abort', running.parentAbort, { once: true });
             }
             this.running.add(running);
-            const admission = { scheduler: this, key, lane, rateLimited: false };
+            const admission = {
+                scheduler: this,
+                key,
+                lane,
+                ownerKey: item.ownerKey,
+                priority: item.priority,
+                rateLimited: false,
+            };
             this.context.run(admission, () => Promise.resolve().then(() => item.task(controller.signal)))
                 .then((value) => {
                     // A retry that eventually succeeds is not evidence that
@@ -292,6 +358,25 @@ export class ProviderAdmissionScheduler {
         if (this._canDeleteLane(lane)) this._deleteLane(key, lane);
     }
 
+    snapshot() {
+        const now = this.now();
+        return {
+            concurrency: Number.isFinite(this.concurrency) ? this.concurrency : null,
+            lanes: [...this.lanes.entries()].map(([key, lane]) => ({
+                key,
+                active: lane.active,
+                queued: lane.queue.length,
+                owners: new Set(lane.queue.map((item) => item.ownerKey || 'anonymous')).size,
+                limit: Number.isFinite(lane.limit) ? lane.limit : null,
+                cooldownMs: Math.max(0, lane.cooldownUntil - now),
+                oldestWaitMs: lane.queue.reduce(
+                    (oldest, item) => Math.max(oldest, Math.max(0, now - (item.queuedAt || now))),
+                    0,
+                ),
+            })),
+        };
+    }
+
     _recordFailure(key, lane, error) {
         if (!lane.adaptive) return false;
         const status = Number(error?.httpStatus || error?.status || error?.response?.status || 0);
@@ -300,7 +385,14 @@ export class ProviderAdmissionScheduler {
             if (this.reportedRateLimits.has(error)) return false;
             this.reportedRateLimits.add(error);
         }
-        lane.limit = Math.max(1, Math.floor(lane.limit / 2));
+        const observed = Number.isFinite(lane.limit)
+            ? lane.limit
+            : Math.max(1, lane.active);
+        lane.recoveryTarget = Math.max(
+            Number(lane.recoveryTarget) || 0,
+            observed,
+        );
+        lane.limit = Math.max(1, Math.floor(observed / 2));
         lane.recoverySuccesses = 0;
         const now = this.now();
         lane.cooldownUntil = Math.max(
@@ -348,6 +440,7 @@ export class ProviderAdmissionScheduler {
             lane.cooldownUntil = 0;
             lane.limit = this.concurrency;
             lane.recoverySuccesses = 0;
+            lane.recoveryTarget = null;
             if (lane.cooldownTimer) {
                 this.clearTimer(lane.cooldownTimer);
                 lane.cooldownTimer = null;
@@ -364,11 +457,15 @@ export class ProviderAdmissionScheduler {
     }
 
     _recordSuccess(lane) {
-        if (!lane.adaptive || lane.limit >= this.concurrency) return;
+        if (!lane.adaptive || !Number.isFinite(lane.limit)) return;
         lane.recoverySuccesses += 1;
         if (lane.recoverySuccesses >= lane.limit) {
             lane.limit += 1;
             lane.recoverySuccesses = 0;
+            if (lane.recoveryTarget && lane.limit >= lane.recoveryTarget) {
+                lane.limit = this.concurrency;
+                lane.recoveryTarget = null;
+            }
         }
     }
 
@@ -505,6 +602,8 @@ export function wrapProviderAdmission(provider, providerName, scheduler = provid
             });
         }, {
             signal,
+            ownerKey: opts.admissionOwner || opts.sessionId || null,
+            priority: opts.admissionPriority || 'user-visible',
             onCooldownWait: (waitMs) => {
                 // Display-only: the TUI/desktop 'reconnecting' stage already
                 // renders a custom verb, so no new stage vocabulary is needed.

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

@@ -23,6 +23,7 @@ import {
     NATIVE_SERVER_TOOL_CALL_BLOCK_TYPES,
     NATIVE_SERVER_TOOL_RESULT_BLOCK_TYPES,
 } from './lib/anthropic-native-blocks.mjs';
+import { parseProviderJsonBatch } from './stream-json-pool.mjs';
 import { stampStreamOutcome, STREAM_TRANSPORTS, STREAM_OUTCOME_VERSION } from './lib/stream-outcome.mjs';
 
 /** Bounded mid-stream SSE retries (transient stream loss); shared with anthropic.mjs.
@@ -486,7 +487,10 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
                 if (!data) continue;
 
                 try {
-                    const event = JSON.parse(data);
+                    // A completed reader.read() owns this frame even if abort
+                    // races immediately afterward; the next read observes the
+                    // cancellation after this frame is relayed.
+                    const [event] = await parseProviderJsonBatch([data]);
 
                     // SEMANTIC idle reset (Part A): reset the idle timer ONLY for
                     // real progress events, NOT for Anthropic keepalives. Anthropic

package/src/runtime/agent/orchestrator/providers/gemini-stream.mjs

@@ -23,6 +23,7 @@ import {
     collectGeminiGroundingSources,
     parseGeminiTextPartMetadata,
 } from './gemini-schema.mjs';
+import { parseProviderJsonBatch } from './stream-json-pool.mjs';
 
 export const GEMINI_FIRST_BYTE_TIMEOUT_MS = resolveTimeoutMs(
     'MIXDOG_GEMINI_FIRST_BYTE_TIMEOUT_MS',
@@ -131,6 +132,19 @@ function geminiChunkHasFunctionCall(chunk) {
     return parts.some((p) => p && p.functionCall);
 }
 
+export function geminiChunkProgressKind(chunk) {
+    const parts = chunk?.candidates?.[0]?.content?.parts;
+    if (!Array.isArray(parts)) return 'transport';
+    if (parts.some((part) => part?.functionCall)) return 'tool';
+    if (parts.some((part) => part?.thought === true && typeof part.text === 'string' && part.text)) {
+        return 'reasoning';
+    }
+    if (parts.some((part) => part?.thought !== true && typeof part?.text === 'string' && part.text)) {
+        return 'text';
+    }
+    return 'transport';
+}
+
 /**
  * Aggregate streamed GenerateContentResponse chunks into one response object
  * (same shape as a non-streaming generateContent JSON body).
@@ -256,7 +270,7 @@ export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolC
         };
         leakedCalls.push(call);
         try { onToolCall?.(call); } catch {}
-        try { onStreamDelta?.(); } catch {}
+        try { onStreamDelta?.('tool'); } catch {}
     };
 
     const pumpLeakBuffer = (final) => {
@@ -407,6 +421,7 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
             if (done) break;
             resetIdleTimer();
             buffer += decoder.decode(value, { stream: true });
+            const payloads = [];
             let lineEnd;
             while ((lineEnd = buffer.indexOf('\n')) >= 0) {
                 let line = buffer.slice(0, lineEnd);
@@ -415,18 +430,24 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
                 if (!line.startsWith('data: ')) continue;
                 const data = line.slice(6).trim();
                 if (!data || data === '[DONE]') continue;
-                let parsed;
-                try {
-                    parsed = JSON.parse(data);
-                } catch (cause) {
-                    throw geminiStreamCorruptionError(`${label} corrupt SSE JSON`, cause);
-                }
+                payloads.push(data);
+            }
+            let parsedChunks;
+            try {
+                // Preserve the established delivery boundary: once read()
+                // returned the bytes, parse and relay them before the next
+                // iteration observes cancellation.
+                parsedChunks = await parseProviderJsonBatch(payloads);
+            } catch (cause) {
+                throw geminiStreamCorruptionError(`${label} corrupt SSE JSON`, cause);
+            }
+            for (const parsed of parsedChunks) {
                 if (!sawStreamChunk) {
                     sawStreamChunk = true;
                     clearFirstByteTimer();
                 }
                 allChunks.push(parsed);
-                try { onStreamDelta?.(); } catch {}
+                try { onStreamDelta?.(geminiChunkProgressKind(parsed)); } catch {}
                 if (!sawFunctionCall && geminiChunkHasFunctionCall(parsed)) sawFunctionCall = true;
                 if (onTextDelta || textLeakGuard) {
                     const t = geminiChunkText(parsed);
@@ -440,13 +461,13 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
                 const data = line.slice(6).trim();
                 if (data && data !== '[DONE]') {
                     try {
-                        const parsed = JSON.parse(data);
+                        const [parsed] = await parseProviderJsonBatch([data]);
                         if (!sawStreamChunk) {
                             sawStreamChunk = true;
                             clearFirstByteTimer();
                         }
                         allChunks.push(parsed);
-                        try { onStreamDelta?.(); } catch {}
+                        try { onStreamDelta?.(geminiChunkProgressKind(parsed)); } catch {}
                         if (!sawFunctionCall && geminiChunkHasFunctionCall(parsed)) sawFunctionCall = true;
                         if (onTextDelta || textLeakGuard) {
                             const t = geminiChunkText(parsed);
@@ -677,7 +698,7 @@ export async function consumeGeminiSdkStream(streamResult, {
             }
             resetIdleTimer();
             if (step.value) collectedChunks.push(step.value);
-            try { onStreamDelta?.(); } catch {}
+            try { onStreamDelta?.(geminiChunkProgressKind(step.value)); } catch {}
             if (!sawFunctionCall && geminiChunkHasFunctionCall(step.value)) sawFunctionCall = true;
             if (onTextDelta || textLeakGuard) {
                 const t = geminiChunkText(step.value);

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

@@ -1,6 +1,6 @@
 import { GoogleGenerativeAI } from '@google/generative-ai';
 import { getAgentApiKey } from '../../../shared/provider-api-key.mjs';
-import { withRetry } from './retry-classifier.mjs';
+import { canFallbackNonStreaming, withRetry } from './retry-classifier.mjs';
 import { traceAgentUsage, appendAgentTrace } from '../agent-trace.mjs';
 import {
     PROVIDER_FIRST_BYTE_TIMEOUT_MS,
@@ -158,6 +158,53 @@ export class GeminiProvider {
         return this.config?.apiKey || process.env.GEMINI_API_KEY || '';
     }
 
+    /**
+     * cc parity (claude.ts:2504): re-issue a dead stream ONCE as a
+     * non-streaming generateContent call instead of failing the turn.
+     * Narrower than cc by design — canFallbackNonStreaming() clears only a
+     * stream that exposed nothing, so rendered text is never duplicated and a
+     * dispatched tool can never run twice. Returns the aggregated response, or
+     * null when the failure is ineligible or the fallback itself fails.
+     */
+    async _recoverGeminiNonStreaming({ streamErr, signal, opts, model, generate }) {
+        if (!canFallbackNonStreaming(streamErr, { signal })) return null;
+        let aggregated;
+        try {
+            try { opts?.onStageChange?.('requesting'); } catch { /* heartbeat best-effort */ }
+            aggregated = await generate(signal || undefined);
+        } catch {
+            return null;
+        }
+        if (!aggregated || !Array.isArray(aggregated.candidates) || aggregated.candidates.length === 0) {
+            return null;
+        }
+        try {
+            process.stderr.write(
+                `[gemini] stream failed (${streamErr?.code || streamErr?.message || 'unknown'}); `
+                + `recovered via non-streaming generateContent\n`,
+            );
+        } catch { /* best-effort */ }
+        try {
+            appendAgentTrace({
+                sessionId: opts?.sessionId || opts?.session?.id || null,
+                iteration: Number.isFinite(Number(opts?.iteration)) ? Number(opts.iteration) : null,
+                kind: 'transport_fallback',
+                provider: 'gemini',
+                model,
+                transport: 'non-streaming',
+                payload: {
+                    from: 'stream',
+                    to: 'non-streaming',
+                    reason: streamErr?.retryClassifier || streamErr?.code || streamErr?.message || 'stream_failed',
+                    error_code: streamErr?.code || null,
+                    error_http_status: Number(streamErr?.httpStatus || streamErr?.status || 0) || null,
+                    error_classifier: streamErr?.retryClassifier || streamErr?.midstreamClassifier || null,
+                },
+            });
+        } catch { /* best-effort */ }
+        return aggregated;
+    }
+
     // Explicit cachedContents API. The implicit cache layer on Gemini 3.x
     // does not surface cachedContentTokenCount in usageMetadata, so the only
     // way to obtain measurable + billable cache savings is to register the
@@ -655,7 +702,30 @@ export class GeminiProvider {
                     }
                     return await this._doSend(messages, model, tools, opts, { skipExplicitCache: true });
                 }
-                throw err;
+                const recovered = await this._recoverGeminiNonStreaming({
+                    streamErr: err,
+                    signal: totalSignal,
+                    opts,
+                    model: useModel,
+                    generate: async (fallbackSignal) => {
+                        const nonStreamUrl = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(useModel)}:generateContent?key=${encodeURIComponent(apiKey)}`;
+                        const res = await this._fetch(nonStreamUrl, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify(body),
+                            signal: fallbackSignal,
+                            dispatcher: getLlmDispatcher(),
+                        });
+                        if (!res.ok) {
+                            const text = await res.text().catch(() => '');
+                            throw geminiRestError(res, text, 'Gemini REST generateContent');
+                        }
+                        return await res.json();
+                    },
+                });
+                if (!recovered) throw err;
+                textLeakGuard = null;
+                response = recovered;
             } finally {
                 restPassthrough.cleanup();
             }
@@ -749,6 +819,23 @@ export class GeminiProvider {
                         },
                     },
                 );
+            } catch (err) {
+                const recovered = await this._recoverGeminiNonStreaming({
+                    streamErr: err,
+                    signal: totalSignal,
+                    opts,
+                    model: useModel,
+                    generate: async (fallbackSignal) => {
+                        const result = await genModel.generateContent(
+                            { contents },
+                            { signal: fallbackSignal },
+                        );
+                        return result?.response ?? null;
+                    },
+                });
+                if (!recovered) throw err;
+                textLeakGuard = null;
+                response = recovered;
             } finally {
                 sdkPassthrough.cleanup();
             }

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

@@ -23,7 +23,7 @@ import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs
 import { enrichModels, getModelMetadataSync } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { makeModelCache } from './model-cache.mjs';
-import { OpenAICompatProvider } from './openai-compat.mjs';
+import { OpenAICompatProvider, preloadOpenAICompatRuntime } from './openai-compat.mjs';
 import { createTimeoutSignal } from '../stall-policy.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { normalizeGrokToolSchemas } from './lib/grok-tool-schema.mjs';
@@ -205,6 +205,17 @@ export class GrokOAuthProvider {
     constructor(config) {
         this.config = config || {};
         this.tokens = loadTokens();
+        // The credential/header-bound inner provider is created lazily, but its
+        // heavy SDK + undici graph and proxy socket are not request-specific.
+        // Pay both during the daemon's process-wide provider warmup so first
+        // Grok send only builds the cheap inner client.
+        try { preloadOpenAICompatRuntime(); } catch { /* authoritative send surfaces load failures */ }
+        if (this.config?.preconnect !== false) {
+            const warm = typeof this.config?.preconnectFn === 'function'
+                ? this.config.preconnectFn
+                : preconnect;
+            try { warm(PROXY_BASE_URL); } catch { /* best-effort */ }
+        }
     }
 
     async ensureAuth({ forceRefresh = false } = {}) {

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

@@ -59,6 +59,22 @@ export function xaiResponsesCacheRouting(opts, params, rawTools, model) {
     const scope = String(opts?.xaiResponsesCacheScope || process.env.MIXDOG_XAI_RESPONSES_CACHE_SCOPE || 'prefix')
         .trim()
         .toLowerCase();
+    // 'none' omits prompt_cache_key entirely, matching xAI's own reference
+    // sampler (grok-build sends prompt_cache_key: None) and zed's xAI provider
+    // (supports_prompt_cache_key() == false): the service falls back to
+    // automatic prompt-prefix caching with no client-supplied lane. Callers
+    // must treat a null key as "do not send the field".
+    if (scope === 'none' || scope === 'off' || scope === 'omit') {
+        const sessionId = String(opts?.sessionId || opts?.session?.id || '').trim();
+        const prefixHash = traceHash(xaiPrefixSeed({ opts, params, rawTools, model }));
+        return {
+            key: null,
+            mode: 'none',
+            seedHash: null,
+            prefixHash,
+            ownerSessionHash: sessionId ? traceHash(sessionId) : null,
+        };
+    }
     if (scope !== 'prefix') {
         return xaiCacheRouting(opts, params, rawTools, model);
     }
@@ -183,7 +199,9 @@ export function useXaiResponsesWebSocketWarmup(opts, config, { previousResponseI
         if (['0', 'false', 'off', 'none', 'disabled'].includes(mode)) return false;
         if (['1', 'true', 'on', 'always', 'force'].includes(mode)) return true;
     }
-    return String(instructions || '').length >= 2048 || (Array.isArray(rawTools) && rawTools.length >= 10);
+    // A generate:false response can still carry provider usage/quota. Keep it
+    // strictly opt-in; transport-only HTTP/WS preconnect remains cost-free.
+    return false;
 }
 
 // Codex-aligned default: no compat cache lane/serialization. Keep the override