@lakphy/local-router 0.3.3 → 0.4.0-beta.2

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 dirname2, 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";
@@ -52102,6 +52103,14 @@ async function buildLogEventDetail(id, parsed, location, context2) {
   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: {
@@ -52153,6 +52162,7 @@ async function buildLogEventDetail(id, parsed, location, context2) {
         ...streamWarning ? [streamWarning] : []
       ]
     },
+    ...pluginsSection && { plugins: pluginsSection },
     rawEvent: event,
     location
   };
@@ -54065,10 +54075,301 @@ var openAPISpec = {
   }
 };
 
+// src/plugin-loader.ts
+import { resolve as resolve5, join as join8 } from "path";
+import { tmpdir } from "os";
+import { mkdtemp, writeFile, rm } from "fs/promises";
+function isLocalPath(pkg) {
+  return pkg.startsWith("./") || pkg.startsWith("../") || pkg.startsWith("/") || /^[A-Za-z]:[\\/]/.test(pkg);
+}
+function isRemoteUrl(pkg) {
+  return pkg.startsWith("http://") || pkg.startsWith("https://");
+}
+function inferExtension(url2, contentType) {
+  const pathname = new URL(url2).pathname;
+  if (pathname.endsWith(".ts") || pathname.endsWith(".tsx"))
+    return ".ts";
+  if (pathname.endsWith(".mjs"))
+    return ".mjs";
+  if (pathname.endsWith(".cjs"))
+    return ".cjs";
+  if (contentType?.includes("typescript"))
+    return ".ts";
+  return ".js";
+}
+var remoteTmpDir = null;
+var remoteTmpFiles = [];
+async function ensureRemoteTmpDir() {
+  if (!remoteTmpDir) {
+    remoteTmpDir = await mkdtemp(join8(tmpdir(), "local-router-plugins-"));
+  }
+  return remoteTmpDir;
+}
+async function fetchRemotePlugin(url2) {
+  const response = await fetch(url2);
+  if (!response.ok) {
+    throw new Error(`\u4E0B\u8F7D\u8FDC\u7A0B\u63D2\u4EF6\u5931\u8D25: HTTP ${response.status} ${response.statusText} (${url2})`);
+  }
+  const content = await response.text();
+  const ext = inferExtension(url2, response.headers.get("content-type"));
+  const dir = await ensureRemoteTmpDir();
+  const fileName = `plugin_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
+  const filePath = join8(dir, fileName);
+  await writeFile(filePath, content, "utf-8");
+  remoteTmpFiles.push(filePath);
+  return filePath;
+}
+async function cleanupRemoteTmpFiles() {
+  if (remoteTmpDir) {
+    try {
+      await rm(remoteTmpDir, { recursive: true, force: true });
+    } catch {}
+    remoteTmpDir = null;
+    remoteTmpFiles.length = 0;
+  }
+}
+async function importPlugin(pkg, configDir) {
+  let modulePath;
+  if (isRemoteUrl(pkg)) {
+    const localPath = await fetchRemotePlugin(pkg);
+    modulePath = `${localPath}?t=${Date.now()}`;
+  } else 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);
+    await cleanupRemoteTmpFiles();
+  }
+  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";
+import { join as join9 } from "path";
+import { tmpdir as tmpdir2 } 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",
@@ -54147,7 +54448,7 @@ function buildLogEvent(logMeta, targetUrl, proxyUrl, tsEnd, overrides) {
   };
 }
 function createTempStreamCapturePath(requestId) {
-  return join8(tmpdir(), `local-router-stream-${requestId}-${Date.now()}.sse.raw`);
+  return join9(tmpdir2(), `local-router-stream-${requestId}-${Date.now()}.sse.raw`);
 }
 async function appendTempStreamCapture(filePath, chunk) {
   await appendFile(filePath, chunk);
@@ -54169,33 +54470,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
@@ -54205,6 +54536,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);
@@ -54226,30 +54584,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;
@@ -54257,10 +54646,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
   });
 }
 
@@ -54275,7 +54664,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];
@@ -54317,49 +54706,60 @@ function createModelRoutingHandler(options) {
       requestBytes: Buffer.byteLength(body, "utf-8"),
       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;
 }
@@ -54520,7 +54920,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;
@@ -54631,18 +55031,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) {
@@ -55067,7 +55471,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) {
@@ -55078,15 +55482,24 @@ function createApp(store, options) {
   }
   const stopLogStorageTask = startLogStorageBackgroundTask(config2.log);
   options?.registerCleanup?.(stopLogStorageTask);
+  const configDir = dirname2(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));
@@ -55115,14 +55528,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