@faapi/faapi 3.0.0 → 3.1.0

package/dist/index.js

@@ -1350,26 +1350,57 @@ function getTool(name) {
   return registry.get(name);
 }
 
-// src/injection/agentRegistry.ts
+// src/injection/skillRegistry.ts
 var registry2 = /* @__PURE__ */ new Map();
+function hydrateSkillRegistry(skills) {
+  const next = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    next.set(skill.name, skill);
+  }
+  registry2 = next;
+}
+function clearSkillRegistry() {
+  registry2 = /* @__PURE__ */ new Map();
+}
+function upsertSkill(core) {
+  registry2.set(core.name, core);
+}
+function removeSkill(name) {
+  registry2.delete(name);
+}
+function getSkill(name) {
+  return registry2.get(name);
+}
+function listSkills() {
+  return Array.from(registry2.values());
+}
+
+// src/injection/agentRegistry.ts
+var registry3 = /* @__PURE__ */ new Map();
 function hydrateAgentRegistry(agents) {
   const next = /* @__PURE__ */ new Map();
   for (const agent of agents) {
     next.set(agent.name, agent);
   }
-  registry2 = next;
+  registry3 = next;
 }
 function clearAgentRegistry() {
-  registry2 = /* @__PURE__ */ new Map();
+  registry3 = /* @__PURE__ */ new Map();
 }
 function getAgent(name) {
-  return registry2.get(name);
+  return getSkill(name) ?? registry3.get(name);
+}
+function getAgentEntry(name) {
+  return registry3.get(name);
 }
 function listAgents() {
-  return Array.from(registry2.values());
+  const merged = /* @__PURE__ */ new Map();
+  for (const agent of registry3.values()) merged.set(agent.name, agent);
+  for (const skill of listSkills()) merged.set(skill.name, skill);
+  return Array.from(merged.values());
 }
 function resolveAgentTools(name) {
-  const agent = registry2.get(name);
+  const agent = getAgent(name);
   if (!agent) return [];
   const result = /* @__PURE__ */ new Map();
   if (agent.tools) {
@@ -1381,11 +1412,11 @@ function resolveAgentTools(name) {
   return Array.from(result.values());
 }
 function resolveSubAgents(name) {
-  const agent = registry2.get(name);
+  const agent = getAgent(name);
   if (!agent || !agent.agents) return [];
   const result = [];
   for (const agentName of agent.agents) {
-    const subAgent = registry2.get(agentName);
+    const subAgent = getAgent(agentName);
     if (subAgent) result.push(subAgent);
   }
   return result;
@@ -1692,12 +1723,29 @@ function isProductFresh(sourceAbsPath, productAbsPath) {
     return false;
   }
 }
-var compiledFiles = /* @__PURE__ */ new Set();
+function createDevOnDemandState() {
+  return {
+    enabled: false,
+    distDir: void 0,
+    compiledFiles: /* @__PURE__ */ new Set(),
+    generatedSchemas: /* @__PURE__ */ new Set(),
+    inFlightCompilations: /* @__PURE__ */ new Map(),
+    inFlightSchemaGenerations: /* @__PURE__ */ new Map()
+  };
+}
+var state = createDevOnDemandState();
 function clearCompiledFiles() {
-  compiledFiles.clear();
+  state.compiledFiles.clear();
+  state.inFlightCompilations.clear();
 }
 async function ensureCompiled(sourceAbsPath, rootDir, dist) {
-  if (compiledFiles.has(sourceAbsPath)) {
+  const inFlight = state.inFlightCompilations.get(sourceAbsPath);
+  if (inFlight) {
+    await inFlight.catch(() => {
+    });
+    return false;
+  }
+  if (state.compiledFiles.has(sourceAbsPath)) {
     return false;
   }
   if (!fs5.existsSync(sourceAbsPath)) {
@@ -1705,17 +1753,25 @@ async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   }
   const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
   if (productPath && isProductFresh(sourceAbsPath, productPath)) {
-    compiledFiles.add(sourceAbsPath);
+    state.compiledFiles.add(sourceAbsPath);
     return false;
   }
-  await compileDevRoutes({
-    rootDir,
-    dist,
-    files: [sourceAbsPath],
-    logLevel: "silent"
-  });
-  compiledFiles.add(sourceAbsPath);
-  return true;
+  const compilePromise = (async () => {
+    await compileDevRoutes({
+      rootDir,
+      dist,
+      files: [sourceAbsPath],
+      logLevel: "silent"
+    });
+    state.compiledFiles.add(sourceAbsPath);
+  })();
+  state.inFlightCompilations.set(sourceAbsPath, compilePromise);
+  try {
+    await compilePromise;
+    return true;
+  } finally {
+    state.inFlightCompilations.delete(sourceAbsPath);
+  }
 }
 function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
   const rel = path6.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
@@ -1724,12 +1780,18 @@ function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
   const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
   return path6.resolve(rootDir, dist, jsRel);
 }
-var generatedSchemas = /* @__PURE__ */ new Set();
 function clearGeneratedSchemas() {
-  generatedSchemas.clear();
+  state.generatedSchemas.clear();
+  state.inFlightSchemaGenerations.clear();
 }
 async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist) {
-  if (generatedSchemas.has(schemaPath)) {
+  const inFlight = state.inFlightSchemaGenerations.get(schemaPath);
+  if (inFlight) {
+    await inFlight.catch(() => {
+    });
+    return false;
+  }
+  if (state.generatedSchemas.has(schemaPath)) {
     return false;
   }
   const prodAbsPath = path6.resolve(rootDir, routeFilePath);
@@ -1738,7 +1800,7 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
     return false;
   }
   if (isProductFresh(sourceAbsPath, schemaPath)) {
-    generatedSchemas.add(schemaPath);
+    state.generatedSchemas.add(schemaPath);
     return false;
   }
   const fileRoutes = routes.filter((r) => r.filePath === routeFilePath);
@@ -1747,9 +1809,17 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   }
   const sourceRelPath = path6.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
-  await generateSchemaFiles(sourceRoutes, rootDir, dist);
-  generatedSchemas.add(schemaPath);
-  return true;
+  const generatePromise = (async () => {
+    await generateSchemaFiles(sourceRoutes, rootDir, dist);
+    state.generatedSchemas.add(schemaPath);
+  })();
+  state.inFlightSchemaGenerations.set(schemaPath, generatePromise);
+  try {
+    await generatePromise;
+    return true;
+  } finally {
+    state.inFlightSchemaGenerations.delete(schemaPath);
+  }
 }
 async function deleteSchemaFiles(routes, rootDir, dist) {
   const deleted = /* @__PURE__ */ new Set();
@@ -1775,17 +1845,15 @@ function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
   if (fs5.existsSync(tsAbs)) return tsAbs;
   return path6.resolve(rootDir, srcRel);
 }
-var devOnDemandEnabled = false;
 function isDevOnDemandEnabled() {
-  return devOnDemandEnabled;
+  return state.enabled;
 }
-var devDistDir;
 function getDevDist() {
-  return devDistDir;
+  return state.distDir;
 }
 
 // src/loader/loadAgentModule.ts
-async function loadAgentModule(filePath, hasConfig, hasRun, rootDir) {
+async function loadAgentModule(filePath, hasRun, rootDir) {
   if (isDevOnDemandEnabled() && rootDir) {
     const dist = getDevDist();
     if (dist) {
@@ -1809,30 +1877,6 @@ async function loadAgentModule(filePath, hasConfig, hasRun, rootDir) {
     const reason = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to load agent module "${filePath}": ${reason}`, { cause: err });
   }
-  let config;
-  if (hasConfig) {
-    const configExport = resolveExport(module, "config");
-    if (configExport === void 0) {
-      throw new Error(
-        `Agent module "${filePath}" does not export "config" (hasConfig=true but export missing).`
-      );
-    }
-    if (typeof configExport === "function") {
-      const returned = configExport();
-      if (returned === null || typeof returned !== "object") {
-        throw new Error(
-          `Agent module "${filePath}" config() did not return an object (got ${returned === null ? "null" : typeof returned}).`
-        );
-      }
-      config = returned;
-    } else if (typeof configExport === "object" && configExport !== null) {
-      config = configExport;
-    } else {
-      throw new Error(
-        `Agent module "${filePath}" config export must be an object or function, got ${typeof configExport}.`
-      );
-    }
-  }
   let run;
   if (hasRun) {
     const runExport = resolveExport(module, "run");
@@ -1843,7 +1887,7 @@ async function loadAgentModule(filePath, hasConfig, hasRun, rootDir) {
     }
     run = runExport;
   }
-  return { config, run };
+  return { run };
 }
 
 // src/loader/loadToolModule.ts
@@ -2509,6 +2553,12 @@ var ModuleLoadError = class extends FaapiError {
     this.name = "ModuleLoadError";
   }
 };
+var PayloadTooLargeError = class extends FaapiError {
+  constructor(maxSize) {
+    super("PAYLOAD_TOO_LARGE", `Request body exceeds size limit of ${maxSize} bytes`, 413);
+    this.name = "PayloadTooLargeError";
+  }
+};
 
 // src/cli/createAppCore.ts
 import fs15 from "fs";
@@ -2795,6 +2845,92 @@ function createSseWriter() {
   return writer;
 }
 
+// src/response/responseFormatter.ts
+function defaultOk(data) {
+  return { data };
+}
+function defaultFail(e) {
+  const error = { message: e.message };
+  if (e.code !== void 0) error.code = e.code;
+  return { error };
+}
+function getResponseConfig(config) {
+  return config?.response;
+}
+function resolveOkFn(config) {
+  return getResponseConfig(config)?.ok ?? defaultOk;
+}
+function resolveFailFn(config) {
+  return getResponseConfig(config)?.fail ?? defaultFail;
+}
+function jsonOk(body, status = 200, extraHeaders) {
+  return jsonRaw(body, status, extraHeaders);
+}
+function jsonRaw(body, status, extraHeaders) {
+  const headers = new Headers({ "Content-Type": "application/json" });
+  if (extraHeaders) {
+    const extra = new Headers(extraHeaders);
+    extra.forEach((value, key) => headers.set(key, value));
+  }
+  return new Response(JSON.stringify(body), { status, headers });
+}
+function wrapOkResult(result, config) {
+  if (result instanceof Response) return result;
+  return resolveOkFn(config)(result);
+}
+function formatFailResponse(options, config) {
+  const failFn = resolveFailFn(config);
+  const body = failFn({
+    status: options.status,
+    code: options.code,
+    message: options.message
+  });
+  return jsonOk(body, options.status ?? 500);
+}
+function formatErrorResponse(error, config) {
+  const failFn = resolveFailFn(config);
+  if (error instanceof ValidationError) {
+    const body2 = failFn({
+      status: error.statusCode,
+      code: error.code,
+      message: error.message
+    });
+    const bodyObj = typeof body2 === "object" && body2 !== null ? body2 : { error: body2 };
+    const errorObj = bodyObj.error ?? bodyObj;
+    if (errorObj) {
+      errorObj.issues = error.issues;
+    }
+    return jsonOk(bodyObj, error.statusCode);
+  }
+  if (error instanceof MethodNotAllowedError) {
+    const body2 = failFn({
+      status: error.statusCode,
+      code: error.code,
+      message: error.message
+    });
+    return jsonOk(body2, error.statusCode, { Allow: error.allowedMethods.join(", ") });
+  }
+  if (error instanceof PayloadTooLargeError) {
+    const body2 = failFn({
+      status: error.statusCode,
+      code: error.code,
+      message: error.message
+    });
+    return jsonOk(body2, error.statusCode);
+  }
+  if (error instanceof FaapiError) {
+    const body2 = failFn({
+      status: error.statusCode,
+      code: error.code,
+      message: error.message
+    });
+    return jsonOk(body2, error.statusCode);
+  }
+  const message = error instanceof Error ? error.message : "An unknown error occurred";
+  const body = failFn({ status: 500, code: "INTERNAL_ERROR", message });
+  return jsonOk(body, 500);
+}
+
 // src/runtime/createContext.ts
 function parseCookies(cookieHeader) {
   const cookies = /* @__PURE__ */ new Map();
@@ -2855,11 +2991,7 @@ function createContext(request, params, config = {}, ip = "") {
       });
     },
     json(data, status) {
-      const headers = { "Content-Type": "application/json" };
-      return new Response(JSON.stringify(data), {
-        status: status ?? 200,
-        headers
-      });
+      return jsonOk(data, status ?? 200);
     },
     html(html, status) {
       const headers = { "Content-Type": "text/html; charset=utf-8" };
@@ -2895,18 +3027,22 @@ function createContext(request, params, config = {}, ip = "") {
     /**
      * 显式包装成功响应(返回 Response,不会被自动包裹再次包装)
      *
+     * 实现委托给 [responseFormatter.wrapOkResult](../response/responseFormatter.ts),
+     * 与 handler `return data` 走的自动包裹路径共享同一套 ok 函数。
+     *
      * 用 config.response.ok(或默认 (data) => ({ data })) 包裹 data 并返回 JSON Response。
      * handler 也可直接 return data,框架会自动用 ok 包裹,两者等价。
      */
     ok(data) {
-      const responseConfig = config.response;
-      const okFn = responseConfig?.ok ?? ((d) => ({ data: d }));
-      const body = okFn(data);
-      return ctx.json(body);
+      const body = wrapOkResult(data, config);
+      return jsonOk(body, 200);
     },
     /**
      * 返回错误响应(对象形式参数,status 和 code 均可省略)
      *
+     * 实现委托给 [responseFormatter.formatFailResponse](../response/responseFormatter.ts),
+     * 与 formatErrorResponse(handler 抛错兜底)共享同一套 fail 函数,确保错误格式一致。
+     *
      * - status 省略时 HTTP 状态码默认 500
      * - code 省略时响应 body 里不含 code 字段(默认 fail 函数只放非 undefined 的字段)
      * - status 和 code 独立无关联
@@ -2914,18 +3050,7 @@ function createContext(request, params, config = {}, ip = "") {
      * body 用 config.response.fail(或默认实现)包装。
      */
     fail(options) {
-      const responseConfig = config.response;
-      const failFn = responseConfig?.fail ?? ((e) => {
-        const error = { message: e.message };
-        if (e.code !== void 0) error.code = e.code;
-        return { error };
-      });
-      const body = failFn({
-        status: options.status,
-        code: options.code,
-        message: options.message
-      });
-      return ctx.json(body, options.status ?? 500);
+      return formatFailResponse(options, config);
     }
   };
   const extend = config?.extendContext;
@@ -3191,10 +3316,7 @@ async function injectParamsAsync(handler, ctx, body, injectors) {
 
 // src/runtime/invokeHandler.ts
 function wrapResult(result, ctx) {
-  if (result instanceof Response) return result;
-  const responseConfig = ctx.config.response;
-  const okFn = responseConfig?.ok ?? ((d) => ({ data: d }));
-  return okFn(result);
+  return wrapOkResult(result, ctx.config);
 }
 function mergeMeta(response, meta) {
   const hasMeta = meta.status !== void 0 || Object.keys(meta.headers).length > 0 || meta.setCookies.length > 0;
@@ -3417,52 +3539,6 @@ import fs12 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
 import path10 from "path";
 
-// src/errors/formatErrorResponse.ts
-function formatErrorResponse(error) {
-  if (error instanceof ValidationError) {
-    const body2 = {
-      code: error.code,
-      message: error.message,
-      issues: error.issues
-    };
-    return new Response(JSON.stringify({ error: body2 }), {
-      status: error.statusCode,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  if (error instanceof MethodNotAllowedError) {
-    const body2 = {
-      code: error.code,
-      message: error.message
-    };
-    return new Response(JSON.stringify({ error: body2 }), {
-      status: error.statusCode,
-      headers: {
-        "Content-Type": "application/json",
-        Allow: error.allowedMethods.join(", ")
-      }
-    });
-  }
-  if (error instanceof FaapiError) {
-    const body2 = {
-      code: error.code,
-      message: error.message
-    };
-    return new Response(JSON.stringify({ error: body2 }), {
-      status: error.statusCode,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  const body = {
-    code: "INTERNAL_ERROR",
-    message: error instanceof Error ? error.message : "An unknown error occurred"
-  };
-  return new Response(JSON.stringify({ error: body }), {
-    status: 500,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-
 // src/server/serverUtils.ts
 function nodeHttpToWebHeaders(req) {
   const headers = new Headers();
@@ -3476,9 +3552,9 @@ function nodeHttpToWebHeaders(req) {
   }
   return headers;
 }
-function buildErrorResponse(err) {
+function buildErrorResponse(err, config) {
   try {
-    return formatErrorResponse(err);
+    return formatErrorResponse(err, config);
   } catch {
     return new Response(
       JSON.stringify({ error: { code: "INTERNAL_ERROR", message: "Internal Server Error" } }),
@@ -3502,37 +3578,42 @@ function setCachedMiddlewares(absPath, bundle) {
   middlewareCache.set(absPath, bundle);
 }
 async function loadMiddlewaresFile(filePath) {
+  let module;
   try {
-    const module = await importWithCacheBust(filePath);
-    const middlewares = module.default ?? module.middlewares ?? [];
-    if (!Array.isArray(middlewares)) {
-      console.warn(`[faapi] middlewares.ts \u5E94\u5BFC\u51FA\u6570\u7EC4\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
-      return { middlewares: [], injectors: {} };
-    }
-    const validMiddlewares = middlewares.filter((m) => {
-      if (typeof m !== "function") {
-        console.warn(`[faapi] \u65E0\u6548\u7684\u4E2D\u95F4\u4EF6\u9879\uFF08\u5E94\u4E3A\u51FD\u6570\uFF09\uFF0C\u5DF2\u5FFD\u7565: ${typeof m}`);
-        return false;
-      }
-      return true;
-    });
-    const injectors = module.injectors ?? {};
-    if (typeof injectors !== "object" || injectors === null) {
-      console.warn(`[faapi] injectors \u5E94\u5BFC\u51FA\u5BF9\u8C61\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
-      return { middlewares: validMiddlewares, injectors: {} };
-    }
-    const validInjectors = {};
-    for (const [name, injector] of Object.entries(injectors)) {
-      if (typeof injector !== "function") {
-        console.warn(`[faapi] \u6CE8\u5165\u5668 ${name} \u5E94\u4E3A\u51FD\u6570\uFF0C\u5DF2\u5FFD\u7565`);
-        continue;
-      }
-      validInjectors[name] = injector;
-    }
-    return { middlewares: validMiddlewares, injectors: validInjectors };
-  } catch {
+    module = await importWithCacheBust(filePath);
+  } catch (err) {
+    console.error(
+      `[faapi] Failed to load middlewares from ${filePath}:`,
+      err instanceof Error ? err.stack ?? err.message : err
+    );
+    return { middlewares: [], injectors: {} };
+  }
+  const middlewares = module.default ?? module.middlewares ?? [];
+  if (!Array.isArray(middlewares)) {
+    console.warn(`[faapi] middlewares.ts \u5E94\u5BFC\u51FA\u6570\u7EC4\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
     return { middlewares: [], injectors: {} };
   }
+  const validMiddlewares = middlewares.filter((m) => {
+    if (typeof m !== "function") {
+      console.warn(`[faapi] \u65E0\u6548\u7684\u4E2D\u95F4\u4EF6\u9879\uFF08\u5E94\u4E3A\u51FD\u6570\uFF09\uFF0C\u5DF2\u5FFD\u7565: ${typeof m}`);
+      return false;
+    }
+    return true;
+  });
+  const injectors = module.injectors ?? {};
+  if (typeof injectors !== "object" || injectors === null) {
+    console.warn(`[faapi] injectors \u5E94\u5BFC\u51FA\u5BF9\u8C61\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
+    return { middlewares: validMiddlewares, injectors: {} };
+  }
+  const validInjectors = {};
+  for (const [name, injector] of Object.entries(injectors)) {
+    if (typeof injector !== "function") {
+      console.warn(`[faapi] \u6CE8\u5165\u5668 ${name} \u5E94\u4E3A\u51FD\u6570\uFF0C\u5DF2\u5FFD\u7565`);
+      continue;
+    }
+    validInjectors[name] = injector;
+  }
+  return { middlewares: validMiddlewares, injectors: validInjectors };
 }
 async function loadMergedMiddlewares(middlewarePaths) {
   if (middlewarePaths.length === 0) return void 0;
@@ -3739,25 +3820,51 @@ function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
 }
 function limitStreamSize(stream, maxSize) {
   let totalSize = 0;
-  const reader = stream.getReader();
-  return new ReadableStream({
-    async pull(controller) {
-      const { done, value } = await reader.read();
-      if (done) {
-        controller.close();
+  let reader;
+  let errored = false;
+  const releaseReader = () => {
+    if (reader) {
+      try {
         reader.releaseLock();
-        return;
+      } catch {
       }
-      totalSize += value.byteLength;
-      if (totalSize > maxSize) {
-        controller.error(new Error(`\u8BF7\u6C42\u4F53\u8D85\u8FC7\u5927\u5C0F\u9650\u5236 ${maxSize} \u5B57\u8282`));
-        reader.releaseLock();
-        return;
+      reader = void 0;
+    }
+  };
+  const failStream = (controller, err) => {
+    if (errored) return;
+    errored = true;
+    controller.error(err instanceof Error ? err : new Error(String(err)));
+    releaseReader();
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      if (!reader) reader = stream.getReader();
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          releaseReader();
+          return;
+        }
+        totalSize += value.byteLength;
+        if (totalSize > maxSize) {
+          failStream(controller, new PayloadTooLargeError(maxSize));
+          return;
+        }
+        controller.enqueue(value);
+      } catch (err) {
+        failStream(controller, err);
       }
-      controller.enqueue(value);
     },
     cancel(reason) {
-      reader.cancel(reason);
+      if (reader) {
+        try {
+          reader.cancel(reason);
+        } catch {
+        }
+        releaseReader();
+      }
     }
   });
 }
@@ -3838,21 +3945,27 @@ function createServer(options) {
   }
   return { server, routesRef };
 }
-async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares, onError, config, globalMiddlewares, globalInjectors, bodyLimit) {
+function prepareRequest(req, config, bodyLimit) {
   const request = toWebRequest(req, bodyLimit);
   const method = request.method.toUpperCase();
   const urlPath = new URL(request.url).pathname;
   const ctx = createContext(request, {}, config, getClientIp(req));
   const meta = ctx.meta;
-  const routePipeline = async () => {
-    const match = matchRoute(routes, method, urlPath);
-    if (!match) {
-      const allowedMethods = findAllowedMethods(routes, urlPath);
-      if (allowedMethods.length > 0) {
-        throw new MethodNotAllowedError(method, urlPath, allowedMethods);
-      }
-      throw new RouteNotFoundError(urlPath);
-    }
+  return { request, ctx, meta, method, urlPath };
+}
+function resolveRouteOrThrow(routes, method, urlPath) {
+  const match = matchRoute(routes, method, urlPath);
+  if (match) return match;
+  const allowedMethods = findAllowedMethods(routes, urlPath);
+  if (allowedMethods.length > 0) {
+    throw new MethodNotAllowedError(method, urlPath, allowedMethods);
+  }
+  throw new RouteNotFoundError(urlPath);
+}
+function createRoutePipeline(opts) {
+  const { routes, method, urlPath, ctx, request, rootDir, dist, globalInjectors } = opts;
+  return async () => {
+    const match = resolveRouteOrThrow(routes, method, urlPath);
     ctx.params = match.params;
     const { route } = match;
     const absoluteFilePath = path11.resolve(rootDir, route.filePath);
@@ -3882,37 +3995,44 @@ async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares,
       }
     }
     const mergedInjectors = globalInjectors ? { ...globalInjectors, ...route.injectors } : route.injectors;
-    const response = await invokeHandler(
-      routeModule.handler,
-      ctx,
-      body,
-      route.middlewares,
-      mergedInjectors
-    );
-    return response;
+    return await invokeHandler(routeModule.handler, ctx, body, route.middlewares, mergedInjectors);
   };
-  try {
-    let response;
-    const outerMiddlewares = [];
-    if (configMiddlewares.length > 0) outerMiddlewares.push(...configMiddlewares);
-    if (globalMiddlewares && globalMiddlewares.length > 0) {
-      outerMiddlewares.push(...globalMiddlewares);
-    }
-    if (outerMiddlewares.length > 0) {
-      response = await compose(outerMiddlewares, ctx, routePipeline);
-    } else {
-      response = await routePipeline();
+}
+async function sendSuccessResponse(response, res) {
+  await sendNodeResponse(response, res);
+}
+async function sendErrorResponse(err, meta, res, onError, ctx) {
+  await sendNodeResponse(mergeMeta(buildErrorResponse(err, ctx.config), meta), res);
+  if (onError) {
+    try {
+      await onError(err, ctx);
+    } catch {
     }
-    await sendNodeResponse(response, res);
+  }
+}
+async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares, onError, config, globalMiddlewares, globalInjectors, bodyLimit) {
+  const { request, ctx, meta, method, urlPath } = prepareRequest(req, config, bodyLimit);
+  const routePipeline = createRoutePipeline({
+    routes,
+    method,
+    urlPath,
+    ctx,
+    request,
+    rootDir,
+    dist,
+    globalMiddlewares,
+    globalInjectors
+  });
+  const outerMiddlewares = [];
+  if (configMiddlewares.length > 0) outerMiddlewares.push(...configMiddlewares);
+  if (globalMiddlewares && globalMiddlewares.length > 0) {
+    outerMiddlewares.push(...globalMiddlewares);
+  }
+  try {
+    const response = outerMiddlewares.length > 0 ? await compose(outerMiddlewares, ctx, routePipeline) : await routePipeline();
+    await sendSuccessResponse(response, res);
   } catch (err) {
-    const errorResponse = buildErrorResponse(err);
-    await sendNodeResponse(mergeMeta(errorResponse, meta), res);
-    if (onError) {
-      try {
-        await onError(err, ctx);
-      } catch {
-      }
-    }
+    await sendErrorResponse(err, meta, res, onError, ctx);
   }
 }
 
@@ -4011,7 +4131,6 @@ function extractAgentMetadata(program, filePath, pathMeta) {
     name: agentNameOverride ?? pathMeta.name,
     description,
     filePath: pathMeta.filePath,
-    hasConfig: pathMeta.hasConfig,
     hasRun: pathMeta.hasRun,
     systemPrompt,
     tools,
@@ -4177,7 +4296,6 @@ function serializeAgents(agents, dist = "dist") {
   return agents.map((a) => ({
     name: a.name,
     description: a.description,
-    hasConfig: a.hasConfig,
     hasRun: a.hasRun,
     systemPrompt: a.systemPrompt,
     tools: a.tools,
@@ -4200,7 +4318,6 @@ function hydrateAgents(manifest) {
     name: a.name,
     description: a.description ?? void 0,
     filePath: a.filePath,
-    hasConfig: a.hasConfig,
     hasRun: a.hasRun,
     systemPrompt: a.systemPrompt ?? void 0,
     tools: a.tools ?? void 0,
@@ -4217,7 +4334,6 @@ async function generateAgentArtifacts(agents, rootDir, dist) {
     const result = extractAgentMetadata(program, absPath, {
       name: manifest.name,
       filePath: manifest.filePath,
-      hasConfig: manifest.hasConfig,
       hasRun: manifest.hasRun
     });
     if (result) {
@@ -4435,10 +4551,8 @@ async function createAppBase(options) {
           if (agents.length > 0) {
             console.log(`- Loaded ${agents.length} agent(s):`);
             for (const agent of agents) {
-              const exports = [];
-              if (agent.hasConfig) exports.push("config");
-              if (agent.hasRun) exports.push("run");
-              console.log(`  ${agent.name} [${exports.join("+")}]  ${agent.filePath}`);
+              const exports = agent.hasRun ? "run" : "-";
+              console.log(`  ${agent.name} [${exports}]  ${agent.filePath}`);
             }
           }
           if (config?.lifecycle?.onClose) {
@@ -4540,6 +4654,7 @@ async function createAppBase(options) {
       }
       clearToolRegistry();
       clearAgentRegistry();
+      clearSkillRegistry();
       clearAgentHandleFactory();
       if (!server.listening) {
         app.server = null;
@@ -4831,7 +4946,6 @@ import fg4 from "fast-glob";
 import path17 from "path";
 import fs18 from "fs";
 var DEFAULT_AGENT_PATTERNS = ["src/agents/*/handler.ts"];
-var CONFIG_EXPORT_RE = /export\s+(?:const|function)\s+config\b/;
 var RUN_EXPORT_RE = /export\s+(?:async\s+)?(?:function\s+|const\s+)run\b/;
 function extractAgentNameFromPath(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
@@ -4845,7 +4959,6 @@ function extractAgentNameFromPath(filePath) {
 }
 function detectAgentExports(source) {
   return {
-    hasConfig: CONFIG_EXPORT_RE.test(source),
     hasRun: RUN_EXPORT_RE.test(source)
   };
 }
@@ -4865,7 +4978,7 @@ async function scanAgents(rootDir, patterns) {
     }
     const absPath = path17.resolve(rootDir, normalizedFile);
     const source = await fs18.promises.readFile(absPath, "utf8").catch(() => "");
-    const { hasConfig, hasRun } = detectAgentExports(source);
+    const { hasRun } = detectAgentExports(source);
     const name = extractAgentNameFromPath(normalizedFile);
     const prevFile = seen.get(name);
     if (prevFile) {
@@ -4877,7 +4990,6 @@ async function scanAgents(rootDir, patterns) {
     agents.push({
       name,
       filePath: normalizedFile,
-      hasConfig,
       hasRun
     });
   }
@@ -4947,11 +5059,15 @@ export {
   createProgram,
   extractTypeInfo,
   getAgent,
+  getAgentEntry,
   getApp,
   getInputTypeForMethod,
+  getSkill,
   getTool,
   helmet,
+  hydrateSkillRegistry,
   invalidateProgramCache,
+  listSkills,
   loadAgentModule,
   loadConfig,
   loadEnv,
@@ -4959,8 +5075,10 @@ export {
   loadToolSchema,
   logger,
   registerAgentHandleFactory,
+  removeSkill,
   resolveAgentTools,
   resolveSubAgents,
-  resolveTypeNode
+  resolveTypeNode,
+  upsertSkill
 };
 //# sourceMappingURL=index.js.map