llm-simple-router 0.6.7 → 0.7.1

package/dist/proxy/{proxy-handler.js → handler/proxy-handler.js}

@@ -1,35 +1,27 @@
 import { randomUUID } from "crypto";
-import { HTTP_UNPROCESSABLE_ENTITY } from "../constants.js";
-import { getProviderById, insertRequestLog } from "../db/index.js";
-import { decrypt } from "../utils/crypto.js";
-import { getSetting } from "../db/settings.js";
-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, buildUpstreamUrl } from "./proxy-core.js";
-import { ProviderSwitchNeeded } from "./types.js";
-import { updateLogStreamContent, updateLogClientStatus } from "../db/index.js";
-import { insertRejectedLog } from "./log-helpers.js";
-import { ToolLoopGuard } from "./loop-prevention/tool-loop-guard.js";
-import { TOOL_USE_ID_PREFIX, TOOL_USE_ID_PROVIDER_PREFIX } from "./enhancement/directive-parser.js";
-import { buildTransportFn } from "./transport-fn.js";
-import { applyOverflowRedirect } from "./overflow.js";
-import { applyProviderPatches } from "./patch/index.js";
-import { loadEnhancementConfig } from "./enhancement-config.js";
+import { HTTP_UNPROCESSABLE_ENTITY } from "../../core/constants.js";
+import { getProviderById, insertRequestLog, updateLogPipelineSnapshot, updateLogStreamContent, updateLogClientStatus } from "../../db/index.js";
+import { decrypt } from "../../utils/crypto.js";
+import { getSetting } from "../../db/settings.js";
+import { resolveMapping } from "../routing/mapping-resolver.js";
+import { applyEnhancement } from "../enhancement/enhancement-handler.js";
+import { SemaphoreQueueFullError, SemaphoreTimeoutError } from "../orchestration/semaphore.js";
+import { logResilienceResult, collectTransportMetrics, handleIntercept, sanitizeHeadersForLog, } from "../proxy-logging.js";
+import { buildUpstreamHeaders, buildUpstreamUrl } from "../proxy-core.js";
+import { ProviderSwitchNeeded } from "../types.js";
+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 { applyProviderPatches } from "../patch/index.js";
+import { PipelineSnapshot } from "../pipeline-snapshot.js";
+import { maybeInjectModelInfoTag } from "../response-transform.js";
+import { loadEnhancementConfig } from "../routing/enhancement-config.js";
+import { getTransportStatusCode, serializeBlocksForStorage, extractLastToolUse } from "./proxy-handler-utils.js";
 const HTTP_ERROR_THRESHOLD = 400;
 const MAX_LOG_FIELD_LENGTH = 80;
 const UPSTREAM_ERROR_STATUS = 502;
 const TIER2_LOOP_THRESHOLD = 2;
-/** 从 TransportResult 中提取最终 HTTP status code */
-function getTransportStatusCode(result) {
-    if (result.kind === "success" || result.kind === "error" || result.kind === "stream_error")
-        return result.statusCode;
-    if (result.kind === "stream_success" || result.kind === "stream_abort")
-        return result.statusCode;
-    // kind === "throw"：无 HTTP 状态码
-    return null;
-}
 function rejectAndReply(reply, params, error, errorMessage, providerId) {
     insertRejectedLog({
         db: params.db, logId: params.logId, apiType: params.apiType, model: params.model,
@@ -38,33 +30,13 @@ function rejectAndReply(reply, params, error, errorMessage, providerId) {
         originalBody: params.originalBody, clientHeaders: params.clientHeaders,
         providerId, originalModel: params.originalModel,
         isFailover: params.isFailover, originalRequestId: params.originalRequestId,
-        sessionId: params.sessionId,
+        sessionId: params.sessionId, pipelineSnapshot: params.pipelineSnapshot,
+        matcher: params.matcher, logFileWriter: params.logFileWriter,
     });
     return reply.code(error.statusCode).send(error.body);
 }
-/** 将 tracker blocks 序列化为前端 tryDirectParse 可解析的 JSON */
-function serializeBlocksForStorage(blocks, apiType) {
-    if (!blocks || blocks.length === 0)
-        return "";
-    if (apiType === "anthropic") {
-        const content = blocks.map(b => {
-            if (b.type === "thinking")
-                return { type: "thinking", thinking: b.content };
-            if (b.type === "tool_use") {
-                let input = {};
-                try {
-                    input = JSON.parse(b.content || "{}");
-                }
-                catch { /* eslint-disable-line taste/no-silent-catch -- tool_use content 非合法 JSON 时保留空对象 */ }
-                return { type: "tool_use", name: b.name ?? "", input };
-            }
-            return { type: "text", text: b.content };
-        });
-        return JSON.stringify({ content });
-    }
-    const text = blocks.filter(b => b.type === "text").map(b => b.content).join("");
-    return JSON.stringify({ choices: [{ message: { content: text } }] });
-}
+import { getConfig } from "../../config/index.js";
+import { SERVICE_KEYS } from "../../core/container.js";
 // ---------- Main entry ----------
 export async function handleProxyRequest(request, reply, apiType, upstreamPath, errors, deps, options) {
     const socketErrorHandler = (err) => request.log.debug({ err }, "client socket error");
@@ -75,24 +47,36 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
     const clientModel = request.body.model || "unknown";
     const sessionId = request.headers["x-claude-code-session-id"];
     const enhancementConfig = loadEnhancementConfig(deps.db);
-    const { effectiveModel, originalModel, interceptResponse } = applyEnhancement(deps.db, request, clientModel, sessionId, enhancementConfig);
-    // --- 工具调用循环检测（受 proxy_enhancement 配置控制） ---
-    if (enhancementConfig.tool_call_loop_enabled && deps.sessionTracker && sessionId) {
+    // 解析 matcher 和 logFileWriter，传递给日志相关调用
+    const matcher = deps.container.resolve(SERVICE_KEYS.matcher);
+    const logFileWriter = deps.container.resolve(SERVICE_KEYS.logFileWriter);
+    // 在所有加工之前捕获原始 body
+    const reqBody = request.body;
+    const rawBody = reqBody ? JSON.parse(JSON.stringify(reqBody)) : {};
+    const snapshot = new PipelineSnapshot();
+    // enhancement 阶段
+    const { body: enhancedBody, effectiveModel, originalModel, interceptResponse, meta: enhMeta } = applyEnhancement(deps.db, request.body, clientModel, sessionId, request.routerKey);
+    snapshot.add({ stage: "enhancement", router_tags_stripped: enhMeta.router_tags_stripped, directive: enhMeta.directive });
+    // tool guard 阶段 — 使用 enhancedBody
+    let pipelineBody = enhancedBody;
+    const sessionTracker = deps.container.resolve(SERVICE_KEYS.sessionTracker);
+    if (enhancementConfig.tool_call_loop_enabled && sessionTracker && sessionId) {
         const routerKeyId = request.routerKey?.id ?? null;
         const sessionKey = routerKeyId ? `${routerKeyId}:${sessionId}` : sessionId;
-        const lastToolUse = extractLastToolUse(request.body);
+        const lastToolUse = extractLastToolUse(enhancedBody);
         if (lastToolUse) {
-            const toolGuard = new ToolLoopGuard(deps.sessionTracker, {
+            const toolGuard = new ToolLoopGuard(sessionTracker, {
                 enabled: true,
                 minConsecutiveCount: 3,
                 detectorConfig: { n: 6, windowSize: 500, repeatThreshold: 5 },
             });
             const checkResult = toolGuard.check(sessionKey, lastToolUse);
             if (checkResult.detected) {
-                const loopCount = deps.sessionTracker.getLoopCount(sessionKey);
+                const loopCount = sessionTracker.getLoopCount(sessionKey);
                 if (loopCount === 1) {
                     // 层级 1：透明重试 — 注入中断提示词
-                    toolGuard.injectLoopBreakPrompt(request.body, apiType, lastToolUse.toolName);
+                    pipelineBody = toolGuard.injectLoopBreakPrompt(enhancedBody, apiType, lastToolUse.toolName);
+                    snapshot.add({ stage: "tool_guard", action: "inject_break_prompt", tool: lastToolUse.toolName });
                     request.log.warn({ sessionId, toolName: lastToolUse.toolName, loopCount }, "Tool call loop detected, injecting break prompt");
                 }
                 else if (loopCount === TIER2_LOOP_THRESHOLD) {
@@ -115,18 +99,24 @@ export async function handleProxyRequest(request, reply, apiType, upstreamPath,
         }
     }
     if (interceptResponse)
-        return handleIntercept(deps.db, apiType, request, reply, interceptResponse, clientModel, sessionId);
+        return handleIntercept(deps.db, apiType, request, reply, interceptResponse, clientModel, sessionId, snapshot.toJSON(), matcher, logFileWriter);
     return executeFailoverLoop({
         request, reply, apiType, upstreamPath, errors, deps, options,
         effectiveModel, originalModel,
-        originalBody: JSON.parse(JSON.stringify(request.body)),
+        pipelineBody,
+        rawBody,
+        baseStages: snapshot.getStages(),
         sessionId,
         streamLoopEnabled: enhancementConfig.stream_loop_enabled,
+        matcher, logFileWriter,
     });
 }
 // ---------- Failover loop ----------
 async function executeFailoverLoop(ctx) {
-    const { request, reply, apiType, upstreamPath, errors, deps, options, effectiveModel, originalModel, originalBody, sessionId, streamLoopEnabled } = ctx;
+    const { request, reply, apiType, upstreamPath, errors, deps, options, effectiveModel, originalModel, pipelineBody, rawBody, baseStages, sessionId, streamLoopEnabled, matcher, logFileWriter } = ctx;
+    const tracker = deps.container.resolve(SERVICE_KEYS.tracker);
+    const usageWindowTracker = deps.container.resolve(SERVICE_KEYS.usageWindowTracker);
+    const config = getConfig();
     const excludeTargets = [];
     let rootLogId = null;
     while (true) {
@@ -136,13 +126,18 @@ async function executeFailoverLoop(ctx) {
             rootLogId = logId;
         const isFailoverIteration = rootLogId !== logId;
         const routerKeyId = request.routerKey?.id ?? null;
-        const body = request.body;
-        const isStream = body.stream === true;
+        // 每次迭代从 pipelineBody 重新开始（不修改 pipelineBody）
+        let currentBody = JSON.parse(JSON.stringify(pipelineBody));
+        const isStream = currentBody.stream === true;
         const cliHdrs = request.headers;
+        // 构建 per-iteration snapshot
+        const iterationSnapshot = new PipelineSnapshot(baseStages);
         const rCtx = {
             db: deps.db, logId, apiType, model: effectiveModel,
-            startTime, isStream, routerKeyId, originalBody, clientHeaders: cliHdrs, originalModel,
+            startTime, isStream, routerKeyId, originalBody: rawBody, clientHeaders: cliHdrs, originalModel,
             isFailover: isFailoverIteration, originalRequestId: isFailoverIteration ? rootLogId : null, sessionId,
+            pipelineSnapshot: iterationSnapshot.toJSON(),
+            matcher, logFileWriter,
         };
         const resolveResult = resolveMapping(deps.db, effectiveModel, { now: new Date(), excludeTargets });
         request.log.debug({ logId, model: effectiveModel, apiType, isStream, action: "resolve_mapping", resolved: !!resolveResult });
@@ -177,47 +172,63 @@ async function executeFailoverLoop(ctx) {
         if (provider.api_type !== apiType) {
             return rejectAndReply(reply, rCtx, errors.providerTypeMismatch(), `API type mismatch: expected '${apiType}'`, resolved.provider_id);
         }
-        body.model = resolved.backend_model;
+        // routing — 创建新对象而非 in-place mutation
+        currentBody = { ...currentBody, model: resolved.backend_model };
+        iterationSnapshot.add({ stage: "routing", client_model: effectiveModel, backend_model: resolved.backend_model, provider_id: resolved.provider_id, strategy: resolveResult.targetCount > 1 ? "failover" : "scheduled" });
         // --- 溢出重定向：上下文超出时切换到更大模型 ---
-        const overflowResult = applyOverflowRedirect(resolved, deps.db, body);
+        const overflowResult = applyOverflowRedirect(resolved, deps.db, currentBody);
         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;
+                currentBody = { ...currentBody, model: overflowResult.backend_model };
+                iterationSnapshot.add({ stage: "overflow", triggered: true, redirect_to: overflowResult.backend_model, redirect_provider: overflowResult.provider_id });
             }
         }
-        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 });
+        else {
+            iterationSnapshot.add({ stage: "overflow", triggered: false });
+        }
+        // provider patches — 使用返回值
+        const { body: patchedBody, meta: patchMeta } = applyProviderPatches(currentBody, provider);
+        iterationSnapshot.add({ stage: "provider_patch", types: patchMeta.types });
+        const encryptionKey = getSetting(deps.db, "encryption_key");
+        if (!encryptionKey) {
+            return rejectAndReply(reply, rCtx, errors.providerUnavailable(), `Encryption key not configured`, provider.id);
+        }
+        const apiKey = decrypt(provider.api_key, encryptionKey);
+        options?.beforeSendProxy?.(patchedBody, isStream);
+        // logging — 使用 rawBody 作为 client_request，patchedBody 作为 upstream_request
+        const reqBodyStr = JSON.stringify(patchedBody);
+        const clientReq = JSON.stringify({ headers: cliHdrs, body: rawBody });
         const upstreamReqBase = JSON.stringify({
             url: buildUpstreamUrl(provider.base_url, upstreamPath),
             headers: sanitizeHeadersForLog(buildUpstreamHeaders(cliHdrs, apiKey, Buffer.byteLength(reqBodyStr), apiType)),
             body: reqBodyStr,
         });
         const transportFn = buildTransportFn({
-            provider, apiKey, body, cliHdrs, reply, upstreamPath, apiType,
+            provider, apiKey, body: patchedBody, cliHdrs, reply, upstreamPath, apiType,
             isStream, startTime, logId, effectiveModel, originalModel,
-            streamTimeoutMs: deps.streamTimeoutMs, tracker: deps.tracker, matcher: deps.matcher, request,
+            streamTimeoutMs: config.STREAM_TIMEOUT_MS, tracker, matcher, request,
             streamLoopEnabled,
         });
+        const pipelineSnapshot = iterationSnapshot.toJSON();
         try {
-            const resilienceResult = await deps.orchestrator.handle(request, reply, apiType, { resolved, provider, clientModel: effectiveModel, isStream, trackerId: logId, sessionId, clientRequest: clientReq, concurrencyOverride }, { retryBaseDelayMs: deps.retryBaseDelayMs, isFailover, ruleMatcher: deps.matcher, transportFn });
+            const resilienceResult = await deps.orchestrator.handle(request, reply, apiType, { resolved, provider, clientModel: effectiveModel, isStream, trackerId: logId, sessionId, clientRequest: clientReq, upstreamRequest: upstreamReqBase, concurrencyOverride }, { retryBaseDelayMs: config.RETRY_BASE_DELAY_MS, isFailover, ruleMatcher: matcher, transportFn });
             const lastLogId = logResilienceResult(deps.db, {
                 apiType, model: effectiveModel, providerId: provider.id, isStream,
                 clientReq, upstreamReqBase, logId, routerKeyId, originalModel, sessionId,
                 failover: { isFailoverIteration, rootLogId: rootLogId },
+                pipelineSnapshot,
+                matcher, logFileWriter,
             }, resilienceResult.attempts, resilienceResult.result, startTime);
             collectTransportMetrics(deps.db, apiType, resilienceResult.result, isStream, lastLogId, provider.id, resolved.backend_model, request, routerKeyId, getTransportStatusCode(resilienceResult.result));
             const tr = resilienceResult.result;
             const succeeded = tr.kind === "success" || tr.kind === "stream_success" || tr.kind === "stream_abort";
             if (succeeded)
-                deps.usageWindowTracker?.recordRequest(provider.id, routerKeyId ?? undefined);
-            if (isStream && deps.tracker) {
-                const sc = deps.tracker.get(logId)?.streamContent;
+                usageWindowTracker?.recordRequest(provider.id, routerKeyId ?? undefined);
+            if (isStream && tracker) {
+                const sc = tracker.get(logId)?.streamContent;
                 const blocks = sc?.blocks;
                 const hasStructured = blocks && blocks.length > 0 && blocks.some(b => b.type !== "text");
                 const content = hasStructured
@@ -239,6 +250,15 @@ async function executeFailoverLoop(ctx) {
             // 对 failover 场景的错误也不发送——这些情况需要外层 proxy-handler 处理
             if (!reply.raw.headersSent) {
                 const tr = resilienceResult.result;
+                if (tr.kind === "success") {
+                    // response transform — 注入 model info tag
+                    const { body: finalBody, meta: respMeta } = maybeInjectModelInfoTag(tr.body, originalModel, effectiveModel);
+                    if (respMeta.model_info_tag_injected) {
+                        iterationSnapshot.add({ stage: "response_transform", model_info_tag_injected: true });
+                        updateLogPipelineSnapshot(deps.db, lastLogId, iterationSnapshot.toJSON());
+                    }
+                    return reply.code(tr.statusCode).send(finalBody);
+                }
                 if (tr.kind === "throw" || (tr.kind === "error" && tr.statusCode >= HTTP_ERROR_THRESHOLD)) {
                     const err = errors.upstreamConnectionFailed();
                     updateLogClientStatus(deps.db, lastLogId, err.statusCode);
@@ -260,6 +280,8 @@ async function executeFailoverLoop(ctx) {
                         apiType, model: effectiveModel, providerId: provider.id, isStream,
                         clientReq, upstreamReqBase, logId, routerKeyId, originalModel, sessionId,
                         failover: { isFailoverIteration, rootLogId: rootLogId },
+                        pipelineSnapshot,
+                        matcher, logFileWriter,
                     }, e.attempts, fakeResult, startTime);
                 }
                 request.log.debug({ logId, action: "provider_switch", targetProviderId: e.targetProviderId });
@@ -282,50 +304,12 @@ async function executeFailoverLoop(ctx) {
                 is_failover: isFailoverIteration ? 1 : 0, original_request_id: isFailoverIteration ? rootLogId : null,
                 router_key_id: routerKeyId, original_model: originalModel,
                 session_id: sessionId,
-            });
+                pipeline_snapshot: pipelineSnapshot,
+            }, (matcher || logFileWriter) ? {
+                matcher, logFileWriter, responseBody: null,
+            } : undefined);
             const err = errors.upstreamConnectionFailed();
             return reply.code(err.statusCode).send(err.body);
         }
     }
 }
-function extractLastToolUse(body) {
-    const messages = body.messages;
-    if (!messages)
-        return null;
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role === "assistant") {
-            const content = msg.content;
-            if (Array.isArray(content)) {
-                for (let j = content.length - 1; j >= 0; j--) {
-                    const block = content[j];
-                    if (block.type !== "tool_use")
-                        continue;
-                    const id = block.id;
-                    if (id && (id.startsWith(TOOL_USE_ID_PREFIX) || id.startsWith(TOOL_USE_ID_PROVIDER_PREFIX))) {
-                        continue;
-                    }
-                    const inputStr = JSON.stringify(block.input ?? {});
-                    return {
-                        toolName: block.name,
-                        toolUseId: typeof block.id === "string" ? block.id : undefined,
-                        inputHash: simpleHash(inputStr),
-                        inputText: inputStr,
-                        timestamp: Date.now(),
-                    };
-                }
-            }
-        }
-    }
-    return null;
-}
-function simpleHash(s) {
-    const HASH_SHIFT = 5;
-    let hash = 0;
-    for (let i = 0; i < s.length; i++) {
-        const char = s.charCodeAt(i);
-        hash = ((hash << HASH_SHIFT) - hash) + char;
-        hash |= 0;
-    }
-    return String(hash);
-}

package/dist/proxy/log-detail-policy.d.ts

@@ -0,0 +1,12 @@
+export interface RetryMatcher {
+    test: (statusCode: number, body: string) => boolean;
+}
+/**
+ * 判断一条日志是否需要保留全文详情到 DB。
+ * - hasFileWriter=false 时保守保留全文（避免数据丢失）
+ * - status >= 400 → 保留
+ * - matcher 为 null → 保守保留
+ * - matcher 命中 → 保留
+ * - 否则 → 只存摘要（文件已有全文备份）
+ */
+export declare function shouldPreserveDetail(statusCode: number | null, responseBody: string | null, matcher: RetryMatcher | null, hasFileWriter?: boolean): boolean;

package/dist/proxy/log-detail-policy.js

@@ -0,0 +1,21 @@
+// src/proxy/log-detail-policy.ts
+const HTTP_ERROR_THRESHOLD = 400;
+/**
+ * 判断一条日志是否需要保留全文详情到 DB。
+ * - hasFileWriter=false 时保守保留全文（避免数据丢失）
+ * - status >= 400 → 保留
+ * - matcher 为 null → 保守保留
+ * - matcher 命中 → 保留
+ * - 否则 → 只存摘要（文件已有全文备份）
+ */
+export function shouldPreserveDetail(statusCode, responseBody, matcher, hasFileWriter = true) {
+    if (!hasFileWriter)
+        return true;
+    if (statusCode !== null && statusCode >= HTTP_ERROR_THRESHOLD)
+        return true;
+    if (!matcher)
+        return true;
+    if (responseBody && matcher.test(statusCode ?? 0, responseBody))
+        return true;
+    return false;
+}

package/dist/proxy/log-helpers.d.ts

@@ -1,5 +1,7 @@
 import Database from "better-sqlite3";
 import type { Provider } from "../db/index.js";
+import type { LogFileWriter } from "../storage/log-file-writer.js";
+import type { RetryMatcher } from "./log-detail-policy.js";
 import type { RawHeaders } from "./types.js";
 export interface FailoverContext {
     isFailoverIteration: boolean;
@@ -25,6 +27,9 @@ export interface RequestLogParams extends LogRetryMeta {
     routerKeyId?: string | null;
     originalModel?: string | null;
     sessionId?: string | null;
+    pipelineSnapshot?: string | null;
+    matcher?: RetryMatcher | null;
+    logFileWriter?: LogFileWriter | null;
 }
 /** 插入成功请求日志，供 openai/anthropic 插件共享 */
 export declare function insertSuccessLog(db: Database.Database, params: RequestLogParams): void;
@@ -43,6 +48,9 @@ export interface RejectedLogParams extends LogRetryMeta {
     providerId?: string | null;
     originalModel?: string | null;
     sessionId?: string | null;
+    pipelineSnapshot?: string | null;
+    matcher?: RetryMatcher | null;
+    logFileWriter?: LogFileWriter | null;
 }
 /** Log a request rejected before reaching upstream */
 export declare function insertRejectedLog(params: RejectedLogParams): void;

package/dist/proxy/log-helpers.js

@@ -1,7 +1,12 @@
 import { insertRequestLog } from "../db/index.js";
 /** 插入成功请求日志，供 openai/anthropic 插件共享 */
 export function insertSuccessLog(db, params) {
-    const { id: logId, apiType, model, provider, isStream, startTime, clientReq, upstreamReq, status, respBody, upHdrs, isRetry = false, isFailover = false, originalRequestId = null, routerKeyId = null, originalModel = null, sessionId = null } = params;
+    const { id: logId, apiType, model, provider, isStream, startTime, clientReq, upstreamReq, status, respBody, upHdrs, isRetry = false, isFailover = false, originalRequestId = null, routerKeyId = null, originalModel = null, sessionId = null, pipelineSnapshot = null, matcher, logFileWriter } = params;
+    const writeContext = (matcher || logFileWriter) ? {
+        matcher,
+        logFileWriter,
+        responseBody: respBody,
+    } : undefined;
     insertRequestLog(db, {
         id: logId, api_type: apiType, model, provider_id: provider.id,
         status_code: status, latency_ms: Date.now() - startTime,
@@ -12,11 +17,17 @@ export function insertSuccessLog(db, params) {
         is_retry: isRetry ? 1 : 0, is_failover: isFailover ? 1 : 0, original_request_id: originalRequestId,
         router_key_id: routerKeyId, original_model: originalModel,
         session_id: sessionId,
-    });
+        pipeline_snapshot: pipelineSnapshot ?? null,
+    }, writeContext);
 }
 /** Log a request rejected before reaching upstream */
 export function insertRejectedLog(params) {
-    const { db, logId, apiType, model, statusCode, errorMessage, startTime, isStream, routerKeyId, originalBody, clientHeaders, providerId = null, isFailover = false, originalRequestId = null, originalModel = null, sessionId = null } = params;
+    const { db, logId, apiType, model, statusCode, errorMessage, startTime, isStream, routerKeyId, originalBody, clientHeaders, providerId = null, isFailover = false, originalRequestId = null, originalModel = null, sessionId = null, pipelineSnapshot = null, matcher, logFileWriter } = params;
+    const writeContext = (matcher || logFileWriter) ? {
+        matcher,
+        logFileWriter,
+        responseBody: null,
+    } : undefined;
     insertRequestLog(db, {
         id: logId,
         api_type: apiType,
@@ -33,5 +44,6 @@ export function insertRejectedLog(params) {
         router_key_id: routerKeyId,
         original_model: originalModel,
         session_id: sessionId,
-    });
+        pipeline_snapshot: pipelineSnapshot ?? null,
+    }, writeContext);
 }

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): void;
+    injectLoopBreakPrompt(body: Record<string, unknown>, apiType: "openai" | "anthropic", toolName: string): Record<string, unknown>;
 }

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

@@ -36,28 +36,25 @@ export class ToolLoopGuard {
         return { detected: false };
     }
     injectLoopBreakPrompt(body, apiType, toolName) {
-        const prompt = `你正在重复调用同一个工具 "${toolName}"。` +
-            `这很可能陷入了一个循环。请仔细回顾对话历史，` +
-            `分析之前调用该工具的结果，停止重复调用，` +
-            `改用其他方式完成任务或直接告知用户你遇到的问题。`;
+        const cloned = JSON.parse(JSON.stringify(body));
+        const prompt = `[系统提醒] 检测到你可能陷入了反复调用 "${toolName}" 工具的循环。请停下来，总结当前进展，直接告知用户。`;
         if (apiType === "anthropic") {
-            const system = body.system;
+            const system = cloned.system;
             if (Array.isArray(system)) {
                 system.push({ type: "text", text: prompt });
             }
             else if (typeof system === "string") {
-                body.system = [{ type: "text", text: system }, { type: "text", text: prompt }];
+                cloned.system = [{ type: "text", text: system }, { type: "text", text: prompt }];
             }
             else {
-                body.system = [{ type: "text", text: prompt }];
+                cloned.system = [{ type: "text", text: prompt }];
             }
         }
         else {
-            // OpenAI: 在 messages 开头插入 system message
-            const messages = body.messages;
-            if (messages) {
-                messages.unshift({ role: "system", content: prompt });
-            }
+            const messages = cloned.messages ?? [];
+            messages.unshift({ role: "system", content: prompt });
+            cloned.messages = messages;
         }
+        return cloned;
     }
 }

package/dist/proxy/{orchestrator.d.ts → orchestration/orchestrator.d.ts}

@@ -1,13 +1,13 @@
 import type { FastifyReply, FastifyRequest } from "fastify";
-import type { TransportResult } from "./types.js";
-import type { Target, ConcurrencyOverride } from "./strategy/types.js";
+import type { TransportResult } from "../types.js";
+import type { Target, ConcurrencyOverride } from "../../core/types.js";
 import type { ResilienceLayer, ResilienceResult } from "./resilience.js";
 import type { RetryRuleMatcher } from "./retry-rules.js";
 import type { SemaphoreScope } from "./scope.js";
 import type { TrackerScope } from "./scope.js";
 import type { ProviderSemaphoreManager } from "./semaphore.js";
-import type { RequestTracker } from "../monitor/request-tracker.js";
-import type { AdaptiveConcurrencyController } from "./adaptive-controller.js";
+import type { RequestTracker } from "../../monitor/request-tracker.js";
+import type { AdaptiveConcurrencyController } from "../adaptive-controller.js";
 export interface OrchestratorConfig {
     resolved: Target;
     provider: {
@@ -26,6 +26,8 @@ export interface OrchestratorConfig {
     sessionId?: string;
     /** 客户端请求的 JSON 字符串（headers + body），用于 Monitor 实时查看 */
     clientRequest?: string;
+    /** 上游请求的 JSON 字符串（url + headers + body），用于 Monitor 实时查看 */
+    upstreamRequest?: string;
     /** Schedule 层的并发覆盖配置，覆盖 Provider 默认并发限制 */
     concurrencyOverride?: ConcurrencyOverride;
 }

package/dist/proxy/{orchestrator.js → orchestration/orchestrator.js}

@@ -1,4 +1,4 @@
-import { ProviderSwitchNeeded } from "./types.js";
+import { ProviderSwitchNeeded } from "../types.js";
 import { ResilienceLayer as ResilienceLayerClass } from "./resilience.js";
 import { SemaphoreScope as SemaphoreScopeClass } from "./scope.js";
 import { TrackerScope as TrackerScopeClass } from "./scope.js";
@@ -69,6 +69,7 @@ export class ProxyOrchestrator {
             clientIp: request.ip,
             sessionId: config.sessionId,
             clientRequest: config.clientRequest,
+            upstreamRequest: config.upstreamRequest,
         };
     }
     createAbortSignal(request) {

package/dist/proxy/{resilience.d.ts → orchestration/resilience.d.ts}

@@ -1,6 +1,6 @@
 import type { RetryRuleMatcher } from "./retry-rules.js";
-import type { TransportResult } from "./types.js";
-import type { Target } from "./strategy/types.js";
+import type { TransportResult } from "../types.js";
+import type { Target, ResilienceAttempt } from "../../core/types.js";
 export interface RetryStrategy {
     getDelay(attempt: number): number;
 }
@@ -28,18 +28,6 @@ export interface ResilienceConfig {
     /** 全局迭代上限，防止极端配置导致 while(true) 循环过多 */
     iterationCap?: number;
 }
-export interface ResilienceAttempt {
-    target: Target;
-    attemptIndex: number;
-    statusCode: number | null;
-    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;
     attempts: ResilienceAttempt[];

package/dist/proxy/{resilience.js → orchestration/resilience.js}

@@ -1,5 +1,5 @@
-import { MS_PER_SECOND } from "../constants.js";
-import { ProviderSwitchNeeded } from "./types.js";
+import { MS_PER_SECOND } from "../../core/constants.js";
+import { ProviderSwitchNeeded } from "../types.js";
 export class FixedIntervalStrategy {
     delayMs;
     constructor(delayMs) {

package/dist/proxy/{retry-rules.d.ts → orchestration/retry-rules.d.ts}

@@ -1,5 +1,5 @@
 import Database from "better-sqlite3";
-import { type RetryRule } from "../db/index.js";
+import { type RetryRule } from "../../db/retry-rules.js";
 export declare class RetryRuleMatcher {
     private cache;
     private raw;

package/dist/proxy/{retry-rules.js → orchestration/retry-rules.js}

@@ -1,4 +1,4 @@
-import { getActiveRetryRules } from "../db/index.js";
+import { getActiveRetryRules } from "../../db/retry-rules.js";
 export class RetryRuleMatcher {
     cache = new Map();
     raw = [];

package/dist/proxy/{scope.d.ts → orchestration/scope.d.ts}

@@ -1,7 +1,7 @@
 import type { ProviderSemaphoreManager } from "./semaphore.js";
-import type { ConcurrencyOverride } from "./strategy/types.js";
-import type { RequestTracker } from "../monitor/request-tracker.js";
-import type { ActiveRequest, AttemptSnapshot } from "../monitor/types.js";
+import type { ConcurrencyOverride } from "../../core/types.js";
+import type { RequestTracker } from "../../monitor/request-tracker.js";
+import type { ActiveRequest, AttemptSnapshot } from "../../monitor/types.js";
 export declare class SemaphoreScope {
     private manager;
     constructor(manager: ProviderSemaphoreManager);