mixdog 0.9.147 → 0.9.148

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

@@ -152,11 +152,16 @@ function mergeToolCallDelta(accByIndex, deltaCalls, bucketState) {
         } else if (tc.function?.name) {
             const anonId = ++bucketState._nextAnonId;
             key = `anon:${anonId}`;
-            bucketState._lastAnonKey = key;
         } else {
             key = bucketState._lastAnonKey;
             if (!key) continue;
         }
+        // Whatever bucket this chunk resolved to becomes the continuation
+        // target for later argument-only chunks (no index, no id, no name).
+        // Only the anonymous branch used to record it, so a provider that
+        // identifies a tool call by id alone and then streams bare argument
+        // deltas had every one of those deltas silently discarded.
+        bucketState._lastAnonKey = key;
         let prev = accByIndex.get(key);
         if (!prev) {
             prev = {
@@ -210,7 +215,7 @@ function emitCompatToolCallOnce(state, call, onToolCall) {
     // Fix 2: cross-path name+args dedupe. A synthesized text-leaked call and an
     // identical native tool_call must fire onToolCall exactly once. state._toolDedupe
     // is created per stream; when absent (older callers) behavior is unchanged.
-    if (state._toolDedupe && !state._toolDedupe.shouldDispatch(call.name, call.arguments)) {
+    if (state._toolDedupe && !state._toolDedupe.shouldDispatch(call.name, call.arguments, call.id)) {
         // Still mark the id as emitted so later id-frames for the same native
         // call don't retry, but do NOT invoke onToolCall (already dispatched).
         state.emittedToolCallKeys.add(key);
@@ -556,6 +561,33 @@ export async function consumeCompatChatCompletionStream(stream, {
     };
 }
 
+// Reconcile a COMPLETED function_call item into state.toolCalls: fill in the
+// id/name a streamed call may still be missing, or adopt the item as a new
+// call. `response.output_item.done` and the `response.completed` sweep see the
+// same item shape and must land on the same single emit, so both route here.
+// Returns the item id the done-branch still needs for its pendingCalls /
+// tool-tracker bookkeeping.
+function reconcileCompatFunctionCallItem(state, item, label, onToolCall) {
+    const itemId = item.id || '';
+    const tc = state.toolCalls.find(t => t._pendingItemId === itemId)
+        || (item.call_id ? state.toolCalls.find(t => t.id === item.call_id) : null);
+    if (tc) {
+        if (!tc.id && item.call_id) tc.id = item.call_id;
+        if (!tc.name && item.name) tc.name = item.name;
+        if (tc.id && tc.name) delete tc._pendingItemId;
+        emitCompatToolCallOnce(state, tc, onToolCall);
+    } else if (item.call_id && item.name) {
+        const call = {
+            id: item.call_id,
+            name: item.name,
+            arguments: parseCompletedToolCallArgumentsJson(item.arguments, label, { id: item.call_id, name: item.name, finishReason: 'done' }),
+        };
+        state.toolCalls.push(call);
+        emitCompatToolCallOnce(state, call, onToolCall);
+    }
+    return itemId;
+}
+
 function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesToolCalls, responseOutputText, onStreamDelta, onToolCall, onTextDelta, relayLeakText }) {
     if (!event || typeof event.type !== 'string') return;
     const pushToolSearchCall = (item) => {
@@ -671,23 +703,7 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
         case 'response.output_item.done': {
             const item = event.item || {};
             if (item.type === 'function_call') {
-                const itemId = item.id || '';
-                const tc = state.toolCalls.find(t => t._pendingItemId === itemId)
-                    || (item.call_id ? state.toolCalls.find(t => t.id === item.call_id) : null);
-                if (tc) {
-                    if (!tc.id && item.call_id) tc.id = item.call_id;
-                    if (!tc.name && item.name) tc.name = item.name;
-                    if (tc.id && tc.name) delete tc._pendingItemId;
-                    emitCompatToolCallOnce(state, tc, onToolCall);
-                } else if (item.call_id && item.name) {
-                    const call = {
-                        id: item.call_id,
-                        name: item.name,
-                        arguments: parseCompletedToolCallArgumentsJson(item.arguments, label, { id: item.call_id, name: item.name, finishReason: 'done' }),
-                    };
-                    state.toolCalls.push(call);
-                    emitCompatToolCallOnce(state, call, onToolCall);
-                }
+                const itemId = reconcileCompatFunctionCallItem(state, item, label, onToolCall);
                 // Drop the resolved function item from pendingCalls before
                 // recomputing toolInFlight — otherwise a completed call keeps
                 // pendingCalls.size > 0 and the latch never clears, so a later
@@ -732,23 +748,7 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
             }
             for (const item of resp.output || []) {
                 if (item?.type === 'function_call') {
-                    const itemId = item.id || '';
-                    const tc = state.toolCalls.find(t => t._pendingItemId === itemId)
-                        || (item.call_id ? state.toolCalls.find(t => t.id === item.call_id) : null);
-                    if (tc) {
-                        if (!tc.id && item.call_id) tc.id = item.call_id;
-                        if (!tc.name && item.name) tc.name = item.name;
-                        if (tc.id && tc.name) delete tc._pendingItemId;
-                        emitCompatToolCallOnce(state, tc, onToolCall);
-                    } else if (item.call_id && item.name) {
-                        const call = {
-                            id: item.call_id,
-                            name: item.name,
-                            arguments: parseCompletedToolCallArgumentsJson(item.arguments, label, { id: item.call_id, name: item.name, finishReason: 'done' }),
-                        };
-                        state.toolCalls.push(call);
-                        emitCompatToolCallOnce(state, call, onToolCall);
-                    }
+                    reconcileCompatFunctionCallItem(state, item, label, onToolCall);
                     try { onStreamDelta?.('tool'); } catch {}
                     reportedBundleProgress = true;
                 } else if (item?.type === 'tool_search_call') {

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

@@ -44,13 +44,15 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
     // strict providers (xai) reject unknown roles/types and would 400 the
     // request. Documented in v0.1.160 (GPT reasoning replay).
     //
-    // DeepSeek thinking models require the prior turn's `reasoning_content`
-    // string to be echoed back inside the assistant message, otherwise the API
-    // returns 400. xAI reasoning models also preserve their official multi-turn
-    // shape and cache prefix stability when prior assistant reasoning_content
-    // is replayed; reasoning_effort itself remains caller/user-selected.
+    // DeepSeek splits by model: thinking-mode models with tools REQUIRE the
+    // prior turn's `reasoning_content` echoed back (400 without it), while
+    // `deepseek-reasoner` REJECTS it with a 400. The caller decides per model
+    // through options.replaysReasoningContent — see
+    // deepseekReplaysReasoningContent below. xAI reasoning models preserve
+    // their official multi-turn shape and cache prefix stability when prior
+    // assistant reasoning_content is replayed; reasoning_effort itself remains
+    // caller/user-selected.
     const replaysReasoningContent = options.replaysReasoningContent === true
-        || providerName === 'deepseek'
         || providerName === 'xai';
     const out = [];
     const pendingToolMedia = [];
@@ -94,6 +96,14 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
     return out;
 }
 
+// deepseek-reasoner returns 400 when `reasoning_content` appears in the input
+// messages; every other DeepSeek thinking model needs it back once tools are in
+// play. Unknown DeepSeek ids default to replaying: a missing echo breaks the
+// tool loop, while a stray field on a non-thinking model is ignored.
+export function deepseekReplaysReasoningContent(model) {
+    return !/reasoner/.test(String(model || '').trim().toLowerCase());
+}
+
 export function toOpenAITools(tools) {
     return tools.map((t) => ({
         type: 'function',

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

@@ -2,10 +2,12 @@
  * openai-compat-xai.mjs — xAI/Grok Responses-API routing, prompt-cache lanes
  * and cache tracing for the OpenAI-compat provider.
  *
- * Extracted from openai-compat.mjs. Owns the xAI cache-lane singletons
- * (xaiResponsesCacheLanes) plus cache routing/fingerprint/trace helpers and
- * the compat cache trace writer shared by chat-completions and Responses
- * paths. openai-compat.mjs imports the routing/lane/trace entry points.
+ * Extracted from openai-compat.mjs. Owns the xAI prompt-cache lane RESOLUTION
+ * (shard/slot selection) plus cache routing/fingerprint/trace helpers and the
+ * compat cache trace writer shared by chat-completions and Responses paths.
+ * openai-compat.mjs imports the routing/lane/trace entry points. Admission is
+ * owned exclusively by the shared provider scheduler — there is no second
+ * cache-lane queue here.
  */
 import { createHash } from 'crypto';
 import { appendAgentTrace } from '../agent-trace.mjs';
@@ -14,6 +16,10 @@ import {
     resolveProviderPromptCacheLane,
 } from '../agent-runtime/cache-strategy.mjs';
 import { shouldFallbackTransport } from './retry-classifier.mjs';
+import { envFlag as _envFlag } from './lib/env-utils.mjs';
+// Same named export as before the shared helper move: importers of this module
+// keep reading `_envFlag` from here.
+export { _envFlag };
 import { traceHash, stableTraceStringify, summarizeTraceTools, traceTextShape } from './trace-utils.mjs';
 import { summarizeTraceMessages, extractCompatCachedTokens } from './openai-compat-trace.mjs';
 
@@ -92,7 +98,7 @@ export function xaiResponsesCacheRouting(opts, params, rawTools, model) {
     // session per process, where round-robin degenerates to slot 0 for
     // everyone). Default stays a single shared key (lane disabled) —
     // identical seed/key to before.
-    const lane = xaiResponsesPromptCacheLane(opts, null, { prefixHash, ownerSessionHash: sessionId ? traceHash(sessionId) : null });
+    const lane = xaiResponsesPromptCacheLane(opts, { prefixHash, ownerSessionHash: sessionId ? traceHash(sessionId) : null });
     const laneEnabled = lane?.enabled === true;
     const laneShards = Number.isFinite(Number(lane?.shards)) && Number(lane.shards) > 0 ? Number(lane.shards) : 0;
     const explicitSlot = Number(opts?.promptCacheLaneSlot ?? opts?.xaiCacheLaneSlot);
@@ -128,6 +134,19 @@ export function normalizeXaiReasoningEffort(value) {
     return ['low', 'medium', 'high', 'xhigh'].includes(effort) ? effort : null;
 }
 
+// grok-3, grok-4 and grok-4-fast REJECT reasoning_effort outright (HTTP 400
+// "does not support parameter reasoningEffort"), so the parameter ships only
+// for the families that document it. An unknown/absent model id keeps the
+// parameter — a custom xAI-compatible deployment that never saw the 400 must
+// not silently lose the caller's effort choice.
+export function xaiModelSupportsReasoningEffort(model) {
+    const id = String(model || '').trim().toLowerCase();
+    if (!id) return true;
+    if (!id.startsWith('grok')) return true;
+    // grok-4.5 / grok-4.6 and anything newer in that line.
+    return /grok[-_]?4\.(?:[5-9]|\d{2,})/.test(id);
+}
+
 function opencodeGoReasoningEffortValues(modelInfo) {
     const effort = (modelInfo?.reasoningOptions || []).find((option) => option?.type === 'effort');
     return Array.isArray(effort?.values)
@@ -170,12 +189,6 @@ export function useXaiResponsesWebSocket(opts, config) {
     return !['0', 'false', 'off', 'http', 'https', 'responses-http', 'sdk'].includes(transport);
 }
 
-export function _envFlag(name, fallback = true) {
-    const raw = process.env[name];
-    if (raw == null || raw === '') return fallback;
-    return !['0', 'false', 'off', 'no'].includes(String(raw).toLowerCase());
-}
-
 // xAI WS→HTTP transport fallback → shared shouldFallbackTransport
 // (retry-classifier.mjs). Identical deny-order + allow-list; the per-provider
 // env flag is computed here and passed via `enabled`.
@@ -186,7 +199,7 @@ export function _shouldFallbackXaiWsToHttp(err, signal) {
     });
 }
 
-export function useXaiResponsesWebSocketWarmup(opts, config, { previousResponseId, instructions, rawTools }) {
+export function useXaiResponsesWebSocketWarmup(opts, config, { previousResponseId }) {
     if (previousResponseId) return false;
     const raw = opts?.xaiResponsesWarmup
         ?? opts?.xaiWsWarmup
@@ -204,97 +217,36 @@ export function useXaiResponsesWebSocketWarmup(opts, config, { previousResponseI
     return false;
 }
 
-// Codex-aligned default: no compat cache lane/serialization. Keep the override
-// knobs so live probes can opt back into a bounded lane if a provider needs it.
-const XAI_RESPONSES_CACHE_LANE_DEFAULT_MAX_IN_FLIGHT = 0;
-const xaiResponsesCacheLanes = new Map();
-
-function parseXaiPositiveInt(value, fallback) {
-    if (value == null || value === '') return fallback;
-    const text = String(value).trim().toLowerCase();
-    if (['0', 'false', 'off', 'none', 'disabled', 'unlimited', 'unbounded', 'auto'].includes(text)) return 0;
-    const n = Number(text);
-    if (!Number.isFinite(n)) return fallback;
-    return Math.max(0, Math.floor(n));
-}
-
-function xaiResponsesCacheLaneMaxInFlight(opts, config) {
-    return parseXaiPositiveInt(
-        opts?.xaiCacheMaxInFlight
-            ?? opts?.xaiResponsesCacheMaxInFlight
-            ?? opts?.grokCacheMaxInFlight
-            ?? opts?.grokResponsesCacheMaxInFlight
-            ?? config?.xaiCacheMaxInFlight
-            ?? config?.xaiResponsesCacheMaxInFlight
-            ?? config?.grokCacheMaxInFlight
-            ?? config?.grokResponsesCacheMaxInFlight
-            ?? process.env.MIXDOG_XAI_CACHE_MAX_INFLIGHT
-            ?? process.env.MIXDOG_XAI_RESPONSES_CACHE_MAX_INFLIGHT
-            ?? process.env.MIXDOG_GROK_CACHE_MAX_INFLIGHT
-            ?? process.env.MIXDOG_GROK_RESPONSES_CACHE_MAX_INFLIGHT
-            ?? process.env.MIXDOG_GROK_OAUTH_CACHE_MAX_INFLIGHT
-            ?? process.env.MIXDOG_GROK_OAUTH_RESPONSES_CACHE_MAX_INFLIGHT,
-        XAI_RESPONSES_CACHE_LANE_DEFAULT_MAX_IN_FLIGHT,
-    );
-}
-
-function xaiResponsesCacheLaneQueueTimeoutMs(opts, config) {
-    return parseXaiPositiveInt(
-        opts?.xaiCacheQueueTimeoutMs
-            ?? opts?.xaiResponsesCacheQueueTimeoutMs
-            ?? opts?.grokCacheQueueTimeoutMs
-            ?? opts?.grokResponsesCacheQueueTimeoutMs
-            ?? config?.xaiCacheQueueTimeoutMs
-            ?? config?.xaiResponsesCacheQueueTimeoutMs
-            ?? config?.grokCacheQueueTimeoutMs
-            ?? config?.grokResponsesCacheQueueTimeoutMs
-            ?? process.env.MIXDOG_XAI_CACHE_QUEUE_TIMEOUT_MS
-            ?? process.env.MIXDOG_XAI_RESPONSES_CACHE_QUEUE_TIMEOUT_MS
-            ?? process.env.MIXDOG_GROK_CACHE_QUEUE_TIMEOUT_MS
-            ?? process.env.MIXDOG_GROK_RESPONSES_CACHE_QUEUE_TIMEOUT_MS
-            ?? process.env.MIXDOG_GROK_OAUTH_CACHE_QUEUE_TIMEOUT_MS
-            ?? process.env.MIXDOG_GROK_OAUTH_RESPONSES_CACHE_QUEUE_TIMEOUT_MS,
-        0,
-    );
-}
-
-function xaiResponsesPromptCacheLane(opts, config, cacheRouting) {
+// No `config` argument: the single caller (xaiResponsesCacheRouting) never had
+// one to pass, so the provider-config lane aliases this used to read were dead
+// operands. Lane selection on this route is opts + env only.
+function xaiResponsesPromptCacheLane(opts, cacheRouting) {
+    // Lane SHARDS only, for xAI/Grok. The `*CacheMaxParallel` /
+    // *_CACHE_MAX_PARALLEL knobs that used to bound the lane's in-flight
+    // admission were removed with the lane queue itself (admission is the
+    // shared provider scheduler's job now). They are deliberately NOT accepted
+    // here as shard aliases — on this route they never selected shards, and a
+    // setting named "max parallel" silently deciding prompt-cache key fan-out
+    // is a different control with different consequences. An xAI operator who
+    // set one gets the documented default until they opt into
+    // `*CacheLaneShards` / MIXDOG_XAI_CACHE_LANE_SHARDS explicitly.
+    // promptCacheLaneIgnoreAliases scopes that refusal to this route only:
+    // OpenAI direct/OAuth keep honouring the aliases (cache-strategy.mjs).
     const shardOverride =
         opts?.xaiCacheLaneShards
             ?? opts?.xaiResponsesCacheLaneShards
-            ?? opts?.xaiCacheMaxParallel
-            ?? opts?.xaiResponsesCacheMaxParallel
             ?? opts?.grokCacheLaneShards
             ?? opts?.grokResponsesCacheLaneShards
-            ?? opts?.grokCacheMaxParallel
-            ?? opts?.grokResponsesCacheMaxParallel
-            ?? config?.xaiCacheLaneShards
-            ?? config?.xaiResponsesCacheLaneShards
-            ?? config?.xaiCacheMaxParallel
-            ?? config?.xaiResponsesCacheMaxParallel
-            ?? config?.grokCacheLaneShards
-            ?? config?.grokResponsesCacheLaneShards
-            ?? config?.grokCacheMaxParallel
-            ?? config?.grokResponsesCacheMaxParallel
-            ?? process.env.MIXDOG_XAI_RESPONSES_CACHE_MAX_PARALLEL
             ?? process.env.MIXDOG_XAI_RESPONSES_CACHE_LANE_SHARDS
-            ?? process.env.MIXDOG_GROK_CACHE_MAX_PARALLEL
             ?? process.env.MIXDOG_GROK_CACHE_LANE_SHARDS
-            ?? process.env.MIXDOG_GROK_RESPONSES_CACHE_MAX_PARALLEL
             ?? process.env.MIXDOG_GROK_RESPONSES_CACHE_LANE_SHARDS
-            ?? process.env.MIXDOG_GROK_OAUTH_CACHE_MAX_PARALLEL
             ?? process.env.MIXDOG_GROK_OAUTH_CACHE_LANE_SHARDS
-            ?? process.env.MIXDOG_GROK_OAUTH_RESPONSES_CACHE_MAX_PARALLEL
             ?? process.env.MIXDOG_GROK_OAUTH_RESPONSES_CACHE_LANE_SHARDS;
     const autoOverride =
         opts?.xaiCacheLaneAuto
             ?? opts?.xaiResponsesCacheLaneAuto
             ?? opts?.grokCacheLaneAuto
             ?? opts?.grokResponsesCacheLaneAuto
-            ?? config?.xaiCacheLaneAuto
-            ?? config?.xaiResponsesCacheLaneAuto
-            ?? config?.grokCacheLaneAuto
-            ?? config?.grokResponsesCacheLaneAuto
             ?? process.env.MIXDOG_XAI_RESPONSES_CACHE_LANE_AUTO
             ?? process.env.MIXDOG_GROK_CACHE_LANE_AUTO
             ?? process.env.MIXDOG_GROK_RESPONSES_CACHE_LANE_AUTO
@@ -319,137 +271,22 @@ function xaiResponsesPromptCacheLane(opts, config, cacheRouting) {
     );
     return resolveProviderPromptCacheLane('xai', {
         ...opts,
+        promptCacheLaneIgnoreAliases: true,
         ...(shardOverride !== undefined ? { promptCacheLaneShards: shardOverride } : {}),
         ...(autoOverride !== undefined ? { promptCacheLaneAuto: autoOverride } : {}),
         ...(slotOverride !== undefined ? { promptCacheLaneSlot: slotOverride } : {}),
         promptCacheLaneSeed: seed || 'xai-cache-lane',
-    }, config);
-}
-
-function xaiResponsesCacheLaneKey({ model, cacheRouting, opts, config }) {
-    const prefix = cacheRouting?.prefixHash || cacheRouting?.seedHash || cacheRouting?.key || 'unknown-prefix';
-    const lane = xaiResponsesPromptCacheLane(opts, config, cacheRouting);
-    const shard = Number.isFinite(Number(lane?.slot)) ? Number(lane.slot) : 0;
-    return {
-        key: `xai-responses:${model || 'default'}:${prefix}:shard-${shard}`,
-        shard,
-        lane,
-    };
-}
-
-function getXaiResponsesCacheLaneState(key, maxInFlight) {
-    let state = xaiResponsesCacheLanes.get(key);
-    if (!state) {
-        state = { key, active: 0, queue: [], maxInFlight, nextId: 0 };
-        xaiResponsesCacheLanes.set(key, state);
-    }
-    state.maxInFlight = maxInFlight;
-    return state;
-}
-
-function cleanupXaiResponsesCacheLane(state) {
-    if (state.active === 0 && state.queue.length === 0) {
-        xaiResponsesCacheLanes.delete(state.key);
-    }
-}
-
-function removeQueuedXaiCacheLaneRequest(state, request) {
-    const index = state.queue.indexOf(request);
-    if (index >= 0) state.queue.splice(index, 1);
-    cleanupXaiResponsesCacheLane(state);
+    }, null);
 }
 
-function makeXaiCacheLaneHandle(state, requestId, enqueuedAt) {
-    let released = false;
-    return {
-        requestId,
-        waitedMs: Date.now() - enqueuedAt,
-        activeCount: state.active,
-        queueDepth: state.queue.length,
-        release() {
-            if (released) return;
-            released = true;
-            releaseXaiResponsesCacheLane(state);
-        },
-    };
-}
-
-function releaseXaiResponsesCacheLane(state) {
-    state.active = Math.max(0, state.active - 1);
-    while (state.queue.length > 0 && state.active < state.maxInFlight) {
-        const next = state.queue.shift();
-        next.cleanup?.();
-        state.active += 1;
-        next.resolve(makeXaiCacheLaneHandle(state, next.requestId, next.enqueuedAt));
-    }
-    cleanupXaiResponsesCacheLane(state);
-}
-
-function acquireXaiResponsesCacheLane({ key, maxInFlight, signal, timeoutMs }) {
-    const state = getXaiResponsesCacheLaneState(key, maxInFlight);
-    const requestId = ++state.nextId;
-    const enqueuedAt = Date.now();
-    if (state.active < state.maxInFlight) {
-        state.active += 1;
-        return Promise.resolve(makeXaiCacheLaneHandle(state, requestId, enqueuedAt));
-    }
-    return new Promise((resolve, reject) => {
-        const request = {
-            requestId,
-            enqueuedAt,
-            resolve,
-            reject,
-            cleanup: null,
-        };
-        const cleanup = () => {
-            if (request.timer) clearTimeout(request.timer);
-            if (signal && request.abortListener) signal.removeEventListener('abort', request.abortListener);
-        };
-        request.cleanup = cleanup;
-        request.abortListener = () => {
-            cleanup();
-            removeQueuedXaiCacheLaneRequest(state, request);
-            const reason = signal?.reason;
-            reject(reason instanceof Error ? reason : new Error('xAI cache lane wait aborted'));
-        };
-        if (signal?.aborted) {
-            request.abortListener();
-            return;
-        }
-        if (signal) signal.addEventListener('abort', request.abortListener, { once: true });
-        if (timeoutMs > 0) {
-            request.timer = setTimeout(() => {
-                cleanup();
-                removeQueuedXaiCacheLaneRequest(state, request);
-                reject(new Error(`xAI cache lane wait timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
-            request.timer.unref?.();
-        }
-        state.queue.push(request);
-    });
-}
-
-function traceXaiCacheLane(opts, payload) {
-    if (!compatCacheTraceEnabled('xai')) return;
-    try {
-        appendAgentTrace({
-            sessionId: opts?.sessionId || opts?.session?.id || null,
-            iteration: Number.isFinite(Number(opts?.iteration)) ? Number(opts.iteration) : null,
-            kind: 'cache_lane',
-            ...payload,
-            payload,
-        });
-    } catch {}
-}
-
-export async function withXaiResponsesCacheLane({ opts, config, cacheRouting, model, transport, previousResponseId, inputCount, signal }, fn) {
-    // Historical prompt-cache lanes formed a second admission queue and could
-    // time out while waiting. xAI is now governed exclusively by the common
-    // fixed-64 provider/account scheduler, regardless of legacy env/option
-    // knobs. Keep this wrapper only as a call-shape compatibility boundary.
-    const laneMeta = { enabled: false, maxInFlight: 0 };
-    return { value: await fn(laneMeta), laneMeta };
-}
+// Historical prompt-cache lanes formed a second admission queue and could time
+// out while waiting. xAI is now governed exclusively by the common fixed-64
+// provider/account scheduler, so no lane is ever taken: the queue/handle
+// machinery and its max-in-flight / queue-timeout knobs were dead code and have
+// been removed rather than left as settings that silently do nothing. The
+// cache-trace payload still reports the lane shape, so this frozen "no lane"
+// record is what the xAI Responses trace writers receive.
+export const XAI_CACHE_LANE_META = Object.freeze({ enabled: false, maxInFlight: 0 });
 
 function deterministicUuidFromKey(key) {
     const hex = createHash('sha256').update(String(key ?? '')).digest('hex');