@jonnyhoo/ccs 1.1.0 → 1.1.1

package/dist/cliproxy/anthropic-to-openai-proxy.js

@@ -0,0 +1,856 @@
+"use strict";
+/**
+ * Anthropic-to-OpenAI Protocol Translation Proxy
+ *
+ * Translates Claude CLI's Anthropic Messages API requests into OpenAI Chat Completions API format.
+ * Used in direct API key mode to bypass CLIProxy entirely.
+ *
+ * Request flow:
+ *   Claude CLI (Anthropic format) → this proxy → OpenAI-compatible endpoint
+ *
+ * Response flow:
+ *   OpenAI-compatible endpoint → this proxy (translates SSE) → Claude CLI (Anthropic format)
+ *
+ * Handles:
+ *   - Path rewriting: /v1/messages → /v1/chat/completions
+ *   - Auth translation: x-api-key → Authorization: Bearer
+ *   - Request body: Anthropic messages/tools/system → OpenAI format
+ *   - Streaming response: OpenAI SSE chunks → Anthropic SSE events
+ *   - Non-streaming response: OpenAI completion → Anthropic message
+ *   - Tool calls and tool results
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicToOpenAIProxy = void 0;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const url_1 = require("url");
+// ─── Request Translation ─────────────────────────────────────────────────────
+function translateSystemPrompt(system) {
+    if (!system)
+        return '';
+    if (typeof system === 'string')
+        return system;
+    // Array of content blocks - extract text
+    return system
+        .filter((b) => b.type === 'text' && b.text)
+        .map((b) => b.text)
+        .join('\n');
+}
+function translateMessages(messages) {
+    const result = [];
+    for (const msg of messages) {
+        if (typeof msg.content === 'string') {
+            result.push({ role: msg.role, content: msg.content });
+            continue;
+        }
+        if (!Array.isArray(msg.content)) {
+            result.push({ role: msg.role, content: String(msg.content ?? '') });
+            continue;
+        }
+        // Process content blocks
+        if (msg.role === 'assistant') {
+            // Assistant message may contain text + tool_use blocks
+            const textParts = [];
+            const toolCalls = [];
+            for (const block of msg.content) {
+                if (block.type === 'text' && block.text) {
+                    textParts.push(block.text);
+                }
+                else if (block.type === 'tool_use') {
+                    toolCalls.push({
+                        id: block.id || `call_${Math.random().toString(36).slice(2, 10)}`,
+                        type: 'function',
+                        function: {
+                            name: block.name || '',
+                            arguments: typeof block.input === 'string' ? block.input : JSON.stringify(block.input ?? {}),
+                        },
+                    });
+                }
+            }
+            const openaiMsg = {
+                role: 'assistant',
+                content: textParts.length > 0 ? textParts.join('') : null,
+            };
+            if (toolCalls.length > 0) {
+                openaiMsg.tool_calls = toolCalls;
+            }
+            result.push(openaiMsg);
+        }
+        else if (msg.role === 'user') {
+            // User message may contain text, images, or tool_result blocks
+            // Split tool_results into separate OpenAI tool messages
+            const textParts = [];
+            for (const block of msg.content) {
+                if (block.type === 'text' && block.text) {
+                    textParts.push(block.text);
+                }
+                else if (block.type === 'tool_result') {
+                    // Tool results become separate messages with role: "tool"
+                    let toolContent = '';
+                    if (typeof block.content === 'string') {
+                        toolContent = block.content;
+                    }
+                    else if (Array.isArray(block.content)) {
+                        toolContent = block.content
+                            .filter((b) => b.type === 'text' && b.text)
+                            .map((b) => b.text)
+                            .join('\n');
+                    }
+                    result.push({
+                        role: 'tool',
+                        content: toolContent,
+                        tool_call_id: block.tool_use_id || '',
+                    });
+                }
+                // Skip image/document blocks for now (not supported by most Chat Completions endpoints)
+            }
+            if (textParts.length > 0) {
+                result.push({ role: 'user', content: textParts.join('') });
+            }
+        }
+        else {
+            // Other roles - just concatenate text
+            const text = msg.content
+                .filter((b) => b.type === 'text' && b.text)
+                .map((b) => b.text)
+                .join('');
+            result.push({ role: msg.role, content: text || '' });
+        }
+    }
+    return result;
+}
+function translateTools(tools) {
+    return tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema,
+        },
+    }));
+}
+function translateToolChoice(choice) {
+    switch (choice.type) {
+        case 'auto':
+            return 'auto';
+        case 'any':
+            return 'required';
+        case 'tool':
+            return { type: 'function', function: { name: choice.name || '' } };
+        case 'none':
+            return 'none';
+        default:
+            return 'auto';
+    }
+}
+function translateRequestChat(anthropicReq) {
+    const messages = [];
+    // Add system message if present
+    const systemText = translateSystemPrompt(anthropicReq.system);
+    if (systemText) {
+        messages.push({ role: 'system', content: systemText });
+    }
+    // Translate conversation messages
+    if (anthropicReq.messages) {
+        messages.push(...translateMessages(anthropicReq.messages));
+    }
+    const openaiReq = {
+        model: anthropicReq.model,
+        messages,
+        stream: anthropicReq.stream,
+    };
+    if (anthropicReq.max_tokens !== undefined) {
+        openaiReq.max_tokens = anthropicReq.max_tokens;
+    }
+    if (anthropicReq.temperature !== undefined) {
+        openaiReq.temperature = anthropicReq.temperature;
+    }
+    if (anthropicReq.top_p !== undefined) {
+        openaiReq.top_p = anthropicReq.top_p;
+    }
+    if (anthropicReq.stop_sequences) {
+        openaiReq.stop = anthropicReq.stop_sequences;
+    }
+    if (anthropicReq.tools && anthropicReq.tools.length > 0) {
+        openaiReq.tools = translateTools(anthropicReq.tools);
+    }
+    if (anthropicReq.tool_choice) {
+        openaiReq.tool_choice = translateToolChoice(anthropicReq.tool_choice);
+    }
+    // Pass through reasoning effort (already in OpenAI format from CodexReasoningProxy)
+    if (anthropicReq.reasoning) {
+        openaiReq.reasoning = anthropicReq.reasoning;
+    }
+    // Request usage info in stream for token counting
+    if (openaiReq.stream) {
+        openaiReq.stream_options = { include_usage: true };
+    }
+    return openaiReq;
+}
+function toResponsesMessages(messages) {
+    const out = [];
+    for (const m of messages) {
+        if (m.role === 'tool') {
+            // Responses API accepts tool results as normal user text; we prefix lightly
+            out.push({ role: 'tool', content: [{ type: 'text', text: m.content ?? '' }] });
+            continue;
+        }
+        out.push({ role: m.role, content: [{ type: 'text', text: m.content ?? '' }] });
+    }
+    return out;
+}
+function translateChatToResponses(chat) {
+    // chat is already an OpenAI Chat Completions payload; convert messages to Responses format
+    const req = {
+        model: chat.model,
+        input: toResponsesMessages(chat.messages),
+        stream: chat.stream,
+        temperature: chat.temperature,
+        top_p: chat.top_p,
+        stop: chat.stop,
+        reasoning: chat.reasoning,
+    };
+    if (chat.tools)
+        req.tools = chat.tools;
+    if (chat.tool_choice)
+        req.tool_choice = chat.tool_choice;
+    return req;
+}
+// ─── Streaming Response Translation ──────────────────────────────────────────
+/** State tracker for translating OpenAI streaming chunks into Anthropic SSE events */
+class StreamingResponseTranslator {
+    constructor(model) {
+        this.contentBlockIndex = 0;
+        this.inTextBlock = false;
+        this.inToolCallBlocks = new Map();
+        this.inputTokens = 0;
+        this.outputTokens = 0;
+        this.headersSent = false;
+        this.messageId = `msg_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+        this.model = model;
+    }
+    sse(event, data) {
+        return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    }
+    /** Produce the initial message_start event */
+    emitMessageStart() {
+        return this.sse('message_start', {
+            type: 'message_start',
+            message: {
+                id: this.messageId,
+                type: 'message',
+                role: 'assistant',
+                content: [],
+                model: this.model,
+                stop_reason: null,
+                stop_sequence: null,
+                usage: { input_tokens: this.inputTokens, output_tokens: 0 },
+            },
+        });
+    }
+    /** Translate a single OpenAI chunk to zero or more Anthropic SSE events */
+    translateChunk(chunk) {
+        let events = '';
+        // Track usage
+        if (chunk.usage) {
+            if (chunk.usage.prompt_tokens)
+                this.inputTokens = chunk.usage.prompt_tokens;
+            if (chunk.usage.completion_tokens)
+                this.outputTokens = chunk.usage.completion_tokens;
+        }
+        if (!chunk.choices || chunk.choices.length === 0)
+            return events;
+        const choice = chunk.choices[0];
+        if (!choice)
+            return events;
+        const delta = choice.delta;
+        // Emit message_start on first content
+        if (!this.headersSent && delta) {
+            this.headersSent = true;
+            events += this.emitMessageStart();
+        }
+        // Handle text content
+        if (delta?.content !== undefined && delta.content !== null) {
+            if (!this.inTextBlock) {
+                // Start a new text content block
+                events += this.sse('content_block_start', {
+                    type: 'content_block_start',
+                    index: this.contentBlockIndex,
+                    content_block: { type: 'text', text: '' },
+                });
+                this.inTextBlock = true;
+            }
+            if (delta.content) {
+                events += this.sse('content_block_delta', {
+                    type: 'content_block_delta',
+                    index: this.contentBlockIndex,
+                    delta: { type: 'text_delta', text: delta.content },
+                });
+            }
+        }
+        // Handle tool calls
+        if (delta?.tool_calls) {
+            // Close text block if open
+            if (this.inTextBlock) {
+                events += this.sse('content_block_stop', {
+                    type: 'content_block_stop',
+                    index: this.contentBlockIndex,
+                });
+                this.contentBlockIndex++;
+                this.inTextBlock = false;
+            }
+            for (const tc of delta.tool_calls) {
+                const tcIndex = tc.index ?? 0;
+                let tracked = this.inToolCallBlocks.get(tcIndex);
+                // New tool call
+                if (tc.id && tc.function?.name) {
+                    tracked = { id: tc.id, name: tc.function.name, started: false };
+                    this.inToolCallBlocks.set(tcIndex, tracked);
+                }
+                if (!tracked)
+                    continue;
+                // Emit content_block_start for new tool call
+                if (!tracked.started) {
+                    events += this.sse('content_block_start', {
+                        type: 'content_block_start',
+                        index: this.contentBlockIndex,
+                        content_block: { type: 'tool_use', id: tracked.id, name: tracked.name, input: {} },
+                    });
+                    tracked.started = true;
+                }
+                // Emit argument deltas
+                if (tc.function?.arguments) {
+                    events += this.sse('content_block_delta', {
+                        type: 'content_block_delta',
+                        index: this.contentBlockIndex,
+                        delta: { type: 'input_json_delta', partial_json: tc.function.arguments },
+                    });
+                }
+            }
+        }
+        // Handle finish
+        if (choice.finish_reason) {
+            // Close any open blocks
+            if (this.inTextBlock) {
+                events += this.sse('content_block_stop', {
+                    type: 'content_block_stop',
+                    index: this.contentBlockIndex,
+                });
+                this.contentBlockIndex++;
+                this.inTextBlock = false;
+            }
+            // Close open tool call blocks
+            for (const [, tracked] of this.inToolCallBlocks) {
+                if (tracked.started) {
+                    events += this.sse('content_block_stop', {
+                        type: 'content_block_stop',
+                        index: this.contentBlockIndex,
+                    });
+                    this.contentBlockIndex++;
+                }
+            }
+            this.inToolCallBlocks.clear();
+            // Map finish reason
+            const stopReason = choice.finish_reason === 'tool_calls' ? 'tool_use' : 'end_turn';
+            events += this.sse('message_delta', {
+                type: 'message_delta',
+                delta: { stop_reason: stopReason, stop_sequence: null },
+                usage: { output_tokens: this.outputTokens },
+            });
+            events += this.sse('message_stop', { type: 'message_stop' });
+        }
+        return events;
+    }
+    /** Handle case where no chunks were received or stream ended without finish_reason */
+    emitFinalIfNeeded() {
+        let events = '';
+        if (!this.headersSent) {
+            events += this.emitMessageStart();
+        }
+        if (this.inTextBlock) {
+            events += this.sse('content_block_stop', {
+                type: 'content_block_stop',
+                index: this.contentBlockIndex,
+            });
+        }
+        for (const [, tracked] of this.inToolCallBlocks) {
+            if (tracked.started) {
+                events += this.sse('content_block_stop', {
+                    type: 'content_block_stop',
+                    index: this.contentBlockIndex,
+                });
+                this.contentBlockIndex++;
+            }
+        }
+        events += this.sse('message_delta', {
+            type: 'message_delta',
+            delta: { stop_reason: 'end_turn', stop_sequence: null },
+            usage: { output_tokens: this.outputTokens },
+        });
+        events += this.sse('message_stop', { type: 'message_stop' });
+        return events;
+    }
+}
+function translateNonStreamingResponse(openaiResp, model) {
+    const choice = openaiResp.choices?.[0];
+    const message = choice?.message;
+    const content = [];
+    // Text content
+    if (message?.content) {
+        content.push({ type: 'text', text: message.content });
+    }
+    // Tool calls
+    if (message?.tool_calls) {
+        for (const tc of message.tool_calls) {
+            let input = {};
+            try {
+                input = JSON.parse(tc.function.arguments);
+            }
+            catch {
+                input = tc.function.arguments;
+            }
+            content.push({
+                type: 'tool_use',
+                id: tc.id,
+                name: tc.function.name,
+                input,
+            });
+        }
+    }
+    const stopReason = choice?.finish_reason === 'tool_calls' ? 'tool_use' : 'end_turn';
+    return {
+        id: `msg_${Date.now().toString(36)}`,
+        type: 'message',
+        role: 'assistant',
+        content,
+        model,
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage: {
+            input_tokens: openaiResp.usage?.prompt_tokens ?? 0,
+            output_tokens: openaiResp.usage?.completion_tokens ?? 0,
+        },
+    };
+}
+// ─── Proxy Server ────────────────────────────────────────────────────────────
+class AnthropicToOpenAIProxy {
+    constructor(config) {
+        this.server = null;
+        this.port = null;
+        this.config = {
+            targetBaseUrl: config.targetBaseUrl.replace(/\/+$/, ''),
+            apiKey: config.apiKey,
+            verbose: config.verbose ?? false,
+            timeoutMs: config.timeoutMs ?? 120000,
+        };
+    }
+    log(msg) {
+        if (this.config.verbose) {
+            console.error(`[anthropic-to-openai] ${msg}`);
+        }
+    }
+    async start() {
+        if (this.server)
+            return this.port ?? 0;
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => {
+                void this.handleRequest(req, res);
+            });
+            this.server.listen(0, '127.0.0.1', () => {
+                const addr = this.server?.address();
+                this.port = typeof addr === 'object' && addr ? addr.port : 0;
+                resolve(this.port);
+            });
+            this.server.on('error', reject);
+        });
+    }
+    stop() {
+        if (!this.server)
+            return;
+        this.server.close();
+        this.server = null;
+        this.port = null;
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            const maxSize = 10 * 1024 * 1024;
+            let total = 0;
+            req.on('data', (chunk) => {
+                total += chunk.length;
+                if (total > maxSize) {
+                    req.destroy();
+                    reject(new Error('Request body too large'));
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+            req.on('error', reject);
+        });
+    }
+    async handleRequest(req, res) {
+        const method = req.method || 'GET';
+        let requestPath = req.url || '/';
+        // Strip /api/provider/{provider} prefix if present
+        // Claude CLI sends to /api/provider/codex/v1/messages, we need /v1/messages
+        const providerPrefixMatch = requestPath.match(/^\/api\/provider\/[^/]+(.*)$/);
+        if (providerPrefixMatch) {
+            requestPath = providerPrefixMatch[1] || '/';
+        }
+        this.log(`${method} ${req.url} → path=${requestPath}`);
+        // Only handle POST /v1/messages (the Anthropic Messages API endpoint)
+        if (method !== 'POST' || !requestPath.startsWith('/v1/messages')) {
+            // For other paths, return a simple response
+            if (method === 'GET' && requestPath === '/') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ status: 'ok', proxy: 'anthropic-to-openai' }));
+                return;
+            }
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: `Unsupported: ${method} ${requestPath}` }));
+            return;
+        }
+        try {
+            const rawBody = await this.readBody(req);
+            let anthropicReq;
+            try {
+                anthropicReq = rawBody.length ? JSON.parse(rawBody) : {};
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                return;
+            }
+            // Translate request
+            const openaiReq = translateRequestChat(anthropicReq);
+            const model = anthropicReq.model || 'unknown';
+            this.log(`Translated request: model=${model}, stream=${openaiReq.stream}, messages=${openaiReq.messages.length}`);
+            // Build target URL
+            const targetUrl = new url_1.URL(`${this.config.targetBaseUrl}/v1/chat/completions`);
+            if (openaiReq.stream) {
+                await this.handleStreaming(req, res, targetUrl, openaiReq, model);
+            }
+            else {
+                await this.handleNonStreaming(req, res, targetUrl, openaiReq, model);
+            }
+        }
+        catch (error) {
+            const err = error;
+            this.log(`Error: ${err.message}`);
+            if (!res.headersSent) {
+                res.writeHead(502, { 'Content-Type': 'application/json' });
+            }
+            // Return error in Anthropic format
+            res.end(JSON.stringify({
+                type: 'error',
+                error: { type: 'api_error', message: err.message },
+            }));
+        }
+    }
+    async handleStreaming(_req, clientRes, targetBase, openaiReqChat, model) {
+        return new Promise((_resolve, _reject) => {
+            const attempt = (mode) => {
+                return new Promise((resolveAttempt, rejectAttempt) => {
+                    const targetUrl = new url_1.URL(mode === 'chat' ? '/v1/chat/completions' : '/v1/responses', targetBase);
+                    const body = mode === 'chat' ? openaiReqChat : translateChatToResponses(JSON.parse(JSON.stringify({ ...openaiReqChat, stream: true })));
+                    const bodyString = JSON.stringify(body);
+                    const requestFn = targetUrl.protocol === 'https:' ? https.request : http.request;
+                    const upstreamReq = requestFn({
+                        protocol: targetUrl.protocol,
+                        hostname: targetUrl.hostname,
+                        port: targetUrl.port,
+                        path: targetUrl.pathname + targetUrl.search,
+                        method: 'POST',
+                        timeout: this.config.timeoutMs,
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Content-Length': Buffer.byteLength(bodyString),
+                            'Authorization': `Bearer ${this.config.apiKey}`,
+                            'Accept': 'text/event-stream',
+                        },
+                    }, (upstreamRes) => {
+                        const statusCode = upstreamRes.statusCode || 200;
+                        if (statusCode >= 400) {
+                            const chunks = [];
+                            upstreamRes.on('data', (c) => chunks.push(c));
+                            upstreamRes.on('end', () => {
+                                const bodyErr = Buffer.concat(chunks).toString('utf8');
+                                this.log(`Upstream ${mode} error ${statusCode}: ${bodyErr.slice(0, 200)}`);
+                                // Try fallback if we attempted chat first
+                                if (mode === 'chat') {
+                                    attempt('responses').then(resolveAttempt).catch(rejectAttempt);
+                                    return;
+                                }
+                                // No fallback left: return error
+                                if (!clientRes.headersSent) {
+                                    clientRes.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                                }
+                                try {
+                                    const parsed = JSON.parse(bodyErr);
+                                    clientRes.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: parsed?.error?.message || bodyErr.slice(0, 500) } }));
+                                }
+                                catch {
+                                    clientRes.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: bodyErr.slice(0, 500) } }));
+                                }
+                                resolveAttempt();
+                            });
+                            return;
+                        }
+                        // Set up Anthropic SSE response
+                        clientRes.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
+                        const translator = new StreamingResponseTranslator(model);
+                        let buffer = '';
+                        let hasFinished = false;
+                        upstreamRes.on('data', (chunk) => {
+                            buffer += chunk.toString('utf8');
+                            const lines = buffer.split('\n');
+                            buffer = lines.pop() || '';
+                            for (const line of lines) {
+                                const trimmed = line.trim();
+                                if (!trimmed || trimmed.startsWith(':'))
+                                    continue;
+                                if (trimmed === 'data: [DONE]') {
+                                    if (!hasFinished) {
+                                        const final = translator.emitFinalIfNeeded();
+                                        if (final)
+                                            clientRes.write(final);
+                                        hasFinished = true;
+                                    }
+                                    continue;
+                                }
+                                if (trimmed.startsWith('data: ')) {
+                                    const jsonStr = trimmed.slice(6);
+                                    try {
+                                        // Try Chat Completions chunk first
+                                        const parsed = JSON.parse(jsonStr);
+                                        if (parsed && parsed.type) {
+                                            // Responses API event
+                                            const evtType = parsed.type;
+                                            if (evtType.endsWith('.output_text.delta') && typeof parsed.delta === 'string') {
+                                                // Start block if needed, then stream text
+                                                const start = translator.translateChunk({ choices: [{ delta: { content: '' } }] });
+                                                // translateChunk will emit start on first delta; we then send delta via a fake chunk with content
+                                                const textDelta = translator.translateChunk({ choices: [{ delta: { content: parsed.delta } }] });
+                                                if (start)
+                                                    clientRes.write(start);
+                                                if (textDelta)
+                                                    clientRes.write(textDelta);
+                                            }
+                                            else if (evtType === 'response.completed') {
+                                                hasFinished = true;
+                                                const final = translator.emitFinalIfNeeded();
+                                                if (final)
+                                                    clientRes.write(final);
+                                            }
+                                            // ignore other event types for now
+                                        }
+                                        else {
+                                            const chunkObj = parsed;
+                                            const events = translator.translateChunk(chunkObj);
+                                            if (events)
+                                                clientRes.write(events);
+                                            if (chunkObj.choices?.[0]?.finish_reason)
+                                                hasFinished = true;
+                                        }
+                                    }
+                                    catch (e) {
+                                        this.log(`Failed to parse SSE chunk: ${jsonStr.slice(0, 100)} - ${e.message}`);
+                                    }
+                                }
+                            }
+                        });
+                        upstreamRes.on('end', () => {
+                            if (buffer.trim()) {
+                                const trimmed = buffer.trim();
+                                if (trimmed.startsWith('data: ') && trimmed !== 'data: [DONE]') {
+                                    try {
+                                        const parsed = JSON.parse(trimmed.slice(6));
+                                        if (parsed && parsed.type) {
+                                            if (parsed.type === 'response.completed') {
+                                                hasFinished = true;
+                                            }
+                                        }
+                                        else {
+                                            const chunk = parsed;
+                                            const events = translator.translateChunk(chunk);
+                                            if (events)
+                                                clientRes.write(events);
+                                            if (chunk.choices?.[0]?.finish_reason)
+                                                hasFinished = true;
+                                        }
+                                    }
+                                    catch {
+                                        // ignore
+                                    }
+                                }
+                            }
+                            if (!hasFinished) {
+                                const final = translator.emitFinalIfNeeded();
+                                if (final)
+                                    clientRes.write(final);
+                            }
+                            clientRes.end();
+                            resolveAttempt();
+                        });
+                        upstreamRes.on('error', rejectAttempt);
+                    });
+                    upstreamReq.on('timeout', () => {
+                        upstreamReq.destroy(new Error('Upstream request timeout'));
+                    });
+                    upstreamReq.on('error', (err) => {
+                        // On network error for chat attempt, fallback to responses
+                        if (mode === 'chat') {
+                            attempt('responses').then(resolveAttempt).catch(rejectAttempt);
+                            return;
+                        }
+                        this.log(`Request error (${mode}): ${err.message}`);
+                        if (!clientRes.headersSent) {
+                            clientRes.writeHead(502, { 'Content-Type': 'application/json' });
+                            clientRes.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: err.message } }));
+                        }
+                        rejectAttempt(err);
+                    });
+                    upstreamReq.write(bodyString);
+                    upstreamReq.end();
+                });
+            };
+            return attempt('chat');
+        });
+    }
+    async handleNonStreaming(_req, clientRes, targetBase, openaiReqChat, model) {
+        return new Promise((_resolve, _reject) => {
+            const doRequest = (mode) => {
+                return new Promise((resolveAttempt, rejectAttempt) => {
+                    const targetUrl = new url_1.URL(mode === 'chat' ? '/v1/chat/completions' : '/v1/responses', targetBase);
+                    const body = mode === 'chat' ? openaiReqChat : translateChatToResponses(openaiReqChat);
+                    const bodyString = JSON.stringify(body);
+                    const requestFn = targetUrl.protocol === 'https:' ? https.request : http.request;
+                    const upstreamReq = requestFn({
+                        protocol: targetUrl.protocol,
+                        hostname: targetUrl.hostname,
+                        port: targetUrl.port,
+                        path: targetUrl.pathname + targetUrl.search,
+                        method: 'POST',
+                        timeout: this.config.timeoutMs,
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Content-Length': Buffer.byteLength(bodyString),
+                            'Authorization': `Bearer ${this.config.apiKey}`,
+                        },
+                    }, (upstreamRes) => {
+                        const chunks = [];
+                        upstreamRes.on('data', (c) => chunks.push(c));
+                        upstreamRes.on('end', () => {
+                            const bodyTxt = Buffer.concat(chunks).toString('utf8');
+                            const statusCode = upstreamRes.statusCode || 200;
+                            if (statusCode >= 400) {
+                                this.log(`Upstream ${mode} error ${statusCode}: ${bodyTxt.slice(0, 200)}`);
+                                if (mode === 'chat') {
+                                    doRequest('responses').then(resolveAttempt).catch(rejectAttempt);
+                                    return;
+                                }
+                                clientRes.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                                clientRes.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: bodyTxt.slice(0, 500) } }));
+                                resolveAttempt();
+                                return;
+                            }
+                            try {
+                                const parsed = JSON.parse(bodyTxt);
+                                if (parsed && parsed.choices) {
+                                    const anthropicResp = translateNonStreamingResponse(parsed, model);
+                                    clientRes.writeHead(200, { 'Content-Type': 'application/json' });
+                                    clientRes.end(JSON.stringify(anthropicResp));
+                                }
+                                else if (parsed && (parsed.output_text || parsed.output)) {
+                                    // Responses API: extract text
+                                    let text = '';
+                                    if (typeof parsed.output_text === 'string') {
+                                        text = parsed.output_text;
+                                    }
+                                    else if (Array.isArray(parsed.output)) {
+                                        for (const item of parsed.output) {
+                                            if (item.type === 'output_text' && typeof item.text === 'string') {
+                                                text += item.text;
+                                            }
+                                            else if (item.type === 'message' && Array.isArray(item.content)) {
+                                                for (const c of item.content) {
+                                                    if (c.type === 'output_text' && typeof c.text === 'string')
+                                                        text += c.text;
+                                                    if (c.type === 'text' && typeof c.text === 'string')
+                                                        text += c.text;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    const anthropicResp = {
+                                        id: `msg_${Date.now().toString(36)}`,
+                                        type: 'message',
+                                        role: 'assistant',
+                                        content: text ? [{ type: 'text', text }] : [],
+                                        model,
+                                        stop_reason: 'end_turn',
+                                        stop_sequence: null,
+                                        usage: { input_tokens: parsed?.usage?.prompt_tokens ?? 0, output_tokens: parsed?.usage?.completion_tokens ?? 0 },
+                                    };
+                                    clientRes.writeHead(200, { 'Content-Type': 'application/json' });
+                                    clientRes.end(JSON.stringify(anthropicResp));
+                                }
+                                else {
+                                    clientRes.writeHead(502, { 'Content-Type': 'application/json' });
+                                    clientRes.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: 'Unrecognized upstream response format' } }));
+                                }
+                            }
+                            catch {
+                                clientRes.writeHead(502, { 'Content-Type': 'application/json' });
+                                clientRes.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: 'Failed to parse upstream response' } }));
+                            }
+                            resolveAttempt();
+                        });
+                        upstreamRes.on('error', rejectAttempt);
+                    });
+                    upstreamReq.on('timeout', () => upstreamReq.destroy(new Error('Upstream request timeout')));
+                    upstreamReq.on('error', (err) => {
+                        if (mode === 'chat') {
+                            doRequest('responses').then(resolveAttempt).catch(rejectAttempt);
+                            return;
+                        }
+                        if (!clientRes.headersSent) {
+                            clientRes.writeHead(502, { 'Content-Type': 'application/json' });
+                            clientRes.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: err.message } }));
+                        }
+                        rejectAttempt(err);
+                    });
+                    upstreamReq.write(bodyString);
+                    upstreamReq.end();
+                });
+            };
+            return doRequest('chat');
+        });
+    }
+}
+exports.AnthropicToOpenAIProxy = AnthropicToOpenAIProxy;
+//# sourceMappingURL=anthropic-to-openai-proxy.js.map