llm-simple-router 0.8.2 → 0.9.4

package/dist/monitor/stream-extractor.js

@@ -19,6 +19,27 @@ export function extractStreamText(line, apiType) {
         const text = delta?.content ?? "";
         return { text, block: text ? { index: 0, type: "text", content: text } : null };
     }
+    if (apiType === "openai-responses") {
+        // Responses SSE uses named events, but line format is "data: {json}" (same as Anthropic)
+        // The event type is in the data JSON's "type" field
+        const type = obj.type;
+        if (type === "response.output_text.delta") {
+            const text = obj.delta ?? "";
+            const outputIndex = obj.output_index ?? 0;
+            return { text, block: text ? { index: outputIndex, type: "text", content: text } : empty.block };
+        }
+        if (type === "response.function_call_arguments.delta") {
+            const partialJson = obj.delta ?? "";
+            const outputIndex = obj.output_index ?? 0;
+            return { text: "", block: { index: outputIndex, type: "tool_use", content: partialJson } };
+        }
+        if (type === "response.reasoning_summary_text.delta") {
+            const thinking = obj.delta ?? "";
+            const outputIndex = obj.output_index ?? 0;
+            return { text: "", block: { index: outputIndex, type: "thinking", content: thinking } };
+        }
+        return empty;
+    }
     // Anthropic
     const type = obj.type;
     const index = obj.index;

package/dist/monitor/types.d.ts

@@ -14,7 +14,7 @@ export interface StreamContentSnapshot {
 }
 export interface ActiveRequest {
     id: string;
-    apiType: "openai" | "anthropic";
+    apiType: "openai" | "openai-responses" | "anthropic";
     model: string;
     providerId: string;
     providerName: string;

package/dist/proxy/handler/proxy-handler-utils.d.ts

@@ -4,6 +4,6 @@ import type { TransportResult } from "../types.js";
 /** 从 TransportResult 中提取最终 HTTP status code */
 export declare function getTransportStatusCode(result: TransportResult): number | null;
 /** 将 tracker blocks 序列化为前端 tryDirectParse 可解析的 JSON */
-export declare function serializeBlocksForStorage(blocks: ContentBlock[] | undefined, apiType: "openai" | "anthropic"): string;
+export declare function serializeBlocksForStorage(blocks: ContentBlock[] | undefined, apiType: "openai" | "openai-responses" | "anthropic"): string;
 /** 从请求体中提取最后一次工具调用记录 */
 export declare function extractLastToolUse(body: Record<string, unknown>): ToolCallRecord | null;

package/dist/proxy/handler/proxy-handler.d.ts

@@ -8,6 +8,6 @@ export interface RouteHandlerDeps {
     container: ServiceContainer;
 }
 import type { ServiceContainer } from "../../core/container.js";
-export declare function handleProxyRequest(request: FastifyRequest, reply: FastifyReply, apiType: "openai" | "anthropic", upstreamPath: string, errors: ProxyErrorFormatter, deps: RouteHandlerDeps, options?: {
+export declare function handleProxyRequest(request: FastifyRequest, reply: FastifyReply, apiType: "openai" | "openai-responses" | "anthropic", upstreamPath: string, errors: ProxyErrorFormatter, deps: RouteHandlerDeps, options?: {
     beforeSendProxy?: (body: Record<string, unknown>, isStream: boolean) => void;
 }): Promise<FastifyReply>;

package/dist/proxy/handler/proxy-handler.js

@@ -13,6 +13,7 @@ import { insertRejectedLog } from "../log-helpers.js";
 import { ToolLoopGuard } from "../loop-prevention/tool-loop-guard.js";
 import { buildTransportFn } from "../transport/transport-fn.js";
 import { applyOverflowRedirect } from "../routing/overflow.js";
+import { parseModels } from "../../config/model-context.js";
 import { applyProviderPatches } from "../patch/index.js";
 import { PipelineSnapshot } from "../pipeline-snapshot.js";
 import { maybeInjectModelInfoTag } from "../response-transform.js";
@@ -223,8 +224,13 @@ async function executeFailoverLoop(ctx) {
             pluginRegistry.applyAfterRequest(pluginCtx);
             injectedHeaders = pluginCtx.headers;
         }
-        // provider patches — 使用返回值
-        const { body: patchedBody, meta: patchMeta } = applyProviderPatches(currentBody, provider);
+        // provider patches — 优先从 DB models JSON 读取 patch 配置，无配置时回退自动检测
+        const providerModels = parseModels(provider.models || "[]");
+        const { body: patchedBody, meta: patchMeta } = applyProviderPatches(currentBody, {
+            base_url: provider.base_url,
+            api_type: provider.api_type,
+            models: providerModels,
+        });
         iterationSnapshot.add({ stage: "provider_patch", types: patchMeta.types });
         const encryptionKey = getSetting(deps.db, "encryption_key");
         if (!encryptionKey) {

package/dist/proxy/handler/responses.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+export interface ResponsesProxyOptions {
+    db: Database.Database;
+    container: import("../../core/container.js").ServiceContainer;
+}
+export declare const responsesProxy: FastifyPluginCallback<ResponsesProxyOptions>;

package/dist/proxy/handler/responses.js

@@ -0,0 +1,48 @@
+import { randomUUID } from "crypto";
+import fp from "fastify-plugin";
+import { insertRequestLog } from "../../db/index.js";
+import { createErrorFormatter } from "../proxy-core.js";
+import { handleProxyRequest } from "./proxy-handler.js";
+import { createOrchestrator } from "../orchestration/orchestrator.js";
+import { HTTP_BAD_GATEWAY } from "../../core/constants.js";
+import { SERVICE_KEYS } from "../../core/container.js";
+const RESPONSES_PATH = "/v1/responses";
+const RESPONSES_COMPAT_PATH = "/responses";
+const RESPONSES_ERROR_META = {
+    modelNotFound: { type: "invalid_request_error", code: "model_not_found" },
+    modelNotAllowed: { type: "invalid_request_error", code: "model_not_allowed" },
+    providerUnavailable: { type: "server_error", code: "provider_unavailable" },
+    providerTypeMismatch: { type: "server_error", code: "provider_type_mismatch" },
+    upstreamConnectionFailed: { type: "upstream_error", code: "upstream_connection_failed" },
+    concurrencyQueueFull: { type: "server_error", code: "concurrency_queue_full" },
+    concurrencyTimeout: { type: "server_error", code: "concurrency_timeout" },
+    promptTooLong: { type: "invalid_request_error", code: "context_window_exceeded" },
+};
+const responsesErrors = createErrorFormatter((kind, message) => ({ error: { message, ...RESPONSES_ERROR_META[kind] } }));
+function sendError(reply, e) {
+    return reply.code(e.statusCode).send(e.body);
+}
+const responsesProxyRaw = (app, opts, done) => {
+    const { db, container } = opts;
+    const orchestrator = createOrchestrator(container.resolve(SERVICE_KEYS.semaphoreManager), container.resolve(SERVICE_KEYS.tracker), container.resolve(SERVICE_KEYS.adaptiveController));
+    const handleResponses = async (request, reply) => {
+        if (!orchestrator) {
+            const body = request.body;
+            insertRequestLog(db, {
+                id: randomUUID(), api_type: "openai-responses", model: body?.model || null,
+                provider_id: null, status_code: HTTP_BAD_GATEWAY, latency_ms: 0, is_stream: 0,
+                error_message: "Orchestrator not available",
+                created_at: new Date().toISOString(),
+                client_request: JSON.stringify({ headers: request.headers }),
+                router_key_id: request.routerKey?.id ?? null,
+            });
+            return sendError(reply, responsesErrors.providerUnavailable());
+        }
+        const deps = { db, orchestrator, container };
+        return handleProxyRequest(request, reply, "openai-responses", RESPONSES_PATH, responsesErrors, deps);
+    };
+    app.post(RESPONSES_PATH, handleResponses);
+    app.post(RESPONSES_COMPAT_PATH, handleResponses);
+    done();
+};
+export const responsesProxy = fp(responsesProxyRaw, { name: "responses-proxy" });

package/dist/proxy/loop-prevention/tool-loop-guard.d.ts

@@ -9,5 +9,5 @@ export declare class ToolLoopGuard {
      * 如果 sessionKey 不可用（无 sessionId），返回 detected: false。
      */
     check(sessionKey: string | null, toolCall: ToolCallRecord | null): LoopCheckResult;
-    injectLoopBreakPrompt(body: Record<string, unknown>, apiType: "openai" | "anthropic", toolName: string): Record<string, unknown>;
+    injectLoopBreakPrompt(body: Record<string, unknown>, apiType: "openai" | "openai-responses" | "anthropic", toolName: string): Record<string, unknown>;
 }

package/dist/proxy/loop-prevention/tool-loop-guard.js

@@ -50,6 +50,16 @@ export class ToolLoopGuard {
                 cloned.system = [{ type: "text", text: prompt }];
             }
         }
+        else if (apiType === "openai-responses") {
+            // Append a user message to input items
+            const inputArr = Array.isArray(body.input) ? [...body.input] : [];
+            inputArr.push({
+                type: "message",
+                role: "user",
+                content: [{ type: "input_text", text: `[系统提醒] 检测到工具 "${toolName}" 可能陷入循环。请停止重复调用，总结当前进展。` }],
+            });
+            return { ...body, input: inputArr };
+        }
         else {
             const messages = cloned.messages ?? [];
             messages.unshift({ role: "system", content: prompt });

package/dist/proxy/orchestration/orchestrator.d.ts

@@ -52,7 +52,7 @@ export declare class ProxyOrchestrator {
         resilience: ResilienceLayer;
         adaptiveController?: AdaptiveConcurrencyController;
     });
-    handle(request: FastifyRequest, reply: FastifyReply, apiType: "openai" | "anthropic", config: OrchestratorConfig, ctx?: HandleContext): Promise<ResilienceResult>;
+    handle(request: FastifyRequest, reply: FastifyReply, apiType: "openai" | "openai-responses" | "anthropic", config: OrchestratorConfig, ctx?: HandleContext): Promise<ResilienceResult>;
     private buildActiveRequest;
     private createAbortSignal;
     private executeResilience;

package/dist/proxy/orchestration/semaphore.js

@@ -34,6 +34,12 @@ export class ProviderSemaphoreManager {
         }
         if (entry.current < 0)
             entry.current = 0;
+        // 当 maxConcurrency 降低时，将 current 限制在新的上限，
+        // 防止 current 停留在旧的高位，导致新请求始终进入队列、
+        // 且 release() 无法通过空队检查来递减 current（排队长驻）
+        if (entry.current > config.maxConcurrency) {
+            entry.current = config.maxConcurrency;
+        }
         while (entry.current < config.maxConcurrency &&
             entry.queue.length > 0) {
             entry.current++;

package/dist/proxy/patch/deepseek/index.d.ts

@@ -15,4 +15,4 @@
  *   1. patchNonDeepSeekToolMessages — 将非 DeepSeek 生成的 tool_calls 降级为 text
  *   2. patchOrphanToolResultsOA — 处理孤儿 tool 消息
  */
-export declare function applyDeepSeekPatches(body: Record<string, unknown>, apiType: "openai" | "anthropic"): void;
+export declare function applyDeepSeekPatches(body: Record<string, unknown>, apiType: "openai" | "openai-responses" | "anthropic"): void;

package/dist/proxy/patch/deepseek/patch-thinking-param.d.ts

@@ -3,4 +3,4 @@
  * 客户端（如 Claude Code）可能在后续轮次省略此参数。
  * 检测历史中是否存在 thinking 内容，自动补上参数。
  */
-export declare function patchThinkingParam(body: Record<string, unknown>, apiType: "openai" | "anthropic"): void;
+export declare function patchThinkingParam(body: Record<string, unknown>, apiType: "openai" | "openai-responses" | "anthropic"): void;

package/dist/proxy/patch/index.d.ts

@@ -1,12 +1,15 @@
+import type { ModelEntry } from "../../config/model-context.js";
 export interface ProviderInfo {
     base_url: string;
     api_type: string;
+    models?: ModelEntry[];
 }
 export interface ProviderPatchMeta {
     types: string[];
 }
 /**
  * 根据 provider 信息分发到对应的补丁逻辑。
+ * 优先使用 DB 配置的 patches 模式，无配置时回退到自动检测。
  * 返回浅拷贝 body + 执行的补丁类型列表，不修改原始 body。
  */
 export declare function applyProviderPatches(body: Record<string, unknown>, provider: ProviderInfo): {

package/dist/proxy/patch/index.js

@@ -2,6 +2,7 @@ import { applyDeepSeekPatches } from "./deepseek/index.js";
 const OPENAI_ORIGIN_HOSTS = ["api.openai.com", "openai.com"];
 /**
  * 根据 provider 信息分发到对应的补丁逻辑。
+ * 优先使用 DB 配置的 patches 模式，无配置时回退到自动检测。
  * 返回浅拷贝 body + 执行的补丁类型列表，不修改原始 body。
  */
 export function applyProviderPatches(body, provider) {
@@ -15,6 +16,33 @@ export function applyProviderPatches(body, provider) {
         }
         return patched;
     };
+    // ---- DB-driven mode：通过 provider.models 配置的 patches 驱动 ----
+    if (provider.models) {
+        const modelName = body.model ?? "";
+        const modelEntry = provider.models.find(m => m.name === modelName);
+        const modelPatches = modelEntry?.patches ?? [];
+        if (modelPatches.length > 0) {
+            // developer_role 补丁（仅 openai 格式需要）
+            if (modelPatches.includes("developer_role") && provider.api_type === "openai" && hasDeveloperRole(body)) {
+                patchDeveloperRole(ensureCloned());
+                patches.push("developer_role");
+            }
+            // DeepSeek Anthropic 补丁
+            const dsAnthropicPatches = ["thinking-param", "cache-control", "thinking-blocks", "orphan-tool-results"];
+            if (dsAnthropicPatches.some(p => modelPatches.includes(p)) && provider.api_type === "anthropic") {
+                applyDeepSeekPatches(ensureCloned(), "anthropic");
+                patches.push("deepseek");
+            }
+            // DeepSeek OpenAI 补丁
+            const dsOpenAIPatches = ["non-ds-tools", "orphan-tool-results-oa"];
+            if (dsOpenAIPatches.some(p => modelPatches.includes(p)) && provider.api_type === "openai") {
+                applyDeepSeekPatches(ensureCloned(), "openai");
+                patches.push("deepseek");
+            }
+            return { body: patched ?? body, meta: { types: patches } };
+        }
+    }
+    // ---- 回退模式：自动检测（保持现有逻辑不变）----
     // 通用补丁：OpenAI 兼容 provider（非 OpenAI 原生）不支持 developer role
     if (provider.api_type === "openai" && !isOpenAIOrigin(provider.base_url)) {
         if (hasDeveloperRole(body)) {

package/dist/proxy/patch/tool-round-limiter.d.ts

@@ -30,7 +30,7 @@ export declare function countConsecutiveToolRounds(messages: Message[]): number;
 /**
  * 检测并注入提示词。返回可能修改后的 body（浅拷贝），未超阈值时原样返回。
  */
-export declare function applyToolRoundLimit(body: Record<string, unknown>, apiType: "openai" | "anthropic", maxRounds?: number): {
+export declare function applyToolRoundLimit(body: Record<string, unknown>, apiType: "openai" | "openai-responses" | "anthropic", maxRounds?: number): {
     body: Record<string, unknown>;
     injected: boolean;
     rounds: number;

package/dist/proxy/patch/tool-round-limiter.js

@@ -50,6 +50,22 @@ export function countConsecutiveToolRounds(messages) {
  * 检测并注入提示词。返回可能修改后的 body（浅拷贝），未超阈值时原样返回。
  */
 export function applyToolRoundLimit(body, apiType, maxRounds = DEFAULT_MAX_ROUNDS) {
+    if (apiType === "openai-responses") {
+        const input = body.input;
+        if (!input || !Array.isArray(input))
+            return { body, injected: false, rounds: 0 };
+        const funcCalls = input.filter(i => i.type === "function_call").length;
+        if (funcCalls <= maxRounds)
+            return { body, injected: false, rounds: funcCalls };
+        // Inject warning: append a user message to input
+        const cloned = { ...body, input: [...input] };
+        cloned.input.push({
+            type: "message",
+            role: "user",
+            content: [{ type: "input_text", text: LOOP_WARNING_PROMPT }],
+        });
+        return { body: cloned, injected: true, rounds: funcCalls };
+    }
     const messages = body.messages ?? [];
     if (messages.length === 0)
         return { body, injected: false, rounds: 0 };

package/dist/proxy/proxy-core.d.ts

@@ -30,5 +30,5 @@ export declare function createErrorFormatter(formatBody: (kind: ErrorKind, messa
 export declare function buildUpstreamUrl(baseUrl: string, upstreamPath: string): string;
 export declare const SKIP_UPSTREAM: Set<string>;
 export declare function selectHeaders(raw: RawHeaders, skip: Set<string>): Record<string, string>;
-export declare function buildUpstreamHeaders(clientHeaders: RawHeaders, apiKey: string, payloadBytes?: number, apiType?: "openai" | "anthropic"): Record<string, string>;
+export declare function buildUpstreamHeaders(clientHeaders: RawHeaders, apiKey: string, payloadBytes?: number, apiType?: "openai" | "openai-responses" | "anthropic"): Record<string, string>;
 export declare function proxyGetRequest(backend: Provider, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string): Promise<GetTransportResult>;

package/dist/proxy/proxy-logging.d.ts

@@ -6,7 +6,7 @@ import type { ResilienceAttempt } from "../core/types.js";
 import type { TransportResult } from "./types.js";
 /** 日志存储前脱敏 Authorization / x-api-key header，避免 API Key 被持久化 */
 export declare function sanitizeHeadersForLog(headers: Record<string, string>): Record<string, string>;
-export declare function handleIntercept(db: Database.Database, apiType: "openai" | "anthropic", request: FastifyRequest, reply: import("fastify").FastifyReply, interceptResponse: {
+export declare function handleIntercept(db: Database.Database, apiType: "openai" | "openai-responses" | "anthropic", request: FastifyRequest, reply: import("fastify").FastifyReply, interceptResponse: {
     statusCode: number;
     body: unknown;
     meta?: unknown;
@@ -14,7 +14,7 @@ export declare function handleIntercept(db: Database.Database, apiType: "openai"
     test: (statusCode: number, body: string) => boolean;
 } | null, logFileWriter?: LogFileWriter | null): import("fastify").FastifyReply;
 export declare function logResilienceResult(db: Database.Database, params: {
-    apiType: "openai" | "anthropic";
+    apiType: "openai" | "openai-responses" | "anthropic";
     model: string;
     providerId: string;
     isStream: boolean;
@@ -31,4 +31,4 @@ export declare function logResilienceResult(db: Database.Database, params: {
     } | null;
     logFileWriter?: LogFileWriter | null;
 }, attempts: ResilienceAttempt[], result: TransportResult, startTime: number): string;
-export declare function collectTransportMetrics(db: Database.Database, apiType: "openai" | "anthropic", result: TransportResult, isStream: boolean, lastSuccessLogId: string, providerId: string, backendModel: string, request: FastifyRequest, routerKeyId?: string | null, statusCode?: number | null): void;
+export declare function collectTransportMetrics(db: Database.Database, apiType: "openai" | "openai-responses" | "anthropic", result: TransportResult, isStream: boolean, lastSuccessLogId: string, providerId: string, backendModel: string, request: FastifyRequest, routerKeyId?: string | null, statusCode?: number | null): void;

package/dist/proxy/response-transform.js

@@ -9,6 +9,19 @@ export function maybeInjectModelInfoTag(responseBody, originalModel, effectiveMo
             bodyObj.content[0].text += `\n\n${buildModelInfoTag(effectiveModel)}`;
             return { body: JSON.stringify(bodyObj), meta: { model_info_tag_injected: true } };
         }
+        // Responses format: output[type=message].content[type=output_text].text
+        if (Array.isArray(bodyObj.output)) {
+            for (const item of bodyObj.output) {
+                if (item.type === "message" && Array.isArray(item.content)) {
+                    for (const part of item.content) {
+                        if (part.type === "output_text" && part.text) {
+                            part.text = part.text + `\n\n${buildModelInfoTag(effectiveModel)}`;
+                            return { body: JSON.stringify(bodyObj), meta: { model_info_tag_injected: true } };
+                        }
+                    }
+                }
+            }
+        }
     }
     catch { /* non-JSON response, skip injection */ }
     return { body: responseBody, meta: { model_info_tag_injected: false } };

package/dist/proxy/transform/id-utils.d.ts

@@ -1,3 +1,4 @@
 export declare function generateMsgId(): string;
 export declare function generateChatcmplId(): string;
+export declare function generateRespId(): string;
 export declare const MS_PER_SECOND = 1000;

package/dist/proxy/transform/id-utils.js

@@ -6,4 +6,7 @@ export function generateMsgId() {
 export function generateChatcmplId() {
     return `chatcmpl-${randomUUID().slice(0, UUID_ID_LENGTH)}`;
 }
+export function generateRespId() {
+    return `resp_${randomUUID().slice(0, UUID_ID_LENGTH)}`;
+}
 export const MS_PER_SECOND = 1000;

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

@@ -5,13 +5,13 @@ export interface PluginMatch {
     providerId?: string;
     providerName?: string;
     providerNamePattern?: string;
-    apiType?: "openai" | "anthropic";
+    apiType?: "openai" | "openai-responses" | "anthropic";
 }
 export interface RequestTransformContext {
     body: Record<string, unknown>;
     headers: Record<string, string>;
-    sourceApiType: "openai" | "anthropic";
-    targetApiType: "openai" | "anthropic";
+    sourceApiType: "openai" | "openai-responses" | "anthropic";
+    targetApiType: "openai" | "openai-responses" | "anthropic";
     provider: {
         id: string;
         name: string;
@@ -21,8 +21,8 @@ export interface RequestTransformContext {
 }
 export interface ResponseTransformContext {
     response: Record<string, unknown>;
-    sourceApiType: "openai" | "anthropic";
-    targetApiType: "openai" | "anthropic";
+    sourceApiType: "openai" | "openai-responses" | "anthropic";
+    targetApiType: "openai" | "openai-responses" | "anthropic";
     provider: {
         id: string;
         name: string;

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

@@ -0,0 +1,19 @@
+/**
+ * Bridge (lossy) request transformation between OpenAI Responses API
+ * and OpenAI Chat Completions API.
+ *
+ * This is the SECONDARY conversion path used when the upstream provider
+ * only supports the opposite API format. It is lossy because Chat Completions
+ * cannot represent `previous_response_id`, built-in tools, or structured
+ * reasoning items.
+ */
+/**
+ * Convert an OpenAI Responses API request body to an OpenAI Chat Completions
+ * request body.
+ */
+export declare function responsesToChatRequest(body: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Convert an OpenAI Chat Completions request body to an OpenAI Responses API
+ * request body.
+ */
+export declare function chatToResponsesRequest(body: Record<string, unknown>): Record<string, unknown>;