aicodeswitch 4.0.4 → 5.1.0

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

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * Claude Messages → OpenAI Responses API request conversion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeToResponses = claudeToResponses;
+const effort_js_1 = require("../../thinking/effort.js");
+const tool_schema_js_1 = require("../../utils/tool-schema.js");
+/**
+ * Convert a Claude Messages request body to an OpenAI Responses API request body.
+ */
+function claudeToResponses(body) {
+    var _a;
+    const input = [];
+    // --- System prompt -> instructions ---
+    let instructions;
+    if (body.system) {
+        instructions = typeof body.system === 'string'
+            ? body.system
+            : Array.isArray(body.system)
+                ? body.system
+                    .filter((s) => s.type === 'text' || typeof s.text === 'string')
+                    .map((s) => s.text || '')
+                    .join('\n')
+                : undefined;
+        // Strip any x-anthropic-billing-header prefixes
+        if (instructions) {
+            instructions = instructions.replace(/^x-anthropic-billing-header[^\n]*\n?/gi, '');
+        }
+    }
+    // --- Messages -> input array ---
+    if (body.messages) {
+        const buffer = new MessageBuffer();
+        for (const msg of body.messages) {
+            buffer.setCurrentRole(msg.role);
+            const content = msg.content;
+            if (typeof content === 'string') {
+                buffer.addText(content);
+            }
+            else if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === 'text') {
+                        buffer.addText(block.text);
+                    }
+                    else if (block.type === 'image') {
+                        buffer.addImage(block);
+                    }
+                    else if (block.type === 'tool_use') {
+                        // Flush buffered content first, then emit standalone function_call
+                        buffer.flush(input);
+                        input.push({
+                            type: 'function_call',
+                            call_id: block.id,
+                            name: block.name,
+                            arguments: typeof block.input === 'string' ? block.input : JSON.stringify(block.input),
+                        });
+                    }
+                    else if (block.type === 'tool_result') {
+                        // Flush buffered content first, then emit standalone function_call_output
+                        buffer.flush(input);
+                        const outputContent = typeof block.content === 'string'
+                            ? block.content
+                            : JSON.stringify(block.content);
+                        input.push({
+                            type: 'function_call_output',
+                            call_id: block.tool_use_id,
+                            output: outputContent,
+                        });
+                    }
+                    else if (block.type === 'thinking' || block.type === 'redacted_thinking') {
+                        // Skip thinking blocks
+                        continue;
+                    }
+                }
+            }
+        }
+        // Flush any remaining buffered content
+        buffer.flush(input);
+    }
+    // --- Build result ---
+    const result = {
+        model: body.model,
+        input,
+        stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false,
+    };
+    if (instructions)
+        result.instructions = instructions;
+    if (body.max_tokens)
+        result.max_output_tokens = body.max_tokens;
+    if (body.temperature !== undefined)
+        result.temperature = body.temperature;
+    if (body.top_p !== undefined)
+        result.top_p = body.top_p;
+    // --- Thinking -> reasoning ---
+    if (body.thinking) {
+        const reasoning = (0, effort_js_1.claudeThinkingToResponsesReasoning)(body.thinking);
+        if (reasoning) {
+            result.reasoning = reasoning;
+        }
+    }
+    // --- Tools ---
+    if (body.tools && body.tools.length > 0) {
+        result.tools = (0, tool_schema_js_1.claudeToResponsesTools)(body.tools);
+    }
+    // --- Tool choice mapping ---
+    if (body.tool_choice) {
+        result.tool_choice = mapClaudeToolChoice(body.tool_choice);
+    }
+    // Note: stop_sequences are dropped (not supported in Responses API)
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Buffer for accumulating text/image content into a single message before
+ * flushing when encountering standalone items like function_call / function_call_output.
+ */
+class MessageBuffer {
+    constructor() {
+        Object.defineProperty(this, "currentRole", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "content", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    setCurrentRole(role) {
+        // If role changed, flush what we have
+        if (this.currentRole !== null && this.currentRole !== role && this.content.length > 0) {
+            // Role changed — caller should flush first, but for safety we just track
+        }
+        this.currentRole = role;
+    }
+    addText(text) {
+        if (!this.currentRole)
+            return;
+        const textType = this.currentRole === 'assistant' ? 'output_text' : 'input_text';
+        this.content.push({ type: textType, text });
+    }
+    addImage(block) {
+        var _a, _b;
+        if (!this.currentRole)
+            return;
+        this.content.push({
+            type: 'input_image',
+            image_url: `data:${((_a = block.source) === null || _a === void 0 ? void 0 : _a.media_type) || block.media_type || 'image/png'};base64,${((_b = block.source) === null || _b === void 0 ? void 0 : _b.data) || block.data}`,
+        });
+    }
+    flush(target) {
+        if (this.content.length === 0 || !this.currentRole) {
+            this.content = [];
+            return;
+        }
+        const role = this.currentRole;
+        target.push({ role, content: this.content });
+        this.content = [];
+    }
+}
+/**
+ * Map Claude tool_choice to Responses API tool_choice.
+ */
+function mapClaudeToolChoice(toolChoice) {
+    if (!toolChoice)
+        return undefined;
+    if (typeof toolChoice === 'string') {
+        switch (toolChoice) {
+            case 'any': return 'required';
+            case 'auto': return 'auto';
+            case 'none': return 'none';
+            default: return 'auto';
+        }
+    }
+    if (toolChoice.type === 'any')
+        return 'required';
+    if (toolChoice.type === 'auto')
+        return 'auto';
+    if (toolChoice.type === 'none')
+        return 'none';
+    if (toolChoice.type === 'tool') {
+        return { type: 'function', name: toolChoice.name };
+    }
+    return 'auto';
+}

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

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * OpenAI Responses API → Claude Messages response conversion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responsesToClaudeResponse = responsesToClaudeResponse;
+exports.claudeToResponsesUsage = claudeToResponsesUsage;
+const id_js_1 = require("../../utils/id.js");
+const stop_reasons_js_1 = require("../../utils/stop-reasons.js");
+const usage_js_1 = require("../../utils/usage.js");
+const mapper_js_1 = require("../../thinking/mapper.js");
+/**
+ * Convert an OpenAI Responses API response to a Claude Messages response.
+ */
+function responsesToClaudeResponse(response) {
+    var _a;
+    const output = response.output || [];
+    const content = [];
+    for (const item of output) {
+        if (item.type === 'message') {
+            // Message with text / refusal content
+            if (Array.isArray(item.content)) {
+                for (const part of item.content) {
+                    if (part.type === 'output_text') {
+                        content.push({ type: 'text', text: part.text || '' });
+                    }
+                    else if (part.type === 'refusal') {
+                        content.push({ type: 'text', text: part.refusal || '' });
+                    }
+                }
+            }
+        }
+        else if (item.type === 'function_call') {
+            let parsedInput;
+            try {
+                parsedInput = typeof item.arguments === 'string' ? JSON.parse(item.arguments) : item.arguments;
+            }
+            catch (_b) {
+                parsedInput = {};
+            }
+            content.push({
+                type: 'tool_use',
+                id: item.call_id || (0, id_js_1.generateCallId)(),
+                name: item.name,
+                input: parsedInput,
+            });
+        }
+        else if (item.type === 'reasoning') {
+            // Reasoning with summary -> thinking block
+            if (Array.isArray(item.summary) && item.summary.length > 0) {
+                const thinkingBlock = (0, mapper_js_1.reasoningToThinking)(item.summary);
+                if (thinkingBlock.thinking) {
+                    content.push(thinkingBlock);
+                }
+            }
+        }
+    }
+    const hasToolUse = content.some((b) => b.type === 'tool_use');
+    const stopReason = (0, stop_reasons_js_1.responsesToClaudeStopReason)(response.status, (_a = response.incomplete_details) === null || _a === void 0 ? void 0 : _a.reason, hasToolUse);
+    const usage = (0, usage_js_1.responsesToClaudeUsage)(response.usage);
+    return {
+        id: response.id || (0, id_js_1.generateMessageId)(),
+        type: 'message',
+        role: 'assistant',
+        content,
+        model: response.model || '',
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage,
+    };
+}
+// ---------------------------------------------------------------------------
+// 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/claude-responses/streaming.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * OpenAI Responses API SSE → Claude Messages SSE streaming conversion.
+ *
+ * Stateful converter that processes SSE events from an OpenAI Responses API
+ * upstream and emits Claude Messages SSE events.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsesToClaudeConverter = void 0;
+const id_js_1 = require("../../utils/id.js");
+const stop_reasons_js_1 = require("../../utils/stop-reasons.js");
+const usage_js_1 = require("../../utils/usage.js");
+const streaming_helpers_js_1 = require("../../utils/streaming-helpers.js");
+/**
+ * Stateful converter: Responses API SSE → Claude Messages SSE.
+ */
+class ResponsesToClaudeConverter {
+    constructor() {
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "messageStopped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "currentBlockType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "currentBlockIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: -1
+        });
+        Object.defineProperty(this, "nextBlockIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "messageId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (0, id_js_1.generateMessageId)()
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+    }
+    convertEvent(event) {
+        var _a;
+        if (!event.data)
+            return [];
+        const eventName = event.event;
+        const events = [];
+        try {
+            const data = (0, streaming_helpers_js_1.parseEventData)(event.data);
+            switch (eventName) {
+                case 'response.created': {
+                    this.model = data.model || '';
+                    this.started = false;
+                    this.messageStopped = false;
+                    // Will emit message_start when we get actual content
+                    break;
+                }
+                case 'response.output_item.added': {
+                    const item = data.item || data;
+                    if (item.type === 'function_call') {
+                        this.ensureStarted(events, data.model);
+                        this.closeCurrentBlock(events);
+                        // Open tool_use block
+                        const idx = this.nextBlockIndex++;
+                        events.push(this.makeSSE('content_block_start', {
+                            type: 'content_block_start',
+                            index: idx,
+                            content_block: {
+                                type: 'tool_use',
+                                id: item.call_id || (0, id_js_1.generateCallId)(),
+                                name: item.name || '',
+                                input: {},
+                            },
+                        }));
+                        this.currentBlockIndex = idx;
+                        this.currentBlockType = null; // tool_use is not tracked as a "block type" for closing
+                    }
+                    break;
+                }
+                case 'response.content_part.added': {
+                    const part = data.part || data;
+                    if (part.type === 'output_text') {
+                        this.ensureStarted(events, data.model);
+                        if (this.currentBlockType !== 'text') {
+                            this.closeCurrentBlock(events);
+                            this.openTextBlock(events);
+                        }
+                    }
+                    break;
+                }
+                case 'response.output_text.delta': {
+                    this.ensureStarted(events, data.model);
+                    if (this.currentBlockType !== 'text') {
+                        this.closeCurrentBlock(events);
+                        this.openTextBlock(events);
+                    }
+                    const delta = data.delta || '';
+                    if (delta) {
+                        events.push(this.makeSSE('content_block_delta', {
+                            type: 'content_block_delta',
+                            index: this.currentBlockIndex,
+                            delta: { type: 'text_delta', text: delta },
+                        }));
+                    }
+                    break;
+                }
+                case 'response.output_text.done': {
+                    this.closeCurrentBlock(events);
+                    break;
+                }
+                case 'response.reasoning.delta':
+                case 'response.reasoning_summary_text.delta': {
+                    this.ensureStarted(events, data.model);
+                    const text = data.delta || data.text || '';
+                    if (!text)
+                        break;
+                    if (this.currentBlockType !== 'thinking') {
+                        this.closeCurrentBlock(events);
+                        this.openThinkingBlock(events);
+                    }
+                    events.push(this.makeSSE('content_block_delta', {
+                        type: 'content_block_delta',
+                        index: this.currentBlockIndex,
+                        delta: { type: 'thinking_delta', thinking: text },
+                    }));
+                    break;
+                }
+                case 'response.reasoning.done': {
+                    this.closeCurrentBlock(events);
+                    break;
+                }
+                case 'response.function_call_arguments.delta': {
+                    const argDelta = data.delta || '';
+                    if (argDelta) {
+                        events.push(this.makeSSE('content_block_delta', {
+                            type: 'content_block_delta',
+                            index: this.currentBlockIndex,
+                            delta: { type: 'input_json_delta', partial_json: argDelta },
+                        }));
+                    }
+                    break;
+                }
+                case 'response.function_call_arguments.done': {
+                    // Close the tool_use block
+                    if (this.currentBlockIndex >= 0 && this.currentBlockType === null) {
+                        events.push(this.makeSSE('content_block_stop', {
+                            type: 'content_block_stop',
+                            index: this.currentBlockIndex,
+                        }));
+                        this.currentBlockIndex = -1;
+                        this.currentBlockType = null;
+                    }
+                    break;
+                }
+                case 'response.completed': {
+                    this.closeCurrentBlock(events);
+                    if (this.started && !this.messageStopped) {
+                        const responseData = data.response || data;
+                        const stopReason = (0, stop_reasons_js_1.responsesToClaudeStopReason)(responseData.status, (_a = responseData.incomplete_details) === null || _a === void 0 ? void 0 : _a.reason, true);
+                        const usage = (0, usage_js_1.responsesToClaudeUsage)(responseData.usage);
+                        events.push(this.makeSSE('message_delta', {
+                            type: 'message_delta',
+                            delta: { stop_reason: stopReason, stop_sequence: null },
+                            usage,
+                        }));
+                        events.push(this.makeSSE('message_stop', {
+                            type: 'message_stop',
+                        }));
+                        this.messageStopped = true;
+                    }
+                    break;
+                }
+                // Skip these events
+                case 'response.in_progress':
+                case 'response.output_item.done':
+                case 'response.content_part.done':
+                case 'response.reasoning_summary_part.added':
+                case 'response.reasoning_summary_part.done':
+                    break;
+                default:
+                    break;
+            }
+        }
+        catch (_b) {
+            // Ignore parse errors
+        }
+        return events;
+    }
+    ensureStarted(events, model) {
+        if (this.started)
+            return;
+        if (model)
+            this.model = model;
+        events.push(this.makeSSE('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: 0, output_tokens: 0 },
+            },
+        }));
+        this.started = true;
+    }
+    openTextBlock(events) {
+        const idx = this.nextBlockIndex++;
+        events.push(this.makeSSE('content_block_start', {
+            type: 'content_block_start',
+            index: idx,
+            content_block: { type: 'text', text: '' },
+        }));
+        this.currentBlockIndex = idx;
+        this.currentBlockType = 'text';
+    }
+    openThinkingBlock(events) {
+        const idx = this.nextBlockIndex++;
+        events.push(this.makeSSE('content_block_start', {
+            type: 'content_block_start',
+            index: idx,
+            content_block: { type: 'thinking', thinking: '' },
+        }));
+        this.currentBlockIndex = idx;
+        this.currentBlockType = 'thinking';
+    }
+    closeCurrentBlock(events) {
+        if (this.currentBlockType !== null && this.currentBlockIndex >= 0) {
+            events.push(this.makeSSE('content_block_stop', {
+                type: 'content_block_stop',
+                index: this.currentBlockIndex,
+            }));
+            this.currentBlockType = null;
+            this.currentBlockIndex = -1;
+        }
+    }
+    makeSSE(claudeEventType, data) {
+        return {
+            event: claudeEventType,
+            data,
+        };
+    }
+}
+exports.ResponsesToClaudeConverter = ResponsesToClaudeConverter;

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

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * OpenAI Chat Completions → Claude Messages request conversion.
+ *
+ * Converts a Chat Completions request body into a Claude Messages request body.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionsToClaude = completionsToClaude;
+const tool_schema_js_1 = require("../../utils/tool-schema.js");
+/**
+ * Convert an OpenAI Chat Completions request body to a Claude Messages request body.
+ */
+function completionsToClaude(body) {
+    const messages = [];
+    let systemPrompt;
+    for (const msg of body.messages) {
+        if (msg.role === 'system') {
+            systemPrompt =
+                typeof msg.content === 'string' ? msg.content : msg.content;
+            continue;
+        }
+        const content = convertCompletionsMessageToClaude(msg);
+        if (content) {
+            const role = msg.role === 'tool'
+                ? 'user'
+                : msg.role === 'function'
+                    ? 'assistant'
+                    : msg.role;
+            messages.push({ role, content });
+        }
+    }
+    const result = {
+        model: body.model,
+        messages,
+        max_tokens: body.max_tokens || 8192,
+        stream: body.stream || 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;
+    if (body.stop) {
+        result.stop_sequences = Array.isArray(body.stop) ? body.stop : [body.stop];
+    }
+    // Tool mapping (OpenAI parameters → Claude input_schema)
+    if (body.tools && body.tools.length > 0) {
+        result.tools = (0, tool_schema_js_1.completionsToClaudeTools)(body.tools);
+    }
+    return result;
+}
+/**
+ * Convert a single OpenAI message into Claude content (string or content block array).
+ */
+function convertCompletionsMessageToClaude(msg) {
+    // Assistant with tool_calls
+    if (msg.role === 'assistant' && msg.tool_calls) {
+        const content = [];
+        // reasoning_content → thinking block (prepend)
+        if (msg.reasoning_content) {
+            content.push({
+                type: 'thinking',
+                thinking: msg.reasoning_content,
+            });
+        }
+        if (msg.content) {
+            content.push({ type: 'text', text: msg.content });
+        }
+        for (const tc of msg.tool_calls) {
+            content.push({
+                type: 'tool_use',
+                id: tc.id,
+                name: tc.function.name,
+                input: typeof tc.function.arguments === 'string'
+                    ? JSON.parse(tc.function.arguments)
+                    : tc.function.arguments,
+            });
+        }
+        return content;
+    }
+    // Tool role → tool_result block
+    if (msg.role === 'tool') {
+        return {
+            type: 'tool_result',
+            tool_use_id: msg.tool_call_id,
+            content: msg.content,
+        };
+    }
+    // Function role → tool_result block
+    if (msg.role === 'function') {
+        return {
+            type: 'tool_result',
+            tool_use_id: msg.name,
+            content: msg.content,
+        };
+    }
+    // Plain assistant with reasoning_content (no tool_calls)
+    if (msg.role === 'assistant' && msg.reasoning_content) {
+        const content = [];
+        content.push({
+            type: 'thinking',
+            thinking: msg.reasoning_content,
+        });
+        if (msg.content) {
+            content.push({ type: 'text', text: msg.content });
+        }
+        return content;
+    }
+    return msg.content;
+}