aicodeswitch 4.0.4 → 5.1.0

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

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Composite streaming converter: Gemini SSE → Responses API SSE.
+ *
+ * Chains: GeminiToCompletionsConverter → CompletionsToResponsesConverter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiToResponsesConverter = void 0;
+const streaming_js_1 = require("../completions-gemini/streaming.js");
+const streaming_js_2 = require("../responses-completions/streaming.js");
+const streaming_helpers_js_1 = require("../../utils/streaming-helpers.js");
+/**
+ * Composite converter: Gemini SSE → Completions SSE → Responses API SSE
+ */
+class GeminiToResponsesConverter {
+    constructor() {
+        Object.defineProperty(this, "first", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "second", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.first = new streaming_js_1.GeminiToCompletionsConverter();
+        this.second = new streaming_js_2.CompletionsToResponsesConverter();
+    }
+    convertEvent(event) {
+        const intermediate = this.first.convertEvent(event);
+        return intermediate.flatMap((e) => this.second.convertEvent(e));
+    }
+    flush() {
+        const intermediate = (0, streaming_helpers_js_1.flushConverter)(this.first);
+        const secondFromIntermediate = intermediate.flatMap((e) => this.second.convertEvent(e));
+        const secondFlush = (0, streaming_helpers_js_1.flushConverter)(this.second);
+        return [...secondFromIntermediate, ...secondFlush];
+    }
+}
+exports.GeminiToResponsesConverter = GeminiToResponsesConverter;

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

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Responses → Responses 同格式降级兼容转换。
+ *
+ * 当 Codex 等客户端向非 OpenAI 的第三方 Responses API 提供商（如火山方舟/豆包）发送请求时，
+ * 需要清理 OpenAI 私有扩展、转换消息格式，以确保兼容性。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downgradeResponsesRequest = downgradeResponsesRequest;
+/**
+ * Responses API 非标准 tool 类型集合。
+ * OpenAI 私有扩展（custom、tool_search、web_search 等），
+ * 其他 Responses API 提供商不支持这些类型，直接转发会导致 400 错误。
+ */
+const NON_STANDARD_TOOL_TYPES = new Set([
+    'custom', 'tool_search', 'web_search', 'file_search', 'code_interpreter',
+]);
+/**
+ * Responses API 降级兼容时需移除的顶层字段集合。
+ * 这些字段非所有 Responses API 提供商都支持，开启降级兼容时会被移除以避免 400 错误。
+ * - reasoning: { effort } — OpenAI 推理努力程度控制（火山方舟不支持）
+ * - text: { verbosity } — OpenAI 响应 verbosity 控制（火山方舟用 text.format 做结构化输出）
+ * - prompt_cache_key — OpenAI 提示缓存键
+ * - client_metadata — OpenAI 客户端元数据
+ * - include — OpenAI 响应包含项（如 reasoning.encrypted_content）
+ * - parallel_tool_calls — OpenAI 并行工具调用控制（火山方舟未明确支持）
+ */
+const DOWNGRADE_STRIP_FIELDS = new Set([
+    'reasoning', 'text', 'prompt_cache_key', 'client_metadata',
+    'include', 'parallel_tool_calls',
+]);
+/**
+ * 将 input message 的 content 规范化为 ContentItem 数组。
+ * 火山方舟等第三方 Responses API 提供商要求 content 为 []*responses.ContentItem 数组格式，
+ * 不接受纯字符串。因此需要确保 content 始终为数组：
+ * - 字符串 → [{type: "input_text"/"output_text", text: "..."}]（根据 role 选择类型）
+ * - 数组 → 保持不变
+ */
+function normalizeInputContent(content, role) {
+    // 已经是数组，保持不变
+    if (Array.isArray(content))
+        return content;
+    // 字符串：根据 role 转为对应的 ContentItem 数组
+    if (typeof content === 'string') {
+        const type = role === 'assistant' ? 'output_text' : 'input_text';
+        return [{ type, text: content }];
+    }
+    return content;
+}
+/**
+ * 对 Responses API 请求体执行降级兼容转换。
+ *
+ * 处理项：
+ * 1. 过滤非标准 tool 类型（custom/tool_search/web_search 等），仅保留 function
+ * 2. 移除非标准顶层字段（reasoning/text/include/parallel_tool_calls 等）
+ * 3. 转换 input 消息格式：
+ *    - role: "developer" → role: "system"
+ *    - content 字符串 → content: [{type:"input_text"/"output_text", text:"..."}]
+ *    - 补全 status: "completed"
+ */
+function downgradeResponsesRequest(body) {
+    if (!body || typeof body !== 'object')
+        return body;
+    let sanitized = body;
+    const ensureCopy = () => {
+        if (sanitized === body)
+            sanitized = Object.assign({}, sanitized);
+        return sanitized;
+    };
+    // 1. 过滤掉非标准 tool 类型，仅保留 function 类型
+    if (Array.isArray(body.tools)) {
+        const filteredTools = body.tools.filter((t) => !NON_STANDARD_TOOL_TYPES.has(t.type));
+        if (filteredTools.length !== body.tools.length) {
+            sanitized = Object.assign(Object.assign({}, sanitized), { tools: filteredTools });
+        }
+    }
+    // 2. 移除非标准顶层字段
+    for (const field of DOWNGRADE_STRIP_FIELDS) {
+        if (field in sanitized) {
+            ensureCopy();
+            delete sanitized[field];
+        }
+    }
+    // 3. 转换 input 消息格式
+    if (Array.isArray(sanitized.input)) {
+        let patched = false;
+        const patchedInput = sanitized.input.map((item) => {
+            if (!item || typeof item !== 'object')
+                return item;
+            let modified = Object.assign({}, item);
+            // 3a. developer → system
+            if (modified.role === 'developer') {
+                modified.role = 'system';
+                patched = true;
+            }
+            // 3b. 规范化 content 为 ContentItem 数组
+            const normalized = normalizeInputContent(modified.content, modified.role);
+            if (normalized !== modified.content) {
+                modified.content = normalized;
+                patched = true;
+            }
+            // 3c. 补全 status 字段
+            if (modified.type === 'message' && !('status' in modified)) {
+                modified.status = 'completed';
+                patched = true;
+            }
+            return modified;
+        });
+        if (patched) {
+            ensureCopy();
+            sanitized.input = patchedInput;
+        }
+    }
+    return sanitized;
+}

package/dist/server/conversions/pipeline.js

@@ -0,0 +1,296 @@
+"use strict";
+/**
+ * SSE streaming pipeline for the conversion system.
+ *
+ * Wraps the conversion StreamConverter in an async generator pipeline
+ * that handles SSE parsing, conversion, and serialization.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEEventParser = void 0;
+exports.serializeSSE = serializeSSE;
+exports.createStreamPipeline = createStreamPipeline;
+const stream_1 = require("stream");
+const index_js_1 = require("./index.js");
+/**
+ * Serialize an SSEEvent to wire format.
+ */
+function serializeSSE(event) {
+    let result = '';
+    if (event.event)
+        result += `event: ${event.event}\n`;
+    if (event.id)
+        result += `id: ${event.id}\n`;
+    const dataStr = typeof event.data === 'string' ? event.data : JSON.stringify(event.data);
+    result += `data: ${dataStr}\n\n`;
+    return result;
+}
+/**
+ * Lightweight SSE event parser.
+ */
+class SSEEventParser {
+    constructor() {
+        Object.defineProperty(this, "buffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "currentEvent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    pushChunk(chunk) {
+        this.buffer += chunk.toString();
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        return this.consumeLines(lines);
+    }
+    flush() {
+        if (!this.buffer) {
+            return this.finishCurrentEvent();
+        }
+        const lines = this.buffer.split('\n');
+        this.buffer = '';
+        const events = this.consumeLines(lines);
+        return events.concat(this.finishCurrentEvent());
+    }
+    consumeLines(lines) {
+        const events = [];
+        for (const rawLine of lines) {
+            const line = rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine;
+            if (line === '') {
+                events.push(...this.finishCurrentEvent());
+            }
+            else if (line.startsWith('event: ')) {
+                this.currentEvent.event = line.substring(7);
+            }
+            else if (line.startsWith('id: ')) {
+                this.currentEvent.id = line.substring(4);
+            }
+            else if (line.startsWith('data: ')) {
+                this.currentEvent.data = (this.currentEvent.data || '') + line.substring(6);
+            }
+            else if (line.startsWith('data:')) {
+                this.currentEvent.data = (this.currentEvent.data || '') + line.substring(5);
+            }
+        }
+        return events;
+    }
+    finishCurrentEvent() {
+        if (this.currentEvent.data === undefined) {
+            this.currentEvent = {};
+            return [];
+        }
+        const event = this.currentEvent;
+        this.currentEvent = {};
+        return [event];
+    }
+}
+exports.SSEEventParser = SSEEventParser;
+/**
+ * Node.js Transform stream that parses SSE bytes into SSEEvent objects.
+ */
+class SSEParserTransform extends stream_1.Transform {
+    constructor() {
+        super({ objectMode: true });
+        Object.defineProperty(this, "parser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new SSEEventParser()
+        });
+    }
+    _transform(chunk, _encoding, callback) {
+        const events = this.parser.pushChunk(chunk);
+        for (const event of events) {
+            this.push(event);
+        }
+        callback();
+    }
+    _flush(callback) {
+        const events = this.parser.flush();
+        for (const event of events) {
+            this.push(event);
+        }
+        callback();
+    }
+}
+/**
+ * Convert a Web ReadableStream to a Node.js Readable.
+ */
+function toNodeReadable(stream) {
+    if (stream instanceof ReadableStream) {
+        const reader = stream.getReader();
+        return new stream_1.Readable({
+            read() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const { done, value } = yield reader.read();
+                        if (done)
+                            this.push(null);
+                        else
+                            this.push(value);
+                    }
+                    catch (e) {
+                        this.destroy(e);
+                    }
+                });
+            },
+        });
+    }
+    return stream;
+}
+/**
+ * Check if the format pair should use raw passthrough (no conversion needed).
+ */
+function shouldPassthroughRaw(fromFormat, toFormat) {
+    return fromFormat === toFormat;
+}
+/**
+ * Creates a streaming pipeline that converts SSE events from one format to another.
+ *
+ * @param upstreamBody - The upstream response body stream
+ * @param fromFormat - The upstream format (source)
+ * @param toFormat - The client format (target)
+ * @param onEvent - Optional callback for monitoring parsed events (e.g., usage tracking)
+ * @returns AsyncGenerator yielding SSE-formatted string chunks
+ */
+function createStreamPipeline(upstreamBody, fromFormat, toFormat, onEvent) {
+    return __asyncGenerator(this, arguments, function* createStreamPipeline_1() {
+        var _a, e_1, _b, _c;
+        const nodeStream = toNodeReadable(upstreamBody);
+        // Raw passthrough: same format, no conversion needed
+        if (shouldPassthroughRaw(fromFormat, toFormat)) {
+            const parser = onEvent ? new SSEEventParser() : null;
+            try {
+                for (var _d = true, _e = __asyncValues(nodeStream), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const chunk = _c;
+                    if (parser) {
+                        const parsedEvents = parser.pushChunk(typeof chunk === 'string' ? chunk : chunk.toString());
+                        for (const event of parsedEvents) {
+                            try {
+                                const parsed = event.data ? JSON.parse(event.data) : null;
+                                onEvent(parsed);
+                            }
+                            catch ( /* ignore */_g) { /* ignore */ }
+                        }
+                    }
+                    yield yield __await(chunk);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (parser) {
+                for (const event of parser.flush()) {
+                    try {
+                        const parsed = event.data ? JSON.parse(event.data) : null;
+                        onEvent(parsed);
+                    }
+                    catch ( /* ignore */_h) { /* ignore */ }
+                }
+            }
+            return yield __await(void 0);
+        }
+        // Conversion path: parse SSE → convert → serialize
+        const parser = new SSEParserTransform();
+        const eventStream = nodeStream.pipe(parser);
+        const eventQueue = [];
+        let resolveEvent = null;
+        let done = false;
+        eventStream.on('data', (event) => {
+            if (resolveEvent) {
+                resolveEvent(event);
+                resolveEvent = null;
+            }
+            else {
+                eventQueue.push(event);
+            }
+        });
+        eventStream.on('end', () => {
+            done = true;
+            if (resolveEvent) {
+                resolveEvent(null);
+                resolveEvent = null;
+            }
+        });
+        eventStream.on('error', () => {
+            done = true;
+            if (resolveEvent) {
+                resolveEvent(null);
+                resolveEvent = null;
+            }
+        });
+        const getNextEvent = () => {
+            if (eventQueue.length > 0)
+                return Promise.resolve(eventQueue.shift());
+            if (done)
+                return Promise.resolve(null);
+            return new Promise((resolve) => {
+                resolveEvent = resolve;
+            });
+        };
+        const converter = (0, index_js_1.createStreamConverter)({ fromFormat, toFormat });
+        while (true) {
+            const event = yield __await(getNextEvent());
+            if (!event)
+                break;
+            if (onEvent) {
+                try {
+                    const parsed = event.data ? JSON.parse(event.data) : null;
+                    onEvent(parsed);
+                }
+                catch ( /* ignore */_j) { /* ignore */ }
+            }
+            const convertedEvents = converter.convertEvent(event);
+            for (const converted of convertedEvents) {
+                yield yield __await(serializeSSE(converted));
+            }
+        }
+        // Flush any remaining state from the converter
+        if (converter.flush) {
+            const finalEvents = converter.flush();
+            for (const converted of finalEvents) {
+                yield yield __await(serializeSSE(converted));
+            }
+        }
+    });
+}

package/dist/server/conversions/stream-converter-adapter.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * StreamConverterAdapter — 将 conversions StreamConverter 桥接为 Node.js Transform 流。
+ *
+ * 新系统的 StreamConverter 是纯对象接口（convertEvent/flush），
+ * 而代理管道使用 Node.js Transform 流通过 stream.pipeline() 串联。
+ * 此 adapter 在两者之间做透明桥接。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamConverterAdapter = void 0;
+const stream_1 = require("stream");
+class StreamConverterAdapter extends stream_1.Transform {
+    constructor(converter) {
+        super({ objectMode: true });
+        Object.defineProperty(this, "converter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: converter
+        });
+    }
+    _transform(event, _encoding, callback) {
+        try {
+            const convertedEvents = this.converter.convertEvent(event);
+            for (const converted of convertedEvents) {
+                this.push(converted);
+            }
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    _flush(callback) {
+        try {
+            if (this.converter.flush) {
+                const finalEvents = this.converter.flush();
+                for (const converted of finalEvents) {
+                    this.push(converted);
+                }
+            }
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+}
+exports.StreamConverterAdapter = StreamConverterAdapter;

package/dist/server/conversions/thinking/effort.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Thinking parameter mapping across API formats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeThinkingToReasoningEffort = claudeThinkingToReasoningEffort;
+exports.claudeThinkingToResponsesReasoning = claudeThinkingToResponsesReasoning;
+exports.reasoningEffortToClaudeThinking = reasoningEffortToClaudeThinking;
+exports.isOSeriesModel = isOSeriesModel;
+/** Maps Claude thinking config to reasoning_effort string */
+function claudeThinkingToReasoningEffort(thinking) {
+    var _a;
+    if (!thinking || thinking.type === 'disabled')
+        return null;
+    // Priority: output_config.effort
+    if ((_a = thinking.output_config) === null || _a === void 0 ? void 0 : _a.effort) {
+        return thinking.output_config.effort;
+    }
+    // Fallback: derive from type + budget_tokens
+    if (thinking.type === 'adaptive')
+        return 'xhigh';
+    if (thinking.budget_tokens !== undefined) {
+        if (thinking.budget_tokens < 4000)
+            return 'low';
+        if (thinking.budget_tokens < 16000)
+            return 'medium';
+        return 'high';
+    }
+    return 'medium';
+}
+/** Maps Claude thinking config to Responses API reasoning parameter */
+function claudeThinkingToResponsesReasoning(thinking) {
+    const effort = claudeThinkingToReasoningEffort(thinking);
+    if (!effort)
+        return null;
+    return { effort };
+}
+/** Reverse: reasoning_effort string → Claude thinking config */
+function reasoningEffortToClaudeThinking(effort) {
+    if (!effort)
+        return undefined;
+    switch (effort) {
+        case 'low':
+            return { type: 'enabled', budget_tokens: 2048 };
+        case 'medium':
+            return { type: 'enabled', budget_tokens: 8192 };
+        case 'high':
+            return { type: 'enabled', budget_tokens: 32000 };
+        case 'xhigh':
+            return { type: 'adaptive' };
+        default:
+            return { type: 'enabled', budget_tokens: 8192 };
+    }
+}
+/** Check if a model is an OpenAI o-series reasoning model */
+function isOSeriesModel(model) {
+    if (!model)
+        return false;
+    const lower = model.toLowerCase();
+    return /\bo[1-9]\b/.test(lower) || /\bo4\b/.test(lower) || /\bgpt-?5\b/.test(lower);
+}

package/dist/server/conversions/thinking/mapper.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Thinking content mapping across API formats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thinkingToReasoningContent = thinkingToReasoningContent;
+exports.reasoningContentToThinking = reasoningContentToThinking;
+exports.reasoningToThinking = reasoningToThinking;
+exports.thinkingToReasoningSummary = thinkingToReasoningSummary;
+exports.fixThinkingHistory = fixThinkingHistory;
+exports.redactedThinkingPlaceholder = redactedThinkingPlaceholder;
+/** Claude thinking text → reasoning_content string */
+function thinkingToReasoningContent(thinking) {
+    return thinking;
+}
+/** reasoning_content string → Claude thinking block */
+function reasoningContentToThinking(content) {
+    return { type: 'thinking', thinking: content };
+}
+/** Responses API reasoning summary → Claude thinking block */
+function reasoningToThinking(summary) {
+    const text = summary
+        .filter((s) => s.type === 'summary_text')
+        .map((s) => s.text || '')
+        .join('');
+    return { type: 'thinking', thinking: text || '' };
+}
+/** Claude thinking text → Responses API reasoning summary array */
+function thinkingToReasoningSummary(thinking) {
+    return [{ type: 'summary_text', text: thinking }];
+}
+/** Fix history messages: ensure thinking/reasoning_content is present alongside tool use */
+function fixThinkingHistory(messages, format) {
+    return messages.map(msg => {
+        var _a, _b, _c, _d, _e;
+        if (msg.role !== 'assistant')
+            return msg;
+        const hasToolUse = (format === 'claude' && ((_b = (_a = msg.content) === null || _a === void 0 ? void 0 : _a.some) === null || _b === void 0 ? void 0 : _b.call(_a, (b) => b.type === 'tool_use'))) ||
+            (format === 'completions' && (((_c = msg.tool_calls) === null || _c === void 0 ? void 0 : _c.length) > 0));
+        if (!hasToolUse)
+            return msg;
+        if (format === 'claude') {
+            const hasThinking = (_e = (_d = msg.content) === null || _d === void 0 ? void 0 : _d.some) === null || _e === void 0 ? void 0 : _e.call(_d, (b) => b.type === 'thinking');
+            if (!hasThinking) {
+                return Object.assign(Object.assign({}, msg), { content: [{ type: 'thinking', thinking: 'tool call' }, ...(msg.content || [])] });
+            }
+        }
+        else {
+            if (!msg.reasoning_content) {
+                return Object.assign(Object.assign({}, msg), { reasoning_content: 'tool call' });
+            }
+        }
+        return msg;
+    });
+}
+/** Placeholder for redacted thinking blocks */
+function redactedThinkingPlaceholder() {
+    return '[redacted thinking]';
+}