llm-simple-router 0.7.1 → 0.8.2

package/dist/proxy/transform/plugin-registry.js

@@ -0,0 +1,130 @@
+import { createRequire } from "module";
+import { existsSync, readdirSync } from "fs";
+import { join, resolve } from "path";
+import { pluginMatches } from "./plugin-types.js";
+import { getAllActiveRules } from "../../db/transform-rules.js";
+const esmRequire = createRequire(import.meta.url);
+export class PluginRegistry {
+    plugins = [];
+    rulesCache = new Map();
+    registerPlugin(plugin) {
+        this.plugins.push(plugin);
+    }
+    loadFromDB(db) {
+        const rules = getAllActiveRules(db);
+        this.rulesCache.clear();
+        for (const rule of rules) {
+            this.rulesCache.set(rule.provider_id, rule);
+            this.plugins.push(this.ruleToPlugin(rule));
+        }
+    }
+    scanPluginsDir(dir) {
+        const resolvedDir = resolve(dir);
+        const loaded = [];
+        if (!existsSync(resolvedDir)) {
+            return loaded;
+        }
+        const files = readdirSync(resolvedDir).filter((f) => f.endsWith(".js") || f.endsWith(".mjs"));
+        for (const file of files) {
+            const filePath = join(resolvedDir, file);
+            try {
+                delete esmRequire.cache[esmRequire.resolve(filePath)];
+                const mod = esmRequire(filePath);
+                const plugin = mod.default || mod;
+                if (!plugin.name) {
+                    continue;
+                }
+                this.plugins.push(plugin);
+                loaded.push(`${plugin.name} (${file})`);
+                // eslint-disable-next-line taste/no-silent-catch -- don't crash server for bad plugin
+            }
+            catch (err) {
+                console.error(`[plugin-registry] Failed to load plugin from ${file}:`, err);
+            }
+        }
+        return loaded;
+    }
+    getMatchingPlugins(provider) {
+        return this.plugins.filter((p) => pluginMatches(p, provider));
+    }
+    applyBeforeRequest(ctx) {
+        for (const p of this.getMatchingPlugins(ctx.provider)) {
+            try {
+                p.beforeRequestTransform?.(ctx);
+            }
+            catch (err) {
+                console.error(`[plugin-registry] Plugin "${p.name}" beforeRequestTransform error:`, err);
+            }
+        }
+    }
+    applyAfterRequest(ctx) {
+        for (const p of this.getMatchingPlugins(ctx.provider)) {
+            try {
+                p.afterRequestTransform?.(ctx);
+            }
+            catch (err) {
+                console.error(`[plugin-registry] Plugin "${p.name}" afterRequestTransform error:`, err);
+            }
+        }
+    }
+    applyBeforeResponse(ctx) {
+        for (const p of this.getMatchingPlugins(ctx.provider)) {
+            try {
+                p.beforeResponseTransform?.(ctx);
+            }
+            catch (err) {
+                console.error(`[plugin-registry] Plugin "${p.name}" beforeResponseTransform error:`, err);
+            }
+        }
+    }
+    applyAfterResponse(ctx) {
+        for (const p of this.getMatchingPlugins(ctx.provider)) {
+            try {
+                p.afterResponseTransform?.(ctx);
+            }
+            catch (err) {
+                console.error(`[plugin-registry] Plugin "${p.name}" afterResponseTransform error:`, err);
+            }
+        }
+    }
+    reload(db, pluginsDir) {
+        this.plugins = [];
+        this.rulesCache.clear();
+        this.loadFromDB(db);
+        const loadedPlugins = this.scanPluginsDir(pluginsDir);
+        return { loadedPlugins, rulesCount: this.rulesCache.size };
+    }
+    ruleToPlugin(rule) {
+        return {
+            name: `declarative:${rule.provider_id}`,
+            match: { providerId: rule.provider_id },
+            afterRequestTransform(ctx) {
+                if (rule.request_defaults) {
+                    for (const [key, val] of Object.entries(rule.request_defaults)) {
+                        if (ctx.body[key] === undefined)
+                            ctx.body[key] = val;
+                    }
+                }
+                if (rule.drop_fields) {
+                    for (const field of rule.drop_fields) {
+                        delete ctx.body[field];
+                    }
+                }
+                if (rule.field_overrides) {
+                    for (const [key, val] of Object.entries(rule.field_overrides)) {
+                        ctx.body[key] = val;
+                    }
+                }
+                if (rule.inject_headers) {
+                    for (const [key, val] of Object.entries(rule.inject_headers)) {
+                        ctx.headers[key] = val;
+                    }
+                }
+            },
+            afterResponseTransform(_ctx) {
+                // field_overrides only applies to request direction;
+                // response should reflect actual upstream data, not override rules
+            },
+        };
+    }
+}

package/dist/proxy/transform/plugin-types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Transform Plugin 类型定义
+ */
+export interface PluginMatch {
+    providerId?: string;
+    providerName?: string;
+    providerNamePattern?: string;
+    apiType?: "openai" | "anthropic";
+}
+export interface RequestTransformContext {
+    body: Record<string, unknown>;
+    headers: Record<string, string>;
+    sourceApiType: "openai" | "anthropic";
+    targetApiType: "openai" | "anthropic";
+    provider: {
+        id: string;
+        name: string;
+        base_url: string;
+        api_type: string;
+    };
+}
+export interface ResponseTransformContext {
+    response: Record<string, unknown>;
+    sourceApiType: "openai" | "anthropic";
+    targetApiType: "openai" | "anthropic";
+    provider: {
+        id: string;
+        name: string;
+        base_url: string;
+        api_type: string;
+    };
+}
+export interface TransformPlugin {
+    name: string;
+    version?: string;
+    match: PluginMatch;
+    beforeRequestTransform?(ctx: RequestTransformContext): void;
+    afterRequestTransform?(ctx: RequestTransformContext): void;
+    beforeResponseTransform?(ctx: ResponseTransformContext): void;
+    afterResponseTransform?(ctx: ResponseTransformContext): void;
+}
+export declare function pluginMatches(plugin: TransformPlugin, provider: {
+    id: string;
+    name: string;
+    api_type: string;
+}): boolean;

package/dist/proxy/transform/plugin-types.js

@@ -0,0 +1,15 @@
+/**
+ * Transform Plugin 类型定义
+ */
+export function pluginMatches(plugin, provider) {
+    const m = plugin.match;
+    if (m.providerId && m.providerId !== provider.id)
+        return false;
+    if (m.providerName && m.providerName !== provider.name)
+        return false;
+    if (m.providerNamePattern && !new RegExp(m.providerNamePattern).test(provider.name))
+        return false;
+    if (m.apiType && m.apiType !== provider.api_type)
+        return false;
+    return true;
+}

package/dist/proxy/transform/provider-meta.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Anthropic Provider-Specific Fields (PSF)
+ *
+ * Preserves fields that would be lost during OA↔Ant conversion:
+ * - thinking signatures (required for multi-turn extended thinking)
+ * - citations
+ * - redacted_thinking blocks
+ * - cache usage metrics
+ */
+export interface AnthropicProviderMeta {
+    thinking_signatures?: Array<{
+        index: number;
+        signature: string;
+    }>;
+    citations?: Array<{
+        block_index: number;
+        citations: unknown[];
+    }>;
+    redacted_thinking?: unknown[];
+    cache_usage?: {
+        cache_read_input_tokens?: number;
+        cache_creation_input_tokens?: number;
+    };
+}
+export declare function extractAnthropicMeta(antResponse: Record<string, unknown>): AnthropicProviderMeta | undefined;
+export declare function stripProviderMeta(body: Record<string, unknown>): {
+    meta: AnthropicProviderMeta | undefined;
+    body: Record<string, unknown>;
+};

package/dist/proxy/transform/provider-meta.js

@@ -0,0 +1,72 @@
+/**
+ * Anthropic Provider-Specific Fields (PSF)
+ *
+ * Preserves fields that would be lost during OA↔Ant conversion:
+ * - thinking signatures (required for multi-turn extended thinking)
+ * - citations
+ * - redacted_thinking blocks
+ * - cache usage metrics
+ */
+export function extractAnthropicMeta(antResponse) {
+    const content = antResponse.content;
+    if (!content)
+        return undefined;
+    const meta = {};
+    let hasMeta = false;
+    // thinking signatures — needed for multi-turn extended thinking
+    const signatures = [];
+    for (let i = 0; i < content.length; i++) {
+        if (content[i].type === "thinking" && content[i].signature) {
+            signatures.push({
+                index: i,
+                signature: content[i].signature,
+            });
+        }
+    }
+    if (signatures.length > 0) {
+        meta.thinking_signatures = signatures;
+        hasMeta = true;
+    }
+    // redacted_thinking blocks
+    const redacted = content.filter((b) => b.type === "redacted_thinking");
+    if (redacted.length > 0) {
+        meta.redacted_thinking = redacted;
+        hasMeta = true;
+    }
+    // citations
+    const citations = [];
+    for (let i = 0; i < content.length; i++) {
+        if (content[i].citations) {
+            citations.push({
+                block_index: i,
+                citations: content[i].citations,
+            });
+        }
+    }
+    if (citations.length > 0) {
+        meta.citations = citations;
+        hasMeta = true;
+    }
+    // cache usage from top-level usage
+    const usage = antResponse.usage;
+    if (usage?.cache_read_input_tokens != null ||
+        usage?.cache_creation_input_tokens != null) {
+        meta.cache_usage = {
+            cache_read_input_tokens: usage.cache_read_input_tokens,
+            cache_creation_input_tokens: usage.cache_creation_input_tokens,
+        };
+        hasMeta = true;
+    }
+    return hasMeta ? meta : undefined;
+}
+export function stripProviderMeta(body) {
+    const pm = body.provider_meta;
+    if (!pm)
+        return { meta: undefined, body };
+    const cleaned = { ...body };
+    delete cleaned.provider_meta;
+    return {
+        meta: pm.anthropic,
+        body: cleaned,
+    };
+}

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

@@ -0,0 +1,4 @@
+export declare function openaiToAnthropicRequest(body: Record<string, unknown>): Record<string, unknown>;
+export declare function anthropicToOpenAIRequest(body: Record<string, unknown>): Record<string, unknown>;
+/** Entry point: transform request body based on direction */
+export declare function transformRequestBody(body: Record<string, unknown>, sourceApiType: string, targetApiType: string, _model: string): Record<string, unknown>;

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

@@ -0,0 +1,151 @@
+import { convertMessagesOA2Ant, convertMessagesAnt2OA } from "./message-mapper.js";
+import { convertToolsOA2Ant, convertToolsAnt2OA, mapToolChoiceOA2Ant, mapToolChoiceAnt2OA } from "./tool-mapper.js";
+import { mapReasoningToThinking, mapThinkingToReasoning } from "./thinking-mapper.js";
+import { stripProviderMeta } from "./provider-meta.js";
+const DEFAULT_MAX_TOKENS = 4096;
+const OA_KNOWN_FIELDS = new Set([
+    "model", "messages", "max_completion_tokens", "max_tokens",
+    "stop", "temperature", "top_p", "stream", "tools", "tool_choice",
+    "parallel_tool_calls", "reasoning", "user", "n", "stream_options",
+    "response_format", "provider_meta",
+]);
+const ANT_KNOWN_FIELDS = new Set([
+    "model", "system", "messages", "max_tokens",
+    "stop_sequences", "temperature", "top_p", "stream", "tools", "tool_choice",
+    "thinking", "metadata",
+]);
+/** Log dropped fields for debugging */
+function logDroppedFields(body, known, direction) {
+    const dropped = Object.keys(body).filter(k => !known.has(k));
+    if (dropped.length > 0) {
+        console.warn(`[request-transform] ${direction}: dropped unknown fields: ${dropped.join(", ")}`);
+    }
+}
+export function openaiToAnthropicRequest(body) {
+    // strip provider_meta before processing, restore PSF to messages later
+    const { meta: antMeta, body: cleanedBody } = stripProviderMeta(body);
+    const result = {};
+    result.model = cleanedBody.model;
+    const { system, messages } = convertMessagesOA2Ant(cleanedBody.messages ?? []);
+    if (system != null)
+        result.system = system;
+    result.messages = messages;
+    result.max_tokens = cleanedBody.max_completion_tokens ?? cleanedBody.max_tokens ?? DEFAULT_MAX_TOKENS;
+    if (cleanedBody.stop != null) {
+        result.stop_sequences = Array.isArray(cleanedBody.stop) ? cleanedBody.stop : [cleanedBody.stop];
+    }
+    if (cleanedBody.temperature != null)
+        result.temperature = cleanedBody.temperature;
+    if (cleanedBody.top_p != null)
+        result.top_p = cleanedBody.top_p;
+    if (cleanedBody.stream != null)
+        result.stream = cleanedBody.stream;
+    if (cleanedBody.tool_choice === "none" || (typeof cleanedBody.tool_choice === "object" && cleanedBody.tool_choice.type === "none")) {
+        // Anthropic has no "none" tool_choice — skip tools entirely
+    }
+    else {
+        if (cleanedBody.tools) {
+            result.tools = convertToolsOA2Ant(cleanedBody.tools);
+        }
+        if (cleanedBody.tool_choice != null) {
+            const mapped = mapToolChoiceOA2Ant(cleanedBody.tool_choice);
+            if (mapped != null) {
+                result.tool_choice = cleanedBody.parallel_tool_calls === false
+                    ? { ...mapped, disable_parallel_tool_use: true }
+                    : mapped;
+            }
+        }
+        else if (cleanedBody.parallel_tool_calls === false) {
+            result.tool_choice = { type: "auto", disable_parallel_tool_use: true };
+        }
+    }
+    if (cleanedBody.reasoning) {
+        const thinking = mapReasoningToThinking(cleanedBody.reasoning);
+        result.thinking = thinking;
+        if (thinking.budget_tokens && result.max_tokens < thinking.budget_tokens) {
+            result.max_tokens = thinking.budget_tokens;
+        }
+    }
+    if (cleanedBody.user) {
+        result.metadata = { user_id: cleanedBody.user };
+    }
+    if (cleanedBody.response_format) {
+        console.warn("[request-transform] response_format dropped: Anthropic has no JSON mode");
+    }
+    // PSF restore in single pass: signatures + redacted blocks
+    if (antMeta?.thinking_signatures?.length || antMeta?.redacted_thinking?.length) {
+        let sigIdx = 0;
+        let redactedApplied = false;
+        for (const msg of result.messages) {
+            if (msg.role !== "assistant")
+                continue;
+            const content = msg.content;
+            if (!content)
+                continue;
+            if (antMeta?.redacted_thinking?.length && !redactedApplied) {
+                msg.content = [...antMeta.redacted_thinking, ...content];
+                redactedApplied = true;
+            }
+            if (antMeta?.thinking_signatures?.length) {
+                for (const block of msg.content) {
+                    if (block.type === "thinking" && sigIdx < antMeta.thinking_signatures.length) {
+                        block.signature = antMeta.thinking_signatures[sigIdx].signature;
+                        sigIdx++;
+                    }
+                }
+            }
+        }
+    }
+    logDroppedFields(cleanedBody, OA_KNOWN_FIELDS, "OA→Ant");
+    return result;
+}
+export function anthropicToOpenAIRequest(body) {
+    const result = {};
+    result.model = body.model;
+    const antMessages = body.messages ?? [];
+    result.messages = convertMessagesAnt2OA(body.system, antMessages);
+    if (body.max_tokens != null)
+        result.max_completion_tokens = body.max_tokens;
+    if (body.stop_sequences)
+        result.stop = body.stop_sequences;
+    if (body.temperature != null)
+        result.temperature = body.temperature;
+    if (body.top_p != null)
+        result.top_p = body.top_p;
+    if (body.stream != null)
+        result.stream = body.stream;
+    if (body.stream === true) {
+        result.stream_options = { include_usage: true };
+    }
+    if (body.tools) {
+        result.tools = convertToolsAnt2OA(body.tools);
+    }
+    if (body.tool_choice != null) {
+        result.tool_choice = mapToolChoiceAnt2OA(body.tool_choice);
+    }
+    if (body.thinking) {
+        const reasoning = mapThinkingToReasoning(body.thinking);
+        if (reasoning)
+            result.reasoning = reasoning;
+    }
+    const metadata = body.metadata;
+    if (metadata?.user_id) {
+        result.user = metadata.user_id;
+    }
+    logDroppedFields(body, ANT_KNOWN_FIELDS, "Ant→OA");
+    return result;
+}
+/** Entry point: transform request body based on direction */
+export function transformRequestBody(body, sourceApiType, targetApiType, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_model) {
+    if (sourceApiType === targetApiType)
+        return body;
+    if (sourceApiType === "openai" && targetApiType === "anthropic") {
+        return openaiToAnthropicRequest(body);
+    }
+    if (sourceApiType === "anthropic" && targetApiType === "openai") {
+        return anthropicToOpenAIRequest(body);
+    }
+    return body;
+}

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

@@ -0,0 +1,4 @@
+export declare function openaiResponseToAnthropic(bodyStr: string): string;
+export declare function anthropicResponseToOpenAI(bodyStr: string): string;
+export declare function transformResponseBody(bodyStr: string, sourceApiType: string, targetApiType: string): string;
+export declare function transformErrorResponse(bodyStr: string, sourceApiType: string, targetApiType: string): string;

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

@@ -0,0 +1,99 @@
+import { generateMsgId, generateChatcmplId, MS_PER_SECOND } from "./id-utils.js";
+import { mapFinishReasonToStopReason, mapStopReasonToFinishReason, mapUsageOA2Ant, mapUsageAnt2OA } from "./usage-mapper.js";
+import { extractAnthropicMeta } from "./provider-meta.js";
+import { parseToolArguments } from "./sanitize.js";
+export function openaiResponseToAnthropic(bodyStr) {
+    const oai = JSON.parse(bodyStr);
+    const choice = oai.choices?.[0];
+    const msg = choice?.message;
+    const content = [];
+    // reasoning_content → thinking block (first)
+    if (msg?.reasoning_content) {
+        content.push({ type: "thinking", thinking: msg.reasoning_content });
+    }
+    // text content
+    if (msg?.content) {
+        content.push({ type: "text", text: msg.content });
+    }
+    // tool_calls → tool_use blocks
+    if (msg?.tool_calls) {
+        for (const tc of msg.tool_calls) {
+            const input = parseToolArguments(tc.function.arguments);
+            content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input });
+        }
+    }
+    if (content.length === 0)
+        content.push({ type: "text", text: "" });
+    return JSON.stringify({
+        id: generateMsgId(),
+        type: "message",
+        role: "assistant",
+        content,
+        model: oai.model,
+        stop_reason: mapFinishReasonToStopReason(choice?.finish_reason ?? "stop"),
+        stop_sequence: null,
+        usage: mapUsageOA2Ant(oai.usage),
+    });
+}
+export function anthropicResponseToOpenAI(bodyStr) {
+    const ant = JSON.parse(bodyStr);
+    const blocks = (ant.content ?? []);
+    const thinkingText = blocks.filter(b => b.type === "thinking").map(b => b.thinking).join("");
+    const textContent = blocks.filter(b => b.type === "text").map(b => b.text).join("");
+    const toolBlocks = blocks.filter(b => b.type === "tool_use");
+    const message = { role: "assistant" };
+    if (thinkingText)
+        message.reasoning_content = thinkingText;
+    if (textContent)
+        message.content = textContent;
+    if (toolBlocks.length > 0) {
+        message.tool_calls = toolBlocks.map(b => ({
+            id: b.id,
+            type: "function",
+            function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) },
+        }));
+    }
+    // preserve Anthropic-specific fields that would be lost in conversion
+    const antMeta = extractAnthropicMeta(ant);
+    const result = {
+        id: ant.id ?? generateChatcmplId(),
+        object: "chat.completion",
+        created: Math.floor(Date.now() / MS_PER_SECOND),
+        model: ant.model,
+        choices: [{ index: 0, message, finish_reason: mapStopReasonToFinishReason(ant.stop_reason ?? "end_turn") }],
+        usage: mapUsageAnt2OA(ant.usage),
+    };
+    if (antMeta) {
+        result.provider_meta = { anthropic: antMeta };
+    }
+    return JSON.stringify(result);
+}
+export function transformResponseBody(bodyStr, sourceApiType, targetApiType) {
+    if (sourceApiType === targetApiType)
+        return bodyStr;
+    if (sourceApiType === "openai" && targetApiType === "anthropic")
+        return openaiResponseToAnthropic(bodyStr);
+    if (sourceApiType === "anthropic" && targetApiType === "openai")
+        return anthropicResponseToOpenAI(bodyStr);
+    return bodyStr;
+}
+export function transformErrorResponse(bodyStr, sourceApiType, targetApiType) {
+    if (sourceApiType === targetApiType)
+        return bodyStr;
+    try {
+        if (sourceApiType === "anthropic" && targetApiType === "openai") {
+            const ant = JSON.parse(bodyStr);
+            const err = ant.error ?? {};
+            return JSON.stringify({ error: { message: err.message ?? "Unknown error", type: err.type ?? "api_error", code: "upstream_error" } });
+        }
+        if (sourceApiType === "openai" && targetApiType === "anthropic") {
+            const oai = JSON.parse(bodyStr);
+            const err = oai.error ?? {};
+            return JSON.stringify({ type: "error", error: { type: err.type ?? "api_error", message: err.message ?? "Unknown error" } });
+        }
+    }
+    catch {
+        return bodyStr;
+    }
+    return bodyStr;
+}

package/dist/proxy/transform/sanitize.d.ts

@@ -0,0 +1,3 @@
+export declare function sanitizeToolUseId(id: string): string;
+export declare function parseToolArguments(args: unknown): Record<string, unknown>;
+export declare function ensureNonEmptyContent(messages: unknown[]): void;

package/dist/proxy/transform/sanitize.js

@@ -0,0 +1,24 @@
+export function sanitizeToolUseId(id) {
+    const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return sanitized || "toolu_unknown";
+}
+export function parseToolArguments(args) {
+    try {
+        return JSON.parse(String(args ?? "{}"));
+    }
+    catch {
+        console.warn("[transform] Failed to parse tool arguments, using empty object");
+        return {};
+    }
+}
+export function ensureNonEmptyContent(messages) {
+    for (const msg of messages) {
+        const m = msg;
+        if (m.role === "assistant")
+            continue;
+        if (!m.content || m.content === "" ||
+            (Array.isArray(m.content) && m.content.length === 0)) {
+            m.content = " ";
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import { BaseSSETransform } from "./stream-transform-base.js";
+export declare class AnthropicToOpenAITransform extends BaseSSETransform {
+    private chatcmplId;
+    private firstContentBlock;
+    private inputTokens;
+    private outputTokens;
+    private finishReasonEmitted;
+    private currentToolCallIndex;
+    private blockToToolCallIndex;
+    private contentBlockTypes;
+    private contentBlockSignatures;
+    private thinkingSignatures;
+    private cacheUsage;
+    protected processEvent(event: {
+        event?: string;
+        data?: string;
+    }): void;
+    protected flushPendingData(): void;
+    protected ensureTerminated(): void;
+}