@appkit/llamacpp-cli 1.13.0 → 1.14.0

package/dist/lib/anthropic-stream-converter.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicStreamConverter = void 0;
+/**
+ * StreamConverter manages state for converting OpenAI streaming responses to Anthropic format.
+ *
+ * It tracks the current state of content blocks and emits proper Anthropic SSE events.
+ */
+class AnthropicStreamConverter {
+    constructor(id, model, estimatedInputTokens) {
+        this.firstChunk = true;
+        this.contentIndex = 0;
+        this.outputTokens = 0;
+        // State tracking
+        this.textStarted = false;
+        this.currentTextContent = '';
+        this.toolCallsInProgress = new Map();
+        this.toolCallsSent = new Set();
+        this.id = id;
+        this.model = model;
+        this.estimatedInputTokens = estimatedInputTokens;
+        this.inputTokens = estimatedInputTokens;
+    }
+    /**
+     * Process an OpenAI streaming chunk and return Anthropic events.
+     */
+    process(chunk) {
+        const events = [];
+        // First chunk: emit message_start
+        if (this.firstChunk) {
+            this.firstChunk = false;
+            events.push(this.createMessageStartEvent());
+        }
+        const choice = chunk.choices[0];
+        if (!choice) {
+            return events;
+        }
+        const delta = choice.delta;
+        // Handle text content
+        if (delta.content) {
+            if (!this.textStarted) {
+                this.textStarted = true;
+                events.push(this.createContentBlockStartEvent('text'));
+            }
+            this.currentTextContent += delta.content;
+            events.push(this.createTextDeltaEvent(delta.content));
+        }
+        // Handle tool calls
+        if (delta.tool_calls) {
+            for (const toolCallDelta of delta.tool_calls) {
+                const index = toolCallDelta.index;
+                const tcEvents = this.processToolCallDelta(toolCallDelta);
+                events.push(...tcEvents);
+            }
+        }
+        // Handle completion
+        if (choice.finish_reason) {
+            // Close any open content blocks
+            if (this.textStarted) {
+                events.push(this.createContentBlockStopEvent(this.contentIndex));
+                this.contentIndex++;
+            }
+            // Close any open tool calls
+            for (const [index, state] of this.toolCallsInProgress.entries()) {
+                if (state.started && !state.completed) {
+                    events.push(this.createContentBlockStopEvent(state.blockIndex));
+                    state.completed = true;
+                }
+            }
+            // Emit message_delta with stop reason
+            const stopReason = this.mapFinishReason(choice.finish_reason);
+            events.push(this.createMessageDeltaEvent(stopReason));
+            // Emit message_stop
+            events.push(this.createMessageStopEvent());
+        }
+        return events;
+    }
+    processToolCallDelta(toolCallDelta) {
+        const events = [];
+        const index = toolCallDelta.index;
+        // Get or create tool call state
+        let state = this.toolCallsInProgress.get(index);
+        if (!state) {
+            state = {
+                id: '',
+                name: '',
+                arguments: '',
+                started: false,
+                completed: false,
+                blockIndex: -1,
+            };
+            this.toolCallsInProgress.set(index, state);
+        }
+        // Accumulate tool call data
+        if (toolCallDelta.id) {
+            state.id = toolCallDelta.id;
+        }
+        if (toolCallDelta.function?.name) {
+            state.name = toolCallDelta.function.name;
+        }
+        if (toolCallDelta.function?.arguments) {
+            state.arguments += toolCallDelta.function.arguments;
+        }
+        // Start tool call block when we have id and name
+        if (!state.started && state.id && state.name) {
+            // Close text block if open
+            if (this.textStarted) {
+                events.push(this.createContentBlockStopEvent(this.contentIndex));
+                this.contentIndex++;
+                this.textStarted = false;
+            }
+            state.started = true;
+            state.blockIndex = this.contentIndex;
+            events.push(this.createToolUseStartEvent(state.id, state.name));
+        }
+        // Emit input_json_delta if we have arguments
+        if (state.started && toolCallDelta.function?.arguments) {
+            events.push(this.createInputJsonDeltaEvent(state.blockIndex, toolCallDelta.function.arguments));
+        }
+        return events;
+    }
+    // ============================================================================
+    // Event Creation Methods
+    // ============================================================================
+    createMessageStartEvent() {
+        return {
+            type: 'message_start',
+            message: {
+                id: this.id,
+                type: 'message',
+                role: 'assistant',
+                model: this.model,
+                content: [],
+                usage: {
+                    input_tokens: this.inputTokens,
+                    output_tokens: 0,
+                },
+            },
+        };
+    }
+    createContentBlockStartEvent(type) {
+        return {
+            type: 'content_block_start',
+            index: this.contentIndex,
+            content_block: {
+                type: 'text',
+                text: '',
+            },
+        };
+    }
+    createToolUseStartEvent(id, name) {
+        return {
+            type: 'content_block_start',
+            index: this.contentIndex,
+            content_block: {
+                type: 'tool_use',
+                id,
+                name,
+                input: {},
+            },
+        };
+    }
+    createTextDeltaEvent(text) {
+        return {
+            type: 'content_block_delta',
+            index: this.contentIndex,
+            delta: {
+                type: 'text_delta',
+                text,
+            },
+        };
+    }
+    createInputJsonDeltaEvent(index, partialJson) {
+        return {
+            type: 'content_block_delta',
+            index,
+            delta: {
+                type: 'input_json_delta',
+                partial_json: partialJson,
+            },
+        };
+    }
+    createContentBlockStopEvent(index) {
+        return {
+            type: 'content_block_stop',
+            index,
+        };
+    }
+    createMessageDeltaEvent(stopReason) {
+        return {
+            type: 'message_delta',
+            delta: {
+                stop_reason: stopReason,
+            },
+            usage: {
+                input_tokens: this.inputTokens,
+                output_tokens: this.outputTokens,
+            },
+        };
+    }
+    createMessageStopEvent() {
+        return {
+            type: 'message_stop',
+        };
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    mapFinishReason(finishReason) {
+        const hasToolCalls = this.toolCallsInProgress.size > 0;
+        if (hasToolCalls) {
+            return 'tool_use';
+        }
+        switch (finishReason) {
+            case 'stop':
+                return 'end_turn';
+            case 'length':
+                return 'max_tokens';
+            case 'tool_calls':
+                return 'tool_use';
+            default:
+                return 'end_turn';
+        }
+    }
+}
+exports.AnthropicStreamConverter = AnthropicStreamConverter;
+//# sourceMappingURL=anthropic-stream-converter.js.map

package/dist/lib/anthropic-stream-converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-stream-converter.js","sourceRoot":"","sources":["../../src/lib/anthropic-stream-converter.ts"],"names":[],"mappings":"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"}

package/dist/lib/router-server.d.ts

@@ -33,6 +33,14 @@ declare class RouterServer {
      * Anthropic Messages API endpoint - convert to OpenAI format and route
      */
     private handleAnthropicMessages;
+    /**
+     * Handle non-streaming Anthropic Messages request
+     */
+    private handleAnthropicNonStreaming;
+    /**
+     * Handle streaming Anthropic Messages request
+     */
+    private handleAnthropicStreaming;
     /**
      * Chat completions endpoint - route to backend server
      */

package/dist/lib/router-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router-server.d.ts","sourceRoot":"","sources":["../../src/lib/router-server.ts"],"names":[],"mappings":";AA6BA;;GAEG;AACH,cAAM,YAAY;IAChB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,MAAM,CAAgB;IAExB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAqC3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;OAEG;YACW,aAAa;IA8C3B;;OAEG;YACW,YAAY;IAS1B;;OAEG;YACW,YAAY;IAoB1B;;;OAGG;YACW,mBAAmB;IAiBjC;;OAEG;YACW,iBAAiB;IAiC/B;;OAEG;YACW,uBAAuB;IA2MrC;;OAEG;YACW,qBAAqB;IAmEnC;;OAEG;YACW,gBAAgB;IA4E9B;;OAEG;YACW,YAAY;IA4D1B;;OAEG;YACW,QAAQ;IAStB;;OAEG;IACH,OAAO,CAAC,SAAS;IAUjB;;OAEG;YACW,aAAa;IAwB3B;;OAEG;YACW,UAAU;IAyBxB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgC5B;;OAEG;YACW,kBAAkB;CAwCjC;AAkBD,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"router-server.d.ts","sourceRoot":"","sources":["../../src/lib/router-server.ts"],"names":[],"mappings":";AA2CA;;GAEG;AACH,cAAM,YAAY;IAChB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,MAAM,CAAgB;IAExB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAqC3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;OAEG;YACW,aAAa;IA8C3B;;OAEG;YACW,YAAY;IAS1B;;OAEG;YACW,YAAY;IAoB1B;;;OAGG;YACW,mBAAmB;IAiBjC;;OAEG;YACW,iBAAiB;IAiC/B;;OAEG;YACW,uBAAuB;IAsIrC;;OAEG;YACW,2BAA2B;IAoHzC;;OAEG;YACW,wBAAwB;IAsGtC;;OAEG;YACW,qBAAqB;IAmEnC;;OAEG;YACW,gBAAgB;IA4E9B;;OAEG;YACW,YAAY;IA4D1B;;OAEG;YACW,QAAQ;IAStB;;OAEG;IACH,OAAO,CAAC,SAAS;IAUjB;;OAEG;YACW,aAAa;IAwB3B;;OAEG;YACW,UAAU;IAyBxB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgC5B;;OAEG;YACW,kBAAkB;CAwCjC;AAkBD,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/lib/router-server.js

@@ -42,6 +42,8 @@ const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const file_utils_1 = require("../utils/file-utils");
 const router_logger_1 = require("./router-logger");
+const anthropic_converter_1 = require("./anthropic-converter");
+const anthropic_stream_converter_1 = require("./anthropic-stream-converter");
 /**
  * Router HTTP server - proxies requests to backend llama.cpp servers
  */
@@ -237,22 +239,45 @@ class RouterServer {
             catch (error) {
                 statusCode = 400;
                 errorMsg = 'Invalid JSON in request body';
-                this.sendError(res, statusCode, 'Bad Request', errorMsg);
+                const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(anthropicError));
                 await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg);
                 return;
             }
             // Extract model name and prompt preview
             modelName = anthropicRequest.model || 'unknown';
             if (anthropicRequest.messages && anthropicRequest.messages.length > 0) {
-                const userMsg = anthropicRequest.messages.find((m) => m.role === 'user');
+                const userMsg = anthropicRequest.messages.find(m => m.role === 'user');
                 if (userMsg && typeof userMsg.content === 'string') {
                     promptPreview = userMsg.content.slice(0, 50);
                 }
             }
+            // Validate required fields
             if (!anthropicRequest.model) {
                 statusCode = 400;
                 errorMsg = 'Missing "model" field in request';
-                this.sendError(res, statusCode, 'Bad Request', errorMsg);
+                const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(anthropicError));
+                await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
+                return;
+            }
+            if (!anthropicRequest.max_tokens || anthropicRequest.max_tokens <= 0) {
+                statusCode = 400;
+                errorMsg = 'max_tokens is required and must be positive';
+                const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(anthropicError));
+                await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
+                return;
+            }
+            if (!anthropicRequest.messages || anthropicRequest.messages.length === 0) {
+                statusCode = 400;
+                errorMsg = 'messages is required and must be non-empty';
+                const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(anthropicError));
                 await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
                 return;
             }
@@ -261,7 +286,9 @@ class RouterServer {
             if (!server) {
                 statusCode = 404;
                 errorMsg = `No server found for model: ${modelName}`;
-                this.sendError(res, statusCode, 'Not Found', errorMsg);
+                const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(anthropicError));
                 await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
                 return;
             }
@@ -269,78 +296,55 @@ class RouterServer {
             if (server.status !== 'running') {
                 statusCode = 503;
                 errorMsg = `Server for model ${modelName} is not running (status: ${server.status})`;
-                this.sendError(res, statusCode, 'Service Unavailable', errorMsg);
+                const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(anthropicError));
                 await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
                 return;
             }
-            // Convert Anthropic Messages format to OpenAI Chat Completions format
-            const openAIMessages = [];
-            // Add system message if present
-            if (anthropicRequest.system) {
-                // System can be a string or array of content blocks
-                let systemContent = '';
-                if (typeof anthropicRequest.system === 'string') {
-                    systemContent = anthropicRequest.system;
-                }
-                else if (Array.isArray(anthropicRequest.system)) {
-                    // Extract text from content blocks
-                    systemContent = anthropicRequest.system
-                        .filter((block) => block.type === 'text')
-                        .map((block) => block.text)
-                        .join('\n');
-                }
-                if (systemContent) {
-                    openAIMessages.push({
-                        role: 'system',
-                        content: systemContent
-                    });
-                }
-            }
-            // Add user/assistant messages
-            if (anthropicRequest.messages) {
-                for (const msg of anthropicRequest.messages) {
-                    let content = '';
-                    // Content can be a string or array of content blocks
-                    if (typeof msg.content === 'string') {
-                        content = msg.content;
-                    }
-                    else if (Array.isArray(msg.content)) {
-                        // Extract text from content blocks
-                        content = msg.content
-                            .filter((block) => block.type === 'text')
-                            .map((block) => block.text)
-                            .join('\n');
-                    }
-                    openAIMessages.push({
-                        role: msg.role,
-                        content
-                    });
-                }
-            }
-            const openAIRequest = {
-                model: anthropicRequest.model,
-                messages: openAIMessages,
-                max_tokens: anthropicRequest.max_tokens || 1024,
-                temperature: anthropicRequest.temperature,
-                top_p: anthropicRequest.top_p,
-                stream: false, // Always disable streaming for now - we don't handle SSE yet
-            };
+            // Convert Anthropic request to OpenAI format
+            const openAIRequest = (0, anthropic_converter_1.fromMessagesRequest)(anthropicRequest);
+            // Generate message ID for response
+            const messageId = (0, anthropic_converter_1.generateMessageId)();
             // Proxy request to backend
-            // Always use 127.0.0.1 as destination (0.0.0.0 is only valid as bind address)
             const backendHost = server.host === '0.0.0.0' ? '127.0.0.1' : server.host;
             const backendUrl = `http://${backendHost}:${server.port}/v1/chat/completions`;
-            // Make request to backend
-            const url = new url_1.URL(backendUrl);
-            const options = {
-                hostname: url.hostname,
-                port: url.port,
-                path: url.pathname,
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                timeout: this.config.requestTimeout,
-            };
+            // Handle streaming vs non-streaming
+            if (anthropicRequest.stream) {
+                await this.handleAnthropicStreaming(anthropicRequest, openAIRequest, backendUrl, messageId, res, timer, modelName, promptPreview, server);
+            }
+            else {
+                await this.handleAnthropicNonStreaming(openAIRequest, backendUrl, messageId, res, timer, modelName, promptPreview, server);
+            }
+        }
+        catch (error) {
+            console.error('[Router] Error handling Anthropic messages request:', error);
+            statusCode = 500;
+            errorMsg = error.message;
+            const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+            if (!res.headersSent) {
+                res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(anthropicError));
+            }
+            await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
+        }
+    }
+    /**
+     * Handle non-streaming Anthropic Messages request
+     */
+    async handleAnthropicNonStreaming(openAIRequest, backendUrl, messageId, res, timer, modelName, promptPreview, server) {
+        const url = new url_1.URL(backendUrl);
+        const options = {
+            hostname: url.hostname,
+            port: url.port,
+            path: url.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            timeout: this.config.requestTimeout,
+        };
+        return new Promise((resolve, reject) => {
             const backendReq = http.request(options, (backendRes) => {
                 let responseData = '';
                 backendRes.on('data', (chunk) => {
@@ -348,64 +352,163 @@ class RouterServer {
                 });
                 backendRes.on('end', async () => {
                     try {
-                        const openAIResponse = JSON.parse(responseData);
+                        const parsedResponse = JSON.parse(responseData);
+                        // Check if backend returned an error
+                        if (parsedResponse.error) {
+                            const statusCode = backendRes.statusCode || 500;
+                            const errorMsg = parsedResponse.error.message || 'Backend error';
+                            console.error('[Router] Backend returned error:', errorMsg);
+                            const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify(anthropicError));
+                            await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, `${server.host}:${server.port}`, promptPreview);
+                            reject(new Error(errorMsg));
+                            return;
+                        }
+                        // Check if response has required fields for a completion
+                        if (!parsedResponse.choices || !Array.isArray(parsedResponse.choices) || parsedResponse.choices.length === 0) {
+                            const statusCode = 502;
+                            const errorMsg = 'Invalid backend response: missing choices array';
+                            console.error('[Router] Backend response missing choices:', responseData.slice(0, 500));
+                            const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify(anthropicError));
+                            await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, `${server.host}:${server.port}`, promptPreview);
+                            reject(new Error(errorMsg));
+                            return;
+                        }
+                        const openAIResponse = parsedResponse;
                         // Convert OpenAI response to Anthropic format
-                        const anthropicResponse = {
-                            id: openAIResponse.id || `msg_${Date.now()}`,
-                            type: 'message',
-                            role: 'assistant',
-                            content: [{
-                                    type: 'text',
-                                    text: openAIResponse.choices?.[0]?.message?.content || ''
-                                }],
-                            model: openAIResponse.model || modelName,
-                            stop_reason: openAIResponse.choices?.[0]?.finish_reason === 'stop' ? 'end_turn' : 'max_tokens',
-                            stop_sequence: null,
-                            usage: {
-                                input_tokens: openAIResponse.usage?.prompt_tokens || 0,
-                                output_tokens: openAIResponse.usage?.completion_tokens || 0
-                            }
-                        };
-                        statusCode = 200;
+                        const anthropicResponse = (0, anthropic_converter_1.toMessagesResponse)(openAIResponse, messageId);
                         res.writeHead(200, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify(anthropicResponse));
-                        await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), undefined, backendHost + ':' + server.port, promptPreview);
+                        await this.logRequest(modelName, '/v1/messages', 200, timer.elapsed(), undefined, `${server.host}:${server.port}`, promptPreview);
+                        resolve();
                     }
                     catch (error) {
-                        console.error('[Router] Error parsing backend response:', error);
+                        console.error('[Router] Error processing backend response:', error);
                         console.error('[Router] Raw response data:', responseData.slice(0, 1000));
-                        statusCode = 502;
-                        errorMsg = `Failed to parse backend response: ${error.message}`;
-                        this.sendError(res, statusCode, 'Bad Gateway', errorMsg);
-                        await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, backendHost + ':' + server.port, promptPreview);
+                        const statusCode = 502;
+                        const errorMsg = `Failed to process backend response: ${error.message}`;
+                        const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(anthropicError));
+                        await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, `${server.host}:${server.port}`, promptPreview);
+                        reject(error);
                     }
                 });
             });
             backendReq.on('error', async (error) => {
                 console.error('[Router] Proxy request failed:', error);
-                statusCode = 502;
-                errorMsg = `Backend request failed: ${error.message}`;
-                this.sendError(res, statusCode, 'Bad Gateway', errorMsg);
-                await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, backendHost + ':' + server.port, promptPreview);
+                const statusCode = 502;
+                const errorMsg = `Backend request failed: ${error.message}`;
+                const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                if (!res.headersSent) {
+                    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(anthropicError));
+                }
+                await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, `${server.host}:${server.port}`, promptPreview);
+                reject(error);
             });
             backendReq.on('timeout', async () => {
                 console.error('[Router] Proxy request timed out');
                 backendReq.destroy();
-                statusCode = 504;
-                errorMsg = 'Request timeout';
-                this.sendError(res, statusCode, 'Gateway Timeout', errorMsg);
-                await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, backendHost + ':' + server.port, promptPreview);
+                const statusCode = 504;
+                const errorMsg = 'Request timeout';
+                const anthropicError = (0, anthropic_converter_1.createAnthropicError)(statusCode, errorMsg);
+                if (!res.headersSent) {
+                    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(anthropicError));
+                }
+                await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, `${server.host}:${server.port}`, promptPreview);
+                reject(new Error('Request timeout'));
             });
             backendReq.write(JSON.stringify(openAIRequest));
             backendReq.end();
-        }
-        catch (error) {
-            console.error('[Router] Error handling Anthropic messages request:', error);
-            statusCode = 500;
-            errorMsg = error.message;
-            this.sendError(res, statusCode, 'Internal Server Error', errorMsg);
-            await this.logRequest(modelName, '/v1/messages', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
-        }
+        });
+    }
+    /**
+     * Handle streaming Anthropic Messages request
+     */
+    async handleAnthropicStreaming(anthropicRequest, openAIRequest, backendUrl, messageId, res, timer, modelName, promptPreview, server) {
+        // Set SSE headers
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+        });
+        // Create stream converter
+        const estimatedTokens = (0, anthropic_converter_1.estimateInputTokens)(anthropicRequest);
+        const converter = new anthropic_stream_converter_1.AnthropicStreamConverter(messageId, anthropicRequest.model, estimatedTokens);
+        const url = new url_1.URL(backendUrl);
+        const options = {
+            hostname: url.hostname,
+            port: url.port,
+            path: url.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            timeout: this.config.requestTimeout,
+        };
+        return new Promise((resolve, reject) => {
+            const backendReq = http.request(options, (backendRes) => {
+                let buffer = '';
+                backendRes.on('data', (chunk) => {
+                    buffer += chunk.toString();
+                    // Process complete SSE events
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                    for (const line of lines) {
+                        if (line.startsWith('data: ')) {
+                            const data = line.slice(6);
+                            if (data === '[DONE]') {
+                                res.write('data: [DONE]\n\n');
+                                continue;
+                            }
+                            try {
+                                const chunk = JSON.parse(data);
+                                const events = converter.process(chunk);
+                                // Emit Anthropic SSE events
+                                for (const event of events) {
+                                    res.write(`event: ${event.type}\n`);
+                                    res.write(`data: ${JSON.stringify(event)}\n\n`);
+                                }
+                            }
+                            catch (error) {
+                                console.error('[Router] Error parsing streaming chunk:', error);
+                            }
+                        }
+                    }
+                });
+                backendRes.on('end', async () => {
+                    res.end();
+                    await this.logRequest(modelName, '/v1/messages', 200, timer.elapsed(), undefined, `${server.host}:${server.port}`, promptPreview);
+                    resolve();
+                });
+            });
+            backendReq.on('error', async (error) => {
+                console.error('[Router] Streaming proxy request failed:', error);
+                const errorEvent = (0, anthropic_converter_1.createAnthropicError)(502, `Backend request failed: ${error.message}`);
+                res.write(`event: error\n`);
+                res.write(`data: ${JSON.stringify(errorEvent)}\n\n`);
+                res.end();
+                await this.logRequest(modelName, '/v1/messages', 502, timer.elapsed(), error.message, `${server.host}:${server.port}`, promptPreview);
+                reject(error);
+            });
+            backendReq.on('timeout', async () => {
+                console.error('[Router] Streaming proxy request timed out');
+                backendReq.destroy();
+                const errorEvent = (0, anthropic_converter_1.createAnthropicError)(504, 'Request timeout');
+                res.write(`event: error\n`);
+                res.write(`data: ${JSON.stringify(errorEvent)}\n\n`);
+                res.end();
+                await this.logRequest(modelName, '/v1/messages', 504, timer.elapsed(), 'Request timeout', `${server.host}:${server.port}`, promptPreview);
+                reject(new Error('Request timeout'));
+            });
+            backendReq.write(JSON.stringify(openAIRequest));
+            backendReq.end();
+        });
     }
     /**
      * Chat completions endpoint - route to backend server