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

package/dist/cli.js

@@ -4935,7 +4935,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;
@@ -4962,7 +4962,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;
@@ -5492,7 +5492,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;
@@ -5720,7 +5720,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve5,
+    resolve: resolve6,
     resolveComponent,
     equal,
     serialize,
@@ -10518,6 +10518,7 @@ import { parseArgs } from "util";
 
 // 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";
@@ -52118,6 +52119,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: {
@@ -52169,6 +52178,7 @@ async function buildLogEventDetail(id, parsed, location, context2) {
         ...streamWarning ? [streamWarning] : []
       ]
     },
+    ...pluginsSection && { plugins: pluginsSection },
     rawEvent: event,
     location
   };
@@ -54081,10 +54091,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",
@@ -54185,33 +54434,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
@@ -54221,6 +54500,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);
@@ -54242,30 +54548,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;
@@ -54273,10 +54610,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
   });
 }
 
@@ -54291,7 +54628,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];
@@ -54333,49 +54670,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;
 }
@@ -54536,7 +54884,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;
@@ -54647,18 +54995,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) {
@@ -55083,7 +55435,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) {
@@ -55094,15 +55446,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));
@@ -55131,10 +55492,10 @@ function createApp(store, options) {
   }
   return app;
 }
-function createAppRuntimeFromConfigPath(configPath) {
+async function createAppRuntimeFromConfigPath(configPath) {
   const store = new ConfigStore(configPath);
   const cleanups = [];
-  const app = createApp(store, {
+  const app = await createApp(store, {
     registerCleanup: (cleanup) => {
       cleanups.push(cleanup);
     }
@@ -55167,8 +55528,8 @@ function resolveIdleTimeoutSeconds(explicit) {
   }
   return DEFAULT_IDLE_TIMEOUT_SECONDS;
 }
-function startServer(options) {
-  const runtime = createAppRuntimeFromConfigPath(options.configPath);
+async function startServer(options) {
+  const runtime = await createAppRuntimeFromConfigPath(options.configPath);
   const idleTimeout = resolveIdleTimeoutSeconds(options.idleTimeoutSeconds);
   const server = Bun.serve({
     fetch: runtime.app.fetch,
@@ -55193,7 +55554,7 @@ function startServer(options) {
 // src/cli/runtime.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join9, resolve as resolve5 } from "path";
+import { join as join9, resolve as resolve7 } from "path";
 function getRuntimeDirs() {
   const root2 = join9(homedir2(), ".local-router");
   return {
@@ -55240,7 +55601,7 @@ function clearRuntimeFiles() {
   rmSync(files.state, { force: true });
 }
 function resolveConfigArgPath(pathValue) {
-  return resolve5(pathValue);
+  return resolve7(pathValue);
 }
 
 // src/cli/process.ts
@@ -55319,7 +55680,7 @@ async function runServerProcess(opts) {
   const idleTimeoutSeconds = opts.idleTimeoutSeconds ?? Number.parseInt(process.env.LOCAL_ROUTER_IDLE_TIMEOUT ?? "", 10);
   let running;
   try {
-    running = startServer({
+    running = await startServer({
       configPath: ensured.path,
       host,
       port,
@@ -55471,7 +55832,7 @@ function readLogDelta(filePath, offset) {
 // src/cli/config-command.ts
 import { createInterface as createInterface4 } from "readline/promises";
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname2, join as join10 } from "path";
+import { dirname as dirname4, join as join10 } from "path";
 import { parseArgs as parseArgs2 } from "util";
 function readConfig(configArg) {
   const path = resolveConfigPath(configArg);
@@ -55479,7 +55840,7 @@ function readConfig(configArg) {
 }
 function saveConfig(path, config2) {
   validateConfigOrThrow(config2);
-  const backupDir = join10(dirname2(path), ".backups");
+  const backupDir = join10(dirname4(path), ".backups");
   mkdirSync4(backupDir, { recursive: true });
   const backupPath = join10(backupDir, `config-${Date.now()}.json5`);
   writeFileSync5(backupPath, readFileSync7(path, "utf-8"), "utf-8");