mixdog 0.8.0 → 0.9.0

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

@@ -1,23 +1,50 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { loadConfig } from '../config.mjs';
 import { sanitizeToolPairs, sanitizeAnthropicContentPairs } from '../session/context-utils.mjs';
-import { classifyError, withRetry } from './retry-classifier.mjs';
-import { traceBridgeUsage } from '../bridge-trace.mjs';
+import { classifyError, midstreamBackoffFor, withRetry } from './retry-classifier.mjs';
+import { traceAgentUsage } from '../agent-trace.mjs';
 import {
     PROVIDER_FIRST_BYTE_TIMEOUT_MS,
     createTimeoutSignal,
     createPassthroughSignal,
 } from '../stall-policy.mjs';
 import { createAbortController } from '../../../shared/abort-controller.mjs';
-import { parseSSEStream, _classifyMidstreamError } from './anthropic-oauth.mjs';
+import {
+    ANTHROPIC_MAX_MIDSTREAM_RETRIES,
+    parseSSEStream,
+    _classifyMidstreamError,
+} from './anthropic-oauth.mjs';
 import { buildAnthropicBetaHeaders, supportsAnthropicFastMode } from './anthropic-betas.mjs';
 import { normalizeContentForAnthropic } from './media-normalization.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 
-// 4-BP cache policy aligned with anthropic-oauth — tools + system + tier3
-// + messages-tail. 1h TTL requires the extended-cache-ttl beta header,
-// which we set on the client via defaultHeaders below.
+async function _midstreamSleepWithAbort(ms, signal) {
+    if (!ms) return;
+    if (!signal) {
+        await new Promise((r) => setTimeout(r, ms));
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        const t = setTimeout(() => {
+            try { signal.removeEventListener('abort', onAbort); } catch {}
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(t);
+            const reason = signal.reason;
+            reject(reason instanceof Error ? reason : new Error('Anthropic mid-stream retry backoff aborted'));
+        };
+        if (signal.aborted) { onAbort(); return; }
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+
+// 4-BP cache policy aligned with anthropic-oauth — system + tier3 +
+// messages-tail. Tool schemas sit before system and are covered by the system
+// breakpoint, so they do not spend a separate cache_control slot. 1h TTL
+// requires the extended-cache-ttl beta header, which we set on the client via
+// defaultHeaders below.
 const CACHE_TTL_STABLE = { type: 'ephemeral', ttl: '1h' };
 const CACHE_TTL_VOLATILE = { type: 'ephemeral' };
 
@@ -39,23 +66,9 @@ function appendCacheControl(content, ttl = CACHE_TTL_VOLATILE) {
     return content;
 }
 
-// Mirrors anthropic-oauth.mjs gate: only the explicitly-tagged sessionMarker
-// claims a 1h BP3 slot. composeSystemPrompt prefixes sessionMarker with
-// `<!-- bp3-sentinel -->`; volatileTail (also a `<system-reminder>` user
-// message) deliberately omits the sentinel so it stays on the message tail.
-const BP3_SENTINEL = '<!-- bp3-sentinel -->';
-
-function findTier3Index(chatMsgs) {
-    for (let i = 0; i < chatMsgs.length; i++) {
-        const m = chatMsgs[i];
-        if (m?.role === 'user' && typeof m.content === 'string'
-            && m.content.startsWith('<system-reminder>')
-            && m.content.includes(BP3_SENTINEL)) {
-            return i;
-        }
-    }
-    return -1;
-}
+// BP3 (tier3) rides its own `system` role block (the 3rd system block, tagged
+// cacheTier:'tier3'). buildSystemBlocks applies the tier3 1h cache_control to
+// that block; BP1/BP2 take the system TTL. Mirrors anthropic-oauth.mjs.
 
 function resolveCacheTtls(opts) {
     const strategy = opts?.cacheStrategy || {};
@@ -67,19 +80,40 @@ function resolveCacheTtls(opts) {
         return fallback;
     };
     return {
-        tools: pick('tools', CACHE_TTL_STABLE),
+        tools: pick('tools', null),
         system: pick('system', CACHE_TTL_STABLE),
         tier3: pick('tier3', CACHE_TTL_STABLE),
         messages: pick('messages', CACHE_TTL_STABLE),
     };
 }
 
+function buildSystemBlocks(systemMsgs, systemTtl, tier3Ttl) {
+    // systemMsgs is an array of { content, cacheTier }. Each non-empty element
+    // becomes its own content block: cacheTier:'tier3' (BP3 sessionMarker) gets
+    // tier3Ttl, every other block (BP1/BP2) gets systemTtl. A null TTL leaves
+    // the corresponding block uncached.
+    const items = Array.isArray(systemMsgs)
+        ? systemMsgs
+            .map(m => ({
+                text: typeof m?.content === 'string' ? m.content.trim() : '',
+                tier: m?.cacheTier === 'tier3' ? 'tier3' : 'system',
+            }))
+            .filter(it => it.text)
+        : [];
+    return items.map(it => {
+        const block = { type: 'text', text: it.text };
+        const ttl = it.tier === 'tier3' ? tier3Ttl : systemTtl;
+        if (ttl) block.cache_control = ttl;
+        return block;
+    });
+}
+
 const MODELS = [
-    { id: 'claude-opus-4-8', name: 'Claude Opus 4.8', provider: 'anthropic', contextWindow: 1000000 },
-    { id: 'claude-opus-4-7', name: 'Claude Opus 4.7', provider: 'anthropic', contextWindow: 1000000 },
-    { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', provider: 'anthropic', contextWindow: 1000000 },
-    { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', provider: 'anthropic', contextWindow: 1000000 },
-    { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', provider: 'anthropic', contextWindow: 200000 },
+    { id: 'claude-opus-4-8', name: 'Claude Opus 4.8', provider: 'anthropic', family: 'opus', contextWindow: 1000000 },
+    { id: 'claude-opus-4-7', name: 'Claude Opus 4.7', provider: 'anthropic', family: 'opus', contextWindow: 1000000 },
+    { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', provider: 'anthropic', family: 'opus', contextWindow: 1000000 },
+    { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', provider: 'anthropic', family: 'sonnet', contextWindow: 1000000 },
+    { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', provider: 'anthropic', family: 'haiku', contextWindow: 200000 },
 ];
 const ANTHROPIC_VERSION = '2023-06-01';
 
@@ -131,8 +165,21 @@ const EFFORT_BUDGET = {
     low: 1024,
     medium: 4096,
     high: 16384,
+    xhigh: 32768,
     max: 32768,
 };
+
+const MIN_THINKING_BUDGET = 1024;
+const THINKING_OUTPUT_RESERVE = 1024;
+
+function clampThinkingBudgetTokens(value, maxTokens) {
+    const desired = Math.floor(Number(value));
+    const max = Math.floor(Number(maxTokens));
+    if (!Number.isFinite(desired) || desired <= 0 || !Number.isFinite(max)) return null;
+    const ceiling = max - THINKING_OUTPUT_RESERVE;
+    if (ceiling < MIN_THINKING_BUDGET) return null;
+    return Math.max(MIN_THINKING_BUDGET, Math.min(desired, ceiling));
+}
 // Anthropic forbids oneOf / allOf / anyOf at the TOP level of input_schema.
 // Mirror the same sanitizer as anthropic-oauth.mjs so both providers are safe.
 function _sanitizeInputSchema(schema, toolName) {
@@ -169,9 +216,11 @@ function _sanitizeInputSchema(schema, toolName) {
         if (addition) description = description ? `${description} ${addition}` : addition;
     }
     const mergedPropsCount = Object.keys(mergedProps).length;
-    process.stderr.write(
-        `[anthropic-sanitizer] tool="${toolName ?? ''}" compound="${compoundKey}" branches=${Array.isArray(compound) ? compound.length : 0} mergedProps=${mergedPropsCount}\n`
-    );
+    if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
+        process.stderr.write(
+            `[anthropic-sanitizer] tool="${toolName ?? ''}" compound="${compoundKey}" branches=${Array.isArray(compound) ? compound.length : 0} mergedProps=${mergedPropsCount}\n`
+        );
+    }
     return {
         type: 'object',
         ...(description ? { description } : {}),
@@ -180,11 +229,28 @@ function _sanitizeInputSchema(schema, toolName) {
 }
 
 function toAnthropicTools(tools) {
-    return tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        input_schema: _sanitizeInputSchema(t.inputSchema, t.name),
-    }));
+    return tools.map((t) => {
+        const out = {
+            name: t.name,
+            description: t.description,
+            input_schema: _sanitizeInputSchema(t.inputSchema, t.name),
+        };
+        if (t.deferLoading === true || t.defer_loading === true) out.defer_loading = true;
+        return out;
+    });
+}
+function nativeAnthropicTools(opts) {
+    return Array.isArray(opts?.nativeTools)
+        ? opts.nativeTools.filter(t => t && typeof t === 'object')
+        : [];
+}
+function deferredAnthropicTools(activeTools, opts) {
+    if (opts?.session?.deferredNativeTools !== true) return [];
+    const active = new Set((activeTools || []).map((tool) => String(tool?.name || '').trim()).filter(Boolean));
+    const catalog = Array.isArray(opts.session.deferredToolCatalog) ? opts.session.deferredToolCatalog : [];
+    return catalog
+        .filter((tool) => tool?.name && !active.has(String(tool.name)))
+        .map((tool) => ({ ...tool, deferLoading: true }));
 }
 function toAnthropicMessages(messages) {
     // Marker-free lowering. cache_control is applied AFTER sanitization by
@@ -218,10 +284,15 @@ function toAnthropicMessages(messages) {
         }
         if (m.role === 'tool') {
             const last = result[result.length - 1];
+            const refs = Array.isArray(m.nativeToolSearch?.toolReferences)
+                ? m.nativeToolSearch.toolReferences.map((name) => String(name || '').trim()).filter(Boolean)
+                : [];
             const block = {
                 type: 'tool_result',
                 tool_use_id: m.toolCallId || '',
-                content: normalizeContentForAnthropic(m.content),
+                content: refs.length
+                    ? refs.map((name) => ({ type: 'tool_reference', tool_name: name }))
+                    : normalizeContentForAnthropic(m.content),
             };
             if (last?.role === 'user' && Array.isArray(last.content)) {
                 last.content.push(block);
@@ -241,17 +312,15 @@ function toAnthropicMessages(messages) {
 // sanitizeAnthropicContentPairs has already run (and must NOT run again
 // after this), the blocks we mark here are exactly the blocks the provider
 // sees, so the cache breakpoint is stable across turns.
-//   tier3:        the user message whose first text block / string content
-//                 startsWith '<system-reminder>' AND includes BP3_SENTINEL —
-//                 mark its last content block with tier3Ttl.
 //   message-anchor: prefer a safe tool_result tail, then a previous real user
 //                   text turn if another slot remains. Synthetic
 //                   <system-reminder> messages and current pure-text prompts
 //                   are excluded so per-call volatileTail/current prompt
 //                   content never becomes a 1h prefix key.
-// messageTtl === null disables the tail; tier3Ttl === null disables tier3.
+// messageTtl === null disables the tail. BP3 (tier3) now rides a system block,
+// so it is no longer marked here.
 // ANTHROPIC_MSG_SLOTS=0 is honoured upstream by passing messageTtl = null.
-function applyAnthropicCacheMarkers(sanitizedMessages, { messageTtl = CACHE_TTL_VOLATILE, messageSlots = 1, tier3Ttl = null } = {}) {
+function applyAnthropicCacheMarkers(sanitizedMessages, { messageTtl = CACHE_TTL_VOLATILE, messageSlots = 1 } = {}) {
     if (!Array.isArray(sanitizedMessages) || sanitizedMessages.length === 0) {
         return sanitizedMessages;
     }
@@ -265,25 +334,20 @@ function applyAnthropicCacheMarkers(sanitizedMessages, { messageTtl = CACHE_TTL_
         return '';
     };
     const isSystemReminder = (content) => firstText(content).startsWith('<system-reminder>');
-    const isTier3SystemReminder = (content) => {
-        const text = firstText(content);
-        return text.startsWith('<system-reminder>') && text.includes(BP3_SENTINEL);
-    };
 
     const markLast = (msg, ttl) => {
         if (!msg) return;
         msg.content = appendCacheControl(msg.content, ttl);
     };
     const ttlRank = (ttl) => ttl?.ttl === '1h' ? 2 : 1;
-    const canMarkMessageIdx = (idx, tier3Idx) => {
+    const canMarkMessageIdx = (idx) => {
+        // System-reminder messages (volatileTail / roleSpecific BP4) vary
+        // per-call, so never pin them with a 1h marker. The 1h system blocks
+        // (BP1/BP2/BP3) already satisfy Anthropic's "1h before 5m" ordering.
         if (idx < 0) return false;
         const msg = sanitizedMessages[idx];
         if (ttlRank(messageTtl) > ttlRank(CACHE_TTL_VOLATILE)
-            && isSystemReminder(msg?.content)
-            && !isTier3SystemReminder(msg?.content)) {
-            return false;
-        }
-        if (tier3Idx >= 0 && idx < tier3Idx && ttlRank(messageTtl) < ttlRank(tier3Ttl)) {
+            && isSystemReminder(msg?.content)) {
             return false;
         }
         return true;
@@ -312,29 +376,16 @@ function applyAnthropicCacheMarkers(sanitizedMessages, { messageTtl = CACHE_TTL_
         return -1;
     };
 
-    // tier3 — locate the sentinel-tagged system-reminder user message.
-    let tier3MsgIdx = -1;
-    if (tier3Ttl !== null) {
-        for (let i = 0; i < sanitizedMessages.length; i++) {
-            const m = sanitizedMessages[i];
-            if (m?.role === 'user' && isTier3SystemReminder(m.content)) {
-                tier3MsgIdx = i;
-                break;
-            }
-        }
-        if (tier3MsgIdx >= 0) markLast(sanitizedMessages[tier3MsgIdx], tier3Ttl);
-    }
-
     if (messageTtl !== null) {
         const slots = Math.max(0, Math.min(4, Number(messageSlots) || 0));
-        const marked = new Set(tier3MsgIdx >= 0 ? [tier3MsgIdx] : []);
+        const marked = new Set();
         const candidates = [latestToolResultTailIdx(), previousUserTextAnchorIdx()];
         for (const idx of candidates) {
             if (slots <= 0) break;
-            if (idx < 0 || marked.has(idx) || !canMarkMessageIdx(idx, tier3MsgIdx)) continue;
+            if (idx < 0 || marked.has(idx) || !canMarkMessageIdx(idx)) continue;
             markLast(sanitizedMessages[idx], messageTtl);
             marked.add(idx);
-            if (marked.size - (tier3MsgIdx >= 0 ? 1 : 0) >= slots) break;
+            if (marked.size >= slots) break;
         }
     }
 
@@ -352,7 +403,7 @@ export class AnthropicProvider {
     constructor(config) {
         this.config = config;
         this.name = config.name || 'anthropic';
-        const betaHeaders = config.disableBetaHeaders ? null : buildAnthropicBetaHeaders();
+        const betaHeaders = config.disableBetaHeaders ? null : buildAnthropicBetaHeaders({ toolSearch: true });
         this.client = new Anthropic({
             apiKey: config.apiKey || process.env.ANTHROPIC_API_KEY,
             ...(config.baseURL ? { baseURL: config.baseURL } : {}),
@@ -366,7 +417,7 @@ export class AnthropicProvider {
             const newKey = cfg?.apiKey || this.config.apiKey || (this.name === 'anthropic' ? process.env.ANTHROPIC_API_KEY : null);
             if (newKey) {
                 this.config = { ...(this.config || {}), ...(cfg || {}), apiKey: newKey };
-                const betaHeaders = this.config.disableBetaHeaders ? null : buildAnthropicBetaHeaders();
+                const betaHeaders = this.config.disableBetaHeaders ? null : buildAnthropicBetaHeaders({ toolSearch: true });
                 this.client = new Anthropic({
                     apiKey: newKey,
                     ...(this.config.baseURL ? { baseURL: this.config.baseURL } : {}),
@@ -402,17 +453,17 @@ export class AnthropicProvider {
 
         const systemMsgs = messages.filter(m => m.role === 'system');
         const chatMsgs = messages.filter(m => m.role !== 'system');
-        const systemText = systemMsgs.map(m => m.content).join('\n\n') || undefined;
+        // BP1 baseRules + BP2 stableSystem at ttls.system; BP3 sessionMarker
+        // (cacheTier:'tier3') at ttls.tier3 — each its own system content block.
+        const systemBlocks = buildSystemBlocks(systemMsgs, ttls.system, ttls.tier3);
 
         // 4-BP budget: aligned with anthropic-oauth. tools BP is dropped —
         // system BP covers the tools prefix via Anthropic prefix semantics
         // (order: tools → system → messages). That frees 1 slot for
         // messages-tail.
         const toolsBpUsed = 0;
-        const systemBpUsed = ttls.system && systemText ? 1 : 0;
-        const tier3Idx = ttls.tier3 ? findTier3Index(chatMsgs) : -1;
-        const tier3BpUsed = tier3Idx >= 0 ? 1 : 0;
-        const usedSlots = toolsBpUsed + systemBpUsed + tier3BpUsed;
+        const systemBpUsed = systemBlocks.filter(b => b.cache_control).length;
+        const usedSlots = toolsBpUsed + systemBpUsed;
         // Env override for BP strategy. ANTHROPIC_MSG_SLOTS=0 disables
         // message caching entirely. Any value >=1 first marks the previous
         // user text turn; a second free slot marks the tail. Mirrors
@@ -428,34 +479,32 @@ export class AnthropicProvider {
         // or delete a marked block. NEVER sanitize again after this.
         // msgSlots === 0 → message-tail disabled.
         const tailTtl = msgSlots > 0 ? ttls.messages : null;
-        const tier3Ttl = tier3Idx >= 0 ? ttls.tier3 : null;
         const anthropicMessages = applyAnthropicCacheMarkers(
             toAnthropicMessages(chatMsgs),
-            { messageTtl: tailTtl, messageSlots: msgSlots, tier3Ttl },
+            { messageTtl: tailTtl, messageSlots: msgSlots },
         );
 
         const params = {
             model: useModel,
             max_tokens: maxTokens,
-            system: systemText
-                ? [ttls.system
-                    ? { type: 'text', text: systemText, cache_control: ttls.system }
-                    : { type: 'text', text: systemText }]
-                : undefined,
+            system: systemBlocks.length ? systemBlocks : undefined,
             messages: anthropicMessages,
         };
-        if (tools?.length) {
+        const nativeTools = nativeAnthropicTools(opts);
+        if (tools?.length || nativeTools.length) {
             // No cache_control on tools — the system BP covers tools via
             // Anthropic prefix semantics (order: tools → system → messages).
-            params.tools = toAnthropicTools(tools);
+            params.tools = [...nativeTools, ...toAnthropicTools([...(tools || []), ...deferredAnthropicTools(tools || [], opts)])];
         }
         // Effort → extended thinking budget. Gateway inherit mode may pass the
-        // exact Claude Code budget from the incoming Anthropic request.
+        // exact OAuth client budget from the incoming Anthropic request.
         const thinkingBudgetTokens = Number(opts.thinkingBudgetTokens);
-        if (Number.isFinite(thinkingBudgetTokens) && thinkingBudgetTokens > 0) {
-            params.thinking = { type: 'enabled', budget_tokens: Math.floor(thinkingBudgetTokens) };
-        } else if (opts.effort && EFFORT_BUDGET[opts.effort]) {
-            params.thinking = { type: 'enabled', budget_tokens: EFFORT_BUDGET[opts.effort] };
+        const requestedThinkingBudget = Number.isFinite(thinkingBudgetTokens) && thinkingBudgetTokens > 0
+            ? thinkingBudgetTokens
+            : (opts.effort && EFFORT_BUDGET[opts.effort] ? EFFORT_BUDGET[opts.effort] : null);
+        const budgetTokens = clampThinkingBudgetTokens(requestedThinkingBudget, maxTokens);
+        if (budgetTokens) {
+            params.thinking = { type: 'enabled', budget_tokens: budgetTokens };
         }
         // Fast mode → speed: "fast" on models Anthropic marks as speed-capable.
         if (opts.fast === true && supportsAnthropicFastMode(useModel)) {
@@ -479,7 +528,7 @@ export class AnthropicProvider {
         // emitting SSE deltas must not be killed by a fixed total-lifetime timer.
         // Mirrors the OAuth provider (Option A). Bounded instead by the
         // per-attempt first-byte/HTTP-response timeout, the SSE idle watchdog,
-        // the bridge stall watchdog, and externalSignal (client disconnect /
+        // the agent stall watchdog, and externalSignal (client disconnect /
         // replaced-by-newer-request). totalSignal is a pure pass-through.
         const externalSignal = opts.signal || null;
         const totalTimeout = createPassthroughSignal(externalSignal);
@@ -493,10 +542,11 @@ export class AnthropicProvider {
         const betaHeaders = {
             'anthropic-beta': buildAnthropicBetaHeaders({
                 fastMode: this.fastModeBetaHeaderLatched,
+                toolSearch: true,
             }),
         };
 
-        const MAX_MIDSTREAM_RETRIES = 1;
+        const MAX_MIDSTREAM_RETRIES = ANTHROPIC_MAX_MIDSTREAM_RETRIES;
         let firstAttemptError = null;
         let firstAttemptClassifier = null;
 
@@ -510,7 +560,7 @@ export class AnthropicProvider {
             const liveModel = parseResult.model || useModel;
 
             if (usageRaw || input || output || cacheRead || cacheWrite) {
-                traceBridgeUsage({
+                traceAgentUsage({
                     sessionId: opts.sessionId || opts.session?.id || null,
                     iteration: Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null,
                     inputTokens: input,
@@ -694,6 +744,7 @@ export class AnthropicProvider {
                                 `[${this.name}] empty stream (no message_start) — retry ${attemptIndex + 1}/${MAX_MIDSTREAM_RETRIES}\n`,
                             );
                         } catch {}
+                        await _midstreamSleepWithAbort(midstreamBackoffFor(attemptIndex + 1), totalSignal);
                         continue;
                     }
                     if ((err?.truncatedStream === true || err?.code === 'TRUNCATED_STREAM')
@@ -708,6 +759,7 @@ export class AnthropicProvider {
                                 `[${this.name}] truncated stream — retry ${attemptIndex + 1}/${MAX_MIDSTREAM_RETRIES}\n`,
                             );
                         } catch {}
+                        await _midstreamSleepWithAbort(midstreamBackoffFor(attemptIndex + 1), totalSignal);
                         continue;
                     }
                     const classifier = _classifyMidstreamError(err, midState);
@@ -720,6 +772,7 @@ export class AnthropicProvider {
                                 `[${this.name}] mid-stream recovered: retry ${attemptIndex + 1}/${MAX_MIDSTREAM_RETRIES} (cause: ${classifier})\n`,
                             );
                         } catch {}
+                        await _midstreamSleepWithAbort(midstreamBackoffFor(attemptIndex + 1), totalSignal);
                         continue;
                     }
                     if (attemptIndex > 0 && firstAttemptError) {