llm-simple-router 0.5.2 → 0.5.4

package/dist/proxy/openai.js

@@ -1,5 +1,6 @@
+import { randomUUID } from "crypto";
 import fp from "fastify-plugin";
-import { getActiveProviders } from "../db/index.js";
+import { getActiveProviders, insertRequestLog } from "../db/index.js";
 import { getSetting } from "../db/settings.js";
 import { decrypt } from "../utils/crypto.js";
 import { proxyGetRequest, createErrorFormatter } from "./proxy-core.js";
@@ -16,6 +17,7 @@ const OPENAI_ERROR_META = {
     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 openaiErrors = createErrorFormatter((kind, message) => ({ error: { message, ...OPENAI_ERROR_META[kind] } }));
 function sendError(reply, e) {
@@ -25,8 +27,18 @@ const openaiProxyRaw = (app, opts, done) => {
     const { db, streamTimeoutMs, retryBaseDelayMs, matcher, semaphoreManager, tracker, usageWindowTracker } = opts;
     const orchestrator = createOrchestrator(semaphoreManager, tracker);
     app.post(CHAT_COMPLETIONS_PATH, async (request, reply) => {
-        if (!orchestrator)
+        if (!orchestrator) {
+            const body = request.body;
+            insertRequestLog(db, {
+                id: randomUUID(), api_type: "openai", model: body?.model || null,
+                provider_id: null, status_code: HTTP_BAD_GATEWAY, latency_ms: 0, is_stream: 0,
+                error_message: "Orchestrator not available (missing semaphore or tracker)",
+                created_at: new Date().toISOString(),
+                client_request: JSON.stringify({ headers: request.headers }),
+                router_key_id: request.routerKey?.id ?? null,
+            });
             return sendError(reply, openaiErrors.providerUnavailable());
+        }
         const deps = { db, streamTimeoutMs, retryBaseDelayMs, matcher, tracker, orchestrator, usageWindowTracker };
         return handleProxyRequest(request, reply, "openai", CHAT_COMPLETIONS_PATH, openaiErrors, deps, {
             beforeSendProxy: (body, isStream) => {
@@ -37,22 +49,47 @@ const openaiProxyRaw = (app, opts, done) => {
         });
     });
     app.get(MODELS_PATH, async (request, reply) => {
+        const startTime = Date.now();
         const providers = getActiveProviders(db, "openai");
-        if (providers.length === 0)
+        if (providers.length === 0) {
+            insertRequestLog(db, {
+                id: randomUUID(), api_type: "openai", model: null,
+                provider_id: null, status_code: HTTP_NOT_FOUND, latency_ms: Date.now() - startTime, is_stream: 0,
+                error_message: "No active OpenAI provider configured",
+                created_at: new Date().toISOString(),
+                client_request: JSON.stringify({ headers: request.headers }),
+                router_key_id: request.routerKey?.id ?? null,
+            });
             return sendError(reply, {
                 statusCode: HTTP_NOT_FOUND,
                 body: { error: { message: "No active OpenAI provider configured", type: "invalid_request_error", code: "no_provider" } },
             });
+        }
         const provider = providers[0];
         const apiKey = decrypt(provider.api_key, getSetting(db, "encryption_key"));
         const cliHdrs = request.headers;
         try {
             const result = await proxyGetRequest(provider, apiKey, cliHdrs, MODELS_PATH);
+            insertRequestLog(db, {
+                id: randomUUID(), api_type: "openai", model: null,
+                provider_id: provider.id, status_code: result.statusCode, latency_ms: Date.now() - startTime, is_stream: 0,
+                error_message: null, created_at: new Date().toISOString(),
+                client_request: JSON.stringify({ headers: request.headers }),
+                router_key_id: request.routerKey?.id ?? null,
+            });
             for (const [k, v] of Object.entries(result.headers))
                 reply.header(k, v);
             return reply.code(result.statusCode).send(result.body);
         }
         catch (err) {
+            insertRequestLog(db, {
+                id: randomUUID(), api_type: "openai", model: null,
+                provider_id: provider.id, status_code: HTTP_BAD_GATEWAY, latency_ms: Date.now() - startTime, is_stream: 0,
+                error_message: err instanceof Error ? err.message : String(err),
+                created_at: new Date().toISOString(),
+                client_request: JSON.stringify({ headers: request.headers }),
+                router_key_id: request.routerKey?.id ?? null,
+            });
             request.log.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to reach OpenAI backend for /v1/models");
             return sendError(reply, {
                 statusCode: HTTP_BAD_GATEWAY,

package/dist/proxy/overflow.d.ts

@@ -0,0 +1,18 @@
+import Database from "better-sqlite3";
+import type { Target } from "./strategy/types.js";
+/**
+ * 估算请求的 token 消耗。
+ * 覆盖 messages、system prompt、tools 的全部文本内容，
+ * 并加乘格式化开销安全系数。
+ */
+export declare function estimateTokens(body: Record<string, unknown>): number;
+interface OverflowResult {
+    provider_id: string;
+    backend_model: string;
+}
+/**
+ * 检查请求是否超出当前模型的上下文窗口，若超出且配置了溢出目标，则返回重定向信息。
+ * 返回 null 表示无需溢出。
+ */
+export declare function applyOverflowRedirect(target: Target, db: Database.Database, body: Record<string, unknown>): OverflowResult | null;
+export {};

package/dist/proxy/overflow.js

@@ -0,0 +1,128 @@
+import { encode } from "gpt-tokenizer";
+import { getModelContextWindowOverride } from "../db/model-info.js";
+import { lookupContextWindow } from "../config/model-context.js";
+const ESTIMATED_TOKENS_PER_IMAGE = 2000;
+// 安全系数：覆盖格式化开销（role 标签、分隔符）+ 不同模型 tokenizer 的差异
+const FORMAT_OVERHEAD_RATIO = 1.3;
+// 上下文窗口使用阈值：当估算 token 超过上下文窗口的 90% 时即触发溢出，
+// 留出余量覆盖不同模型 tokenizer 差异和难以精确估算的格式开销
+const CONTEXT_WINDOW_USAGE_THRESHOLD = 0.9;
+// 采样编码的最大字符数：对大文本只编码样本再外推，避免 BPE 全量编码耗时过长
+const SAMPLE_SIZE = 4000;
+/** 从 message content 中提取文本（兼容 OpenAI 和 Anthropic 格式） */
+function extractTextFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((block) => typeof block === "object" && block !== null && "type" in block)
+        .map(block => {
+        if (block.type === "text" && typeof block.text === "string")
+            return block.text;
+        if (block.type === "tool_result") {
+            if (typeof block.content === "string")
+                return block.content;
+            if (Array.isArray(block.content))
+                return extractTextFromContent(block.content);
+        }
+        if (block.type === "tool_use" && typeof block.input === "object" && block.input !== null) {
+            return JSON.stringify(block.input);
+        }
+        return "";
+    })
+        .join(" ");
+}
+/** 从请求体中提取所有需要计算 token 的文本 */
+function extractAllText(body) {
+    const parts = [];
+    // messages（OpenAI 和 Anthropic 共有）
+    const messages = body.messages;
+    if (Array.isArray(messages)) {
+        for (const msg of messages) {
+            parts.push(extractTextFromContent(msg.content));
+        }
+    }
+    // Anthropic 格式的 system prompt
+    if (typeof body.system === "string") {
+        parts.push(body.system);
+    }
+    else if (Array.isArray(body.system)) {
+        parts.push(extractTextFromContent(body.system));
+    }
+    // tools（OpenAI 格式带 function 字段，Anthropic 格式带 name + input_schema）
+    if (Array.isArray(body.tools)) {
+        for (const tool of body.tools) {
+            const t = tool;
+            const fn = t.function;
+            if (fn) {
+                parts.push(fn.name ?? "");
+                parts.push(fn.description ?? "");
+                if (fn.parameters)
+                    parts.push(JSON.stringify(fn.parameters));
+            }
+            else if (t.name) {
+                parts.push(t.name);
+                if (t.description)
+                    parts.push(t.description);
+                if (t.input_schema)
+                    parts.push(JSON.stringify(t.input_schema));
+            }
+        }
+    }
+    return parts.join(" ");
+}
+/** 统计 messages 中的图片块数量 */
+function countImageBlocks(obj) {
+    if (Array.isArray(obj))
+        return obj.reduce((sum, item) => sum + countImageBlocks(item), 0);
+    if (obj && typeof obj === "object") {
+        const r = obj;
+        if (r.type === "image" || r.type === "image_url")
+            return 1;
+        return Object.values(r).reduce((sum, v) => sum + countImageBlocks(v), 0);
+    }
+    return 0;
+}
+/**
+ * 使用 gpt-tokenizer (o200k_base) 估算 token 数。
+ * 对长文本采用采样策略：只编码前 SAMPLE_SIZE 个字符，按比率外推。
+ */
+function countTokens(text) {
+    if (text.length === 0)
+        return 0;
+    if (text.length <= SAMPLE_SIZE)
+        return encode(text).length;
+    const sample = text.slice(0, SAMPLE_SIZE);
+    const sampleTokens = encode(sample).length;
+    return Math.ceil((sampleTokens / sample.length) * text.length);
+}
+/**
+ * 估算请求的 token 消耗。
+ * 覆盖 messages、system prompt、tools 的全部文本内容，
+ * 并加乘格式化开销安全系数。
+ */
+export function estimateTokens(body) {
+    const allText = extractAllText(body);
+    const textTokens = Math.ceil(countTokens(allText) * FORMAT_OVERHEAD_RATIO);
+    const messages = (body.messages ?? []);
+    const imageTokens = countImageBlocks(messages) * ESTIMATED_TOKENS_PER_IMAGE;
+    return textTokens + imageTokens;
+}
+function getContextWindow(db, providerId, modelName) {
+    return getModelContextWindowOverride(db, providerId, modelName) ?? lookupContextWindow(modelName);
+}
+/**
+ * 检查请求是否超出当前模型的上下文窗口，若超出且配置了溢出目标，则返回重定向信息。
+ * 返回 null 表示无需溢出。
+ */
+export function applyOverflowRedirect(target, db, body) {
+    if (!target.overflow_provider_id || !target.overflow_model)
+        return null;
+    const estimated = estimateTokens(body);
+    const contextWindow = getContextWindow(db, target.provider_id, target.backend_model);
+    if (estimated > contextWindow * CONTEXT_WINDOW_USAGE_THRESHOLD) {
+        return { provider_id: target.overflow_provider_id, backend_model: target.overflow_model };
+    }
+    return null;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * 按序执行所有 DeepSeek 特定补丁。
+ * thinking 补丁先执行（影响 assistant 消息结构），
+ * tool_result 配对修复后执行。
+ */
+export declare function applyDeepSeekPatches(body: Record<string, unknown>): void;

package/dist/proxy/patch/deepseek/index.js

@@ -0,0 +1,11 @@
+import { patchMissingThinkingBlocks } from "./patch-thinking-blocks.js";
+import { patchOrphanToolResults } from "./patch-orphan-tool-results.js";
+/**
+ * 按序执行所有 DeepSeek 特定补丁。
+ * thinking 补丁先执行（影响 assistant 消息结构），
+ * tool_result 配对修复后执行。
+ */
+export function applyDeepSeekPatches(body) {
+    patchMissingThinkingBlocks(body);
+    patchOrphanToolResults(body);
+}

package/dist/proxy/patch/deepseek/patch-orphan-tool-results.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 修复孤儿 tool_result 块——Claude Code 的 context management 截断历史消息时
+ * 可能丢失 tool_use 块但保留对应的 tool_result，导致 DeepSeek 严格校验失败。
+ *
+ * 算法：
+ * 1. 收集所有 assistant 消息中的 tool_use ID
+ * 2. 移除 tool_use_id 不在集合中的 tool_result 块
+ * 3. 移除清空后的空 user 消息
+ * 4. 合并相邻的 user 消息（Anthropic API 不允许连续 user 消息）
+ * 5. 合并相邻的 assistant 消息（同理）
+ */
+export declare function patchOrphanToolResults(body: Record<string, unknown>): void;

package/dist/proxy/patch/deepseek/patch-orphan-tool-results.js

@@ -0,0 +1,90 @@
+/**
+ * 修复孤儿 tool_result 块——Claude Code 的 context management 截断历史消息时
+ * 可能丢失 tool_use 块但保留对应的 tool_result，导致 DeepSeek 严格校验失败。
+ *
+ * 算法：
+ * 1. 收集所有 assistant 消息中的 tool_use ID
+ * 2. 移除 tool_use_id 不在集合中的 tool_result 块
+ * 3. 移除清空后的空 user 消息
+ * 4. 合并相邻的 user 消息（Anthropic API 不允许连续 user 消息）
+ * 5. 合并相邻的 assistant 消息（同理）
+ */
+export function patchOrphanToolResults(body) {
+    if (!body.messages)
+        return;
+    const messages = body.messages;
+    if (!Array.isArray(messages) || messages.length === 0)
+        return;
+    // Step 1: 收集所有已知的 tool_use ID
+    const knownToolUseIds = new Set();
+    for (const msg of messages) {
+        if (msg.role !== "assistant" || !Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block?.type === "tool_use" && typeof block.id === "string") {
+                knownToolUseIds.add(block.id);
+            }
+        }
+    }
+    if (knownToolUseIds.size === 0)
+        return;
+    // Step 2: 移除孤儿 tool_result 块
+    let removedAny = false;
+    for (const msg of messages) {
+        if (msg.role !== "user" || !Array.isArray(msg.content))
+            continue;
+        const blocks = msg.content;
+        const before = blocks.length;
+        const filtered = blocks.filter(block => {
+            if (block?.type === "tool_result" && typeof block.tool_use_id === "string") {
+                return knownToolUseIds.has(block.tool_use_id);
+            }
+            return true;
+        });
+        if (filtered.length < before) {
+            msg.content = filtered;
+            removedAny = true;
+        }
+    }
+    if (!removedAny)
+        return;
+    // Step 3: 移除清空后的空 user 消息（向后遍历避免索引错乱）
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== "user")
+            continue;
+        if (Array.isArray(msg.content) && msg.content.length === 0) {
+            messages.splice(i, 1);
+        }
+        else if (typeof msg.content === "string" && msg.content.trim() === "") {
+            messages.splice(i, 1);
+        }
+    }
+    // Step 4: 合并相邻的 user 消息
+    mergeConsecutive(messages, "user");
+    // Step 5: 合并相邻的 assistant 消息（删除空 user 消息后可能产生）
+    mergeConsecutive(messages, "assistant");
+}
+function mergeConsecutive(messages, role) {
+    let i = 1;
+    while (i < messages.length) {
+        if (messages[i].role === role && messages[i - 1].role === role) {
+            const prev = messages[i - 1];
+            const curr = messages[i];
+            const prevContent = normalizeToArray(prev.content);
+            const currContent = normalizeToArray(curr.content);
+            prev.content = [...prevContent, ...currContent];
+            messages.splice(i, 1);
+        }
+        else {
+            i++;
+        }
+    }
+}
+function normalizeToArray(content) {
+    if (Array.isArray(content))
+        return content;
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    return [{ type: "text", text: String(content ?? "") }];
+}

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

@@ -0,0 +1,6 @@
+/**
+ * DeepSeek thinking 协议实现不完整：开启 thinking 模式后部分轮次不返回 thinking block，
+ * 但后续请求要求历史 assistant 消息必须携带 thinking block。
+ * 在 content 数组开头补一个空 thinking block 以绕过上游校验。
+ */
+export declare function patchMissingThinkingBlocks(body: Record<string, unknown>): void;

package/dist/proxy/patch/deepseek/patch-thinking-blocks.js

@@ -0,0 +1,24 @@
+/**
+ * DeepSeek thinking 协议实现不完整：开启 thinking 模式后部分轮次不返回 thinking block，
+ * 但后续请求要求历史 assistant 消息必须携带 thinking block。
+ * 在 content 数组开头补一个空 thinking block 以绕过上游校验。
+ */
+export function patchMissingThinkingBlocks(body) {
+    if (!body.messages)
+        return;
+    const messages = body.messages;
+    // DeepSeek 可能在不传 thinking 参数时也启用 thinking 模式（从历史推断），
+    // 所以只要历史中存在任何 thinking block，就视为 thinking 模式激活。
+    const thinkingActive = !!body.thinking || messages.some((msg) => msg.role === "assistant" && Array.isArray(msg.content)
+        && msg.content.some((b) => b && typeof b === "object" && b.type === "thinking"));
+    if (!thinkingActive)
+        return;
+    for (const msg of messages) {
+        if (msg.role !== "assistant" || !Array.isArray(msg.content))
+            continue;
+        const hasThinking = msg.content.some((b) => b && typeof b === "object" && b.type === "thinking");
+        if (!hasThinking) {
+            msg.content.unshift({ type: "thinking", thinking: "", signature: "" });
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+interface ProviderInfo {
+    base_url: string;
+}
+/**
+ * 根据 provider 信息分发到对应的补丁逻辑。
+ * 每个补丁直接修改 body，不返回新对象。
+ */
+export declare function applyProviderPatches(body: Record<string, unknown>, provider: ProviderInfo): void;
+export {};

package/dist/proxy/patch/index.js

@@ -0,0 +1,17 @@
+import { applyDeepSeekPatches } from "./deepseek/index.js";
+/**
+ * 根据 provider 信息分发到对应的补丁逻辑。
+ * 每个补丁直接修改 body，不返回新对象。
+ */
+export function applyProviderPatches(body, provider) {
+    if (needsDeepSeekPatch(body, provider)) {
+        applyDeepSeekPatches(body);
+    }
+}
+/** DeepSeek patch 触发条件：直连 DeepSeek，或经代理转发且模型名含 deepseek */
+function needsDeepSeekPatch(body, provider) {
+    if (provider.base_url.includes("deepseek"))
+        return true;
+    const model = body.model ?? "";
+    return model.includes("deepseek");
+}

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

@@ -13,15 +13,22 @@ export interface ProxyErrorFormatter {
     upstreamConnectionFailed(): ProxyErrorResponse;
     concurrencyQueueFull(providerId: string): ProxyErrorResponse;
     concurrencyTimeout(providerId: string, timeoutMs: number): ProxyErrorResponse;
+    promptTooLong(): ProxyErrorResponse;
 }
-export type ErrorKind = "modelNotFound" | "modelNotAllowed" | "providerUnavailable" | "providerTypeMismatch" | "upstreamConnectionFailed" | "concurrencyQueueFull" | "concurrencyTimeout";
+export type ErrorKind = "modelNotFound" | "modelNotAllowed" | "providerUnavailable" | "providerTypeMismatch" | "upstreamConnectionFailed" | "concurrencyQueueFull" | "concurrencyTimeout" | "promptTooLong";
 /**
  * 工厂函数，消除 openai/anthropic 错误格式化的重复代码。
  * statusCode 和 message 两个 provider 完全一致，仅 body 格式不同，
  * 由 formatBody 回调根据 kind 参数映射各自的 type/code 并组装 body。
  */
 export declare function createErrorFormatter(formatBody: (kind: ErrorKind, message: string) => Record<string, unknown>): ProxyErrorFormatter;
+/**
+ * 拼接上游 URL，自动处理 base_url 已包含 API 路径的情况。
+ * 用户可能将 base_url 配置为 `https://host/v1/messages`，
+ * 此时不应再追加 upstreamPath（`/v1/messages`），否则路径重复。
+ */
+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): Record<string, string>;
+export declare function buildUpstreamHeaders(clientHeaders: RawHeaders, apiKey: string, payloadBytes?: number, apiType?: "openai" | "anthropic"): Record<string, string>;
 export declare function proxyGetRequest(backend: Provider, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string): Promise<GetTransportResult>;

package/dist/proxy/proxy-core.js

@@ -34,14 +34,31 @@ export function createErrorFormatter(formatBody) {
             statusCode: 504,
             body: formatBody("concurrencyTimeout", `Provider '${providerId}' concurrency wait timeout (${timeoutMs}ms)`),
         }),
+        promptTooLong: () => ({
+            statusCode: 400,
+            body: formatBody("promptTooLong", "Prompt is too long: the input tokens exceed the model context window limit."),
+        }),
     };
 }
+// ---------- URL utilities ----------
+/**
+ * 拼接上游 URL，自动处理 base_url 已包含 API 路径的情况。
+ * 用户可能将 base_url 配置为 `https://host/v1/messages`，
+ * 此时不应再追加 upstreamPath（`/v1/messages`），否则路径重复。
+ */
+export function buildUpstreamUrl(baseUrl, upstreamPath) {
+    const normalized = baseUrl.replace(/\/+$/, "");
+    if (normalized.endsWith(upstreamPath))
+        return normalized;
+    return `${normalized}${upstreamPath}`;
+}
 // ---------- Header utilities ----------
 export const SKIP_UPSTREAM = new Set([
     "host",
     "content-length",
     "accept-encoding",
     "authorization",
+    "x-api-key",
     "connection",
     "keep-alive",
     "transfer-encoding",
@@ -56,9 +73,14 @@ export function selectHeaders(raw, skip) {
     }
     return out;
 }
-export function buildUpstreamHeaders(clientHeaders, apiKey, payloadBytes) {
+export function buildUpstreamHeaders(clientHeaders, apiKey, payloadBytes, apiType) {
     const headers = selectHeaders(clientHeaders, SKIP_UPSTREAM);
-    headers["Authorization"] = `Bearer ${apiKey}`;
+    if (apiType === "anthropic") {
+        headers["x-api-key"] = apiKey;
+    }
+    else {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
     if (payloadBytes !== undefined) {
         headers["Content-Type"] = "application/json";
         headers["Content-Length"] = String(payloadBytes);

package/dist/proxy/proxy-handler.js

@@ -6,12 +6,16 @@ import { resolveMapping } from "./mapping-resolver.js";
 import { applyEnhancement } from "./enhancement/enhancement-handler.js";
 import { SemaphoreQueueFullError, SemaphoreTimeoutError } from "./semaphore.js";
 import { logResilienceResult, collectTransportMetrics, handleIntercept, sanitizeHeadersForLog, } from "./proxy-logging.js";
-import { buildUpstreamHeaders } from "./proxy-core.js";
+import { buildUpstreamHeaders, buildUpstreamUrl } from "./proxy-core.js";
 import { ProviderSwitchNeeded } from "./types.js";
-import { updateLogStreamContent } from "../db/index.js";
+import { updateLogStreamContent, updateLogClientStatus } from "../db/index.js";
 import { insertRejectedLog } from "./log-helpers.js";
 import { buildTransportFn } from "./transport-fn.js";
+import { applyOverflowRedirect } from "./overflow.js";
+import { applyProviderPatches } from "./patch/index.js";
 const HTTP_ERROR_THRESHOLD = 400;
+const MAX_LOG_FIELD_LENGTH = 80;
+const UPSTREAM_ERROR_STATUS = 502;
 function rejectAndReply(reply, params, error, errorMessage, providerId) {
     insertRejectedLog({
         db: params.db, logId: params.logId, apiType: params.apiType, model: params.model,
@@ -84,7 +88,7 @@ async function executeFailoverLoop(ctx) {
             startTime, isStream, routerKeyId, originalBody, clientHeaders: cliHdrs, originalModel,
             isFailover: isFailoverIteration, originalRequestId: isFailoverIteration ? rootLogId : null, sessionId,
         };
-        const resolved = resolveMapping(deps.db, effectiveModel, { now: new Date(), excludeTargets });
+        let resolved = resolveMapping(deps.db, effectiveModel, { now: new Date(), excludeTargets });
         request.log.debug({ logId, model: effectiveModel, apiType, isStream, action: "resolve_mapping", resolved: !!resolved });
         if (!resolved) {
             if (isFailover && excludeTargets.length > 0) {
@@ -102,11 +106,11 @@ async function executeFailoverLoop(ctx) {
                     }
                 }
                 catch {
-                    request.log.warn({ allowedModels: allowedModels?.slice(0, 80) }, "Invalid allowed_models JSON, allowing all models");
-                } // eslint-disable-line no-magic-numbers
+                    request.log.warn({ allowedModels: allowedModels?.slice(0, MAX_LOG_FIELD_LENGTH) }, "Invalid allowed_models JSON, allowing all models");
+                }
             }
         }
-        const provider = getProviderById(deps.db, resolved.provider_id);
+        let provider = getProviderById(deps.db, resolved.provider_id);
         if (!provider || !provider.is_active) {
             return rejectAndReply(reply, rCtx, errors.providerUnavailable(), `Provider '${resolved.provider_id}' unavailable`, resolved.provider_id);
         }
@@ -114,13 +118,24 @@ async function executeFailoverLoop(ctx) {
             return rejectAndReply(reply, rCtx, errors.providerTypeMismatch(), `API type mismatch: expected '${apiType}'`, resolved.provider_id);
         }
         body.model = resolved.backend_model;
+        // --- 溢出重定向：上下文超出时切换到更大模型 ---
+        const overflowResult = applyOverflowRedirect(resolved, deps.db, body);
+        if (overflowResult) {
+            const overflowProvider = getProviderById(deps.db, overflowResult.provider_id);
+            if (overflowProvider && overflowProvider.is_active && overflowProvider.api_type === apiType) {
+                resolved = { ...resolved, provider_id: overflowResult.provider_id, backend_model: overflowResult.backend_model };
+                provider = overflowProvider;
+                body.model = overflowResult.backend_model;
+            }
+        }
+        applyProviderPatches(body, provider);
         const apiKey = decrypt(provider.api_key, getSetting(deps.db, "encryption_key"));
         options?.beforeSendProxy?.(body, isStream);
         const reqBodyStr = JSON.stringify(body);
         const clientReq = JSON.stringify({ headers: cliHdrs, body: originalBody });
         const upstreamReqBase = JSON.stringify({
-            url: `${provider.base_url}${upstreamPath}`,
-            headers: sanitizeHeadersForLog(buildUpstreamHeaders(cliHdrs, apiKey, Buffer.byteLength(reqBodyStr))),
+            url: buildUpstreamUrl(provider.base_url, upstreamPath),
+            headers: sanitizeHeadersForLog(buildUpstreamHeaders(cliHdrs, apiKey, Buffer.byteLength(reqBodyStr), apiType)),
             body: reqBodyStr,
         });
         const transportFn = buildTransportFn({
@@ -165,6 +180,7 @@ async function executeFailoverLoop(ctx) {
                 const tr = resilienceResult.result;
                 if (tr.kind === "throw" || (tr.kind === "error" && tr.statusCode >= HTTP_ERROR_THRESHOLD)) {
                     const err = errors.upstreamConnectionFailed();
+                    updateLogClientStatus(deps.db, lastLogId, err.statusCode);
                     return reply.code(err.statusCode).send(err.body);
                 }
             }
@@ -172,6 +188,15 @@ async function executeFailoverLoop(ctx) {
         }
         catch (e) {
             if (e instanceof ProviderSwitchNeeded) {
+                // 跨 provider failover：resilience 层携带了 attempts 数据，补写失败日志
+                if (e.attempts && e.attempts.length > 0) {
+                    const fakeResult = e.lastResult ?? { kind: "throw", error: new Error("provider switch") };
+                    logResilienceResult(deps.db, {
+                        apiType, model: effectiveModel, providerId: provider.id, isStream,
+                        clientReq, upstreamReqBase, logId, routerKeyId, originalModel, sessionId,
+                        failover: { isFailoverIteration, rootLogId: rootLogId },
+                    }, e.attempts, fakeResult, startTime);
+                }
                 request.log.debug({ logId, action: "provider_switch", targetProviderId: e.targetProviderId });
                 excludeTargets.push(resolved);
                 continue;
@@ -186,7 +211,7 @@ async function executeFailoverLoop(ctx) {
             request.log.debug({ logId, error: errMsg, action: "upstream_error" });
             insertRequestLog(deps.db, {
                 id: logId, api_type: apiType, model: effectiveModel, provider_id: provider.id,
-                status_code: 502, latency_ms: Date.now() - startTime, is_stream: isStream ? 1 : 0,
+                status_code: UPSTREAM_ERROR_STATUS, latency_ms: Date.now() - startTime, is_stream: isStream ? 1 : 0,
                 error_message: errMsg || "Upstream connection failed", created_at: new Date().toISOString(),
                 client_request: clientReq, upstream_request: upstreamReqBase,
                 is_failover: isFailoverIteration ? 1 : 0, original_request_id: isFailoverIteration ? rootLogId : null,

package/dist/proxy/proxy-logging.js

@@ -44,7 +44,25 @@ export function logResilienceResult(db, params, attempts, result, startTime) {
         const attemptLogId = isOriginal ? params.logId : randomUUID();
         const isFailoverLog = isOriginal && isFailoverIteration;
         const parentId = isOriginal ? (isFailoverIteration ? rootLogId : null) : params.logId;
-        if (attempt.error) {
+        // stream_error + statusCode 200: 上游返回 200 但 body 包含错误内容（如 early error detection）
+        // 非 200 的 stream_error（如上游 429/500）走下方的正常错误路径
+        if (attempt.resultKind === "stream_error" && attempt.statusCode === UPSTREAM_SUCCESS) {
+            insertRequestLog(db, {
+                id: attemptLogId, api_type: params.apiType, model: params.model,
+                provider_id: attempt.target.provider_id,
+                status_code: HTTP_BAD_GATEWAY, latency_ms: attempt.latencyMs,
+                is_stream: params.isStream ? 1 : 0,
+                error_message: "stream_error: upstream returned 200 but body contains error",
+                created_at: new Date().toISOString(),
+                client_request: params.clientReq, upstream_request: params.upstreamReqBase,
+                upstream_response: JSON.stringify({ statusCode: attempt.statusCode, headers: attempt.responseHeaders, body: attempt.responseBody }),
+                is_retry: isOriginal ? 0 : 1, is_failover: isFailoverLog ? 1 : 0,
+                original_request_id: parentId,
+                router_key_id: params.routerKeyId, original_model: params.originalModel,
+                session_id: params.sessionId,
+            });
+        }
+        else if (attempt.error) {
             insertRequestLog(db, {
                 id: attemptLogId, api_type: params.apiType, model: params.model,
                 provider_id: attempt.target.provider_id,
@@ -52,6 +70,9 @@ export function logResilienceResult(db, params, attempts, result, startTime) {
                 is_stream: params.isStream ? 1 : 0, error_message: attempt.error,
                 created_at: new Date().toISOString(),
                 client_request: params.clientReq, upstream_request: params.upstreamReqBase,
+                upstream_response: attempt.responseHeaders
+                    ? JSON.stringify({ statusCode: HTTP_BAD_GATEWAY, headers: attempt.responseHeaders, error: attempt.error })
+                    : null,
                 is_retry: isOriginal ? 0 : 1, is_failover: isFailoverLog ? 1 : 0,
                 original_request_id: parentId,
                 router_key_id: params.routerKeyId, original_model: params.originalModel,
@@ -66,7 +87,7 @@ export function logResilienceResult(db, params, attempts, result, startTime) {
                 is_stream: params.isStream ? 1 : 0, error_message: null,
                 created_at: new Date().toISOString(),
                 client_request: params.clientReq, upstream_request: params.upstreamReqBase,
-                upstream_response: JSON.stringify({ statusCode: attempt.statusCode, body: attempt.responseBody }),
+                upstream_response: JSON.stringify({ statusCode: attempt.statusCode, headers: attempt.responseHeaders, body: attempt.responseBody }),
                 is_retry: isOriginal ? 0 : 1, is_failover: isFailoverLog ? 1 : 0,
                 original_request_id: parentId,
                 router_key_id: params.routerKeyId, original_model: params.originalModel,

package/dist/proxy/resilience.d.ts

@@ -37,6 +37,10 @@ export interface ResilienceAttempt {
     error: string | null;
     latencyMs: number;
     responseBody: string | null;
+    /** 上游响应 headers（throw 和 stream_success/stream_abort 时为 null） */
+    responseHeaders: Record<string, string> | null;
+    /** TransportResult.kind，用于区分 stream_error 等特殊类型 */
+    resultKind: TransportResult["kind"];
 }
 export interface ResilienceResult {
     result: TransportResult;