aicodeswitch 4.0.4 → 5.1.0

package/dist/server/conversions/pairs/responses-claude/request.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * OpenAI Responses API → Claude Messages request conversion.
+ *
+ * Converts a Responses API request body into a Claude Messages request body.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responsesToClaude = responsesToClaude;
+const effort_js_1 = require("../../thinking/effort.js");
+const tool_schema_js_1 = require("../../utils/tool-schema.js");
+/**
+ * Convert an OpenAI Responses API request body to a Claude Messages request body.
+ */
+function responsesToClaude(body) {
+    var _a, _b;
+    const messages = [];
+    let systemPrompt;
+    // --- Instructions -> system ---
+    if (body.instructions) {
+        systemPrompt = typeof body.instructions === 'string'
+            ? body.instructions
+            : undefined;
+    }
+    // --- Input -> messages ---
+    // Track pending thinking blocks from reasoning items to merge into next assistant message
+    let pendingThinking = [];
+    if (body.input) {
+        for (const item of body.input) {
+            if (item.type === 'message') {
+                if (item.role === 'user') {
+                    const content = extractMessageContent(item, 'input_text');
+                    if (content.length > 0) {
+                        messages.push({ role: 'user', content });
+                    }
+                }
+                else if (item.role === 'assistant' || item.role === 'developer') {
+                    const content = extractMessageContent(item, 'output_text');
+                    // Prepend pending thinking blocks from preceding reasoning items
+                    if (pendingThinking.length > 0) {
+                        content.unshift(...pendingThinking);
+                        pendingThinking = [];
+                    }
+                    if (content.length > 0) {
+                        messages.push({ role: item.role === 'developer' ? 'user' : 'assistant', content });
+                    }
+                }
+            }
+            else if (item.type === 'function_call') {
+                let parsedInput;
+                try {
+                    parsedInput = typeof item.arguments === 'string' ? JSON.parse(item.arguments) : item.arguments;
+                }
+                catch (_c) {
+                    parsedInput = item.arguments;
+                }
+                const content = [];
+                // Prepend pending thinking blocks from preceding reasoning items
+                if (pendingThinking.length > 0) {
+                    content.push(...pendingThinking);
+                    pendingThinking = [];
+                }
+                content.push({
+                    type: 'tool_use',
+                    id: item.call_id,
+                    name: item.name,
+                    input: parsedInput,
+                });
+                messages.push({ role: 'assistant', content });
+            }
+            else if (item.type === 'function_call_output') {
+                messages.push({
+                    role: 'user',
+                    content: [{
+                            type: 'tool_result',
+                            tool_use_id: item.call_id,
+                            content: item.output,
+                        }],
+                });
+            }
+            else if (item.type === 'reasoning') {
+                // Convert reasoning summary to Claude thinking block and attach to next assistant message
+                if (item.summary && Array.isArray(item.summary)) {
+                    const thinkingText = item.summary
+                        .filter((s) => s.type === 'summary_text')
+                        .map((s) => s.text || '')
+                        .join('');
+                    if (thinkingText) {
+                        pendingThinking.push({ type: 'thinking', thinking: thinkingText });
+                    }
+                }
+                continue;
+            }
+        }
+    }
+    // If there are orphaned thinking blocks (reasoning at end with no following assistant message),
+    // create a standalone assistant message to hold them
+    if (pendingThinking.length > 0) {
+        messages.push({ role: 'assistant', content: pendingThinking });
+    }
+    // --- Build result ---
+    const result = {
+        model: body.model,
+        messages,
+        max_tokens: body.max_output_tokens || 8192,
+        stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false,
+    };
+    if (systemPrompt)
+        result.system = systemPrompt;
+    if (body.temperature !== undefined)
+        result.temperature = body.temperature;
+    if (body.top_p !== undefined)
+        result.top_p = body.top_p;
+    // --- Reasoning -> thinking ---
+    if ((_b = body.reasoning) === null || _b === void 0 ? void 0 : _b.effort) {
+        result.thinking = (0, effort_js_1.reasoningEffortToClaudeThinking)(body.reasoning.effort);
+    }
+    // --- Tools ---
+    if (body.tools && body.tools.length > 0) {
+        result.tools = (0, tool_schema_js_1.responsesToClaudeTools)(body.tools);
+    }
+    // --- Tool choice reverse mapping ---
+    if (body.tool_choice !== undefined) {
+        result.tool_choice = mapResponsesToolChoice(body.tool_choice);
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract content blocks from a Responses API message item into Claude content blocks.
+ */
+function extractMessageContent(item, textType) {
+    const content = [];
+    if (item.content) {
+        if (typeof item.content === 'string') {
+            content.push({ type: 'text', text: item.content });
+        }
+        else if (Array.isArray(item.content)) {
+            for (const part of item.content) {
+                if (part.type === textType || part.type === 'text') {
+                    content.push({ type: 'text', text: part.text || '' });
+                }
+                else if (part.type === 'input_image' && part.image_url) {
+                    // Parse data URL back into image block
+                    const dataUrlMatch = part.image_url.match(/^data:([^;]+);base64,(.+)$/);
+                    if (dataUrlMatch) {
+                        content.push({
+                            type: 'image',
+                            source: {
+                                type: 'base64',
+                                media_type: dataUrlMatch[1],
+                                data: dataUrlMatch[2],
+                            },
+                        });
+                    }
+                }
+            }
+        }
+    }
+    if (item.text) {
+        content.push({ type: 'text', text: item.text });
+    }
+    return content;
+}
+/**
+ * Map Responses API tool_choice to Claude tool_choice.
+ */
+function mapResponsesToolChoice(toolChoice) {
+    if (toolChoice === 'required')
+        return { type: 'any' };
+    if (toolChoice === 'auto')
+        return { type: 'auto' };
+    if (toolChoice === 'none')
+        return { type: 'none' };
+    if (typeof toolChoice === 'object' && toolChoice.type === 'function') {
+        return { type: 'tool', name: toolChoice.name };
+    }
+    return { type: 'auto' };
+}

package/dist/server/conversions/pairs/responses-claude/response.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Claude Messages → OpenAI Responses API response conversion.
+ *
+ * Converts a Claude Messages response body into an OpenAI Responses API response body.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeToResponsesResponse = claudeToResponsesResponse;
+const id_js_1 = require("../../utils/id.js");
+const stop_reasons_js_1 = require("../../utils/stop-reasons.js");
+const mapper_js_1 = require("../../thinking/mapper.js");
+/**
+ * Convert a Claude Messages response to an OpenAI Responses API response.
+ */
+function claudeToResponsesResponse(response) {
+    const output = [];
+    for (const block of (response.content || [])) {
+        if (block.type === 'thinking') {
+            output.push({
+                type: 'reasoning',
+                id: `rs_${(0, id_js_1.generateCallId)().slice(5)}`,
+                summary: (0, mapper_js_1.thinkingToReasoningSummary)(block.thinking || ''),
+            });
+        }
+        else if (block.type === 'text') {
+            output.push({
+                type: 'message',
+                status: 'completed',
+                role: 'assistant',
+                content: [{
+                        type: 'output_text',
+                        text: block.text,
+                        annotations: [],
+                    }],
+            });
+        }
+        else if (block.type === 'tool_use') {
+            output.push({
+                type: 'function_call',
+                status: 'completed',
+                call_id: block.id,
+                name: block.name,
+                arguments: typeof block.input === 'string' ? block.input : JSON.stringify(block.input),
+            });
+        }
+    }
+    const { status, incomplete_details } = (0, stop_reasons_js_1.claudeToResponsesStatus)(response.stop_reason);
+    const usage = claudeToResponsesUsage(response.usage);
+    const responseId = response.id || (0, id_js_1.generateResponseId)();
+    return Object.assign(Object.assign({ id: responseId, object: 'response', status,
+        output, model: response.model || '', created_at: Math.floor(Date.now() / 1000), usage }, (incomplete_details ? { incomplete_details } : {})), { metadata: {} });
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Map Claude usage to Responses API usage.
+ */
+function claudeToResponsesUsage(usage) {
+    var _a, _b;
+    if (!usage)
+        return { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+    const input = (_a = usage.input_tokens) !== null && _a !== void 0 ? _a : 0;
+    const output = (_b = usage.output_tokens) !== null && _b !== void 0 ? _b : 0;
+    return {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: input + output,
+    };
+}

package/dist/server/conversions/pairs/responses-claude/streaming.js

@@ -0,0 +1,345 @@
+"use strict";
+/**
+ * Claude Messages SSE → OpenAI Responses API SSE streaming conversion.
+ *
+ * Stateful converter that translates Claude Messages SSE events into
+ * OpenAI Responses API SSE events.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeToResponsesConverter = void 0;
+const id_js_1 = require("../../utils/id.js");
+const stop_reasons_js_1 = require("../../utils/stop-reasons.js");
+const streaming_helpers_js_1 = require("../../utils/streaming-helpers.js");
+/**
+ * ClaudeToResponsesConverter: Claude Messages SSE → Responses API SSE
+ */
+class ClaudeToResponsesConverter {
+    constructor() {
+        Object.defineProperty(this, "finalized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "textStarted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "thinkingStarted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "responseId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (0, id_js_1.generateResponseId)()
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "usage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { input_tokens: 0, output_tokens: 0 }
+        });
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "currentToolCallId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "currentToolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "currentToolArguments", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "reasoningText", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "pendingStopReason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    convertEvent(event) {
+        var _a, _b, _c, _d, _e;
+        if (!event.data)
+            return [];
+        const events = [];
+        try {
+            const data = (0, streaming_helpers_js_1.parseEventData)(event.data);
+            switch (data.type) {
+                case 'message_start': {
+                    this.model = ((_a = data.message) === null || _a === void 0 ? void 0 : _a.model) || '';
+                    this.responseId = ((_b = data.message) === null || _b === void 0 ? void 0 : _b.id) || this.responseId;
+                    events.push(this.makeSSE('response.created', {
+                        id: this.responseId,
+                        object: 'response',
+                        status: 'in_progress',
+                        model: this.model,
+                        output: [],
+                    }));
+                    events.push(this.makeSSE('response.in_progress', {
+                        id: this.responseId,
+                        object: 'response',
+                        status: 'in_progress',
+                        model: this.model,
+                        output: [],
+                    }));
+                    break;
+                }
+                case 'content_block_start': {
+                    const block = data.content_block;
+                    if ((block === null || block === void 0 ? void 0 : block.type) === 'thinking') {
+                        // Close text if open
+                        this.closeText(events);
+                        const rsIdx = this.output.length;
+                        events.push(this.makeSSE('response.output_item.added', {
+                            output_index: rsIdx,
+                            item: { type: 'reasoning', id: `rs_${(0, id_js_1.generateCallId)().slice(5)}` },
+                        }));
+                        events.push(this.makeSSE('response.reasoning_summary_part.added', {
+                            output_index: rsIdx,
+                            summary_index: 0,
+                            part: { type: 'summary_text' },
+                        }));
+                        this.thinkingStarted = true;
+                        this.reasoningText = '';
+                    }
+                    else if ((block === null || block === void 0 ? void 0 : block.type) === 'text') {
+                        // Close thinking if open
+                        this.closeThinking(events);
+                        const msgIdx = this.output.length;
+                        events.push(this.makeSSE('response.output_item.added', {
+                            output_index: msgIdx,
+                            item: { type: 'message', status: 'in_progress', role: 'assistant', content: [] },
+                        }));
+                        events.push(this.makeSSE('response.content_part.added', {
+                            output_index: msgIdx,
+                            content_index: 0,
+                            part: { type: 'output_text', text: '', annotations: [] },
+                        }));
+                        this.textStarted = true;
+                    }
+                    else if ((block === null || block === void 0 ? void 0 : block.type) === 'tool_use') {
+                        // Close any open blocks
+                        this.closeText(events);
+                        this.closeThinking(events);
+                        this.currentToolCallId = block.id;
+                        this.currentToolName = block.name;
+                        this.currentToolArguments = '';
+                        const toolIdx = this.output.length;
+                        events.push(this.makeSSE('response.output_item.added', {
+                            output_index: toolIdx,
+                            item: {
+                                type: 'function_call',
+                                status: 'in_progress',
+                                call_id: block.id,
+                                name: block.name,
+                                arguments: '',
+                            },
+                        }));
+                    }
+                    break;
+                }
+                case 'content_block_delta': {
+                    const delta = data.delta;
+                    if ((delta === null || delta === void 0 ? void 0 : delta.type) === 'thinking_delta') {
+                        const text = delta.thinking || '';
+                        if (text) {
+                            this.reasoningText += text;
+                            events.push(this.makeSSE('response.reasoning_summary_text.delta', {
+                                output_index: this.output.length,
+                                delta: text,
+                            }));
+                        }
+                    }
+                    else if ((delta === null || delta === void 0 ? void 0 : delta.type) === 'text_delta') {
+                        const text = delta.text || '';
+                        if (text) {
+                            events.push(this.makeSSE('response.output_text.delta', {
+                                output_index: this.textMessageOutputIndex(),
+                                content_index: 0,
+                                delta: text,
+                            }));
+                        }
+                    }
+                    else if ((delta === null || delta === void 0 ? void 0 : delta.type) === 'input_json_delta') {
+                        const partialJson = delta.partial_json || '';
+                        if (partialJson) {
+                            this.currentToolArguments += partialJson;
+                            events.push(this.makeSSE('response.function_call_arguments.delta', {
+                                output_index: this.output.length,
+                                call_id: this.currentToolCallId,
+                                delta: partialJson,
+                            }));
+                        }
+                    }
+                    break;
+                }
+                case 'content_block_stop': {
+                    // If this was a tool_use block, emit function_call_arguments.done and output_item.done
+                    if (this.currentToolCallId !== null) {
+                        const tcIdx = this.output.length;
+                        events.push(this.makeSSE('response.function_call_arguments.done', {
+                            output_index: tcIdx,
+                            call_id: this.currentToolCallId,
+                        }));
+                        events.push(this.makeSSE('response.output_item.done', {
+                            output_index: tcIdx,
+                            item: {
+                                type: 'function_call',
+                                status: 'completed',
+                                call_id: this.currentToolCallId,
+                                name: this.currentToolName || '',
+                                arguments: this.currentToolArguments,
+                            },
+                        }));
+                        this.output.push({
+                            type: 'function_call',
+                            status: 'completed',
+                            call_id: this.currentToolCallId,
+                            name: this.currentToolName,
+                            arguments: this.currentToolArguments,
+                        });
+                        this.currentToolCallId = null;
+                        this.currentToolName = null;
+                        this.currentToolArguments = '';
+                    }
+                    break;
+                }
+                case 'message_delta': {
+                    this.pendingStopReason = ((_c = data.delta) === null || _c === void 0 ? void 0 : _c.stop_reason) || null;
+                    if (data.usage) {
+                        this.usage = {
+                            input_tokens: this.usage.input_tokens,
+                            output_tokens: (_e = (_d = data.usage.output_tokens) !== null && _d !== void 0 ? _d : data.usage.tokens) !== null && _e !== void 0 ? _e : 0,
+                        };
+                    }
+                    break;
+                }
+                case 'message_stop': {
+                    this.finalize(events);
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        catch (_f) {
+            // Ignore parse errors
+        }
+        return events;
+    }
+    /**
+     * Get the output index of the text message.
+     * The text message is at the last output index that hasn't been pushed yet.
+     */
+    textMessageOutputIndex() {
+        // During streaming, text output hasn't been pushed yet.
+        // Its index is determined by what's already been pushed + whether it's after reasoning.
+        return this.thinkingStarted ? this.output.length : this.output.length;
+    }
+    closeText(events) {
+        if (this.textStarted) {
+            const msgIdx = this.output.length;
+            events.push(this.makeSSE('response.output_text.done', {
+                output_index: msgIdx,
+                content_index: 0,
+                text: '',
+            }));
+            events.push(this.makeSSE('response.content_part.done', {
+                output_index: msgIdx,
+                content_index: 0,
+                part: { type: 'output_text', text: '', annotations: [] },
+            }));
+            this.output.push({ type: 'message', status: 'completed', role: 'assistant' });
+            events.push(this.makeSSE('response.output_item.done', {
+                output_index: this.output.length - 1,
+                item: { type: 'message', status: 'completed', role: 'assistant' },
+            }));
+            this.textStarted = false;
+        }
+    }
+    closeThinking(events) {
+        if (this.thinkingStarted) {
+            const rsIdx = this.output.length;
+            events.push(this.makeSSE('response.reasoning.done', {
+                output_index: rsIdx,
+                summary: [{ type: 'summary_text', text: this.reasoningText }],
+            }));
+            events.push(this.makeSSE('response.reasoning_summary_part.done', {
+                output_index: rsIdx,
+            }));
+            events.push(this.makeSSE('response.output_item.done', {
+                output_index: rsIdx,
+                item: { type: 'reasoning' },
+            }));
+            this.output.push({ type: 'reasoning' });
+            this.thinkingStarted = false;
+            this.reasoningText = '';
+        }
+    }
+    finalize(events) {
+        if (this.finalized)
+            return;
+        this.finalized = true;
+        // Close any open blocks
+        this.closeText(events);
+        this.closeThinking(events);
+        const { status, incomplete_details } = (0, stop_reasons_js_1.claudeToResponsesStatus)(this.pendingStopReason);
+        const responseObj = {
+            id: this.responseId,
+            object: 'response',
+            status,
+            output: this.output,
+            model: this.model,
+            created_at: Math.floor(Date.now() / 1000),
+            usage: {
+                input_tokens: this.usage.input_tokens,
+                output_tokens: this.usage.output_tokens,
+                total_tokens: this.usage.input_tokens + this.usage.output_tokens,
+            },
+            metadata: {},
+        };
+        if (incomplete_details) {
+            responseObj.incomplete_details = incomplete_details;
+        }
+        events.push(this.makeSSE('response.completed', { response: responseObj }));
+        events.push({ data: '[DONE]', event: '' });
+    }
+    makeSSE(eventName, data) {
+        return {
+            event: eventName,
+            data,
+        };
+    }
+}
+exports.ClaudeToResponsesConverter = ClaudeToResponsesConverter;