@lakphy/local-router 0.3.1 → 0.4.0-beta.1

package/dist/entry.js

@@ -4934,7 +4934,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root2.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve5.call(this, root2, ref);
+    let _sch = resolve6.call(this, root2, ref);
     if (_sch === undefined) {
       const schema = (_a21 = root2.localRefs) === null || _a21 === undefined ? undefined : _a21[ref];
       const { schemaId } = this.opts;
@@ -4961,7 +4961,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve5(root2, ref) {
+  function resolve6(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -5491,7 +5491,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve5(baseURI, relativeURI, options) {
+  function resolve6(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse7(baseURI, schemelessOptions), parse7(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -5719,7 +5719,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve5,
+    resolve: resolve6,
     resolveComponent,
     equal,
     serialize,
@@ -9285,6 +9285,7 @@ var require_dist2 = __commonJS((exports, module) => {
 
 // src/index.ts
 import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname3, resolve as resolve6 } from "path";
 
 // node_modules/.bun/@ai-sdk+provider@3.0.8/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
@@ -51279,7 +51280,7 @@ var DEFAULT_CONFIG = `{
   // \u65E5\u5FD7\u914D\u7F6E\uFF08\u53EF\u9009\uFF0C\u4E0D\u914D\u7F6E\u5219\u4E0D\u542F\u7528\u65E5\u5FD7\u8BB0\u5F55\uFF09
   // log: {
   //   enabled: true,
-  //   bodyPolicy: "off",       // off | masked | full
+  //   bodyPolicy: "off",       // off | full
   //   streams: {
   //     enabled: true,
   //     maxBytesPerRequest: 10485760,  // 10MB
@@ -51807,7 +51808,6 @@ var MAX_QUERY_LIMIT = 200;
 var DEFAULT_QUERY_LIMIT = 50;
 var MAX_EXPORT_ROWS = 5000;
 var MAX_Q_LENGTH = 200;
-var SENSITIVE_FIELD_PATTERN = /(authorization|token|cookie|password|passphrase|secret|api[_-]?key)/i;
 function encodeBase64Url(value) {
   return Buffer.from(value, "utf-8").toString("base64url");
 }
@@ -52023,34 +52023,6 @@ function eventToSummary(item) {
     sessionId: identity.sessionId
   };
 }
-function maskValue(value) {
-  if (value == null)
-    return value;
-  if (typeof value === "string") {
-    return value.length > 4 ? `${value.slice(0, 2)}****` : "****";
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return "****";
-  }
-  return "****";
-}
-function maskSensitiveDeep(value, parentKey = "") {
-  if (Array.isArray(value)) {
-    return value.map((item) => maskSensitiveDeep(item, parentKey));
-  }
-  if (value && typeof value === "object") {
-    const output = {};
-    for (const [key2, child] of Object.entries(value)) {
-      if (SENSITIVE_FIELD_PATTERN.test(key2) || SENSITIVE_FIELD_PATTERN.test(parentKey)) {
-        output[key2] = maskValue(child);
-      } else {
-        output[key2] = maskSensitiveDeep(child, key2);
-      }
-    }
-    return output;
-  }
-  return value;
-}
 function detectBodyPolicy(event) {
   const hasRequestBody = event.request_body !== undefined;
   const hasResponseBody = event.response_body !== undefined;
@@ -52123,53 +52095,61 @@ function readStreamContent(baseDir, streamFile) {
   }
 }
 async function buildLogEventDetail(id, parsed, location, context2) {
-  const maskedEvent = maskSensitiveDeep(parsed);
-  const level = getLevel(maskedEvent);
-  const statusClass = getStatusClass2(maskedEvent);
-  const bodyPolicy = detectBodyPolicy(maskedEvent);
-  const requestBodyAvailable = maskedEvent.request_body !== undefined;
-  const responseBodyAvailable = maskedEvent.response_body !== undefined;
-  const streamCaptured = Boolean(maskedEvent.stream_file);
-  const { content: streamContent, warning: streamWarning } = readStreamContent(resolveLogBaseDir(context2.logConfig), maskedEvent.stream_file);
+  const event = parsed;
+  const level = getLevel(event);
+  const statusClass = getStatusClass2(event);
+  const bodyPolicy = detectBodyPolicy(event);
+  const requestBodyAvailable = event.request_body !== undefined;
+  const responseBodyAvailable = event.response_body !== undefined;
+  const streamCaptured = Boolean(event.stream_file);
+  const { content: streamContent, warning: streamWarning } = readStreamContent(resolveLogBaseDir(context2.logConfig), event.stream_file);
+  const hasPluginData = event.plugins_request || event.plugins_response || event.request_body_after_plugins !== undefined || event.request_url_after_plugins !== undefined || event.response_body_after_plugins !== undefined;
+  const pluginsSection = hasPluginData ? {
+    request: event.plugins_request,
+    response: event.plugins_response,
+    requestBodyAfterPlugins: event.request_body_after_plugins,
+    requestUrlAfterPlugins: event.request_url_after_plugins,
+    responseBodyAfterPlugins: event.response_body_after_plugins
+  } : undefined;
   return {
     id,
     summary: {
       id,
-      ts: maskedEvent.ts_start,
+      ts: event.ts_start,
       level,
-      provider: maskedEvent.provider,
-      routeType: maskedEvent.route_type,
-      routeRuleKey: maskedEvent.route_rule_key,
-      requestId: maskedEvent.request_id,
-      latencyMs: Math.max(0, maskedEvent.latency_ms ?? 0),
-      upstreamStatus: maskedEvent.upstream_status ?? 0,
+      provider: event.provider,
+      routeType: event.route_type,
+      routeRuleKey: event.route_rule_key,
+      requestId: event.request_id,
+      latencyMs: Math.max(0, event.latency_ms ?? 0),
+      upstreamStatus: event.upstream_status ?? 0,
       statusClass,
       hasError: level === "error",
-      model: maskedEvent.model_out || maskedEvent.model_in,
-      modelIn: maskedEvent.model_in,
-      modelOut: maskedEvent.model_out
+      model: event.model_out || event.model_in,
+      modelIn: event.model_in,
+      modelOut: event.model_out
     },
     request: {
-      method: maskedEvent.method,
-      path: maskedEvent.path,
-      contentType: maskedEvent.content_type_req,
-      requestHeadersMasked: maskedEvent.request_headers_masked,
-      requestBody: maskedEvent.request_body ?? null
+      method: event.method,
+      path: event.path,
+      contentType: event.content_type_req,
+      requestHeaders: event.request_headers,
+      requestBody: event.request_body ?? null
     },
     response: {
-      upstreamStatus: maskedEvent.upstream_status ?? 0,
-      contentType: maskedEvent.content_type_res,
-      responseHeaders: maskedEvent.response_headers,
-      responseBody: maskedEvent.response_body ?? null
+      upstreamStatus: event.upstream_status ?? 0,
+      contentType: event.content_type_res,
+      responseHeaders: event.response_headers,
+      responseBody: event.response_body ?? null
     },
     upstream: {
-      targetUrl: maskedEvent.target_url,
-      proxyUrl: maskedEvent.proxy_url ?? null,
-      providerRequestId: maskedEvent.provider_request_id,
-      errorType: maskedEvent.error_type,
-      errorMessage: maskedEvent.error_message,
-      isStream: maskedEvent.is_stream,
-      streamFile: maskedEvent.stream_file ?? null,
+      targetUrl: event.target_url,
+      proxyUrl: event.proxy_url ?? null,
+      providerRequestId: event.provider_request_id,
+      errorType: event.error_type,
+      errorMessage: event.error_message,
+      isStream: event.is_stream,
+      streamFile: event.stream_file ?? null,
       streamContent
     },
     capture: {
@@ -52178,11 +52158,12 @@ async function buildLogEventDetail(id, parsed, location, context2) {
       responseBodyAvailable,
       streamCaptured,
       truncatedHints: [
-        ...buildTruncatedHints(maskedEvent, context2.logConfig?.bodyPolicy ?? bodyPolicy),
+        ...buildTruncatedHints(event, context2.logConfig?.bodyPolicy ?? bodyPolicy),
         ...streamWarning ? [streamWarning] : []
       ]
     },
-    rawEvent: maskedEvent,
+    ...pluginsSection && { plugins: pluginsSection },
+    rawEvent: event,
     location
   };
 }
@@ -52894,13 +52875,6 @@ function startLogStorageBackgroundTask(logConfig) {
 // src/logger.ts
 import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
 import { join as join7 } from "path";
-var SENSITIVE_HEADERS = new Set([
-  "authorization",
-  "x-api-key",
-  "cookie",
-  "set-cookie",
-  "proxy-authorization"
-]);
 
 class Logger {
   baseDir;
@@ -52981,14 +52955,10 @@ function getLogger() {
 function resetLogger() {
   instance = null;
 }
-function maskHeaders(headers) {
+function collectHeaders(headers) {
   const result = {};
   headers.forEach((value, key2) => {
-    if (SENSITIVE_HEADERS.has(key2.toLowerCase())) {
-      result[key2] = value.length > 4 ? `${value.slice(0, 4)}****` : "****";
-    } else {
-      result[key2] = value;
-    }
+    result[key2] = value;
   });
   return result;
 }
@@ -53000,19 +52970,8 @@ function extractProviderRequestId(headers) {
   }
   return null;
 }
-function maskUrlCredentials(rawUrl) {
-  try {
-    const parsed = new URL(rawUrl);
-    if (!parsed.username && !parsed.password)
-      return rawUrl;
-    if (parsed.username)
-      parsed.username = "****";
-    if (parsed.password)
-      parsed.password = "****";
-    return parsed.toString();
-  } catch {
-    return rawUrl;
-  }
+function normalizeUrl(rawUrl) {
+  return rawUrl;
 }
 
 // src/openapi.ts
@@ -53459,7 +53418,7 @@ var openAPISpec = {
                         method: { type: "string" },
                         path: { type: "string" },
                         contentType: { type: ["string", "null"] },
-                        requestHeadersMasked: {
+                        requestHeaders: {
                           type: "object",
                           additionalProperties: { type: "string" }
                         },
@@ -54116,10 +54075,249 @@ var openAPISpec = {
   }
 };
 
+// src/plugin-loader.ts
+import { resolve as resolve5 } from "path";
+function isLocalPath(pkg) {
+  return pkg.startsWith("./") || pkg.startsWith("../") || pkg.startsWith("/") || /^[A-Za-z]:[\\/]/.test(pkg);
+}
+async function importPlugin(pkg, configDir) {
+  let modulePath;
+  if (isLocalPath(pkg)) {
+    const absolutePath = resolve5(configDir, pkg);
+    modulePath = `${absolutePath}?t=${Date.now()}`;
+  } else {
+    modulePath = pkg;
+  }
+  const mod = await import(modulePath);
+  const definition = mod.default ?? mod;
+  if (!definition || typeof definition.name !== "string" || typeof definition.create !== "function") {
+    throw new Error(`\u63D2\u4EF6 "${pkg}" \u5BFC\u51FA\u683C\u5F0F\u4E0D\u6B63\u786E\uFF0C\u9700\u5BFC\u51FA\u5305\u542B name \u548C create \u7684 PluginDefinition`);
+  }
+  return definition;
+}
+
+class PluginManager {
+  plugins = new Map;
+  configDir;
+  constructor(configDir) {
+    this.configDir = configDir;
+  }
+  async loadPluginsForProvider(providerName, pluginConfigs) {
+    const loaded = [];
+    const failures = [];
+    for (const config2 of pluginConfigs) {
+      try {
+        const definition = await importPlugin(config2.package, this.configDir);
+        const instance2 = await definition.create(config2.params ?? {});
+        loaded.push({ config: config2, definition, instance: instance2 });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        console.error(`[plugin] \u52A0\u8F7D\u63D2\u4EF6 "${config2.package}" \u5931\u8D25 (provider: ${providerName}):`, errorMsg);
+        failures.push({ provider: providerName, package: config2.package, error: errorMsg });
+      }
+    }
+    return { loaded, failures };
+  }
+  async reloadAll(providers) {
+    const newPlugins = new Map;
+    const allFailures = [];
+    const oldPluginsToDispose = [];
+    for (const [providerName, providerConfig] of Object.entries(providers)) {
+      if (providerConfig.plugins && providerConfig.plugins.length > 0) {
+        const { loaded, failures } = await this.loadPluginsForProvider(providerName, providerConfig.plugins);
+        allFailures.push(...failures);
+        if (failures.length > 0) {
+          console.warn(`[plugin] provider "${providerName}" \u6709\u63D2\u4EF6\u52A0\u8F7D\u5931\u8D25\uFF0C\u4FDD\u7559\u65E7\u63D2\u4EF6\u94FE`);
+          const oldLoaded = this.plugins.get(providerName);
+          if (oldLoaded) {
+            newPlugins.set(providerName, oldLoaded);
+          }
+          for (const { instance: instance2, config: config2 } of loaded) {
+            try {
+              await instance2.dispose?.();
+            } catch (err) {
+              console.error(`[plugin] \u56DE\u6EDA\u9500\u6BC1\u63D2\u4EF6 "${config2.package}" \u5931\u8D25:`, err instanceof Error ? err.message : err);
+            }
+          }
+        } else {
+          newPlugins.set(providerName, loaded);
+          const oldLoaded = this.plugins.get(providerName);
+          if (oldLoaded) {
+            oldPluginsToDispose.push(...oldLoaded);
+          }
+        }
+      }
+    }
+    for (const [providerName, oldLoaded] of this.plugins) {
+      if (!newPlugins.has(providerName)) {
+        oldPluginsToDispose.push(...oldLoaded);
+      }
+    }
+    this.plugins = newPlugins;
+    if (oldPluginsToDispose.length > 0) {
+      setTimeout(() => {
+        this.disposePluginList(oldPluginsToDispose).catch((err) => {
+          console.error("[plugin] \u65E7\u63D2\u4EF6\u9500\u6BC1\u5931\u8D25:", err);
+        });
+      }, 5000);
+    }
+    if (allFailures.length > 0) {
+      console.warn(`[plugin] \u70ED\u91CD\u8F7D\u5B8C\u6210\uFF0C\u4F46\u6709 ${allFailures.length} \u4E2A\u63D2\u4EF6\u52A0\u8F7D\u5931\u8D25:`, allFailures.map((f) => `${f.provider}/${f.package}`).join(", "));
+    }
+    return { ok: allFailures.length === 0, failures: allFailures };
+  }
+  getPlugins(providerName) {
+    const loaded = this.plugins.get(providerName);
+    if (!loaded)
+      return [];
+    return loaded.map((l) => l.instance);
+  }
+  getLoadedPlugins(providerName) {
+    return this.plugins.get(providerName) ?? [];
+  }
+  async disposeAll() {
+    const allPlugins = [];
+    for (const [, loadedPlugins] of this.plugins) {
+      allPlugins.push(...loadedPlugins);
+    }
+    this.plugins.clear();
+    await this.disposePluginList(allPlugins);
+  }
+  async disposePluginList(plugins) {
+    for (const { instance: instance2, config: config2 } of plugins) {
+      try {
+        await instance2.dispose?.();
+      } catch (err) {
+        console.error(`[plugin] \u9500\u6BC1\u63D2\u4EF6 "${config2.package}" \u5931\u8D25:`, err instanceof Error ? err.message : err);
+      }
+    }
+  }
+  async disposePluginMap(pluginMap) {
+    const allPlugins = [];
+    for (const [, loadedPlugins] of pluginMap) {
+      allPlugins.push(...loadedPlugins);
+    }
+    await this.disposePluginList(allPlugins);
+  }
+}
+
 // src/proxy.ts
 import { appendFile, readFile, unlink } from "fs/promises";
 import { join as join8 } from "path";
 import { tmpdir } from "os";
+
+// src/plugin-engine.ts
+async function executeRequestPlugins(plugins, ctx, url2, headers, body) {
+  let currentUrl = url2;
+  let currentHeaders = headers;
+  let currentBody = body;
+  for (const plugin of plugins) {
+    if (!plugin.onRequest)
+      continue;
+    try {
+      const result = await plugin.onRequest({
+        ctx,
+        url: currentUrl,
+        headers: currentHeaders,
+        body: currentBody
+      });
+      if (result) {
+        if (result.url !== undefined)
+          currentUrl = result.url;
+        if (result.headers !== undefined)
+          currentHeaders = result.headers;
+        if (result.body !== undefined)
+          currentBody = result.body;
+      }
+    } catch (err) {
+      const error48 = err instanceof Error ? err : new Error(String(err));
+      try {
+        await plugin.onError?.({ ctx, phase: "request", error: error48 });
+      } catch {}
+    }
+  }
+  return { url: currentUrl, headers: currentHeaders, body: currentBody };
+}
+async function executeJsonResponsePlugins(plugins, ctx, status, headers, body) {
+  let currentStatus = status;
+  let currentHeaders = headers;
+  let currentBody = body;
+  for (let i = plugins.length - 1;i >= 0; i--) {
+    const plugin = plugins[i];
+    if (!plugin.onResponse)
+      continue;
+    try {
+      const result = await plugin.onResponse({
+        ctx,
+        status: currentStatus,
+        headers: currentHeaders,
+        body: currentBody
+      });
+      if (result) {
+        if (result.status !== undefined)
+          currentStatus = result.status;
+        if (result.headers !== undefined)
+          currentHeaders = result.headers;
+        if (result.body !== undefined)
+          currentBody = result.body;
+      }
+    } catch (err) {
+      const error48 = err instanceof Error ? err : new Error(String(err));
+      try {
+        await plugin.onError?.({ ctx, phase: "response", error: error48 });
+      } catch {}
+    }
+  }
+  return { status: currentStatus, headers: currentHeaders, body: currentBody };
+}
+async function createSSEPluginTransform(plugins, ctx, status, headers) {
+  let currentStatus = status;
+  let currentHeaders = headers;
+  const transforms = [];
+  for (let i = plugins.length - 1;i >= 0; i--) {
+    const plugin = plugins[i];
+    if (!plugin.onSSEResponse)
+      continue;
+    try {
+      const result = await plugin.onSSEResponse({
+        ctx,
+        status: currentStatus,
+        headers: currentHeaders
+      });
+      if (result) {
+        if (result.status !== undefined)
+          currentStatus = result.status;
+        if (result.headers !== undefined)
+          currentHeaders = result.headers;
+        if (result.transform)
+          transforms.push(result.transform);
+      }
+    } catch (err) {
+      const error48 = err instanceof Error ? err : new Error(String(err));
+      try {
+        await plugin.onError?.({ ctx, phase: "response", error: error48 });
+      } catch {}
+    }
+  }
+  if (transforms.length === 0) {
+    return { status: currentStatus, headers: currentHeaders, transform: null };
+  }
+  if (transforms.length === 1) {
+    return { status: currentStatus, headers: currentHeaders, transform: transforms[0] };
+  }
+  const entry = new TransformStream;
+  let stream = entry.readable;
+  for (const t of transforms) {
+    stream = stream.pipeThrough(t);
+  }
+  return {
+    status: currentStatus,
+    headers: currentHeaders,
+    transform: { writable: entry.writable, readable: stream }
+  };
+}
+
+// src/proxy.ts
 var HOP_BY_HOP_HEADERS = new Set([
   "connection",
   "keep-alive",
@@ -54179,14 +54377,14 @@ function buildLogEvent(logMeta, targetUrl, proxyUrl, tsEnd, overrides) {
     provider: logMeta.provider,
     model_in: logMeta.modelIn,
     model_out: logMeta.modelOut,
-    target_url: maskUrlCredentials(targetUrl),
-    proxy_url: proxyUrl ? maskUrlCredentials(proxyUrl) : null,
+    target_url: normalizeUrl(targetUrl),
+    proxy_url: proxyUrl ? normalizeUrl(proxyUrl) : null,
     is_stream: logMeta.isStream,
     upstream_status: 0,
     content_type_req: logMeta.contentTypeReq,
     content_type_res: null,
     user_agent: logMeta.userAgent,
-    request_headers_masked: logMeta.requestHeadersMasked,
+    request_headers: logMeta.requestHeaders,
     response_headers: {},
     request_bytes: logMeta.requestBytes,
     response_bytes: null,
@@ -54220,33 +54418,63 @@ async function flushTempCaptureToLogger(tempPath, requestId, dateStr, logger) {
   }
 }
 async function proxyRequest(c2, options) {
-  const { logMeta } = options;
+  const { logMeta, plugins, pluginConfigs } = options;
   const logger = getLogger();
   const shouldLog = logger?.enabled ?? false;
-  const headers = buildUpstreamHeaders(c2.req.raw.headers, options.apiKey, options.authType);
+  const hasPlugins = plugins && plugins.length > 0;
+  let targetUrl = options.targetUrl;
+  let headers = buildUpstreamHeaders(c2.req.raw.headers, options.apiKey, options.authType);
+  let bodyStr = options.body;
+  const pluginLogOverrides = {};
+  if (hasPlugins) {
+    const bodyObj = JSON.parse(bodyStr);
+    const ctx = {
+      requestId: logMeta.requestId,
+      provider: logMeta.provider,
+      modelIn: logMeta.modelIn,
+      modelOut: logMeta.modelOut,
+      routeType: logMeta.routeType,
+      isStream: logMeta.isStream
+    };
+    const result = await executeRequestPlugins(plugins, ctx, targetUrl, headers, bodyObj);
+    if (pluginConfigs) {
+      pluginLogOverrides.plugins_request = pluginConfigs;
+    }
+    if (result.url !== targetUrl) {
+      targetUrl = result.url;
+      pluginLogOverrides.request_url_after_plugins = targetUrl;
+    }
+    headers = result.headers;
+    const newBodyStr = JSON.stringify(result.body);
+    if (newBodyStr !== bodyStr) {
+      bodyStr = newBodyStr;
+      pluginLogOverrides.request_body_after_plugins = result.body;
+    }
+  }
   const requestBody = shouldLog && logger?.bodyPolicy !== "off" ? JSON.parse(options.body) : undefined;
   const proxy = options.proxy?.trim() ? options.proxy.trim() : undefined;
   let upstreamRes;
   try {
-    upstreamRes = await fetch(options.targetUrl, {
+    upstreamRes = await fetch(targetUrl, {
       method: c2.req.method,
       headers,
-      body: options.body,
+      body: bodyStr,
       ...proxy ? { proxy } : {},
       decompress: true
     });
   } catch (err) {
     if (shouldLog) {
-      logger?.writeEvent(buildLogEvent(logMeta, options.targetUrl, proxy, Date.now(), {
+      logger?.writeEvent(buildLogEvent(logMeta, targetUrl, proxy, Date.now(), {
         error_type: err instanceof Error ? err.constructor.name : "UnknownError",
         error_message: err instanceof Error ? err.message : String(err),
-        ...requestBody !== undefined && { request_body: requestBody }
+        ...requestBody !== undefined && { request_body: requestBody },
+        ...pluginLogOverrides
       }));
     }
     throw err;
   }
   const responseHeaders = buildResponseHeaders(upstreamRes.headers);
-  if (!shouldLog) {
+  if (!shouldLog && !hasPlugins) {
     return new Response(upstreamRes.body, {
       status: upstreamRes.status,
       headers: responseHeaders
@@ -54256,6 +54484,33 @@ async function proxyRequest(c2, options) {
   const providerRequestId = extractProviderRequestId(upstreamRes.headers);
   const dateStr = new Date(logMeta.tsStart).toISOString().slice(0, 10);
   if (logMeta.isStream && upstreamRes.body) {
+    let sseStatus = upstreamRes.status;
+    let sseHeaders = responseHeaders;
+    let sseTransform = null;
+    if (hasPlugins) {
+      const ctx = {
+        requestId: logMeta.requestId,
+        provider: logMeta.provider,
+        modelIn: logMeta.modelIn,
+        modelOut: logMeta.modelOut,
+        routeType: logMeta.routeType,
+        isStream: logMeta.isStream
+      };
+      const sseResult = await createSSEPluginTransform(plugins, ctx, upstreamRes.status, responseHeaders);
+      sseStatus = sseResult.status;
+      sseHeaders = sseResult.headers;
+      sseTransform = sseResult.transform;
+      if (pluginConfigs) {
+        pluginLogOverrides.plugins_response = pluginConfigs;
+      }
+    }
+    if (!shouldLog) {
+      const outputBody2 = sseTransform ? upstreamRes.body.pipeThrough(sseTransform) : upstreamRes.body;
+      return new Response(outputBody2, {
+        status: sseStatus,
+        headers: sseHeaders
+      });
+    }
     const [clientStream, logStream] = upstreamRes.body.tee();
     (async () => {
       const tempPath = createTempStreamCapturePath(logMeta.requestId);
@@ -54277,30 +54532,61 @@ async function proxyRequest(c2, options) {
         });
         console.error("[logger] \u6D41\u5F0F\u65E5\u5FD7\u5904\u7406\u5931\u8D25:", err);
       } finally {
-        logger?.writeEvent(buildLogEvent(logMeta, options.targetUrl, proxy, Date.now(), {
-          upstream_status: upstreamRes.status,
+        logger?.writeEvent(buildLogEvent(logMeta, targetUrl, proxy, Date.now(), {
+          upstream_status: sseStatus,
           content_type_res: contentTypeRes,
-          response_headers: responseHeaders,
+          response_headers: sseHeaders,
           stream_bytes: streamBytes,
           provider_request_id: providerRequestId,
           ...streamFile != null && { stream_file: streamFile },
-          ...requestBody !== undefined && { request_body: requestBody }
+          ...requestBody !== undefined && { request_body: requestBody },
+          ...pluginLogOverrides
         }));
       }
     })();
-    return new Response(clientStream, {
-      status: upstreamRes.status,
-      headers: responseHeaders
+    const outputBody = sseTransform ? clientStream.pipeThrough(sseTransform) : clientStream;
+    return new Response(outputBody, {
+      status: sseStatus,
+      headers: sseHeaders
+    });
+  }
+  let responseText = await upstreamRes.text();
+  let responseStatus = upstreamRes.status;
+  let finalResponseHeaders = responseHeaders;
+  if (hasPlugins) {
+    const ctx = {
+      requestId: logMeta.requestId,
+      provider: logMeta.provider,
+      modelIn: logMeta.modelIn,
+      modelOut: logMeta.modelOut,
+      routeType: logMeta.routeType,
+      isStream: logMeta.isStream
+    };
+    const result = await executeJsonResponsePlugins(plugins, ctx, upstreamRes.status, responseHeaders, responseText);
+    if (pluginConfigs) {
+      pluginLogOverrides.plugins_response = pluginConfigs;
+    }
+    if (result.body !== responseText) {
+      pluginLogOverrides.response_body_after_plugins = result.body;
+    }
+    responseStatus = result.status;
+    finalResponseHeaders = result.headers;
+    responseText = result.body;
+  }
+  if (!shouldLog) {
+    return new Response(responseText, {
+      status: responseStatus,
+      headers: finalResponseHeaders
     });
   }
-  const responseText = await upstreamRes.text();
   const responseBytes = Buffer.byteLength(responseText, "utf-8");
   const eventOverrides = {
     upstream_status: upstreamRes.status,
     content_type_res: contentTypeRes,
-    response_headers: responseHeaders,
+    response_headers: finalResponseHeaders,
     response_bytes: responseBytes,
-    provider_request_id: providerRequestId
+    provider_request_id: providerRequestId,
+    ...pluginLogOverrides
   };
   if (requestBody !== undefined) {
     eventOverrides.request_body = requestBody;
@@ -54308,10 +54594,10 @@ async function proxyRequest(c2, options) {
   if (logger?.bodyPolicy !== "off") {
     eventOverrides.response_body = responseText;
   }
-  logger?.writeEvent(buildLogEvent(logMeta, options.targetUrl, proxy, Date.now(), eventOverrides));
+  logger?.writeEvent(buildLogEvent(logMeta, targetUrl, proxy, Date.now(), eventOverrides));
   return new Response(responseText, {
-    status: upstreamRes.status,
-    headers: responseHeaders
+    status: responseStatus,
+    headers: finalResponseHeaders
   });
 }
 
@@ -54326,7 +54612,7 @@ function resolveRoute(modelMap, incomingModel) {
   return;
 }
 function createModelRoutingHandler(options) {
-  const { routeType, store, authType, buildTargetUrl } = options;
+  const { routeType, store, authType, buildTargetUrl, pluginManager } = options;
   return async (c2) => {
     const config2 = store.get();
     const modelMap = config2.routes[routeType];
@@ -54366,51 +54652,62 @@ function createModelRoutingHandler(options) {
       contentTypeReq: c2.req.header("content-type") ?? null,
       userAgent: c2.req.header("user-agent") ?? null,
       requestBytes: Buffer.byteLength(body, "utf-8"),
-      requestHeadersMasked: maskHeaders(c2.req.raw.headers)
+      requestHeaders: collectHeaders(c2.req.raw.headers)
     };
+    const plugins = pluginManager?.getPlugins(target.provider) ?? [];
+    const pluginConfigs = pluginManager?.getLoadedPlugins(target.provider) ?? [];
     return proxyRequest(c2, {
       targetUrl,
       apiKey: provider.apiKey,
       proxy: provider.proxy,
       authType,
       body,
-      logMeta
+      logMeta,
+      plugins: plugins.length > 0 ? plugins : undefined,
+      pluginConfigs: pluginConfigs.length > 0 ? pluginConfigs.map((lp) => ({
+        name: lp.definition.name,
+        package: lp.config.package,
+        params: lp.config.params ?? {}
+      })) : undefined
     });
   };
 }
 
 // src/routes/anthropic-messages.ts
-function createAnthropicMessagesRoutes(routeType, store) {
+function createAnthropicMessagesRoutes(routeType, store, pluginManager) {
   const routes = new Hono2;
   routes.post("/v1/messages", createModelRoutingHandler({
     routeType,
     store,
     authType: "x-api-key",
-    buildTargetUrl: (base) => `${base}/v1/messages`
+    buildTargetUrl: (base) => `${base}/v1/messages`,
+    pluginManager
   }));
   return routes;
 }
 
 // src/routes/openai-completions.ts
-function createOpenaiCompletionsRoutes(routeType, store) {
+function createOpenaiCompletionsRoutes(routeType, store, pluginManager) {
   const routes = new Hono2;
   routes.post("/v1/chat/completions", createModelRoutingHandler({
     routeType,
     store,
     authType: "bearer",
-    buildTargetUrl: (base) => `${base}/v1/chat/completions`
+    buildTargetUrl: (base) => `${base}/v1/chat/completions`,
+    pluginManager
   }));
   return routes;
 }
 
 // src/routes/openai-responses.ts
-function createOpenaiResponsesRoutes(routeType, store) {
+function createOpenaiResponsesRoutes(routeType, store, pluginManager) {
   const routes = new Hono2;
   routes.post("/v1/responses", createModelRoutingHandler({
     routeType,
     store,
     authType: "bearer",
-    buildTargetUrl: (base) => `${base}/v1/responses`
+    buildTargetUrl: (base) => `${base}/v1/responses`,
+    pluginManager
   }));
   return routes;
 }
@@ -54571,7 +54868,7 @@ function createChatProxyModel(providerName, providerConfig, model) {
       throw new Error(`\u6682\u4E0D\u652F\u6301\u7684 provider \u7C7B\u578B: ${providerConfig.type}`);
   }
 }
-function createAdminApiRoutes(store, registerCleanup) {
+function createAdminApiRoutes(store, pluginManager, registerCleanup) {
   const api2 = new Hono2;
   const cryptoSessions = new Map;
   const CRYPTO_SESSION_TTL_MS = 2 * 60 * 1000;
@@ -54682,18 +54979,22 @@ function createAdminApiRoutes(store, registerCleanup) {
       session.dispose();
     }
   });
-  api2.post("/config/apply", (_c) => {
+  api2.post("/config/apply", async (_c) => {
     try {
       const config2 = store.reload();
       if (config2.log) {
         const logBaseDir = resolveLogBaseDir(config2.log);
         initLogger(logBaseDir, config2.log);
       }
+      const pluginResult = await pluginManager.reloadAll(config2.providers);
       return _c.json({
         ok: true,
         summary: {
           providers: Object.keys(config2.providers).length,
           routes: Object.keys(config2.routes).length
+        },
+        ...pluginResult.failures.length > 0 && {
+          pluginWarnings: pluginResult.failures
         }
       });
     } catch (err) {
@@ -55118,7 +55419,7 @@ async function proxyAdminToDevServer(c2, origin) {
     headers: buildProxyResponseHeaders(upstreamRes.headers)
   });
 }
-function createApp(store, options) {
+async function createApp(store, options) {
   const config2 = store.get();
   console.log(`\u5DF2\u52A0\u8F7D\u914D\u7F6E: ${store.getPath()}`);
   if (config2.log) {
@@ -55129,15 +55430,24 @@ function createApp(store, options) {
   }
   const stopLogStorageTask = startLogStorageBackgroundTask(config2.log);
   options?.registerCleanup?.(stopLogStorageTask);
+  const configDir = dirname3(resolve6(store.getPath()));
+  const pluginManager = new PluginManager(configDir);
+  const reloadResult = await pluginManager.reloadAll(config2.providers);
+  if (!reloadResult.ok) {
+    console.warn(`[plugin] \u63D2\u4EF6\u521D\u59CB\u5316\u5B8C\u6210\uFF0C\u4F46\u6709 ${reloadResult.failures.length} \u4E2A\u63D2\u4EF6\u52A0\u8F7D\u5931\u8D25`);
+  }
+  options?.registerCleanup?.(() => {
+    pluginManager.disposeAll().catch(() => {});
+  });
   printIntegrationGuide(config2);
   const app = new Hono2;
   app.get("/", (c2) => c2.text("local-router is running"));
   for (const [routeType, entry] of Object.entries(ROUTE_REGISTRY)) {
-    const subApp = entry.create(routeType, store);
+    const subApp = entry.create(routeType, store, pluginManager);
     app.route(entry.mountPrefix, subApp);
     console.log(`\u5DF2\u6CE8\u518C\u8DEF\u7531: ${routeType} -> ${entry.mountPrefix}`);
   }
-  app.route("/api", createAdminApiRoutes(store, options?.registerCleanup));
+  app.route("/api", createAdminApiRoutes(store, pluginManager, options?.registerCleanup));
   console.log("\u5DF2\u6CE8\u518C\u7BA1\u7406 API: /api");
   app.get("/api/docs", middleware({ url: "/api/openapi.json" }));
   app.get("/api/openapi.json", (c2) => c2.json(openAPISpec));
@@ -55166,14 +55476,14 @@ function createApp(store, options) {
   }
   return app;
 }
-function createDefaultAppFromProcessArgs() {
+async function createDefaultAppFromProcessArgs() {
   const configPath = parseConfigPath();
   const store = new ConfigStore(configPath);
   return createApp(store);
 }
 
 // src/entry.ts
-var app = createDefaultAppFromProcessArgs();
+var app = await createDefaultAppFromProcessArgs();
 var entry_default = app;
 export {
   entry_default as default