mixdog 0.7.7 → 0.7.11

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

@@ -1,13 +1,15 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { loadConfig } from '../config.mjs';
 import { sanitizeToolPairs, sanitizeAnthropicContentPairs } from '../session/trim.mjs';
-import { withRetry } from './retry-classifier.mjs';
+import { classifyError, withRetry } from './retry-classifier.mjs';
 import { traceBridgeUsage } from '../bridge-trace.mjs';
 import {
     PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-    PROVIDER_GENERATE_TOTAL_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
@@ -327,96 +329,251 @@ export class AnthropicProvider {
             params.speed = 'fast';
             this.fastModeBetaHeaderLatched = true;
         }
-        const totalSignal = createTimeoutSignal(opts.signal || null, PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, 'Anthropic total');
         params.messages = sanitizeAnthropicContentPairs(params.messages);
-        // Wrap the SDK call in shared retry — surfaces "overloaded" / 5xx
-        // through populateHttpStatusFromMessage and retries up to 5 times
-        // with exponential backoff. The Anthropic SDK throws errors with
-        // .status set on HTTP responses; the classifier picks that up too.
-        let response;
-        try {
-            response = await withRetry(
-                ({ signal: attemptSignal }) => this.client.messages.create(params, {
-                    signal: attemptSignal,
-                    headers: {
-                        'anthropic-beta': buildAnthropicBetaHeaders({
-                            fastMode: this.fastModeBetaHeaderLatched,
-                        }),
-                    },
-                }),
-                {
-                    signal: totalSignal.signal,
-                    perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-                    perAttemptLabel: 'Anthropic first byte',
-                    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`);
-                    },
-                },
-            );
-        } finally {
-            totalSignal.cleanup();
-        }
-        const textBlock = response.content.find(b => b.type === 'text');
-        const toolCalls = parseToolCalls(response);
-        // Mirror anthropic-oauth SSE parser: classify the assistant turn by
-        // content-block presence so the orchestrator can distinguish a
-        // synthesis-stalled "thinking-only" turn (no text, no tool_use)
-        // from a silent empty response. Track block types and a quick
-        // hasThinkingContent flag from response.content directly since the
-        // non-streaming SDK call exposes the final block list.
-        let hasThinkingContent = false;
-        const contentBlockTypes = new Set();
-        for (const block of Array.isArray(response.content) ? response.content : []) {
-            if (block?.type) contentBlockTypes.add(block.type);
-            if (block?.type === 'thinking' || block?.type === 'redacted_thinking') {
-                hasThinkingContent = true;
+        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',
+                });
             }
-        }
-        const usageRaw = response.usage || null;
-        if (usageRaw) {
-            const input = usageRaw.input_tokens || 0;
-            const cacheRead = usageRaw.cache_read_input_tokens || 0;
-            const cacheWrite = usageRaw.cache_creation_input_tokens || 0;
-            traceBridgeUsage({
-                sessionId: opts.sessionId || opts.session?.id || null,
-                iteration: Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null,
-                inputTokens: input,
-                outputTokens: usageRaw.output_tokens || 0,
-                cachedTokens: cacheRead,
-                cacheWriteTokens: cacheWrite,
-                promptTokens: input + cacheRead + cacheWrite,
-                model: response.model,
-                modelDisplay: response.model,
-                responseId: response.id || null,
-                rawUsage: usageRaw,
-                provider: 'anthropic',
-            });
-        }
-        return {
-            content: textBlock?.type === 'text' ? textBlock.text : '',
-            model: response.model,
-            toolCalls,
-            stopReason: response.stop_reason || null,
-            hasThinkingContent,
-            contentBlockTypes: Array.from(contentBlockTypes),
-            usage: (() => {
-                const input = response.usage.input_tokens || 0;
-                const cacheRead = response.usage.cache_read_input_tokens || 0;
-                const cacheWrite = response.usage.cache_creation_input_tokens || 0;
-                return {
+
+            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: response.usage.output_tokens || 0,
+                    outputTokens: output,
                     cachedTokens: cacheRead,
                     cacheWriteTokens: cacheWrite,
-                    // Unified prompt volume — what the model actually ingested,
-                    // regardless of cache splitting. Anthropic reports input
-                    // uncached-only; sum the three billable slots so the
-                    // cross-provider `promptTokens` field has consistent meaning.
-                    promptTokens: input + cacheRead + 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;