aicodeswitch 4.0.4 → 5.0.0

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

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * OpenAI Responses API → OpenAI Chat Completions API request conversion.
+ *
+ * Converts a Responses API request body into a Chat Completions request body.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responsesToCompletions = responsesToCompletions;
+const effort_js_1 = require("../../thinking/effort.js");
+const id_js_1 = require("../../utils/id.js");
+/**
+ * Convert an OpenAI Responses API request body to a Chat Completions request body.
+ */
+function responsesToCompletions(body) {
+    var _a, _b;
+    const messages = [];
+    // --- instructions -> system message ---
+    if (body.instructions) {
+        messages.push({ role: 'system', content: body.instructions });
+    }
+    // --- input -> messages ---
+    if (typeof body.input === 'string') {
+        messages.push({ role: 'user', content: body.input });
+    }
+    else if (Array.isArray(body.input)) {
+        // We accumulate items that belong to the same assistant message
+        // (e.g. reasoning + content + function_calls need to merge)
+        let pendingAssistantMessage = null;
+        let pendingToolCalls = [];
+        let pendingReasoningContent;
+        for (const item of body.input) {
+            if (item.type === 'message') {
+                // Flush any pending assistant message before processing a new message
+                flushPendingAssistant(messages, pendingAssistantMessage, pendingToolCalls, pendingReasoningContent);
+                pendingAssistantMessage = null;
+                pendingToolCalls = [];
+                pendingReasoningContent = undefined;
+                if (item.role === 'system' || item.role === 'developer') {
+                    // Merge system/developer messages into the system message at head
+                    const text = extractContent(item.content, item.role === 'assistant' ? 'output_text' : 'input_text');
+                    if (text) {
+                        const existingSystem = messages.find((m) => m.role === 'system');
+                        if (existingSystem) {
+                            existingSystem.content += '\n' + text;
+                        }
+                        else {
+                            messages.unshift({ role: 'system', content: text });
+                        }
+                    }
+                }
+                else if (item.role === 'user') {
+                    const text = extractContent(item.content, 'input_text');
+                    messages.push({ role: 'user', content: text || '' });
+                }
+                else if (item.role === 'assistant') {
+                    const text = extractContent(item.content, 'output_text');
+                    pendingAssistantMessage = { role: 'assistant', content: text || null };
+                }
+            }
+            else if (item.type === 'function_call') {
+                // Accumulate as tool_calls on the nearest assistant message
+                if (!pendingAssistantMessage) {
+                    pendingAssistantMessage = { role: 'assistant', content: null };
+                }
+                pendingToolCalls.push({
+                    id: item.call_id || (0, id_js_1.generateCallId)(),
+                    type: 'function',
+                    function: {
+                        name: item.name || '',
+                        arguments: item.arguments || '{}',
+                    },
+                });
+            }
+            else if (item.type === 'function_call_output') {
+                // Flush any pending assistant message first
+                flushPendingAssistant(messages, pendingAssistantMessage, pendingToolCalls, pendingReasoningContent);
+                pendingAssistantMessage = null;
+                pendingToolCalls = [];
+                pendingReasoningContent = undefined;
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: item.call_id,
+                    content: item.output || '',
+                });
+            }
+            else if (item.type === 'reasoning') {
+                if (!pendingAssistantMessage) {
+                    pendingAssistantMessage = { role: 'assistant', content: null };
+                }
+                const summaryTexts = Array.isArray(item.summary)
+                    ? item.summary.map((s) => s.text || '').filter(Boolean)
+                    : [];
+                if (summaryTexts.length > 0) {
+                    pendingReasoningContent = summaryTexts.join('\n');
+                }
+            }
+        }
+        // Flush any remaining pending assistant message
+        flushPendingAssistant(messages, pendingAssistantMessage, pendingToolCalls, pendingReasoningContent);
+    }
+    // --- Build result ---
+    const result = {
+        model: body.model,
+        messages,
+        stream: (_a = body.stream) !== null && _a !== void 0 ? _a : false,
+    };
+    // --- Parameter mapping ---
+    if (body.max_output_tokens !== undefined) {
+        if (body.model && (0, effort_js_1.isOSeriesModel)(body.model)) {
+            result.max_completion_tokens = body.max_output_tokens;
+        }
+        else {
+            result.max_tokens = body.max_output_tokens;
+        }
+    }
+    if (body.temperature !== undefined)
+        result.temperature = body.temperature;
+    if (body.top_p !== undefined)
+        result.top_p = body.top_p;
+    // --- Reasoning effort ---
+    if ((_b = body.reasoning) === null || _b === void 0 ? void 0 : _b.effort) {
+        result.reasoning_effort = body.reasoning.effort;
+    }
+    // --- Tools ---
+    // 仅转换标准 function 类型工具，过滤掉 OpenAI 私有扩展类型
+    // （custom/tool_search/web_search/file_search/code_interpreter 等）
+    // 这些非标准类型没有 name 字段，直接转换会导致上游 API 返回参数错误
+    const functionTools = (body.tools || []).filter((t) => t.type === 'function');
+    if (functionTools.length > 0) {
+        result.tools = functionTools.map((tool) => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description || '',
+                parameters: tool.parameters || {},
+            },
+        }));
+    }
+    // --- Tool choice mapping ---
+    if (body.tool_choice !== undefined) {
+        result.tool_choice = responsesToCompletionsToolChoice(body.tool_choice);
+    }
+    // --- Auto-inject stream_options when streaming ---
+    if (result.stream) {
+        result.stream_options = { include_usage: true };
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract text content from a Responses API message item's content array.
+ */
+function extractContent(content, textType) {
+    if (!content)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((part) => part.type === textType || part.type === 'text')
+        .map((part) => part.text || '')
+        .join('');
+}
+/**
+ * Flush a pending assistant message with accumulated tool_calls and reasoning_content.
+ */
+function flushPendingAssistant(messages, pendingAssistant, pendingToolCalls, pendingReasoningContent) {
+    if (!pendingAssistant && pendingToolCalls.length === 0 && !pendingReasoningContent) {
+        return;
+    }
+    const msg = {
+        role: 'assistant',
+        content: (pendingAssistant === null || pendingAssistant === void 0 ? void 0 : pendingAssistant.content) || null,
+    };
+    if (pendingReasoningContent) {
+        msg.reasoning_content = pendingReasoningContent;
+    }
+    if (pendingToolCalls.length > 0) {
+        msg.tool_calls = pendingToolCalls;
+        // When tool_calls are present but no reasoning_content was provided,
+        // inject a placeholder so the receiver can detect tool-use context
+        if (!pendingReasoningContent) {
+            msg.reasoning_content = 'tool call';
+        }
+    }
+    messages.push(msg);
+}
+/**
+ * Map Responses API tool_choice to Chat Completions tool_choice.
+ */
+function responsesToCompletionsToolChoice(toolChoice) {
+    if (typeof toolChoice === 'string') {
+        switch (toolChoice) {
+            case 'required': return 'required';
+            case 'auto': return 'auto';
+            case 'none': return 'none';
+            default: return 'auto';
+        }
+    }
+    if (typeof toolChoice === 'object' && toolChoice.type === 'function') {
+        return { type: 'function', function: { name: toolChoice.name } };
+    }
+    return 'auto';
+}

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

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * OpenAI Chat Completions → OpenAI Responses API response conversion.
+ *
+ * Converts a Chat Completions response body into an OpenAI Responses API response body.
+ * Reasoning content (reasoning_content) is converted to a standard `reasoning` output
+ * item following the official Responses API specification.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionsToResponsesResponse = completionsToResponsesResponse;
+const stop_reasons_js_1 = require("../../utils/stop-reasons.js");
+const usage_js_1 = require("../../utils/usage.js");
+const id_js_1 = require("../../utils/id.js");
+/**
+ * Convert a Chat Completions response to a Responses API response.
+ */
+function completionsToResponsesResponse(response) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const choice = (_a = response.choices) === null || _a === void 0 ? void 0 : _a[0];
+    if (!choice)
+        return response;
+    const output = [];
+    // reasoning_content -> reasoning output item (official Responses API format)
+    if ((_b = choice.message) === null || _b === void 0 ? void 0 : _b.reasoning_content) {
+        output.push({
+            type: 'reasoning',
+            id: (0, id_js_1.generateCallId)().replace('call_', 'rs_'),
+            summary: [{ type: 'summary_text', text: choice.message.reasoning_content }],
+        });
+    }
+    // Text content -> message item
+    if ((_c = choice.message) === null || _c === void 0 ? void 0 : _c.content) {
+        const messageContent = [
+            { type: 'output_text', text: choice.message.content, annotations: [] },
+        ];
+        // Refusal -> add as refusal in message content
+        if ((_d = choice.message) === null || _d === void 0 ? void 0 : _d.refusal) {
+            messageContent.push({ type: 'refusal', refusal: choice.message.refusal });
+        }
+        output.push({
+            type: 'message',
+            status: 'completed',
+            role: 'assistant',
+            content: messageContent,
+        });
+    }
+    else if ((_e = choice.message) === null || _e === void 0 ? void 0 : _e.refusal) {
+        // Message with only refusal, no text content
+        output.push({
+            type: 'message',
+            status: 'completed',
+            role: 'assistant',
+            content: [
+                { type: 'output_text', text: '', annotations: [] },
+                { type: 'refusal', refusal: choice.message.refusal },
+            ],
+        });
+    }
+    // Tool calls -> function_call items
+    if ((_f = choice.message) === null || _f === void 0 ? void 0 : _f.tool_calls) {
+        for (const tc of choice.message.tool_calls) {
+            output.push({
+                type: 'function_call',
+                status: 'completed',
+                call_id: tc.id,
+                name: ((_g = tc.function) === null || _g === void 0 ? void 0 : _g.name) || '',
+                arguments: ((_h = tc.function) === null || _h === void 0 ? void 0 : _h.arguments) || '{}',
+            });
+        }
+    }
+    // If no message was emitted (edge case: only tool calls), still emit a message
+    if (!((_j = choice.message) === null || _j === void 0 ? void 0 : _j.content) && !((_k = choice.message) === null || _k === void 0 ? void 0 : _k.refusal) && !((_l = choice.message) === null || _l === void 0 ? void 0 : _l.tool_calls)) {
+        output.push({
+            type: 'message',
+            status: 'completed',
+            role: 'assistant',
+            content: [{ type: 'output_text', text: '', annotations: [] }],
+        });
+    }
+    const finishReason = (0, stop_reasons_js_1.completionsToResponsesFinishReason)(choice.finish_reason);
+    const status = finishReason === 'incomplete' ? 'incomplete' : 'completed';
+    const usage = (0, usage_js_1.completionsToResponsesUsage)(response.usage);
+    const result = {
+        id: ((_m = response.id) === null || _m === void 0 ? void 0 : _m.startsWith('resp_')) ? response.id : (0, id_js_1.generateResponseId)(),
+        object: 'response',
+        status,
+        output,
+        model: response.model,
+        usage,
+        created_at: response.created || Math.floor(Date.now() / 1000),
+    };
+    if (status === 'incomplete') {
+        result.incomplete_details = { reason: 'max_output_tokens' };
+    }
+    return result;
+}

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

@@ -0,0 +1,344 @@
+"use strict";
+/**
+ * OpenAI Chat Completions SSE → OpenAI Responses API SSE streaming conversion.
+ *
+ * Stateful converter that translates Chat Completions SSE events into
+ * OpenAI Responses API SSE events, following the official Responses API spec.
+ *
+ * Reasoning content (reasoning_content) is emitted as standard `reasoning`
+ * output items with `response.reasoning_summary_text.delta` events.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompletionsToResponsesConverter = void 0;
+const usage_js_1 = require("../../utils/usage.js");
+const id_js_1 = require("../../utils/id.js");
+const streaming_helpers_js_1 = require("../../utils/streaming-helpers.js");
+/**
+ * CompletionsToResponsesConverter: Chat Completions SSE → Responses API SSE
+ */
+class CompletionsToResponsesConverter {
+    constructor() {
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "responseId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "reasoningStarted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "textStarted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "reasoningOutputIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: -1
+        });
+        Object.defineProperty(this, "messageOutputIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: -1
+        });
+        Object.defineProperty(this, "currentToolCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "pendingReasoningText", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "accumulatedText", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "finalized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "nextOutputIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "usage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "finishReason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    convertEvent(event) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if (!event.data)
+            return [];
+        // [DONE] -> trigger finalize
+        if (event.data === '[DONE]' || ((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === 'done') {
+            return this.flush();
+        }
+        try {
+            const chunk = (0, streaming_helpers_js_1.parseEventData)(event.data);
+            const events = [];
+            const delta = (_c = (_b = chunk.choices) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.delta;
+            const finishReason = (_e = (_d = chunk.choices) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.finish_reason;
+            const usage = chunk.usage;
+            const chunkId = chunk.id;
+            const chunkModel = chunk.model;
+            // First chunk -> emit response.created + response.in_progress
+            if (!this.started) {
+                this.responseId = (chunkId === null || chunkId === void 0 ? void 0 : chunkId.startsWith('resp_')) ? chunkId : (0, id_js_1.generateResponseId)();
+                this.model = chunkModel || '';
+                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: [],
+                }));
+                this.started = true;
+            }
+            // --- reasoning_content -> standard reasoning output item ---
+            if (delta === null || delta === void 0 ? void 0 : delta.reasoning_content) {
+                this.pendingReasoningText += delta.reasoning_content;
+                if (!this.reasoningStarted) {
+                    this.reasoningOutputIndex = this.nextOutputIndex++;
+                    const rsId = (0, id_js_1.generateCallId)().replace('call_', 'rs_');
+                    events.push(this.makeSSE('response.output_item.added', {
+                        output_index: this.reasoningOutputIndex,
+                        item: { type: 'reasoning', id: rsId },
+                    }));
+                    events.push(this.makeSSE('response.reasoning_summary_part.added', {
+                        output_index: this.reasoningOutputIndex,
+                        summary_index: 0,
+                        part: { type: 'summary_text' },
+                    }));
+                    this.reasoningStarted = true;
+                }
+                // Emit using official standard event name
+                events.push(this.makeSSE('response.reasoning_summary_text.delta', {
+                    output_index: this.reasoningOutputIndex,
+                    summary_index: 0,
+                    delta: delta.reasoning_content,
+                }));
+            }
+            // --- content (text) ---
+            if (delta === null || delta === void 0 ? void 0 : delta.content) {
+                this.accumulatedText += delta.content;
+                if (!this.textStarted) {
+                    this.messageOutputIndex = this.nextOutputIndex++;
+                    events.push(this.makeSSE('response.output_item.added', {
+                        output_index: this.messageOutputIndex,
+                        item: { type: 'message', status: 'in_progress', role: 'assistant', content: [] },
+                    }));
+                    events.push(this.makeSSE('response.content_part.added', {
+                        output_index: this.messageOutputIndex,
+                        content_index: 0,
+                        part: { type: 'output_text', text: '', annotations: [] },
+                    }));
+                    this.textStarted = true;
+                }
+                events.push(this.makeSSE('response.output_text.delta', {
+                    output_index: this.messageOutputIndex,
+                    content_index: 0,
+                    delta: delta.content,
+                }));
+            }
+            // --- tool_calls ---
+            if (Array.isArray(delta === null || delta === void 0 ? void 0 : delta.tool_calls)) {
+                for (const tc of delta.tool_calls) {
+                    const toolIdx = (_f = tc.index) !== null && _f !== void 0 ? _f : 0;
+                    const existing = this.currentToolCalls.get(toolIdx);
+                    if (!existing) {
+                        // New tool call
+                        const tcId = tc.id || (0, id_js_1.generateCallId)();
+                        const tcName = ((_g = tc.function) === null || _g === void 0 ? void 0 : _g.name) || '';
+                        const tcOutputIndex = this.nextOutputIndex++;
+                        this.currentToolCalls.set(toolIdx, {
+                            id: tcId,
+                            name: tcName,
+                            argumentsText: '',
+                            outputIndex: tcOutputIndex,
+                        });
+                        events.push(this.makeSSE('response.output_item.added', {
+                            output_index: tcOutputIndex,
+                            item: {
+                                type: 'function_call',
+                                status: 'in_progress',
+                                call_id: tcId,
+                                name: tcName,
+                                arguments: '',
+                            },
+                        }));
+                    }
+                    // Arguments fragment
+                    const argsFragment = (0, streaming_helpers_js_1.normalizeToolArgumentsFragment)((_h = tc.function) === null || _h === void 0 ? void 0 : _h.arguments);
+                    if (argsFragment) {
+                        const current = this.currentToolCalls.get(toolIdx);
+                        if (current) {
+                            current.argumentsText += argsFragment;
+                        }
+                        events.push(this.makeSSE('response.function_call_arguments.delta', {
+                            output_index: (_j = current === null || current === void 0 ? void 0 : current.outputIndex) !== null && _j !== void 0 ? _j : this.output.length,
+                            call_id: current === null || current === void 0 ? void 0 : current.id,
+                            delta: argsFragment,
+                        }));
+                    }
+                }
+            }
+            // --- Finish reason ---
+            if (finishReason) {
+                this.finishReason = finishReason;
+            }
+            // --- Usage ---
+            if (usage) {
+                this.usage = usage;
+            }
+            return events;
+        }
+        catch (_k) {
+            return [event];
+        }
+    }
+    flush() {
+        if (this.finalized)
+            return [];
+        this.finalized = true;
+        const events = [];
+        // Finalize reasoning
+        if (this.reasoningStarted) {
+            events.push(this.makeSSE('response.reasoning.done', {
+                output_index: this.reasoningOutputIndex,
+                summary: [{ type: 'summary_text', text: this.pendingReasoningText }],
+            }));
+            events.push(this.makeSSE('response.reasoning_summary_part.done', {
+                output_index: this.reasoningOutputIndex,
+            }));
+            events.push(this.makeSSE('response.output_item.done', {
+                output_index: this.reasoningOutputIndex,
+                item: { type: 'reasoning' },
+            }));
+            this.output.push({
+                type: 'reasoning',
+                id: (0, id_js_1.generateCallId)().replace('call_', 'rs_'),
+                summary: [{ type: 'summary_text', text: this.pendingReasoningText }],
+            });
+        }
+        // Finalize text
+        if (this.textStarted) {
+            events.push(this.makeSSE('response.output_text.done', {
+                output_index: this.messageOutputIndex,
+                content_index: 0,
+                text: '',
+            }));
+            events.push(this.makeSSE('response.content_part.done', {
+                output_index: this.messageOutputIndex,
+                content_index: 0,
+                part: { type: 'output_text', text: '', annotations: [] },
+            }));
+            this.output.push({
+                type: 'message',
+                status: 'completed',
+                role: 'assistant',
+                content: [{ type: 'output_text', text: this.accumulatedText }],
+            });
+            events.push(this.makeSSE('response.output_item.done', {
+                output_index: this.messageOutputIndex,
+                item: { type: 'message', status: 'completed', role: 'assistant' },
+            }));
+        }
+        // Finalize tool calls
+        for (const [, tc] of this.currentToolCalls) {
+            events.push(this.makeSSE('response.function_call_arguments.done', {
+                output_index: tc.outputIndex,
+                call_id: tc.id,
+            }));
+            events.push(this.makeSSE('response.output_item.done', {
+                output_index: tc.outputIndex,
+                item: {
+                    type: 'function_call',
+                    status: 'completed',
+                    call_id: tc.id,
+                    name: tc.name,
+                    arguments: tc.argumentsText,
+                },
+            }));
+            this.output.push({
+                type: 'function_call',
+                status: 'completed',
+                call_id: tc.id,
+                name: tc.name,
+                arguments: tc.argumentsText,
+            });
+        }
+        // Build full response object
+        const status = this.finishReason === 'length' ? 'incomplete' : 'completed';
+        const responseObj = {
+            id: this.responseId,
+            object: 'response',
+            status,
+            output: this.output,
+            model: this.model,
+            usage: this.usage ? (0, usage_js_1.completionsToResponsesUsage)(this.usage) : {},
+            created_at: Math.floor(Date.now() / 1000),
+            metadata: {},
+        };
+        if (status === 'incomplete') {
+            responseObj.incomplete_details = { reason: 'max_output_tokens' };
+        }
+        events.push(this.makeSSE('response.completed', { response: responseObj }));
+        events.push({ data: '[DONE]', event: '' });
+        return events;
+    }
+    makeSSE(eventName, data) {
+        return { event: eventName, data };
+    }
+}
+exports.CompletionsToResponsesConverter = CompletionsToResponsesConverter;

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

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Responses API → Gemini composite request conversion.
+ *
+ * Composes: responses → completions → gemini
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responsesToGeminiRequest = responsesToGeminiRequest;
+const request_js_1 = require("../responses-completions/request.js");
+const request_js_2 = require("../completions-gemini/request.js");
+/**
+ * Convert Responses API request to Gemini request.
+ * Path: responses → completions → gemini
+ */
+function responsesToGeminiRequest(body) {
+    const completionsBody = (0, request_js_1.responsesToCompletions)(body);
+    return (0, request_js_2.completionsToGemini)(completionsBody);
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Gemini → Responses API composite response conversion.
+ *
+ * Composes: gemini → completions → responses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiToResponsesResponse = geminiToResponsesResponse;
+const response_js_1 = require("../completions-gemini/response.js");
+const response_js_2 = require("../responses-completions/response.js");
+/**
+ * Convert Gemini response to Responses API response.
+ * Path: gemini → completions → responses
+ */
+function geminiToResponsesResponse(response) {
+    const completionsResponse = (0, response_js_1.geminiToCompletionsResponse)(response);
+    return (0, response_js_2.completionsToResponsesResponse)(completionsResponse);
+}