mixdog 0.7.18 → 0.8.0

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

@@ -1,598 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { loadConfig } from '../config.mjs';
-import { sanitizeToolPairs, sanitizeAnthropicContentPairs } from '../session/trim.mjs';
-import { classifyError, withRetry } from './retry-classifier.mjs';
-import { traceBridgeUsage } from '../bridge-trace.mjs';
-import {
-    PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-    PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS,
-    createTimeoutSignal,
-} from '../stall-policy.mjs';
-import { createAbortController } from '../../../shared/abort-controller.mjs';
-import { parseSSEStream, _classifyMidstreamError } from './anthropic-oauth.mjs';
-import { buildAnthropicBetaHeaders, supportsAnthropicFastMode } from './anthropic-betas.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.
-const CACHE_TTL_STABLE = { type: 'ephemeral', ttl: '1h' };
-const CACHE_TTL_VOLATILE = { type: 'ephemeral' };
-
-function withCacheControl(block, ttl = CACHE_TTL_VOLATILE) {
-    if (!block || typeof block !== 'object' || block.cache_control) return block;
-    return { ...block, cache_control: ttl };
-}
-
-function appendCacheControl(content, ttl = CACHE_TTL_VOLATILE) {
-    if (Array.isArray(content)) {
-        if (content.length === 0) return content;
-        const next = [...content];
-        next[next.length - 1] = withCacheControl(next[next.length - 1], ttl);
-        return next;
-    }
-    if (typeof content === 'string') {
-        return [withCacheControl({ type: 'text', text: content }, ttl)];
-    }
-    return content;
-}
-
-function collectRecentCacheableMessageIndexes(messages, availableSlots = 1) {
-    const slots = Math.max(0, Math.min(4, availableSlots));
-    const marked = new Set();
-    for (let i = messages.length - 1; i >= 0 && marked.size < slots; i--) {
-        if (messages[i]?.role !== 'system') marked.add(i);
-    }
-    return marked;
-}
-
-// 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 5m 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;
-}
-
-function resolveCacheTtls(opts) {
-    const strategy = opts?.cacheStrategy || {};
-    const pick = (layer, fallback) => {
-        const v = strategy[layer];
-        if (v === '1h') return CACHE_TTL_STABLE;
-        if (v === '5m') return CACHE_TTL_VOLATILE;
-        if (v === 'none') return null;
-        return fallback;
-    };
-    return {
-        tools: pick('tools', CACHE_TTL_STABLE),
-        system: pick('system', CACHE_TTL_STABLE),
-        tier3: pick('tier3', CACHE_TTL_STABLE),
-        messages: pick('messages', CACHE_TTL_VOLATILE),
-    };
-}
-
-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 },
-];
-// Family-based heuristic so new model ids (including custom user-configured
-// ones) resolve a sensible max_tokens without requiring a code change.
-function resolveMaxTokens(model) {
-    const id = String(model || '').toLowerCase();
-    if (id.includes('opus')) return 32768;
-    if (id.includes('sonnet')) return 16384;
-    if (id.includes('haiku')) return 8192;
-    return 8192;
-}
-
-// Effort → thinking budget tokens (Anthropic extended thinking)
-const EFFORT_BUDGET = {
-    low: 1024,
-    medium: 4096,
-    high: 16384,
-    max: 32768,
-};
-// 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) {
-    if (!schema || typeof schema !== 'object') {
-        return { type: 'object', properties: {} };
-    }
-    const compound = schema.oneOf || schema.anyOf || schema.allOf;
-    if (!compound) return structuredClone(schema);
-    const mergedProps = {};
-    const branchDescs = [];
-    for (const branch of Array.isArray(compound) ? compound : []) {
-        if (branch && typeof branch === 'object' && branch.properties) {
-            Object.assign(mergedProps, branch.properties);
-        }
-        if (branch && typeof branch === 'object') {
-            const parts = [];
-            if (branch.description) parts.push(branch.description);
-            else if (branch.type) parts.push(`type:${branch.type}`);
-            if (parts.length) branchDescs.push(parts.join(' '));
-        }
-    }
-    const compoundKey = schema.oneOf ? 'oneOf' : schema.anyOf ? 'anyOf' : 'allOf';
-    let description = schema.description || '';
-    if (branchDescs.length) {
-        const parts = [];
-        let used = 0;
-        for (let i = 0; i < branchDescs.length; i++) {
-            const v = `(variant ${i + 1}: ${branchDescs[i]})`;
-            if (used + v.length + (parts.length ? 1 : 0) > 500) break;
-            parts.push(v);
-            used += v.length + (parts.length > 1 ? 1 : 0);
-        }
-        const addition = parts.join(' ');
-        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`
-    );
-    return {
-        type: 'object',
-        ...(description ? { description } : {}),
-        properties: mergedProps,
-    };
-}
-
-function toAnthropicTools(tools) {
-    return tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        input_schema: _sanitizeInputSchema(t.inputSchema, t.name),
-    }));
-}
-function toAnthropicMessages(
-    messages,
-    cacheableIndexes = new Set(),
-    messageTtl = CACHE_TTL_VOLATILE,
-    tier3Idx = -1,
-    tier3Ttl = null,
-) {
-    const applyMsgTtl = messageTtl || CACHE_TTL_VOLATILE;
-    const shouldCacheMsg = (idx) => messageTtl !== null && cacheableIndexes.has(idx);
-    const shouldCacheTier3 = (idx) => tier3Ttl !== null && idx === tier3Idx;
-    const pickTtl = (idx) => shouldCacheTier3(idx) ? tier3Ttl : applyMsgTtl;
-    const anyCache = (idx) => shouldCacheMsg(idx) || shouldCacheTier3(idx);
-
-    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) {
-            let content = [];
-            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,
-                });
-            }
-            if (anyCache(idx)) content = appendCacheControl(content, pickTtl(idx));
-            result.push({ role: 'assistant', content });
-            continue;
-        }
-        if (m.role === 'tool') {
-            const last = result[result.length - 1];
-            const block = {
-                type: 'tool_result',
-                tool_use_id: m.toolCallId || '',
-                content: m.content,
-            };
-            if (last?.role === 'user' && Array.isArray(last.content)) {
-                last.content.push(block);
-                if (anyCache(idx)) {
-                    last.content = appendCacheControl(last.content, pickTtl(idx));
-                }
-            }
-            else {
-                let content = [block];
-                if (anyCache(idx)) content = appendCacheControl(content, pickTtl(idx));
-                result.push({ role: 'user', content });
-            }
-            continue;
-        }
-        const content = anyCache(idx)
-            ? appendCacheControl(m.content, pickTtl(idx))
-            : m.content;
-        result.push({ role: m.role, content });
-    }
-    return sanitizeAnthropicContentPairs(result);
-}
-function parseToolCalls(response) {
-    const blocks = response.content.filter((b) => b.type === 'tool_use');
-    if (!blocks.length)
-        return undefined;
-    return blocks.map((b) => ({
-        id: b.id,
-        name: b.name,
-        arguments: (b.input ?? {}),
-    }));
-}
-export class AnthropicProvider {
-    // Anthropic reports usage.input_tokens EXCLUDING cache_read/cache_creation
-    // (those are separate fields), so the live context-window footprint must
-    // add cache_read back. See providerInputExcludesCache() in registry.mjs.
-    static inputExcludesCache = true;
-    name = 'anthropic';
-    client;
-    config;
-    fastModeBetaHeaderLatched = false;
-    constructor(config) {
-        this.config = config;
-        this.client = new Anthropic({
-            apiKey: config.apiKey || process.env.ANTHROPIC_API_KEY,
-            defaultHeaders: { 'anthropic-beta': buildAnthropicBetaHeaders() },
-        });
-    }
-    reloadApiKey() {
-        try {
-            const freshConfig = loadConfig();
-            const cfg = freshConfig.providers?.anthropic;
-            const newKey = cfg?.apiKey || process.env.ANTHROPIC_API_KEY;
-            if (newKey) {
-                this.client = new Anthropic({
-                    apiKey: newKey,
-                    defaultHeaders: { 'anthropic-beta': buildAnthropicBetaHeaders() },
-                });
-            }
-        } catch { /* best effort */ }
-    }
-    async send(messages, model, tools, sendOpts) {
-        // Defense-in-depth: enforce tool_use / tool_result pairing before
-        // the Anthropic API call. Mirror of the OAuth path; loop.mjs only
-        // runs sanitizeToolPairs when budget is exceeded, so an under-budget
-        // dispatch with an aborted-mid-flight tool_use would otherwise hit
-        // the provider as a hard 400 (`tool_use ids ... without tool_result`).
-        messages = sanitizeToolPairs(messages);
-        try {
-            return await this._doSend(messages, model, tools, sendOpts);
-        } catch (err) {
-            if (err.message && (err.message.includes('401') || err.message.includes('403'))) {
-                process.stderr.write(`[provider] Auth error, re-reading config...\n`);
-                this.reloadApiKey();
-                return await this._doSend(messages, model, tools, sendOpts);
-            }
-            throw err;
-        }
-    }
-    async _doSend(messages, model, tools, sendOpts) {
-        if (!model) throw new Error('[anthropic] model is required — pass it from the caller preset');
-        const useModel = model;
-        const maxTokens = resolveMaxTokens(useModel);
-        const opts = sendOpts || {};
-        const ttls = resolveCacheTtls(opts);
-
-        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;
-
-        // 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 msgSlots = ttls.messages ? Math.max(0, 4 - usedSlots) : 0;
-        const cacheableIndexes = collectRecentCacheableMessageIndexes(chatMsgs, msgSlots);
-        if (tier3Idx >= 0) cacheableIndexes.delete(tier3Idx);
-
-        const anthropicMessages = toAnthropicMessages(
-            chatMsgs,
-            cacheableIndexes,
-            ttls.messages,
-            tier3Idx,
-            ttls.tier3,
-        );
-
-        const params = {
-            model: useModel,
-            max_tokens: maxTokens,
-            system: systemText
-                ? [ttls.system
-                    ? { type: 'text', text: systemText, cache_control: ttls.system }
-                    : { type: 'text', text: systemText }]
-                : undefined,
-            messages: anthropicMessages,
-        };
-        if (tools?.length) {
-            // No cache_control on tools — the system BP covers tools via
-            // Anthropic prefix semantics (order: tools → system → messages).
-            params.tools = toAnthropicTools(tools);
-        }
-        // Effort → extended thinking budget. Gateway inherit mode may pass the
-        // exact Claude Code 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] };
-        }
-        // Fast mode → speed: "fast" on models Anthropic marks as speed-capable.
-        if (opts.fast === true && supportsAnthropicFastMode(useModel)) {
-            params.speed = 'fast';
-            this.fastModeBetaHeaderLatched = true;
-        }
-        params.messages = sanitizeAnthropicContentPairs(params.messages);
-        params.stream = true;
-
-        const onStageChange = typeof opts.onStageChange === 'function' ? opts.onStageChange : null;
-        const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
-        const onToolCall = typeof opts.onToolCall === 'function' ? opts.onToolCall : null;
-
-        const totalTimeout = createTimeoutSignal(
-            opts.signal || null,
-            PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS,
-            'Anthropic total',
-        );
-        const totalSignal = totalTimeout.signal;
-
-        const cleanupCancelHandler = (handler) => {
-            if (!handler) return;
-            try { totalSignal.removeEventListener('abort', handler); } catch {}
-        };
-
-        const betaHeaders = {
-            'anthropic-beta': buildAnthropicBetaHeaders({
-                fastMode: this.fastModeBetaHeaderLatched,
-            }),
-        };
-
-        const MAX_MIDSTREAM_RETRIES = 1;
-        let firstAttemptError = null;
-        let firstAttemptClassifier = null;
-
-        const buildReturnFromParse = (parseResult) => {
-            const usageRaw = parseResult.usage?.raw || null;
-            const input = parseResult.usage?.inputTokens || 0;
-            const cacheRead = parseResult.usage?.cachedTokens || 0;
-            const cacheWrite = parseResult.usage?.cacheWriteTokens || 0;
-            const output = parseResult.usage?.outputTokens || 0;
-            const promptTokens = parseResult.usage?.promptTokens ?? (input + cacheRead + cacheWrite);
-            const liveModel = parseResult.model || useModel;
-
-            if (usageRaw || input || output || cacheRead || cacheWrite) {
-                traceBridgeUsage({
-                    sessionId: opts.sessionId || opts.session?.id || null,
-                    iteration: Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null,
-                    inputTokens: input,
-                    outputTokens: output,
-                    cachedTokens: cacheRead,
-                    cacheWriteTokens: cacheWrite,
-                    promptTokens,
-                    model: liveModel,
-                    modelDisplay: liveModel,
-                    responseId: null,
-                    rawUsage: usageRaw,
-                    provider: 'anthropic',
-                });
-            }
-
-            return {
-                content: parseResult.content || '',
-                model: liveModel,
-                toolCalls: parseResult.toolCalls,
-                stopReason: parseResult.stopReason || null,
-                hasThinkingContent: !!parseResult.hasThinkingContent,
-                contentBlockTypes: Array.isArray(parseResult.contentBlockTypes)
-                    ? parseResult.contentBlockTypes
-                    : [],
-                usage: {
-                    inputTokens: input,
-                    outputTokens: output,
-                    cachedTokens: cacheRead,
-                    cacheWriteTokens: cacheWrite,
-                    promptTokens,
-                },
-            };
-        };
-
-        try {
-            for (let attemptIndex = 0; attemptIndex <= MAX_MIDSTREAM_RETRIES; attemptIndex++) {
-                const streamController = createAbortController();
-                let cancelHandler = null;
-
-                if (totalSignal) {
-                    if (totalSignal.aborted) {
-                        const reason = totalSignal.reason;
-                        throw reason instanceof Error
-                            ? reason
-                            : new Error('Anthropic request aborted');
-                    }
-                    cancelHandler = () => {
-                        try { streamController.abort(totalSignal.reason); } catch {}
-                    };
-                    totalSignal.addEventListener('abort', cancelHandler, { once: true });
-                }
-
-                const midState = {
-                    attemptIndex,
-                    sawMessageStart: false,
-                    sawCompleted: false,
-                    emittedToolCall: false,
-                    userAbort: false,
-                    watchdogAbort: null,
-                };
-
-                let firstBytePoll = null;
-                let firstByteTimeout = null;
-
-                try {
-                    try { onStageChange?.('requesting'); } catch {}
-
-                    const response = await withRetry(
-                        async ({ signal: attemptSignal }) => {
-                            const res = await this.client.messages.create(params, {
-                                signal: attemptSignal,
-                                headers: betaHeaders,
-                            }).asResponse();
-                            if (!res.ok) {
-                                const text = await res.text().catch(() => '');
-                                const err = new Error(`Anthropic API ${res.status}: ${text.slice(0, 200)}`);
-                                err.status = res.status;
-                                err.httpStatus = res.status;
-                                throw err;
-                            }
-                            if (!res.body) {
-                                throw new Error('Anthropic streaming response has no body');
-                            }
-                            return res;
-                        },
-                        {
-                            signal: totalSignal,
-                            perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-                            perAttemptLabel: 'Anthropic streaming response',
-                            onRetry: ({ attempt, lastErr, delayMs, delayReason }) => {
-                                const delayLabel = Number.isFinite(Number(delayMs))
-                                    ? `, delay ${delayMs}ms${delayReason ? ` (${delayReason})` : ''}`
-                                    : '';
-                                process.stderr.write(
-                                    `[anthropic] retry attempt ${attempt + 1} after ${lastErr?.message || lastErr?.code || 'transient error'}${delayLabel}\n`,
-                                );
-                            },
-                        },
-                    );
-
-                    try { onStageChange?.('streaming'); } catch {}
-
-                    firstByteTimeout = createTimeoutSignal(
-                        streamController.signal,
-                        PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-                        'Anthropic SSE first byte',
-                    );
-                    firstByteTimeout.signal.addEventListener('abort', () => {
-                        if (!midState.sawMessageStart) {
-                            try { streamController.abort(firstByteTimeout.signal.reason); } catch {}
-                        }
-                    }, { once: true });
-
-                    firstBytePoll = setInterval(() => {
-                        if (midState.sawMessageStart) {
-                            firstByteTimeout?.cleanup();
-                            clearInterval(firstBytePoll);
-                            firstBytePoll = null;
-                        }
-                    }, 25);
-
-                    const parseResult = await parseSSEStream(
-                        response,
-                        streamController.signal,
-                        () => streamController.abort(),
-                        onStreamDelta,
-                        onToolCall,
-                        midState,
-                    );
-
-                    if (firstBytePoll) {
-                        clearInterval(firstBytePoll);
-                        firstBytePoll = null;
-                    }
-                    firstByteTimeout?.cleanup();
-
-                    if (!midState.sawMessageStart
-                        && !midState.userAbort
-                        && !midState.watchdogAbort
-                        && !parseResult.content
-                        && !(parseResult.toolCalls && parseResult.toolCalls.length)
-                        && !(parseResult.usage && parseResult.usage.inputTokens > 0)) {
-                        const emptyErr = new Error(
-                            'Anthropic SSE stream produced no message_start (empty/dropped stream — likely transient or rate-limited)',
-                        );
-                        emptyErr.code = 'EEMPTYSTREAM';
-                        emptyErr.isEmptyStream = true;
-                        throw emptyErr;
-                    }
-
-                    return buildReturnFromParse(parseResult);
-                } catch (err) {
-                    if (err?.isEmptyStream && attemptIndex < MAX_MIDSTREAM_RETRIES) {
-                        firstAttemptError = err;
-                        firstAttemptClassifier = 'empty_stream';
-                        try { streamController.abort?.(err); } catch {}
-                        try {
-                            process.stderr.write(
-                                `[anthropic] empty stream (no message_start) — retry ${attemptIndex + 1}/${MAX_MIDSTREAM_RETRIES}\n`,
-                            );
-                        } catch {}
-                        continue;
-                    }
-                    if ((err?.truncatedStream === true || err?.code === 'TRUNCATED_STREAM')
-                        && classifyError(err) === 'transient'
-                        && !midState.emittedToolCall
-                        && attemptIndex < MAX_MIDSTREAM_RETRIES) {
-                        firstAttemptError = err;
-                        firstAttemptClassifier = 'truncated_stream';
-                        try { streamController.abort?.(err); } catch {}
-                        try {
-                            process.stderr.write(
-                                `[anthropic] truncated stream — retry ${attemptIndex + 1}/${MAX_MIDSTREAM_RETRIES}\n`,
-                            );
-                        } catch {}
-                        continue;
-                    }
-                    const classifier = _classifyMidstreamError(err, midState);
-                    if (classifier && attemptIndex < MAX_MIDSTREAM_RETRIES) {
-                        firstAttemptError = err;
-                        firstAttemptClassifier = classifier;
-                        try { streamController.abort?.(err); } catch {}
-                        try {
-                            process.stderr.write(
-                                `[anthropic] mid-stream recovered: retry ${attemptIndex + 1}/${MAX_MIDSTREAM_RETRIES} (cause: ${classifier})\n`,
-                            );
-                        } catch {}
-                        continue;
-                    }
-                    if (attemptIndex > 0 && firstAttemptError) {
-                        try { firstAttemptError.midstreamRetries = attemptIndex; } catch {}
-                        try { firstAttemptError.midstreamClassifier = firstAttemptClassifier; } catch {}
-                        throw firstAttemptError;
-                    }
-                    throw err;
-                } finally {
-                    if (firstBytePoll) clearInterval(firstBytePoll);
-                    firstByteTimeout?.cleanup();
-                    cleanupCancelHandler(cancelHandler);
-                }
-            }
-            throw firstAttemptError || new Error('Anthropic mid-stream retry: unreachable');
-        } finally {
-            totalTimeout.cleanup();
-        }
-    }
-    async listModels() {
-        return MODELS;
-    }
-    async isAvailable() {
-        try {
-            await this.client.messages.create({
-                model: 'claude-haiku-4-5-20251001',
-                max_tokens: 1,
-                messages: [{ role: 'user', content: 'hi' }],
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-}