llm-simple-router 0.7.1 → 0.8.2

package/dist/proxy/transform/stream-ant2oa.js

@@ -0,0 +1,200 @@
+import { BaseSSETransform } from "./stream-transform-base.js";
+import { generateChatcmplId } from "./id-utils.js";
+import { mapStopReasonToFinishReason } from "./usage-mapper.js";
+export class AnthropicToOpenAITransform extends BaseSSETransform {
+    chatcmplId = generateChatcmplId();
+    firstContentBlock = true;
+    inputTokens = 0;
+    outputTokens = 0;
+    finishReasonEmitted = false;
+    currentToolCallIndex = 0;
+    blockToToolCallIndex = new Map();
+    // track content block types for PSF capture
+    contentBlockTypes = new Map();
+    contentBlockSignatures = new Map();
+    // PSF accumulation for streaming
+    thinkingSignatures = [];
+    cacheUsage;
+    processEvent(event) {
+        let data;
+        try {
+            data = JSON.parse(event.data);
+        }
+        catch (err) {
+            this.emit("warning", err);
+            return;
+        }
+        switch (data.type) {
+            case "message_start": {
+                const msg = data.message;
+                const usage = msg?.usage;
+                this.inputTokens = usage?.input_tokens ?? 0;
+                // capture cache usage from initial usage
+                if (usage?.cache_read_input_tokens != null || usage?.cache_creation_input_tokens != null) {
+                    this.cacheUsage = {
+                        cache_read_input_tokens: usage.cache_read_input_tokens,
+                        cache_creation_input_tokens: usage.cache_creation_input_tokens,
+                    };
+                }
+                break;
+            }
+            case "content_block_start": {
+                const block = data.content_block;
+                const blockType = block?.type;
+                const blockIdx = data.index ?? 0;
+                // track block type for PSF capture at content_block_stop
+                this.contentBlockTypes.set(blockIdx, blockType);
+                if (blockType === "thinking" && block.signature) {
+                    this.contentBlockSignatures.set(blockIdx, block.signature);
+                }
+                if (this.firstContentBlock) {
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId, object: "chat.completion.chunk",
+                        choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }],
+                    });
+                    this.firstContentBlock = false;
+                }
+                if (blockType === "tool_use") {
+                    const tcIndex = this.currentToolCallIndex++;
+                    this.blockToToolCallIndex.set(blockIdx, tcIndex);
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId, object: "chat.completion.chunk",
+                        choices: [{
+                                index: 0,
+                                delta: {
+                                    tool_calls: [{
+                                            index: tcIndex, id: block.id, type: "function",
+                                            function: { name: block.name, arguments: "" },
+                                        }],
+                                },
+                                finish_reason: null,
+                            }],
+                    });
+                }
+                break;
+            }
+            case "content_block_delta": {
+                const delta = data.delta;
+                const blockIdx = data.index ?? 0;
+                const deltaType = delta?.type;
+                if (deltaType === "text_delta") {
+                    const text = delta.text;
+                    if (!text)
+                        break;
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId, object: "chat.completion.chunk",
+                        choices: [{ index: 0, delta: { content: text }, finish_reason: null }],
+                    });
+                }
+                else if (deltaType === "thinking_delta") {
+                    const thinking = delta.thinking;
+                    if (!thinking)
+                        break;
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId, object: "chat.completion.chunk",
+                        choices: [{ index: 0, delta: { reasoning_content: thinking }, finish_reason: null }],
+                    });
+                }
+                else if (deltaType === "input_json_delta") {
+                    const partialJson = delta.partial_json;
+                    if (!partialJson)
+                        break;
+                    const tcIndex = this.blockToToolCallIndex.get(blockIdx) ?? 0;
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId, object: "chat.completion.chunk",
+                        choices: [{
+                                index: 0,
+                                delta: { tool_calls: [{ index: tcIndex, function: { arguments: partialJson } }] },
+                                finish_reason: null,
+                            }],
+                    });
+                }
+                break;
+            }
+            case "content_block_stop": {
+                const blockIdx = data.index ?? 0;
+                // capture thinking signature from completed block
+                const sig = this.contentBlockSignatures.get(blockIdx);
+                if (sig && this.contentBlockTypes.get(blockIdx) === "thinking") {
+                    this.thinkingSignatures.push({ index: blockIdx, signature: sig });
+                }
+                // Anthropic may also send signature in content_block_stop's content_block field
+                const stopBlock = data.content_block;
+                if (stopBlock?.type === "thinking" && stopBlock.signature && !sig) {
+                    this.thinkingSignatures.push({ index: blockIdx, signature: stopBlock.signature });
+                }
+                break;
+            }
+            case "message_delta": {
+                const msgDelta = data.delta;
+                const usage = data.usage;
+                this.outputTokens = usage?.output_tokens ?? this.outputTokens;
+                const stopReason = msgDelta?.stop_reason;
+                if (stopReason && !this.finishReasonEmitted) {
+                    this.finishReasonEmitted = true;
+                    const fr = mapStopReasonToFinishReason(stopReason);
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId, object: "chat.completion.chunk",
+                        choices: [{ index: 0, delta: {}, finish_reason: fr }],
+                    });
+                }
+                break;
+            }
+            case "message_stop": {
+                // emit PSF as custom message_meta event before final usage
+                if (this.thinkingSignatures.length > 0 || this.cacheUsage) {
+                    const meta = {};
+                    if (this.thinkingSignatures.length > 0)
+                        meta.thinking_signatures = this.thinkingSignatures;
+                    if (this.cacheUsage)
+                        meta.cache_usage = this.cacheUsage;
+                    this.push(`event: message_meta\ndata: ${JSON.stringify({ provider_meta: { anthropic: meta } })}\n\n`);
+                }
+                this.pushOpenAISSE({
+                    id: this.chatcmplId, object: "chat.completion.chunk",
+                    choices: [],
+                    usage: {
+                        prompt_tokens: this.inputTokens,
+                        completion_tokens: this.outputTokens,
+                        total_tokens: this.inputTokens + this.outputTokens,
+                    },
+                });
+                this.pushDone();
+                break;
+            }
+            case "error": {
+                const error = data.error;
+                this.pushOpenAISSE({
+                    error: {
+                        message: error?.message ?? "Stream error",
+                        type: error?.type ?? "api_error",
+                        code: "upstream_error",
+                    },
+                });
+                this.pushDone();
+                break;
+            }
+            case "ping": {
+                break;
+            }
+            default: {
+                this.emit("warning", { event: "unknown_event", type: data.type });
+                break;
+            }
+        }
+    }
+    flushPendingData() {
+        // Anthropic 流不产生交错数据
+    }
+    ensureTerminated() {
+        if (!this.done) {
+            if (!this.finishReasonEmitted) {
+                this.pushOpenAISSE({
+                    id: this.chatcmplId, object: "chat.completion.chunk",
+                    choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+                });
+            }
+            this.pushDone();
+        }
+    }
+}

package/dist/proxy/transform/stream-oa2ant.d.ts

@@ -0,0 +1,25 @@
+import { BaseSSETransform } from "./stream-transform-base.js";
+export declare class OpenAIToAnthropicTransform extends BaseSSETransform {
+    private state;
+    private blockIndex;
+    private msgId;
+    private inputTokens;
+    private outputTokens;
+    private pendingStopReason;
+    private hasSentMessageStop;
+    private hasSentMessageStart;
+    private activeToolCallIndex;
+    private toolCallBlocks;
+    private completedToolCallIndices;
+    private finishReasonReceived;
+    protected processEvent(event: {
+        event?: string;
+        data?: string;
+    }): void;
+    private ensureBlockState;
+    private handleToolCallDelta;
+    private closeCurrentBlock;
+    private emitStopSequence;
+    protected flushPendingData(): void;
+    protected ensureTerminated(): void;
+}

package/dist/proxy/transform/stream-oa2ant.js

@@ -0,0 +1,201 @@
+import { BaseSSETransform } from "./stream-transform-base.js";
+import { generateMsgId } from "./id-utils.js";
+import { mapFinishReasonToStopReason } from "./usage-mapper.js";
+export class OpenAIToAnthropicTransform extends BaseSSETransform {
+    state = "init";
+    blockIndex = 0;
+    msgId = generateMsgId();
+    inputTokens = 0;
+    outputTokens = 0;
+    pendingStopReason = null;
+    hasSentMessageStop = false;
+    hasSentMessageStart = false;
+    activeToolCallIndex = -1;
+    toolCallBlocks = new Map();
+    completedToolCallIndices = new Set();
+    finishReasonReceived = false;
+    processEvent(event) {
+        let chunk;
+        try {
+            chunk = JSON.parse(event.data);
+        }
+        catch (err) {
+            this.emit("warning", err);
+            return;
+        }
+        // P0 fix: always extract usage when present, even if choices are in the same chunk
+        if (chunk.usage) {
+            const usage = chunk.usage;
+            this.inputTokens = usage.prompt_tokens ?? this.inputTokens;
+            this.outputTokens = usage.completion_tokens ?? this.outputTokens;
+        }
+        // Usage-only chunk (no choices) triggers stop sequence
+        if (chunk.usage && !(Array.isArray(chunk.choices) && chunk.choices.length > 0)) {
+            if (this.pendingStopReason !== null) {
+                this.emitStopSequence();
+            }
+            return;
+        }
+        const choices = chunk.choices;
+        const choice = choices?.[0];
+        if (!choice)
+            return;
+        const delta = choice.delta;
+        if (!delta)
+            return;
+        if (!this.hasSentMessageStart) {
+            this.pushAnthropicSSE("message_start", {
+                type: "message_start",
+                message: {
+                    id: this.msgId, type: "message", role: "assistant", content: [],
+                    model: this.model, status: "in_progress",
+                    usage: { input_tokens: this.inputTokens },
+                },
+            });
+            this.hasSentMessageStart = true;
+        }
+        if (delta.reasoning_content != null && delta.reasoning_content !== "") {
+            this.ensureBlockState("thinking");
+            this.pushAnthropicSSE("content_block_delta", {
+                type: "content_block_delta", index: this.blockIndex,
+                delta: { type: "thinking_delta", thinking: delta.reasoning_content },
+            });
+        }
+        if (delta.content != null && delta.content !== "") {
+            this.ensureBlockState("text");
+            this.pushAnthropicSSE("content_block_delta", {
+                type: "content_block_delta", index: this.blockIndex,
+                delta: { type: "text_delta", text: delta.content },
+            });
+        }
+        const toolCalls = delta.tool_calls;
+        if (toolCalls) {
+            for (const tc of toolCalls) {
+                this.handleToolCallDelta(tc);
+            }
+        }
+        const finishReason = choice.finish_reason;
+        if (finishReason && !this.finishReasonReceived) {
+            this.finishReasonReceived = true;
+            this.closeCurrentBlock();
+            this.pendingStopReason = mapFinishReasonToStopReason(finishReason);
+        }
+    }
+    ensureBlockState(target) {
+        if (this.state === target)
+            return;
+        if (this.state !== "init") {
+            this.pushAnthropicSSE("content_block_stop", {
+                type: "content_block_stop", index: this.blockIndex,
+            });
+            this.blockIndex++;
+        }
+        this.state = target;
+        const blockContent = target === "text" ? { type: "text", text: "" } : { type: "thinking", thinking: "" };
+        this.pushAnthropicSSE("content_block_start", {
+            type: "content_block_start", index: this.blockIndex, content_block: blockContent,
+        });
+    }
+    handleToolCallDelta(tc) {
+        const idx = tc.index ?? 0;
+        const fn = tc.function;
+        const tcId = tc.id;
+        const tcName = fn?.name;
+        if (tcId && tcName) {
+            if (this.state !== "init") {
+                this.pushAnthropicSSE("content_block_stop", {
+                    type: "content_block_stop", index: this.blockIndex,
+                });
+                this.blockIndex++;
+            }
+            this.activeToolCallIndex = idx;
+            this.state = "tool_use";
+            this.pushAnthropicSSE("content_block_start", {
+                type: "content_block_start", index: this.blockIndex,
+                content_block: { type: "tool_use", id: tcId, name: tcName, input: {} },
+            });
+            this.completedToolCallIndices.add(idx);
+            const args = fn?.arguments;
+            if (args && args !== "") {
+                this.pushAnthropicSSE("content_block_delta", {
+                    type: "content_block_delta", index: this.blockIndex,
+                    delta: { type: "input_json_delta", partial_json: args },
+                });
+            }
+            return;
+        }
+        if (idx !== this.activeToolCallIndex && this.completedToolCallIndices.has(idx)) {
+            const args = fn?.arguments;
+            if (args) {
+                const existing = this.toolCallBlocks.get(idx);
+                if (existing) {
+                    existing.args += args;
+                }
+                else {
+                    this.toolCallBlocks.set(idx, { id: "", name: "", args });
+                }
+            }
+            return;
+        }
+        if (idx !== this.activeToolCallIndex && !this.completedToolCallIndices.has(idx)) {
+            if (this.state !== "init") {
+                this.pushAnthropicSSE("content_block_stop", {
+                    type: "content_block_stop", index: this.blockIndex,
+                });
+                this.blockIndex++;
+            }
+            this.activeToolCallIndex = idx;
+            this.state = "tool_use";
+            // P1 fix: emit content_block_start for previously unseen tool call index
+            this.pushAnthropicSSE("content_block_start", {
+                type: "content_block_start", index: this.blockIndex,
+                content_block: { type: "tool_use", id: `tool_${idx}`, name: `tool_${idx}`, input: {} },
+            });
+            this.completedToolCallIndices.add(idx);
+        }
+        const args = fn?.arguments;
+        if (args && args !== "") {
+            this.pushAnthropicSSE("content_block_delta", {
+                type: "content_block_delta", index: this.blockIndex,
+                delta: { type: "input_json_delta", partial_json: args },
+            });
+        }
+    }
+    closeCurrentBlock() {
+        if (this.state !== "init" && this.state !== "closing") {
+            this.pushAnthropicSSE("content_block_stop", {
+                type: "content_block_stop", index: this.blockIndex,
+            });
+            this.state = "closing";
+        }
+    }
+    emitStopSequence() {
+        if (this.hasSentMessageStop)
+            return;
+        const stopReason = this.pendingStopReason ?? "end_turn";
+        this.pushAnthropicSSE("message_delta", {
+            type: "message_delta",
+            delta: { stop_reason: stopReason, stop_sequence: null },
+            usage: { output_tokens: this.outputTokens },
+        });
+        this.pushAnthropicSSE("message_stop", { type: "message_stop" });
+        this.hasSentMessageStop = true;
+        this.pendingStopReason = null;
+    }
+    flushPendingData() {
+        for (const [idx, data] of this.toolCallBlocks) {
+            if (data.args) {
+                this.emit("warning", { event: "buffered_tool_call", index: idx, argsLength: data.args.length });
+            }
+        }
+        this.toolCallBlocks.clear();
+    }
+    ensureTerminated() {
+        if (!this.hasSentMessageStop) {
+            this.closeCurrentBlock();
+            if (this.pendingStopReason === null)
+                this.pendingStopReason = "end_turn";
+            this.emitStopSequence();
+        }
+    }
+}

package/dist/proxy/transform/stream-transform-base.d.ts

@@ -0,0 +1,19 @@
+import { Transform, TransformCallback } from "stream";
+import { SafeSSEParser } from "../patch/safe-sse-parser.js";
+export declare abstract class BaseSSETransform extends Transform {
+    protected parser: SafeSSEParser;
+    protected done: boolean;
+    protected model: string;
+    constructor(model: string);
+    _transform(chunk: Buffer, _: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    protected abstract processEvent(event: {
+        event?: string;
+        data?: string;
+    }): void;
+    protected abstract flushPendingData(): void;
+    protected abstract ensureTerminated(): void;
+    protected pushAnthropicSSE(eventType: string, data: unknown): void;
+    protected pushOpenAISSE(data: unknown): void;
+    protected pushDone(): void;
+}

package/dist/proxy/transform/stream-transform-base.js

@@ -0,0 +1,61 @@
+import { Transform } from "stream";
+import { SafeSSEParser } from "../patch/safe-sse-parser.js";
+export class BaseSSETransform extends Transform {
+    parser = new SafeSSEParser();
+    done = false;
+    model;
+    constructor(model) {
+        super();
+        this.model = model;
+    }
+    _transform(chunk, _, callback) {
+        if (this.done) {
+            callback();
+            return;
+        }
+        try {
+            const text = chunk.toString("utf-8");
+            const events = this.parser.feed(text);
+            for (const event of events) {
+                if (event.data == null)
+                    continue;
+                try {
+                    this.processEvent(event);
+                }
+                catch (err) {
+                    this.emit("warning", { event: "process_error", error: String(err) });
+                }
+            }
+        }
+        catch (err) {
+            this.emit("warning", { event: "buffer_overflow", error: String(err) });
+            this.flushPendingData();
+            this.ensureTerminated();
+        }
+        callback();
+    }
+    _flush(callback) {
+        const events = this.parser.flush();
+        for (const event of events) {
+            try {
+                this.processEvent(event);
+            }
+            catch (err) {
+                this.emit("warning", err);
+            }
+        }
+        this.flushPendingData();
+        this.ensureTerminated();
+        callback();
+    }
+    pushAnthropicSSE(eventType, data) {
+        this.push(`event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`);
+    }
+    pushOpenAISSE(data) {
+        this.push(`data: ${JSON.stringify(data)}\n\n`);
+    }
+    pushDone() {
+        this.push("data: [DONE]\n\n");
+        this.done = true;
+    }
+}

package/dist/proxy/transform/thinking-mapper.d.ts

@@ -0,0 +1,4 @@
+/** OpenAI reasoning → Anthropic thinking */
+export declare function mapReasoningToThinking(reasoning: Record<string, unknown>): Record<string, unknown>;
+/** Anthropic thinking → OpenAI reasoning */
+export declare function mapThinkingToReasoning(thinking: Record<string, unknown> | undefined): Record<string, unknown> | undefined;

package/dist/proxy/transform/thinking-mapper.js

@@ -0,0 +1,15 @@
+const EFFORT_BUDGET = { low: 1024, medium: 8192, high: 32768 };
+const DEFAULT_BUDGET = 8192;
+/** OpenAI reasoning → Anthropic thinking */
+export function mapReasoningToThinking(reasoning) {
+    const effort = reasoning.effort;
+    const maxTokens = reasoning.max_tokens;
+    const budget = maxTokens ?? EFFORT_BUDGET[effort ?? ""] ?? DEFAULT_BUDGET;
+    return { type: "enabled", budget_tokens: budget };
+}
+/** Anthropic thinking → OpenAI reasoning */
+export function mapThinkingToReasoning(thinking) {
+    if (!thinking || thinking.type !== "enabled")
+        return undefined;
+    return { max_tokens: thinking.budget_tokens };
+}

package/dist/proxy/transform/tool-mapper.d.ts

@@ -0,0 +1,8 @@
+/** OpenAI tools[] → Anthropic tools[] */
+export declare function convertToolsOA2Ant(tools: unknown[]): unknown[];
+/** Anthropic tools[] → OpenAI tools[] */
+export declare function convertToolsAnt2OA(tools: unknown[]): unknown[];
+/** OpenAI tool_choice → Anthropic tool_choice */
+export declare function mapToolChoiceOA2Ant(tc: unknown): unknown;
+/** Anthropic tool_choice → OpenAI tool_choice */
+export declare function mapToolChoiceAnt2OA(tc: unknown): unknown;

package/dist/proxy/transform/tool-mapper.js

@@ -0,0 +1,67 @@
+/** OpenAI tools[] → Anthropic tools[] */
+export function convertToolsOA2Ant(tools) {
+    return tools.map((t) => {
+        const tool = t;
+        const fn = tool.function;
+        const result = { name: fn.name };
+        if (fn.description != null)
+            result.description = fn.description;
+        if (fn.parameters != null)
+            result.input_schema = fn.parameters;
+        return result;
+    });
+}
+/** Anthropic tools[] → OpenAI tools[] */
+export function convertToolsAnt2OA(tools) {
+    return tools.map((t) => {
+        const tool = t;
+        return {
+            type: "function",
+            function: {
+                name: tool.name,
+                ...(tool.description != null ? { description: tool.description } : {}),
+                ...(tool.input_schema != null ? { parameters: tool.input_schema } : {}),
+            },
+        };
+    });
+}
+/** OpenAI tool_choice → Anthropic tool_choice */
+export function mapToolChoiceOA2Ant(tc) {
+    if (tc === "none")
+        return undefined;
+    if (tc === "auto")
+        return { type: "auto" };
+    if (tc === "required")
+        return { type: "any" };
+    if (typeof tc === "object" && tc !== null) {
+        const obj = tc;
+        if (obj.type === "function" && obj.function) {
+            const fn = obj.function;
+            return { type: "tool", name: fn.name };
+        }
+    }
+    return { type: "auto" };
+}
+/** Anthropic tool_choice → OpenAI tool_choice */
+export function mapToolChoiceAnt2OA(tc) {
+    if (typeof tc === "string") {
+        if (tc === "auto")
+            return "auto";
+        if (tc === "any")
+            return "required";
+        return "auto";
+    }
+    if (typeof tc === "object" && tc !== null) {
+        const obj = tc;
+        if (obj.type === "auto") {
+            if (obj.disable_parallel_tool_use)
+                return { type: "auto", parallel_tool_calls: false };
+            return "auto";
+        }
+        if (obj.type === "any")
+            return "required";
+        if (obj.type === "tool")
+            return { type: "function", function: { name: obj.name } };
+    }
+    return "auto";
+}

package/dist/proxy/transform/transform-coordinator.d.ts

@@ -0,0 +1,11 @@
+import type { Transform } from "stream";
+export declare class TransformCoordinator {
+    needsTransform(entryApiType: string, providerApiType: string): boolean;
+    transformRequest(body: Record<string, unknown>, entryApiType: string, providerApiType: string, model: string): {
+        body: Record<string, unknown>;
+        upstreamPath: string;
+    };
+    transformResponse(bodyStr: string, sourceApiType: string, targetApiType: string): string;
+    transformErrorResponse(bodyStr: string, sourceApiType: string, targetApiType: string): string;
+    createFormatTransform(entryApiType: string, providerApiType: string, model: string): Transform | undefined;
+}

package/dist/proxy/transform/transform-coordinator.js

@@ -0,0 +1,32 @@
+import { transformRequestBody } from "./request-transform.js";
+import { transformResponseBody, transformErrorResponse } from "./response-transform.js";
+import { OpenAIToAnthropicTransform } from "./stream-oa2ant.js";
+import { AnthropicToOpenAITransform } from "./stream-ant2oa.js";
+export class TransformCoordinator {
+    needsTransform(entryApiType, providerApiType) {
+        return entryApiType !== providerApiType;
+    }
+    transformRequest(body, entryApiType, providerApiType, model) {
+        const upstreamPath = providerApiType === "openai" ? "/v1/chat/completions" : "/v1/messages";
+        return { body: transformRequestBody(body, entryApiType, providerApiType, model), upstreamPath };
+    }
+    transformResponse(bodyStr, sourceApiType, targetApiType) {
+        return transformResponseBody(bodyStr, sourceApiType, targetApiType);
+    }
+    transformErrorResponse(bodyStr, sourceApiType, targetApiType) {
+        return transformErrorResponse(bodyStr, sourceApiType, targetApiType);
+    }
+    createFormatTransform(entryApiType, providerApiType, model) {
+        if (!this.needsTransform(entryApiType, providerApiType))
+            return undefined;
+        // 上游=provider格式, 客户端=entry格式
+        // OA provider + Ant client → OpenAIToAnthropicTransform
+        if (providerApiType === "openai" && entryApiType === "anthropic") {
+            return new OpenAIToAnthropicTransform(model);
+        }
+        if (providerApiType === "anthropic" && entryApiType === "openai") {
+            return new AnthropicToOpenAITransform(model);
+        }
+        return undefined;
+    }
+}