mixdog 0.9.147 → 0.9.148

package/src/runtime/agent/orchestrator/mcp/client.mjs

@@ -377,12 +377,28 @@ export async function executeMcpTool(name, args, options = {}) {
     if (!server)
         throw new Error(`MCP server "${serverName}" not connected`);
     const gate = callAdmissionFor(server);
+    const callSignal = options?.signal || null;
     return gate.run(options?.ownerKey || currentToolExecutionOwner(), async () => {
+        // The gate stops forwarding the caller's abort once this task is
+        // admitted, so the task itself observes the signal for its whole run.
+        if (callSignal?.aborted) {
+            throw mcpAbortError(
+                callSignal,
+                `MCP tool call aborted before dispatch (server="${serverName}", tool="${toolName}")`,
+            );
+        }
         let result;
         try {
-            result = await _callToolWithTimeout(server, toolName, args);
+            result = await _callToolWithTimeout(server, toolName, args, callSignal);
         } catch (firstErr) {
             const firstMsg = firstErr instanceof Error ? firstErr.message : String(firstErr);
+            if (isMcpCallAbortError(firstErr) || callSignal?.aborted) {
+                // A cancelled call is not a transport failure: reconnecting and
+                // replaying it would duplicate the side effect the caller just
+                // walked away from.
+                mcpLog(`[mcp-client] Tool call aborted by caller for "${serverName}/${toolName}".\n`);
+                throw firstErr;
+            }
             if (isMcpToolCallTimeoutError(firstErr)) {
                 mcpLog(`[mcp-client] Tool call timed out; skipping reconnect retry for "${serverName}/${toolName}".\n`);
                 throw firstErr;
@@ -390,14 +406,33 @@ export async function executeMcpTool(name, args, options = {}) {
             mcpLog(`[mcp-client] Tool call failed, attempting shared reconnect...\n`);
             let retryServer;
             try {
-                retryServer = await reconnectMcpServer(scopeId, serverName, server);
+                // The reconnect is SHARED (singleflight): the race only stops
+                // THIS caller from waiting on it — the reconnect keeps running
+                // for its other waiters. Without this, an abort mid-reconnect
+                // could not settle the call and the admission slot stayed held
+                // until the reconnect finished, or forever if it hung.
+                retryServer = await raceMcpAbort(
+                    reconnectMcpServer(scopeId, serverName, server),
+                    callSignal,
+                    `MCP tool call aborted during reconnect (server="${serverName}", tool="${toolName}")`,
+                );
             } catch (reconnectErr) {
+                if (isMcpCallAbortError(reconnectErr) || callSignal?.aborted) throw reconnectErr;
                 const reconnectMsg = reconnectErr instanceof Error ? reconnectErr.message : String(reconnectErr);
                 throw new Error(`Tool call failed: ${firstMsg}; reconnect also failed: ${reconnectMsg}`);
             }
+            // A reconnect that outlived the caller's abort must not dispatch the
+            // retry: that would run the side effect after cancellation.
+            if (callSignal?.aborted) {
+                throw mcpAbortError(
+                    callSignal,
+                    `MCP tool call aborted after reconnect (server="${serverName}", tool="${toolName}")`,
+                );
+            }
             try {
-                result = await _callToolWithTimeout(retryServer, toolName, args);
+                result = await _callToolWithTimeout(retryServer, toolName, args, callSignal);
             } catch (retryErr) {
+                if (isMcpCallAbortError(retryErr) || callSignal?.aborted) throw retryErr;
                 const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
                 throw new Error(`Tool call failed: ${firstMsg}; retry after reconnect also failed: ${retryMsg}`);
             }
@@ -408,7 +443,7 @@ export async function executeMcpTool(name, args, options = {}) {
             ? makeToolEnvelope(text, [], { explicitSuccess: true })
             : text;
     }, {
-        signal: options?.signal || null,
+        signal: callSignal,
     });
 }
 
@@ -471,11 +506,58 @@ export function resolveMcpStartupTimeoutMs(cfg = {}, env = process.env) {
     return Math.round(parsed);
 }
 
-async function _callToolWithTimeout(server, toolName, args) {
+// Caller-driven cancellation (hook timeout, aborted turn, closed pane).
+// Admission alone is not cancellation: an admitted call that ignores the
+// caller's signal keeps its concurrency slot until the SERVER timeout, which an
+// operator may have disabled entirely.
+function mcpAbortError(signal, message) {
+    const reason = signal?.reason;
+    if (reason instanceof Error) return reason;
+    const error = new Error(reason ? String(reason) : message);
+    error.code = 'EMCPCALLABORTED';
+    return error;
+}
+
+function isMcpCallAbortError(err) {
+    return err?.code === 'EMCPCALLABORTED' || err?.name === 'AbortError';
+}
+
+/** Settle as soon as `signal` aborts. Promise.race keeps a later rejection of
+ *  `promise` handled, so the abandoned call cannot surface as an unhandled
+ *  rejection. */
+function raceMcpAbort(promise, signal, message) {
+    if (!signal) return promise;
+    if (signal.aborted) {
+        void Promise.resolve(promise).catch(() => {});
+        return Promise.reject(mcpAbortError(signal, message));
+    }
+    let onAbort = null;
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(mcpAbortError(signal, message));
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+    return Promise.race([promise, aborted]).finally(() => {
+        if (onAbort) {
+            try { signal.removeEventListener('abort', onAbort); } catch { /* already detached */ }
+        }
+    });
+}
+
+async function _callToolWithTimeout(server, toolName, args, signal = null) {
     let timer;
     const timeoutMs = resolveMcpCallTimeoutMs(server?.cfg);
+    // The signal goes INTO the SDK request: an aborted caller cancels the live
+    // JSON-RPC request (notifications/cancelled) instead of merely walking away
+    // from it. The race below additionally frees the admission slot at once.
+    const requestOptions = signal ? { signal } : undefined;
+    const abortMessage = `MCP tool call aborted (server="${server?.name}", tool="${toolName}")`;
     if (!(timeoutMs > 0)) {
-        return server.client.callTool({ name: toolName, arguments: args });
+        // Server timeout disabled: the caller's signal is then the ONLY bound.
+        return raceMcpAbort(
+            server.client.callTool({ name: toolName, arguments: args }, undefined, requestOptions),
+            signal,
+            abortMessage,
+        );
     }
     const timeout = new Promise((_, rej) => {
         timer = setTimeout(() => {
@@ -492,10 +574,10 @@ async function _callToolWithTimeout(server, toolName, args) {
         if (timer.unref) timer.unref();
     });
     try {
-        return await Promise.race([
-            server.client.callTool({ name: toolName, arguments: args }),
+        return await raceMcpAbort(Promise.race([
+            server.client.callTool({ name: toolName, arguments: args }, undefined, requestOptions),
             timeout,
-        ]);
+        ]), signal, abortMessage);
     } finally {
         if (timer) clearTimeout(timer);
     }
@@ -878,7 +960,9 @@ export function _registerMcpServerForTest(scopeId, name, rawTools = [], options
             callTool: typeof options.callTool === 'function'
                 ? options.callTool
                 : async () => ({ content: [{ type: 'text', text: 'ok' }] }),
-            close: async () => {},
+            // Injectable so a test can stall teardown (and therefore the shared
+            // reconnect) without a transport or a child process.
+            close: typeof options.close === 'function' ? options.close : async () => {},
         },
         generation: currentConnectAbortGeneration(normalizedScopeId),
     };

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

@@ -4,6 +4,7 @@ const EXTENDED_CACHE_TTL_BETA_HEADER = 'extended-cache-ttl-2025-04-11';
 const INTERLEAVED_THINKING_BETA_HEADER = 'interleaved-thinking-2025-05-14';
 const FAST_MODE_BETA_HEADER = 'fast-mode-2026-02-01';
 const TOOL_SEARCH_BETA_HEADER = 'advanced-tool-use-2025-11-20';
+export const SERVER_SIDE_FALLBACK_BETA_HEADER = 'server-side-fallback-2026-07-01';
 export { EFFORT_BETA_HEADER };
 
 export function supportsAnthropicFastMode(model) {
@@ -16,6 +17,7 @@ export function buildAnthropicBetaHeaders({
     fastMode = false,
     toolSearch = false,
     effort = false,
+    serverFallback = false,
 } = {}) {
     const headers = String(base || '')
         .split(',')
@@ -30,5 +32,8 @@ export function buildAnthropicBetaHeaders({
     if (effort && !headers.includes(EFFORT_BETA_HEADER)) {
         headers.push(EFFORT_BETA_HEADER);
     }
+    if (serverFallback && !headers.includes(SERVER_SIDE_FALLBACK_BETA_HEADER)) {
+        headers.push(SERVER_SIDE_FALLBACK_BETA_HEADER);
+    }
     return headers.join(',');
 }

package/src/runtime/agent/orchestrator/providers/anthropic-fast-mode.mjs

@@ -0,0 +1,98 @@
+// Fast-mode capacity policy for the Anthropic providers.
+//
+// `speed: 'fast'` rides a separate capacity pool. When that pool is exhausted
+// the request comes back 429 (rate limit) or 529 (overloaded) — waiting out a
+// long Retry-After on the fast pool wastes the turn AND thrashes the prompt
+// cache, because the retry after the wait carries a different speed anyway.
+// The reference client's rule: a SHORT server window is worth waiting for at
+// fast speed (the cache prefix survives), anything longer drops to standard
+// speed for a cooldown. An explicit "overage billing unavailable" header is
+// terminal for the process — no cooldown can make paid overage appear.
+//
+// State is process-wide because the capacity pool is per-account, not per
+// session: one session discovering the pool is empty must not leave sibling
+// sessions hammering it.
+
+// Server-declared reason header for a fast-mode rejection caused by missing
+// overage billing (matches the reference client's header name).
+const OVERAGE_DISABLED_HEADER = 'anthropic-ratelimit-unified-overage-disabled-reason';
+
+// A Retry-After under this bound is short enough that waiting keeps fast mode
+// (and its cache prefix) worthwhile.
+const SHORT_RETRY_THRESHOLD_MS = 10_000;
+// Cooldown floor: without it a 1s window would flip fast mode on and off every
+// turn, which costs more in cache misses than the downgrade saves.
+const MIN_COOLDOWN_MS = 60_000;
+// Applied when the server gives no window at all.
+const DEFAULT_COOLDOWN_MS = 300_000;
+
+let _cooldownUntilMs = 0;
+let _disabledReason = null;
+
+function _headerValue(headers, name) {
+    if (!headers) return null;
+    const lower = name.toLowerCase();
+    if (typeof headers.get === 'function') return headers.get(name) ?? headers.get(lower);
+    for (const [key, value] of Object.entries(headers)) {
+        if (String(key).toLowerCase() === lower) return Array.isArray(value) ? value[0] : value;
+    }
+    return null;
+}
+
+/** True when a request may still ask for `speed: 'fast'`. */
+export function fastModeAvailable(now = Date.now()) {
+    return _disabledReason === null && now >= _cooldownUntilMs;
+}
+
+export function fastModeCooldownRemainingMs(now = Date.now()) {
+    if (_disabledReason !== null) return Number.POSITIVE_INFINITY;
+    return Math.max(0, _cooldownUntilMs - now);
+}
+
+export function fastModeDisabledReason() {
+    return _disabledReason;
+}
+
+/**
+ * Record a capacity failure observed on a fast-mode request.
+ *
+ * Returns the decision for the caller:
+ *   'ignored'   — not a fast request or not a capacity status; nothing changed.
+ *   'retry-fast'— short server window; keep fast mode and let the normal retry
+ *                 path wait it out.
+ *   'downgrade' — cooldown started; the next attempt must drop `speed`.
+ *   'disabled'  — overage unavailable; fast mode is off for this process.
+ */
+export function noteFastModeCapacityError(err, { fast = false, now = Date.now() } = {}) {
+    if (!fast) return 'ignored';
+    const status = Number(err?.httpStatus || err?.status || err?.response?.status || 0);
+    if (status !== 429 && status !== 529) return 'ignored';
+
+    const headers = err?.headers || err?.response?.headers || err?.data?.responseHeaders || null;
+    const overageReason = _headerValue(headers, OVERAGE_DISABLED_HEADER);
+    if (overageReason != null && String(overageReason) !== '') {
+        _disabledReason = String(overageReason);
+        return 'disabled';
+    }
+
+    const retryAfterMs = Number(err?.retryAfterMs);
+    const hasWindow = Number.isFinite(retryAfterMs) && retryAfterMs >= 0;
+    if (hasWindow && retryAfterMs < SHORT_RETRY_THRESHOLD_MS) return 'retry-fast';
+
+    const cooldownMs = Math.max(hasWindow ? retryAfterMs : DEFAULT_COOLDOWN_MS, MIN_COOLDOWN_MS);
+    _cooldownUntilMs = Math.max(_cooldownUntilMs, now + cooldownMs);
+    return 'downgrade';
+}
+
+/** Manual re-enable (user action) and test seam. */
+export function clearFastModeCooldown() {
+    _cooldownUntilMs = 0;
+    _disabledReason = null;
+}
+
+export const _FAST_MODE_POLICY = Object.freeze({
+    OVERAGE_DISABLED_HEADER,
+    SHORT_RETRY_THRESHOLD_MS,
+    MIN_COOLDOWN_MS,
+    DEFAULT_COOLDOWN_MS,
+});

package/src/runtime/agent/orchestrator/providers/anthropic-fast-mode.test.mjs

@@ -0,0 +1,90 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+    _FAST_MODE_POLICY,
+    clearFastModeCooldown,
+    fastModeAvailable,
+    fastModeCooldownRemainingMs,
+    fastModeDisabledReason,
+    noteFastModeCapacityError,
+} from './anthropic-fast-mode.mjs';
+
+test.beforeEach(() => clearFastModeCooldown());
+test.after(() => clearFastModeCooldown());
+
+test('non-capacity failures and standard-speed requests leave fast mode alone', () => {
+    assert.equal(noteFastModeCapacityError({ httpStatus: 429 }, { fast: false }), 'ignored');
+    assert.equal(noteFastModeCapacityError({ httpStatus: 500 }, { fast: true }), 'ignored');
+    assert.equal(noteFastModeCapacityError({ httpStatus: 401 }, { fast: true }), 'ignored');
+    assert.equal(fastModeAvailable(), true);
+});
+
+test('a short server window keeps fast mode so the cache prefix survives', () => {
+    const decision = noteFastModeCapacityError(
+        { httpStatus: 429, retryAfterMs: _FAST_MODE_POLICY.SHORT_RETRY_THRESHOLD_MS - 1 },
+        { fast: true },
+    );
+    assert.equal(decision, 'retry-fast');
+    assert.equal(fastModeAvailable(), true);
+});
+
+test('a long window downgrades to standard speed for at least the cooldown floor', () => {
+    const now = 1_000_000;
+    const retryAfterMs = 20_000;
+    assert.equal(
+        noteFastModeCapacityError({ httpStatus: 429, retryAfterMs }, { fast: true, now }),
+        'downgrade',
+    );
+    assert.equal(fastModeAvailable(now), false);
+    // 20s window is below the floor, so the floor wins.
+    assert.equal(fastModeCooldownRemainingMs(now), _FAST_MODE_POLICY.MIN_COOLDOWN_MS);
+    assert.equal(fastModeAvailable(now + _FAST_MODE_POLICY.MIN_COOLDOWN_MS), true);
+});
+
+test('a long window longer than the floor is honored verbatim', () => {
+    const now = 2_000_000;
+    const retryAfterMs = _FAST_MODE_POLICY.MIN_COOLDOWN_MS * 3;
+    noteFastModeCapacityError({ httpStatus: 529, retryAfterMs }, { fast: true, now });
+    assert.equal(fastModeCooldownRemainingMs(now), retryAfterMs);
+});
+
+test('a 529 with no window uses the default cooldown', () => {
+    const now = 3_000_000;
+    assert.equal(noteFastModeCapacityError({ httpStatus: 529 }, { fast: true, now }), 'downgrade');
+    assert.equal(fastModeCooldownRemainingMs(now), _FAST_MODE_POLICY.DEFAULT_COOLDOWN_MS);
+});
+
+test('cooldowns never shrink an existing longer cooldown', () => {
+    const now = 4_000_000;
+    noteFastModeCapacityError({ httpStatus: 429, retryAfterMs: 600_000 }, { fast: true, now });
+    noteFastModeCapacityError({ httpStatus: 429, retryAfterMs: 60_000 }, { fast: true, now });
+    assert.equal(fastModeCooldownRemainingMs(now), 600_000);
+});
+
+test('an overage-disabled header turns fast mode off for the process', () => {
+    const decision = noteFastModeCapacityError(
+        {
+            httpStatus: 429,
+            headers: new Map([[_FAST_MODE_POLICY.OVERAGE_DISABLED_HEADER, 'no_overage']]),
+            retryAfterMs: 1,
+        },
+        { fast: true },
+    );
+    assert.equal(decision, 'disabled');
+    assert.equal(fastModeDisabledReason(), 'no_overage');
+    assert.equal(fastModeAvailable(Date.now() + 86_400_000), false);
+    clearFastModeCooldown();
+    assert.equal(fastModeAvailable(), true);
+});
+
+test('plain-object headers resolve case-insensitively', () => {
+    noteFastModeCapacityError(
+        {
+            httpStatus: 429,
+            response: { headers: { 'ANTHROPIC-RateLimit-Unified-Overage-Disabled-Reason': 'billing' } },
+        },
+        { fast: true },
+    );
+    assert.equal(fastModeDisabledReason(), 'billing');
+});

package/src/runtime/agent/orchestrator/providers/anthropic-leaked-toolcall.mjs

@@ -394,14 +394,43 @@ export function toolCallFingerprint(name, args) {
     if (a === null || typeof a !== 'object' || Array.isArray(a)) a = {};
     return traceHash(stableTraceStringify({ name: name || '', args: a }));
 }
+// Ids minted locally when a call is recovered from text (`call_leaked_…`,
+// `toolu_leaked_…`, `gemini_leaked_…`). Such an id is not a server identity, so
+// a synthetic call can only be identified by its name+args fingerprint —
+// whereas a provider-assigned id IS the identity of a real call.
+export function isLeakedSyntheticToolCallId(id) {
+    return typeof id === 'string' && id.includes('_leaked_');
+}
 export function createToolCallDedupe() {
     const seen = new Set();
+    const leaked = new Set();
+    const dispatchedIds = new Set();
     return {
-        // True the first time this (name,args) fingerprint is seen; false on
-        // any later identical call (synthetic-then-native or vice-versa).
-        shouldDispatch(name, args) {
+        // True the first time this call should be dispatched.
+        //
+        // Identity depends on what the provider gave us:
+        //   - no id / a locally minted `_leaked_` id → the (name,args)
+        //     fingerprint, because that is all a text-recovered call has, and
+        //   - a provider-assigned id → the id itself. Parallel tool calls are
+        //     emitted with identical name+args and DIFFERENT ids; each one owns
+        //     a tool_result the next request must carry, so collapsing them by
+        //     fingerprint drops results and breaks the response chain.
+        // The cross-path guard survives: a native call whose fingerprint a
+        // synthetic leak already dispatched is still suppressed (once).
+        shouldDispatch(name, args, id = '') {
             const fp = toolCallFingerprint(name, args);
-            if (seen.has(fp)) return false;
+            const callId = typeof id === 'string' ? id : '';
+            if (!callId || isLeakedSyntheticToolCallId(callId)) {
+                if (seen.has(fp)) return false;
+                seen.add(fp);
+                leaked.add(fp);
+                return true;
+            }
+            if (dispatchedIds.has(callId)) return false;
+            dispatchedIds.add(callId);
+            // Claim (consume) one pending leak of the same shape: this native
+            // frame is that leak surfacing on the native path.
+            if (leaked.delete(fp)) return false;
             seen.add(fp);
             return true;
         },
@@ -410,26 +439,48 @@ export function createToolCallDedupe() {
 }
 
 /**
- * Drop duplicate tool calls from a RETURNED `toolCalls` array by name+args
- * fingerprint (Fix 2, array side). Dispatch-time dedupe (`createToolCallDedupe`)
- * only suppresses the second `onToolCall`; providers that also RETURN a
- * `toolCalls` array (which the agent loop executes) can still carry a
- * synthetic-leaked + identical-native duplicate. Run the final array through
- * this so the loop never executes a side-effecting tool twice. Order is
- * preserved; the FIRST occurrence of each fingerprint wins.
+ * Drop duplicate tool calls from a RETURNED `toolCalls` array (Fix 2, array
+ * side). Dispatch-time dedupe (`createToolCallDedupe`) only suppresses the
+ * second `onToolCall`; providers that also RETURN a `toolCalls` array (which
+ * the agent loop executes) can still carry a synthetic-leaked + identical-native
+ * duplicate. Run the final array through this so the loop never executes a
+ * side-effecting tool twice.
  *
- * @param {Array<{name?:string,arguments?:object}>} calls
- * @returns {Array} the array with later duplicate-fingerprint calls removed.
+ * Identity mirrors createToolCallDedupe: a provider-assigned id identifies a
+ * real call, so parallel calls sharing a name+args fingerprint but carrying
+ * distinct ids are ALL kept — collapsing them would leave the model waiting for
+ * tool_results that never arrive and break the next request's chain. Only a
+ * repeated id, a synthetic leak the native path already carries, or an id-less
+ * exact repeat is dropped. Order is preserved; the FIRST occurrence wins.
+ *
+ * @param {Array<{id?:string,name?:string,arguments?:object}>} calls
+ * @returns {Array} the array with genuine duplicates removed.
  */
 export function dedupeToolCallList(calls) {
     if (!Array.isArray(calls) || calls.length < 2) return calls;
-    const seen = new Set();
+    // Fingerprints that reached the array through a provider-assigned id: a
+    // synthetic leak matching one of these is the same call, recovered twice.
+    const nativeFingerprints = new Set();
+    for (const call of calls) {
+        if (!call || typeof call !== 'object') continue;
+        if (!call.id || isLeakedSyntheticToolCallId(call.id)) continue;
+        nativeFingerprints.add(toolCallFingerprint(call.name, call.arguments));
+    }
+    const seenIds = new Set();
+    const seenSyntheticFingerprints = new Set();
     const out = [];
     for (const call of calls) {
         if (!call || typeof call !== 'object') { out.push(call); continue; }
+        const id = typeof call.id === 'string' ? call.id : '';
+        if (id && !isLeakedSyntheticToolCallId(id)) {
+            if (seenIds.has(id)) continue;
+            seenIds.add(id);
+            out.push(call);
+            continue;
+        }
         const fp = toolCallFingerprint(call.name, call.arguments);
-        if (seen.has(fp)) continue;
-        seen.add(fp);
+        if (nativeFingerprints.has(fp) || seenSyntheticFingerprints.has(fp)) continue;
+        seenSyntheticFingerprints.add(fp);
         out.push(call);
     }
     return out.length === calls.length ? calls : out;

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

@@ -1,7 +1,6 @@
 // Anthropic model catalog + message conversion helpers, extracted from anthropic.mjs.
 import { createRequire } from 'node:module';
 import { getAgentApiKey } from '../../../shared/provider-api-key.mjs';
-import { sanitizeToolPairs, sanitizeAnthropicContentPairs, foldUserTextIntoToolResultTail } from '../session/context-utils.mjs';
 import {
     ANTHROPIC_RETRY_BACKOFF_MS,
     ANTHROPIC_RETRY_JITTER_RATIO,
@@ -32,7 +31,6 @@ import {
     effortValuesForModel,
     shouldIncludeEffortBeta,
 } from './anthropic-effort.mjs';
-import { normalizeContentForAnthropic } from './media-normalization.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { makeModelCache } from './model-cache.mjs';
@@ -49,8 +47,12 @@ import {
     normalizeAnthropicNonStreamingResponse,
     resolveAnthropicCacheTtls as resolveCacheTtls,
     sanitizeAnthropicInputSchema,
+    toAnthropicMessages,
     toAnthropicToolChoice,
 } from './lib/anthropic-request-utils.mjs';
+// Message lowering lives in the shared request-utils lib (one implementation
+// for both Anthropic providers); re-exported here for existing importers.
+export { toAnthropicMessages };
 
 
 export const require = createRequire(import.meta.url);
@@ -235,86 +237,6 @@ export function deferredAnthropicTools(activeTools, messages, opts) {
 export function requestAnthropicTools(tools, messages, opts) {
     return sharedRequestAnthropicTools(tools, messages, opts, 'anthropic');
 }
-export function toAnthropicMessages(messages) {
-    // Marker-free lowering. cache_control is applied AFTER sanitization by
-    // applyAnthropicCacheMarkers() so that block drops/inserts/reorders
-    // performed by sanitizeAnthropicContentPairs cannot move or delete a
-    // marked block (the root cause of the sporadic COLD-turn cache miss:
-    // pre-sanitize markers landed on blocks the sanitizer then rewrote, so
-    // the provider-visible breakpoint diverged from the cached one).
-    const result = [];
-    for (let idx = 0; idx < messages.length; idx++) {
-        const m = messages[idx];
-        if (m.role === 'system') continue;
-        if (m.role === 'assistant' && (m.toolCalls?.length || m.assistantBlocks?.length || m.thinkingBlocks?.length)) {
-            let content;
-            if (m.assistantBlocks?.length) {
-                content = m.assistantBlocks.slice();
-            } else {
-                content = [];
-                // Adaptive-thinking round-trip: prior-turn thinking blocks are
-                // REQUIRED back, unmodified (signature intact; empty thinking
-                // field allowed), and MUST precede tool_use blocks.
-                if (Array.isArray(m.thinkingBlocks)) {
-                    for (const tb of m.thinkingBlocks) {
-                        if (tb && typeof tb === 'object') content.push(tb);
-                    }
-                }
-                if (m.content) content.push({ type: 'text', text: m.content });
-                for (const tc of m.toolCalls || []) {
-                    content.push({
-                        type: 'tool_use',
-                        id: tc.id,
-                        name: tc.name,
-                        input: tc.arguments,
-                    });
-                }
-            }
-            result.push({ role: 'assistant', content });
-            continue;
-        }
-        if (m.role === 'tool') {
-            const last = result[result.length - 1];
-            const native = m.nativeToolSearch;
-            const nativeProvider = String(native?.provider || '').toLowerCase();
-            const anthropicNative = new Set(['anthropic', 'anthropic-oauth']);
-            const references = (!nativeProvider || anthropicNative.has(nativeProvider))
-                && Array.isArray(native?.toolReferences)
-                ? native.toolReferences.map((name) => String(name || '').trim()).filter(Boolean)
-                : [];
-            const block = {
-                type: 'tool_result',
-                tool_use_id: m.toolCallId || '',
-                content: references.length
-                    ? references.map((tool_name) => ({ type: 'tool_reference', tool_name }))
-                    : normalizeContentForAnthropic(m.content),
-                ...((m.toolKind === 'error' || m.isError === true) ? { is_error: true } : {}),
-            };
-            if (last?.role === 'user' && Array.isArray(last.content)) {
-                last.content.push(block);
-            }
-            else {
-                result.push({ role: 'user', content: [block] });
-            }
-            continue;
-        }
-        // First-party client parity: fold a user text turn that directly follows a
-        // tool_result turn into that tool_result's content (empty end_turn
-        // livelock prevention; see foldUserTextIntoToolResultTail).
-        //   EXCEPTION: steering-origin user messages (human/TUI interjections)
-        //   keep their own user turn so provenance survives — folding them would
-        //   disguise user input as tool output. Anthropic accepts a user text
-        //   message after a tool_result message, so the turn stays request-valid.
-        const isSteering = m.role === 'user' && m.meta?.source === 'steering';
-        if (m.role === 'user' && !isSteering
-            && foldUserTextIntoToolResultTail(result, normalizeContentForAnthropic(m.content))) {
-            continue;
-        }
-        result.push({ role: m.role, content: normalizeContentForAnthropic(m.content) });
-    }
-    return sanitizeAnthropicContentPairs(result);
-}
-
 // Test-only: expose the lowering so the steering-provenance test can assert
 // the API-key provider keeps steering-tagged user turns distinct (mirrors
 // anthropic-oauth._buildRequestBodyForCacheSmoke coverage).

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

@@ -115,11 +115,6 @@ function _loadCredentialsFile(path) {
     }
 }
 
-export function loadCredentialsFromPath(path) {
-    if (!path) return null;
-    return _loadCredentialsFile(resolve(path));
-}
-
 // Cross-process safe credential save. Lockfile (O_EXCL) prevents two Mixdog
 // refreshers from clobbering each other; atomic rename guarantees readers see
 // either the old or new file, never a half-written one. Used so refresh_token