claude-codex-proxy 1.0.0

package/src/response-streamer.js

@@ -0,0 +1,469 @@
+/**
+ * Response Streamer
+ * Streams SSE events from OpenAI Responses API and converts to Anthropic format
+ */
+
+import { generateMessageId, sanitizeAnthropicToolInputJson, toAnthropicToolId } from './format-converter.js';
+import { cacheSignature, cacheThinkingSignature, SIGNATURE_CONSTANTS } from './signature-cache.js';
+import { getServerSettings } from './server-settings.js';
+import { logger } from './utils/logger.js';
+
+const { MIN_SIGNATURE_LENGTH } = SIGNATURE_CONSTANTS;
+
+function shouldLogRawProxyPayloads() {
+    return getServerSettings().logRawProxyPayloads === true;
+}
+
+export function createResponsesAPIError(message, status = 502) {
+    const error = new Error(message);
+    error.status = status;
+    error.anthropicErrorType = 'api_error';
+    error.isUpstreamError = true;
+    return error;
+}
+
+function isResponsesAPIErrorEvent(event) {
+    return ['response.failed', 'response.incomplete', 'response.error', 'error'].includes(event?.type) || Boolean(event?.error);
+}
+
+function getResponsesAPIErrorMessage(event) {
+    const error = event?.error || event?.response?.error || event?.response?.incomplete_details;
+    if (!error) return `Upstream Responses API failed: ${event?.type || 'unknown_error'}`;
+    if (typeof error === 'string') return error;
+    return error.message || error.reason || JSON.stringify(error);
+}
+
+function throwIfResponsesAPIError(event) {
+    if (!isResponsesAPIErrorEvent(event)) return;
+    throw createResponsesAPIError(getResponsesAPIErrorMessage(event));
+}
+
+/**
+ * Stream OpenAI Responses API SSE events and yield Anthropic-format events
+ *
+ * OpenAI Responses API event types:
+ * - response.created
+ * - response.in_progress
+ * - response.output_item.added (type: message, function_call, reasoning)
+ * - response.output_text.delta
+ * - response.function_call_arguments.delta
+ * - response.function_call_arguments.done
+ * - response.output_item.done
+ * - response.completed
+ *
+ * Anthropic event types:
+ * - message_start
+ * - content_block_start
+ * - content_block_delta
+ * - content_block_stop
+ * - message_delta
+ * - message_stop
+ *
+ * @param {Response} response - The HTTP response with SSE body
+ * @param {string} model - The model name
+ * @yields {Object} Anthropic-format SSE events
+ */
+export async function* streamResponsesAPI(response, model) {
+    const messageId = generateMessageId();
+    let hasEmittedStart = false;
+    let blockIndex = 0;
+    let currentBlockType = null;
+    let currentBlockId = null;
+    let currentToolName = null;
+    let currentThinkingSignature = '';
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let stopReason = 'end_turn';
+    let pendingArguments = '';
+    let usage = { input_tokens: 0, output_tokens: 0 };
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+            if (!line.startsWith('data:')) continue;
+
+            const jsonText = line.slice(5).trim();
+            if (!jsonText) continue;
+
+            try {
+                const event = JSON.parse(jsonText);
+                throwIfResponsesAPIError(event);
+                const eventType = event.type;
+
+                // Extract usage from completed response
+                if (eventType === 'response.completed' && event.response?.usage) {
+                    if (shouldLogRawProxyPayloads()) {
+                        logger.info('[OpenAI Response Completed]', event.response);
+                    }
+                    inputTokens = event.response.usage.input_tokens || 0;
+                    outputTokens = event.response.usage.output_tokens || 0;
+                    usage = {
+                        input_tokens: inputTokens,
+                        output_tokens: outputTokens,
+                        cache_read_input_tokens: event.response.usage.cache_read_input_tokens || event.response.usage.input_tokens_details?.cached_tokens || 0
+                    };
+                }
+
+                // Handle output item added
+                if (eventType === 'response.output_item.added') {
+                    const item = event.item;
+                    
+                    if (!hasEmittedStart) {
+                        hasEmittedStart = true;
+                        yield {
+                            event: 'message_start',
+                            data: {
+                                type: 'message_start',
+                                message: {
+                                    id: messageId,
+                                    type: 'message',
+                                    role: 'assistant',
+                                    model: model,
+                                    content: [],
+                                    stop_reason: null,
+                                    stop_sequence: null,
+                                    usage: { input_tokens: 0, output_tokens: 0 }
+                                }
+                            }
+                        };
+                    }
+
+                    // Close previous block if any (with signature_delta for thinking)
+                    if (currentBlockType !== null) {
+                        // Emit signature_delta before closing thinking block
+                        if (currentBlockType === 'thinking' && currentThinkingSignature) {
+                            yield {
+                                event: 'content_block_delta',
+                                data: {
+                                    type: 'content_block_delta',
+                                    index: blockIndex,
+                                    delta: { type: 'signature_delta', signature: currentThinkingSignature }
+                                }
+                            };
+                            currentThinkingSignature = '';
+                        }
+                        yield {
+                            event: 'content_block_stop',
+                            data: { type: 'content_block_stop', index: blockIndex }
+                        };
+                        blockIndex++;
+                    }
+
+                    // Start new block based on item type
+                    if (item.type === 'message') {
+                        currentBlockType = 'text';
+                        currentBlockId = item.id;
+                        yield {
+                            event: 'content_block_start',
+                            data: {
+                                type: 'content_block_start',
+                                index: blockIndex,
+                                content_block: { type: 'text', text: '' }
+                            }
+                        };
+                    } else if (item.type === 'function_call') {
+                        currentBlockType = 'tool_use';
+                        // Convert OpenAI fc_ ID back to Anthropic ID
+                        const openAIId = item.call_id || item.id;
+                        currentBlockId = toAnthropicToolId(openAIId);
+                        currentToolName = item.name;
+                        pendingArguments = '';
+                        stopReason = 'tool_use';
+
+                        yield {
+                            event: 'content_block_start',
+                            data: {
+                                type: 'content_block_start',
+                                index: blockIndex,
+                                content_block: {
+                                    type: 'tool_use',
+                                    id: currentBlockId,
+                                    name: item.name,
+                                    input: {}
+                                }
+                            }
+                        };
+                    } else if (item.type === 'reasoning') {
+                        currentBlockType = 'thinking';
+                        currentBlockId = item.id;
+                        currentThinkingSignature = '';
+                        
+                        yield {
+                            event: 'content_block_start',
+                            data: {
+                                type: 'content_block_start',
+                                index: blockIndex,
+                                content_block: { type: 'thinking', thinking: '' }
+                            }
+                        };
+                    }
+                }
+
+                // Handle text delta
+                if (eventType === 'response.output_text.delta') {
+                    const delta = event.delta;
+                    if (delta) {
+                        // If we're in a thinking block, treat text as thinking content
+                        if (currentBlockType === 'thinking') {
+                            yield {
+                                event: 'content_block_delta',
+                                data: {
+                                    type: 'content_block_delta',
+                                    index: blockIndex,
+                                    delta: { type: 'thinking_delta', thinking: delta }
+                                }
+                            };
+                        } else if (currentBlockType === 'text') {
+                            yield {
+                                event: 'content_block_delta',
+                                data: {
+                                    type: 'content_block_delta',
+                                    index: blockIndex,
+                                    delta: { type: 'text_delta', text: delta }
+                                }
+                            };
+                        }
+                    }
+                }
+
+                // Handle thinking/reasoning delta
+                if (eventType === 'response.reasoning.delta' || eventType === 'response.thinking.delta') {
+                    const delta = event.delta || event.thinking;
+                    if (delta && currentBlockType === 'thinking') {
+                        // Check for signature in the event
+                        if (event.signature && event.signature.length >= MIN_SIGNATURE_LENGTH) {
+                            currentThinkingSignature = event.signature;
+                            // Cache the signature with model family
+                            cacheThinkingSignature(event.signature, 'openai');
+                        }
+                        
+                        yield {
+                            event: 'content_block_delta',
+                            data: {
+                                type: 'content_block_delta',
+                                index: blockIndex,
+                                delta: { type: 'thinking_delta', thinking: delta }
+                            }
+                        };
+                    }
+                }
+
+                // Handle function call arguments delta
+                if (eventType === 'response.function_call_arguments.delta') {
+                    const delta = event.delta;
+                    if (delta && currentBlockType === 'tool_use') {
+                        if (currentToolName === 'Read') {
+                            pendingArguments += delta;
+                        } else {
+                            yield {
+                                event: 'content_block_delta',
+                                data: {
+                                    type: 'content_block_delta',
+                                    index: blockIndex,
+                                    delta: { type: 'input_json_delta', partial_json: delta }
+                                }
+                            };
+                        }
+                    }
+                }
+
+                // Handle function call arguments done
+                if (eventType === 'response.function_call_arguments.done') {
+                    if (currentToolName === 'Read') {
+                        const rawArguments = event.arguments || pendingArguments;
+                        const sanitizedArguments = sanitizeAnthropicToolInputJson(currentToolName, rawArguments);
+                        if (sanitizedArguments && currentBlockType === 'tool_use') {
+                            yield {
+                                event: 'content_block_delta',
+                                data: {
+                                    type: 'content_block_delta',
+                                    index: blockIndex,
+                                    delta: { type: 'input_json_delta', partial_json: sanitizedArguments }
+                                }
+                            };
+                        }
+                    }
+                    pendingArguments = '';
+
+                    // Check for signature on the tool call
+                    if (event.signature && event.signature.length >= MIN_SIGNATURE_LENGTH && currentBlockId) {
+                        cacheSignature(currentBlockId, event.signature);
+                    }
+                }
+
+                // Handle output item done - capture signature if present
+                if (eventType === 'response.output_item.done') {
+                    const item = event.item;
+                    if (item) {
+                        // Capture thinking signature
+                        if (item.type === 'reasoning' && item.signature) {
+                            if (item.signature.length >= MIN_SIGNATURE_LENGTH) {
+                                currentThinkingSignature = item.signature;
+                                cacheThinkingSignature(item.signature, 'openai');
+                            }
+                        }
+                        // Capture tool signature
+                        if (item.type === 'function_call' && item.signature && currentBlockId) {
+                            cacheSignature(currentBlockId, item.signature);
+                        }
+                    }
+                }
+
+            } catch (parseError) {
+                if (parseError.isUpstreamError) throw parseError;
+                // Ignore parse errors for individual lines
+            }
+        }
+    }
+
+    // Handle no content received
+    if (!hasEmittedStart) {
+        hasEmittedStart = true;
+        yield {
+            event: 'message_start',
+            data: {
+                type: 'message_start',
+                message: {
+                    id: messageId,
+                    type: 'message',
+                    role: 'assistant',
+                    model: model,
+                    content: [],
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: { input_tokens: 0, output_tokens: 0 }
+                }
+            }
+        };
+        
+        // Emit empty text block
+        yield {
+            event: 'content_block_start',
+            data: {
+                type: 'content_block_start',
+                index: 0,
+                content_block: { type: 'text', text: '' }
+            }
+        };
+        
+        yield {
+            event: 'content_block_delta',
+            data: {
+                type: 'content_block_delta',
+                index: 0,
+                delta: { type: 'text_delta', text: '' }
+            }
+        };
+        
+        yield {
+            event: 'content_block_stop',
+            data: { type: 'content_block_stop', index: 0 }
+        };
+        
+        blockIndex = 1;
+        currentBlockType = null;
+    } else if (currentBlockType !== null) {
+        // Close any open block with signature_delta if thinking
+        if (currentBlockType === 'thinking' && currentThinkingSignature) {
+            yield {
+                event: 'content_block_delta',
+                data: {
+                    type: 'content_block_delta',
+                    index: blockIndex,
+                    delta: { type: 'signature_delta', signature: currentThinkingSignature }
+                }
+            };
+        }
+        yield {
+            event: 'content_block_stop',
+            data: { type: 'content_block_stop', index: blockIndex }
+        };
+    }
+
+    // Emit message_delta with final usage
+    yield {
+        event: 'message_delta',
+        data: {
+            type: 'message_delta',
+            delta: { stop_reason: stopReason, stop_sequence: null },
+            usage: usage
+        }
+    };
+
+    // Emit message_stop
+    yield {
+        event: 'message_stop',
+        data: { type: 'message_stop' }
+    };
+}
+
+/**
+ * Parse SSE events from OpenAI Responses API (non-streaming)
+ * Returns the final response object
+ *
+ * @param {Response} response - The HTTP response with SSE body
+ * @returns {Object} The parsed response object
+ */
+export async function parseResponsesAPIResponse(response) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let finalResponse = null;
+
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+            if (!line.startsWith('data:')) continue;
+
+            const jsonText = line.slice(5).trim();
+            if (!jsonText) continue;
+
+            try {
+                const event = JSON.parse(jsonText);
+                throwIfResponsesAPIError(event);
+
+                // Capture the completed response
+                if (event.type === 'response.completed') {
+                    if (shouldLogRawProxyPayloads()) {
+                        logger.info('[OpenAI Response Completed]', event.response);
+                    }
+                    finalResponse = event.response;
+                }
+            } catch (parseError) {
+                if (parseError.isUpstreamError) throw parseError;
+                // Ignore parse errors
+            }
+        }
+    }
+
+    return finalResponse;
+}
+
+/**
+ * Format Anthropic SSE event for HTTP response
+ */
+export function formatSSEEvent(event) {
+    return `event: ${event.event}\ndata: ${JSON.stringify(event.data)}\n\n`;
+}
+
+export default {
+    streamResponsesAPI,
+    parseResponsesAPIResponse,
+    formatSSEEvent
+};