condukt 0.25.0 → 0.27.0

package/dist/runtimes/claude/translate-chat.js

@@ -0,0 +1,857 @@
+"use strict";
+/**
+ * Anthropic ⇄ OpenAI chat/completions translation (reference-proxy parity).
+ *
+ * Pure, side-effect-free functions plus a streaming state machine. The
+ * bridge owns HTTP concerns; this module owns wire-shape semantics:
+ *
+ *   - anthropicToOpenAI:     Claude SDK request → chat/completions body
+ *   - applyChatExtras:       DeepSeek/GLM thinking+effort extras (in place)
+ *   - openAIToAnthropic:     non-streaming response → Anthropic message
+ *   - ChatStreamTranslator:  streaming chunks → Anthropic SSE frames
+ *   - estimateInputTokens:   pre-stream input estimate for message_start
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractThinkingType = exports.extractEffort = exports.ChatStreamTranslator = exports.NO_MULTIMODAL = void 0;
+exports.asObject = asObject;
+exports.anthropicToOpenAI = anthropicToOpenAI;
+exports.maxTokensFloorFor = maxTokensFloorFor;
+exports.applyChatExtras = applyChatExtras;
+exports.mapFinishReason = mapFinishReason;
+exports.openAIToAnthropic = openAIToAnthropic;
+exports.parseToolArgs = parseToolArgs;
+exports.estimateInputTokens = estimateInputTokens;
+const node_crypto_1 = require("node:crypto");
+const bridge_cache_1 = require("./bridge-cache");
+const protocol_router_1 = require("./protocol-router");
+Object.defineProperty(exports, "extractEffort", { enumerable: true, get: function () { return protocol_router_1.extractEffort; } });
+Object.defineProperty(exports, "extractThinkingType", { enumerable: true, get: function () { return protocol_router_1.extractThinkingType; } });
+const sse_1 = require("./sse");
+// ── Media support (reference parity) ─────────────────────────────────
+const IMAGE_FORMATS = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/gif']);
+const DOCUMENT_FORMATS = new Set([
+    'application/pdf',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+]);
+const TEXT_FORMATS = new Set([
+    'text/plain',
+    'text/csv',
+    'text/html',
+    'text/markdown',
+    'application/json',
+    'text/xml',
+]);
+/** Chat models that only accept string content (media dropped with warning). */
+exports.NO_MULTIMODAL = new Set();
+function dataUrl(mediaType, data) {
+    return `data:${mediaType};base64,${data}`;
+}
+/** Convert an Anthropic image/document block to a chat-compatible block. */
+function convertMediaBlock(block) {
+    const source = (block['source'] ?? {});
+    const mt = String(source['media_type'] ?? '').toLowerCase();
+    const sourceType = String(source['type'] ?? '');
+    const isUrl = sourceType === 'url';
+    const data = typeof source['data'] === 'string' ? source['data'] : '';
+    const url = typeof source['url'] === 'string' ? source['url'] : '';
+    if (IMAGE_FORMATS.has(mt)) {
+        const imageUrl = isUrl ? url : data ? dataUrl(mt, data) : '';
+        if (!imageUrl)
+            return null;
+        return { type: 'image_url', image_url: { url: imageUrl } };
+    }
+    if (TEXT_FORMATS.has(mt)) {
+        if (!isUrl && data) {
+            try {
+                return { type: 'text', text: Buffer.from(data, 'base64').toString('utf8') };
+            }
+            catch {
+                return null;
+            }
+        }
+        if (isUrl && url)
+            return { type: 'text', text: url };
+        return null;
+    }
+    if (DOCUMENT_FORMATS.has(mt)) {
+        const filename = mt === 'application/pdf'
+            ? 'document.pdf'
+            : mt === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+                ? 'document.docx'
+                : 'document.xlsx';
+        const fileData = isUrl ? url : data ? dataUrl(mt, data) : '';
+        if (!fileData)
+            return null;
+        return { type: 'file', file: { filename, file_data: fileData } };
+    }
+    return null;
+}
+function isMediaBlock(block) {
+    const t = block['type'];
+    return t === 'image' || t === 'document';
+}
+function extractToolResultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((c) => {
+            if (typeof c === 'string')
+                return c;
+            const x = (c ?? {});
+            if (typeof x['text'] === 'string')
+                return x['text'];
+            if (typeof x['content'] === 'string')
+                return x['content'];
+            try {
+                return JSON.stringify(c);
+            }
+            catch {
+                return String(c);
+            }
+        })
+            .join('\n');
+    }
+    if (content && typeof content === 'object') {
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return String(content);
+        }
+    }
+    return '';
+}
+// ── Shape narrowing ──────────────────────────────────────────────────
+/**
+ * Narrow an untrusted JSON value to an indexable object. Upstream bodies and
+ * Anthropic requests are both untrusted, so every nested read goes through a
+ * check like this rather than an `any` cast.
+ */
+function asObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+/**
+ * Convert an Anthropic messages body to an OpenAI chat/completions body.
+ * Ported 1:1 from the reference proxy (system media, thinking replay,
+ * tool ordering, tool_choice, thinking budget → max_completion_tokens).
+ */
+function anthropicToOpenAI(body, model, opts = {}) {
+    const noMulti = opts.noMultimodal ?? exports.NO_MULTIMODAL;
+    const thinking = (0, protocol_router_1.thinkingEnabled)(body);
+    const messages = [];
+    // System prompt.
+    const system = body['system'] ?? '';
+    if (typeof system === 'string') {
+        if (system)
+            messages.push({ role: 'system', content: system });
+    }
+    else if (Array.isArray(system)) {
+        const sysBlocks = [];
+        for (const block of system) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const b = block;
+            const btype = b['type'];
+            if (btype === 'text') {
+                sysBlocks.push({ type: 'text', text: b['text'] ?? '' });
+            }
+            else if (isMediaBlock(b)) {
+                const converted = convertMediaBlock(b);
+                if (converted)
+                    sysBlocks.push(converted);
+            }
+        }
+        if (sysBlocks.length > 0) {
+            const hasMedia = sysBlocks.some((b) => b['type'] !== 'text');
+            if (hasMedia && !noMulti.has(model)) {
+                messages.push({ role: 'system', content: sysBlocks });
+            }
+            else {
+                const texts = sysBlocks.filter((b) => b['type'] === 'text').map((b) => String(b['text'] ?? ''));
+                messages.push({ role: 'system', content: texts.join('\n') });
+            }
+        }
+    }
+    const rawMessages = Array.isArray(body['messages']) ? body['messages'] : [];
+    for (let mi = 0; mi < rawMessages.length; mi += 1) {
+        const msg = rawMessages[mi];
+        if (!msg || typeof msg !== 'object')
+            continue;
+        const role = String(msg['role'] ?? 'user');
+        const isAssistant = role === 'assistant';
+        const content = msg['content'] ?? '';
+        if (typeof content === 'string') {
+            const out = { role, content };
+            if (thinking && isAssistant)
+                out['reasoning_content'] = ' ';
+            messages.push(out);
+            continue;
+        }
+        if (!Array.isArray(content))
+            continue;
+        const textParts = [];
+        const contentBlocks = [];
+        const toolCalls = [];
+        const thinkingParts = [];
+        const toolResults = [];
+        let hasMedia = false;
+        for (const block of content) {
+            if (typeof block === 'string') {
+                textParts.push(block);
+                contentBlocks.push({ type: 'text', text: block });
+                continue;
+            }
+            if (!block || typeof block !== 'object')
+                continue;
+            const b = block;
+            const btype = b['type'];
+            if (btype === 'text') {
+                const t = String(b['text'] ?? '');
+                textParts.push(t);
+                contentBlocks.push({ type: 'text', text: t });
+            }
+            else if (isMediaBlock(b)) {
+                const converted = convertMediaBlock(b);
+                if (converted) {
+                    hasMedia = true;
+                    contentBlocks.push(converted);
+                }
+            }
+            else if (btype === 'thinking') {
+                thinkingParts.push(String(b['thinking'] ?? ''));
+            }
+            else if (btype === 'tool_use') {
+                toolCalls.push({
+                    id: (0, bridge_cache_1.normalizeToolCallId)(b['id'], String(b['name'] ?? ''), `${mi}.${toolCalls.length}`, b['input'] ?? {}),
+                    type: 'function',
+                    function: {
+                        name: b['name'] ?? '',
+                        arguments: (0, bridge_cache_1.stableJson)(b['input'] ?? {}),
+                    },
+                });
+            }
+            else if (btype === 'tool_result') {
+                toolResults.push({
+                    role: 'tool',
+                    tool_call_id: b['tool_use_id'] ?? '',
+                    content: extractToolResultText(b['content']),
+                });
+            }
+        }
+        // Tool results must immediately follow the assistant tool_calls they
+        // answer — emit them before this message's own content.
+        messages.push(...toolResults);
+        const joinedThinking = thinkingParts.join('\n');
+        const forceString = noMulti.has(model);
+        if (toolCalls.length > 0) {
+            // Keep any assistant text that accompanied the calls: dropping it loses
+            // the model's preamble ("I'll check the file"), and OpenAI-compatible
+            // upstreams accept a string content alongside `tool_calls`.
+            const out = {
+                role,
+                content: textParts.length > 0 ? textParts.join('\n') : null,
+                tool_calls: toolCalls,
+            };
+            if (joinedThinking)
+                out['reasoning_content'] = joinedThinking;
+            else if (thinking && isAssistant)
+                out['reasoning_content'] = ' ';
+            messages.push(out);
+        }
+        else if (hasMedia && !forceString) {
+            const out = { role, content: contentBlocks };
+            if (joinedThinking)
+                out['reasoning_content'] = joinedThinking;
+            else if (thinking && isAssistant)
+                out['reasoning_content'] = ' ';
+            messages.push(out);
+        }
+        else if (textParts.length > 0 || thinkingParts.length > 0 || (thinking && isAssistant) || hasMedia) {
+            const out = { role, content: textParts.length > 0 ? textParts.join('\n') : '' };
+            if (joinedThinking)
+                out['reasoning_content'] = joinedThinking;
+            else if (thinking && isAssistant)
+                out['reasoning_content'] = ' ';
+            messages.push(out);
+        }
+    }
+    const oai = {
+        model,
+        messages,
+        max_tokens: body['max_tokens'] ?? 16384,
+        stream: body['stream'] ?? false,
+    };
+    const thinkingCfg = asObject(body['thinking']);
+    // Only reasoning families (deepseek/glm) accept max_completion_tokens;
+    // non-reasoning chat models reject the field when max_tokens is also set.
+    if (thinking && thinkingCfg?.['budget_tokens'] && (0, protocol_router_1.chatFamilyOf)(model) !== null) {
+        oai['max_completion_tokens'] = thinkingCfg['budget_tokens'];
+    }
+    for (const [key, oaiKey] of [
+        ['temperature', 'temperature'],
+        ['top_p', 'top_p'],
+        ['stop_sequences', 'stop'],
+    ]) {
+        if (key in body)
+            oai[oaiKey] = body[key];
+    }
+    if (Array.isArray(body['tools'])) {
+        oai['tools'] = body['tools']
+            .map((t) => asObject(t))
+            .filter((t) => t !== null && typeof t['name'] === 'string' && t['name'] !== '')
+            .map((t) => ({
+            type: 'function',
+            function: {
+                name: t['name'],
+                description: t['description'] ?? '',
+                parameters: t['input_schema'] ?? {},
+            },
+        }));
+        const tc = body['tool_choice'] ?? 'auto';
+        const tcObj = asObject(tc);
+        if (tcObj !== null) {
+            const tcType = tcObj['type'] ?? 'auto';
+            if (tcType === 'tool') {
+                oai['tool_choice'] = { type: 'function', function: { name: tcObj['name'] ?? '' } };
+            }
+            else if (tcType === 'any') {
+                oai['tool_choice'] = 'required';
+            }
+            else {
+                oai['tool_choice'] = 'auto';
+            }
+        }
+        else {
+            oai['tool_choice'] = tc;
+        }
+    }
+    return oai;
+}
+// ── Chat reasoning extras (DeepSeek / GLM) ───────────────────────────
+const MAX_TOKENS_FLOOR = {
+    low: 16384,
+    high: 65536,
+    max: 131072,
+};
+function maxTokensFloorFor(effort) {
+    return MAX_TOKENS_FLOOR[effort ?? 'low'] ?? 16384;
+}
+function sanitizeUserId(session) {
+    const s = String(session ?? '');
+    if (!s)
+        return 'default';
+    return (0, node_crypto_1.createHash)('sha256').update(s, 'utf8').digest('hex').slice(0, 32);
+}
+/**
+ * Family-gated chat extras, in place (reference parity).
+ *
+ * Emits thinking + reasoning_effort + user_id for deepseek-/glm- families
+ * only; sets top_p 0.95 default (DeepSeek, client wins); floors max_tokens
+ * by sent effort (never lowers); rejects required/named tool_choice with
+ * thinking on (upstream 400s). Returns the wire truth for telemetry.
+ */
+function applyChatExtras(oaiBody, modelId, session, clientEffort = null, clientThinking = null) {
+    const fam = (0, protocol_router_1.chatFamilyOf)(modelId);
+    if (!fam)
+        return { effortSent: null, thinkingSent: null };
+    const wireEffort = (0, protocol_router_1.mapChatEffort)(modelId, clientEffort);
+    let wireThinking = (0, protocol_router_1.mapChatThinking)(modelId, clientThinking);
+    // GLM always-on; DeepSeek defaults enabled when unset.
+    if (fam === 'glm')
+        wireThinking = 'enabled';
+    else if (fam === 'deepseek' && wireThinking === null && (clientThinking === null || clientThinking === '' || clientThinking === 'none')) {
+        wireThinking = 'enabled';
+    }
+    // Explicit-off shapes: DeepSeek disable drops effort; GLM cannot
+    // disable (thinking stays on; a client 'none' effort just omits it).
+    let effortSent = wireEffort;
+    if (clientEffort === 'none' || clientThinking === 'disabled') {
+        if (fam === 'deepseek') {
+            wireThinking = 'disabled';
+            effortSent = null;
+        }
+    }
+    if (wireThinking !== null)
+        oaiBody['thinking'] = { type: wireThinking };
+    if (effortSent !== null)
+        oaiBody['reasoning_effort'] = effortSent;
+    try {
+        oaiBody['user_id'] = sanitizeUserId(session);
+    }
+    catch {
+        /* ignore */
+    }
+    if (fam === 'deepseek' && !('top_p' in oaiBody))
+        oaiBody['top_p'] = 0.95;
+    // max_tokens floors by SENT effort (raise only; never coerce odd shapes).
+    try {
+        const floor = maxTokensFloorFor(effortSent ?? 'low');
+        const cur = oaiBody['max_tokens'];
+        if (cur === undefined || cur === null) {
+            oaiBody['max_tokens'] = floor;
+        }
+        else if (typeof cur === 'number' && Number.isInteger(cur) && cur < floor) {
+            oaiBody['max_tokens'] = floor;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    // Tool-choice guard: required/named + thinking on → upstream 400.
+    try {
+        const tc = oaiBody['tool_choice'];
+        const thinkingOn = wireThinking === 'enabled';
+        if (thinkingOn && tc !== undefined && tc !== null) {
+            let bad = false;
+            if (tc && typeof tc === 'object') {
+                const t = tc['type'];
+                if (t === 'required')
+                    bad = true;
+                if (t === 'function') {
+                    const fn = tc['function'];
+                    if (fn && typeof fn === 'object' && typeof fn.name === 'string')
+                        bad = true;
+                }
+            }
+            else if (tc === 'required') {
+                bad = true;
+            }
+            if (bad) {
+                throw new Error(`model ${modelId} rejects required/named tool_choice with thinking on (upstream 400); ` +
+                    'use auto/none or disable thinking');
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.includes('rejects required/named'))
+            throw e;
+        // Shape errors are ignored (defensive total function).
+    }
+    return { effortSent, thinkingSent: wireThinking };
+}
+// ── Response translation (non-streaming) ─────────────────────────────
+const FINISH_TO_STOP = {
+    stop: 'end_turn',
+    length: 'max_tokens',
+    tool_calls: 'tool_use',
+    content_filter: 'content_filter',
+};
+function mapFinishReason(finish) {
+    return FINISH_TO_STOP[String(finish ?? '')] ?? 'end_turn';
+}
+function oaiUsageToAnthropic(usage) {
+    const u = (usage && typeof usage === 'object' ? usage : {});
+    const input = Number(u['prompt_tokens'] ?? u['input_tokens'] ?? 0) || 0;
+    const output = (0, bridge_cache_1.getOutputTokens)(u);
+    return (0, bridge_cache_1.withReasoningSplit)({
+        input_tokens: input,
+        output_tokens: output,
+        cache_creation_input_tokens: (0, bridge_cache_1.extractCacheCreationTokens)(u),
+        cache_read_input_tokens: (0, bridge_cache_1.extractCacheReadTokens)(u),
+    }, u);
+}
+/**
+ * Convert a non-streaming chat/completions response to an Anthropic
+ * message. Loud on malformed tool-call arguments.
+ */
+function openAIToAnthropic(resp, requested, messageId) {
+    if (!resp || typeof resp !== 'object') {
+        throw new Error('upstream returned a malformed response envelope');
+    }
+    const choices = resp['choices'];
+    const choice = Array.isArray(choices) && choices.length > 0 && choices[0] && typeof choices[0] === 'object' ? choices[0] : {};
+    const msg = choice['message'] && typeof choice['message'] === 'object' ? choice['message'] : {};
+    const usage = resp['usage'] && typeof resp['usage'] === 'object' ? resp['usage'] : {};
+    const blocks = [];
+    const reasoning = msg['reasoning_content'];
+    if (typeof reasoning === 'string' && reasoning) {
+        blocks.push({ type: 'thinking', thinking: reasoning });
+    }
+    const content = msg['content'];
+    if (content) {
+        const text = typeof content === 'string'
+            ? content
+            : Array.isArray(content)
+                ? content.map((p) => String(asObject(p)?.['text'] ?? '')).join('')
+                : '';
+        if (text)
+            blocks.push({ type: 'text', text });
+    }
+    const toolCalls = Array.isArray(msg['tool_calls']) ? msg['tool_calls'] : [];
+    for (let ti = 0; ti < toolCalls.length; ti += 1) {
+        const tc = toolCalls[ti];
+        if (!tc || typeof tc !== 'object') {
+            throw new Error('upstream returned invalid function-call arguments');
+        }
+        const fn = tc['function'] && typeof tc['function'] === 'object' ? tc['function'] : {};
+        let input;
+        try {
+            input = parseToolArgs(String(fn['arguments'] ?? '{}'));
+        }
+        catch {
+            throw new Error('upstream returned invalid function-call arguments');
+        }
+        blocks.push({
+            type: 'tool_use',
+            id: (0, bridge_cache_1.normalizeToolCallId)(tc['id'], String(fn['name'] ?? ''), ti, input),
+            name: fn['name'] ?? '',
+            input,
+        });
+    }
+    if (blocks.length === 0)
+        blocks.push({ type: 'text', text: '' });
+    let stop = mapFinishReason(choice['finish_reason']);
+    if (toolCalls.length > 0)
+        stop = 'tool_use';
+    return {
+        id: messageId ?? `msg_${Math.random().toString(16).slice(2, 26)}`,
+        type: 'message',
+        role: 'assistant',
+        content: blocks,
+        model: requested,
+        stop_reason: stop,
+        stop_sequence: null,
+        usage: oaiUsageToAnthropic(usage),
+    };
+}
+function parseToolArgs(raw) {
+    if (!raw || !raw.trim())
+        return {};
+    const obj = JSON.parse(raw);
+    if (Array.isArray(obj)) {
+        // Some servers stream bare arrays for a single positional argument;
+        // fail loudly rather than silently reshaping (reference parity).
+        throw new Error('upstream function-call arguments are not a JSON object');
+    }
+    if (!obj || typeof obj !== 'object') {
+        throw new Error('upstream function-call arguments are not a JSON object');
+    }
+    return obj;
+}
+function countInvalidToolArgs(toolBlocks) {
+    let bad = 0;
+    for (const b of toolBlocks) {
+        try {
+            parseToolArgs(b.args);
+        }
+        catch {
+            bad += 1;
+        }
+    }
+    return bad;
+}
+class ChatStreamTranslator {
+    requestedModel;
+    estimatedInput;
+    messageId;
+    reader = (0, sse_1.createLineReader)();
+    started = false;
+    textBlockIdx = null;
+    reasoningBlockIdx = null;
+    nextBlockIdx = 0;
+    openBlocks = new Set();
+    toolBlocks = new Map();
+    finishReason = null;
+    usage = null;
+    stopped = false;
+    onFinalUsage;
+    constructor(opts) {
+        this.requestedModel = opts.requestedModel;
+        this.estimatedInput = opts.estimatedInput ?? 0;
+        this.messageId = opts.messageId ?? `msg_${Math.random().toString(16).slice(2, 26)}`;
+        this.onFinalUsage = opts.onFinalUsage;
+    }
+    get messageStarted() {
+        return this.started;
+    }
+    get isStopped() {
+        return this.stopped;
+    }
+    /** Feed decoded upstream bytes; returns Anthropic SSE frames to forward. */
+    push(text) {
+        if (this.stopped)
+            return [];
+        return this.consume(this.reader.push(text));
+    }
+    /**
+     * Parse complete SSE lines into Anthropic frames. `finish()` also
+     * drains the reader's unterminated trailing line, so a usage-only
+     * event at EOF (no final newline) still reaches `onFinalUsage`.
+     */
+    consume(lines) {
+        const frames = [];
+        for (const line of lines) {
+            const data = (0, sse_1.parseDataLine)(line);
+            if (!data)
+                continue;
+            let chunk;
+            try {
+                chunk = JSON.parse(data);
+            }
+            catch {
+                continue;
+            }
+            frames.push(...this.handleChunk(chunk));
+        }
+        return frames;
+    }
+    /** Upstream ended ([DONE] or EOF): emit closing frames. */
+    finish() {
+        if (this.stopped)
+            return [];
+        const frames = this.consume(this.reader.flush());
+        this.stopped = true;
+        if (!this.started) {
+            frames.push(...this.startMessage());
+        }
+        for (const idx of [...this.openBlocks]) {
+            frames.push((0, sse_1.sseFrame)('content_block_stop', { type: 'content_block_stop', index: idx }));
+        }
+        this.openBlocks.clear();
+        const hasTools = this.toolBlocks.size > 0;
+        let stop = mapFinishReason(this.finishReason);
+        if (hasTools) {
+            if (this.finishReason === 'length' && countInvalidToolArgs(this.toolBlocks.values()) > 0) {
+                const bad = countInvalidToolArgs(this.toolBlocks.values());
+                const msg = `upstream cut off ${bad} tool call(s) mid-arguments (length): ` +
+                    'raise max_tokens or shorten context';
+                frames.push((0, sse_1.sseFrame)('error', { type: 'error', error: { type: 'api_error', message: msg } }));
+                return frames; // reference: error close breaks the stream (no delta/stop)
+            }
+            stop = 'tool_use';
+        }
+        frames.push(...this.terminalFrames(stop));
+        return frames;
+    }
+    /** Transport/upstream failure: emit the reference error close. */
+    fail(message) {
+        if (this.stopped)
+            return [];
+        this.stopped = true;
+        const frames = [];
+        const payload = { type: 'error', error: { type: 'api_error', message } };
+        if (!this.started) {
+            frames.push((0, sse_1.sseFrame)('error', payload));
+            return frames;
+        }
+        for (const idx of [...this.openBlocks]) {
+            frames.push((0, sse_1.sseFrame)('content_block_stop', { type: 'content_block_stop', index: idx }));
+        }
+        this.openBlocks.clear();
+        frames.push((0, sse_1.sseFrame)('message_delta', {
+            type: 'message_delta',
+            delta: { stop_reason: 'error' },
+            usage: { output_tokens: this.finalOutputTokens() },
+        }));
+        frames.push((0, sse_1.sseFrame)('message_stop', { type: 'message_stop' }));
+        return frames;
+    }
+    // ── internals ──────────────────────────────────────────────────────
+    handleChunk(chunk) {
+        const frames = [];
+        const u = chunk['usage'];
+        if (u && typeof u === 'object') {
+            this.usage = { ...(this.usage ?? {}), ...u };
+        }
+        const choices = chunk['choices'];
+        if (!Array.isArray(choices) || choices.length === 0)
+            return frames;
+        const choice = choices[0] && typeof choices[0] === 'object' ? choices[0] : {};
+        if (choice['finish_reason'])
+            this.finishReason = String(choice['finish_reason']);
+        const delta = choice['delta'] && typeof choice['delta'] === 'object' ? choice['delta'] : {};
+        if (!this.started) {
+            frames.push(...this.startMessage());
+        }
+        // Text.
+        let text = '';
+        const c = delta['content'];
+        if (typeof c === 'string')
+            text = c;
+        else if (Array.isArray(c)) {
+            text = c.map((p) => String(asObject(p)?.['text'] ?? '')).join('');
+        }
+        if (text) {
+            if (this.textBlockIdx === null) {
+                this.textBlockIdx = this.nextBlockIdx++;
+                this.openBlocks.add(this.textBlockIdx);
+                frames.push((0, sse_1.sseFrame)('content_block_start', {
+                    type: 'content_block_start',
+                    index: this.textBlockIdx,
+                    content_block: { type: 'text', text: '' },
+                }));
+            }
+            frames.push((0, sse_1.sseFrame)('content_block_delta', {
+                type: 'content_block_delta',
+                index: this.textBlockIdx,
+                delta: { type: 'text_delta', text },
+            }));
+        }
+        // Reasoning.
+        const reasoning = delta['reasoning_content'];
+        if (typeof reasoning === 'string' && reasoning) {
+            if (this.reasoningBlockIdx === null) {
+                this.reasoningBlockIdx = this.nextBlockIdx++;
+                this.openBlocks.add(this.reasoningBlockIdx);
+                frames.push((0, sse_1.sseFrame)('content_block_start', {
+                    type: 'content_block_start',
+                    index: this.reasoningBlockIdx,
+                    content_block: { type: 'thinking', thinking: '' },
+                }));
+            }
+            frames.push((0, sse_1.sseFrame)('content_block_delta', {
+                type: 'content_block_delta',
+                index: this.reasoningBlockIdx,
+                delta: { type: 'thinking_delta', thinking: reasoning },
+            }));
+        }
+        // Tool calls.
+        const toolCalls = delta['tool_calls'];
+        if (Array.isArray(toolCalls)) {
+            for (const tc of toolCalls) {
+                if (!tc || typeof tc !== 'object')
+                    continue;
+                const apiIdx = typeof tc['index'] === 'number' ? tc['index'] : 0;
+                const fn = tc['function'] && typeof tc['function'] === 'object' ? tc['function'] : {};
+                let state = this.toolBlocks.get(apiIdx);
+                if (!state) {
+                    const blockIdx = this.nextBlockIdx++;
+                    const providedId = typeof tc['id'] === 'string' && tc['id'] ? tc['id'] : undefined;
+                    const name = typeof fn['name'] === 'string' ? fn['name'] : '';
+                    const id = providedId ?? `toolu_${(0, bridge_cache_1.normalizeToolCallId)(undefined, name || 'tool', apiIdx, '').slice(7)}`;
+                    state = { blockIdx, id, name, args: '' };
+                    this.toolBlocks.set(apiIdx, state);
+                    this.openBlocks.add(blockIdx);
+                    frames.push((0, sse_1.sseFrame)('content_block_start', {
+                        type: 'content_block_start',
+                        index: blockIdx,
+                        content_block: { type: 'tool_use', id, name, input: {} },
+                    }));
+                }
+                if (typeof fn['name'] === 'string' && fn['name'] && !state.name)
+                    state.name = fn['name'];
+                if (typeof fn['arguments'] === 'string' && fn['arguments']) {
+                    state.args += fn['arguments'];
+                    frames.push((0, sse_1.sseFrame)('content_block_delta', {
+                        type: 'content_block_delta',
+                        index: state.blockIdx,
+                        delta: { type: 'input_json_delta', partial_json: fn['arguments'] },
+                    }));
+                }
+            }
+        }
+        return frames;
+    }
+    startMessage() {
+        this.started = true;
+        return [
+            (0, sse_1.sseFrame)('message_start', {
+                type: 'message_start',
+                message: {
+                    id: this.messageId,
+                    type: 'message',
+                    role: 'assistant',
+                    content: [],
+                    model: this.requestedModel,
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: {
+                        input_tokens: this.estimatedInput,
+                        output_tokens: 0,
+                        cache_creation_input_tokens: 0,
+                        cache_read_input_tokens: 0,
+                    },
+                },
+            }),
+        ];
+    }
+    finalOutputTokens() {
+        if (this.usage) {
+            const n = this.usage['completion_tokens'] ?? this.usage['output_tokens'];
+            if (typeof n === 'number' && Number.isFinite(n))
+                return n;
+        }
+        return 0;
+    }
+    terminalFrames(stop) {
+        try {
+            this.onFinalUsage?.((0, bridge_cache_1.upstreamUsageFromOpenAI)(this.usage));
+        }
+        catch {
+            /* observability only: never fail the stream on a usage callback */
+        }
+        const u = this.usage ?? {};
+        const finalIn = Number(u['prompt_tokens'] ?? u['input_tokens'] ?? this.estimatedInput) || this.estimatedInput;
+        const finalOut = this.finalOutputTokens();
+        // Report reads and writes under their own Anthropic fields. Folding the
+        // write count into `cache_read_input_tokens` (as the reference does) makes
+        // an assistant client see cache hits that never happened.
+        const usage = (0, bridge_cache_1.withReasoningSplit)({
+            output_tokens: finalOut,
+            input_tokens: finalIn,
+            cache_read_input_tokens: (0, bridge_cache_1.extractCacheReadTokens)(u),
+            cache_creation_input_tokens: (0, bridge_cache_1.extractCacheCreationTokens)(u),
+        }, u);
+        return [
+            (0, sse_1.sseFrame)('message_delta', { type: 'message_delta', delta: { stop_reason: stop }, usage }),
+            (0, sse_1.sseFrame)('message_stop', { type: 'message_stop' }),
+        ];
+    }
+}
+exports.ChatStreamTranslator = ChatStreamTranslator;
+// ── Input estimation ─────────────────────────────────────────────────
+/** Rough pre-stream input estimate (reference `_estimate_input_tokens`). */
+function estimateInputTokens(body) {
+    const chunks = [];
+    const system = body?.['system'] ?? '';
+    if (typeof system === 'string')
+        chunks.push(system);
+    else if (Array.isArray(system)) {
+        for (const s of system) {
+            if (typeof s === 'string')
+                chunks.push(s);
+            else if (s && typeof s === 'object') {
+                const src = (s['source'] ?? {});
+                chunks.push(String(src['data'] ?? src['url'] ?? s['text'] ?? ''));
+            }
+        }
+    }
+    for (const t of Array.isArray(body?.['tools']) ? body['tools'] : []) {
+        if (!t || typeof t !== 'object')
+            continue;
+        chunks.push(String(t['name'] ?? ''), String(t['description'] ?? ''), (0, bridge_cache_1.stableJson)(t['input_schema'] ?? {}));
+    }
+    for (const msg of Array.isArray(body?.['messages']) ? body['messages'] : []) {
+        const content = msg?.['content'] ?? '';
+        if (typeof content === 'string')
+            chunks.push(content);
+        else if (Array.isArray(content)) {
+            for (const block of content) {
+                if (typeof block === 'string')
+                    chunks.push(block);
+                else if (block && typeof block === 'object') {
+                    const btype = block['type'];
+                    if (btype === 'tool_result')
+                        chunks.push(extractToolResultText(block['content']));
+                    else if (btype === 'thinking')
+                        chunks.push(String(block['thinking'] ?? ''));
+                    else if (btype === 'image' || btype === 'document') {
+                        const src = (block['source'] ?? {});
+                        chunks.push(String(src['data'] ?? src['url'] ?? ''));
+                    }
+                    else {
+                        chunks.push(String(block['text'] ?? ''));
+                        chunks.push((0, bridge_cache_1.stableJson)(block['input'] ?? ''));
+                    }
+                }
+            }
+        }
+    }
+    const combined = chunks.join('\n');
+    return Math.max(1, Math.floor(combined.length / 3));
+}
+//# sourceMappingURL=translate-chat.js.map