@faapi/faapi 3.0.0 → 3.2.0

package/dist/cli/index.js

@@ -579,37 +579,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: {} };
+    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;
     }
-    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 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;
     }
-    return { middlewares: validMiddlewares, injectors: validInjectors };
-  } catch {
-    return { middlewares: [], injectors: {} };
+    validInjectors[name] = injector;
   }
+  return { middlewares: validMiddlewares, injectors: validInjectors };
 }
 async function loadMergedMiddlewares(middlewarePaths) {
   if (middlewarePaths.length === 0) return void 0;
@@ -2485,7 +2490,6 @@ function extractAgentNameFromPath(filePath) {
 }
 function detectAgentExports(source) {
   return {
-    hasConfig: CONFIG_EXPORT_RE.test(source),
     hasRun: RUN_EXPORT_RE.test(source)
   };
 }
@@ -2505,7 +2509,7 @@ async function scanAgents(rootDir, patterns) {
     }
     const absPath = path10.resolve(rootDir, normalizedFile);
     const source = await fs9.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) {
@@ -2517,18 +2521,16 @@ async function scanAgents(rootDir, patterns) {
     agents.push({
       name,
       filePath: normalizedFile,
-      hasConfig,
       hasRun
     });
   }
   return agents;
 }
-var DEFAULT_AGENT_PATTERNS, CONFIG_EXPORT_RE, RUN_EXPORT_RE;
+var DEFAULT_AGENT_PATTERNS, RUN_EXPORT_RE;
 var init_scanAgents = __esm({
   "src/agents/scanAgents.ts"() {
     "use strict";
     DEFAULT_AGENT_PATTERNS = ["src/agents/*/handler.ts"];
-    CONFIG_EXPORT_RE = /export\s+(?:const|function)\s+config\b/;
     RUN_EXPORT_RE = /export\s+(?:async\s+)?(?:function\s+|const\s+)run\b/;
   }
 });
@@ -2570,7 +2572,6 @@ function extractAgentMetadata(program, filePath, pathMeta) {
     name: agentNameOverride ?? pathMeta.name,
     description,
     filePath: pathMeta.filePath,
-    hasConfig: pathMeta.hasConfig,
     hasRun: pathMeta.hasRun,
     systemPrompt,
     tools,
@@ -2741,7 +2742,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,
@@ -2764,7 +2764,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,
@@ -2781,7 +2780,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) {
@@ -4921,11 +4919,28 @@ function isProductFresh(sourceAbsPath, productAbsPath) {
     return false;
   }
 }
+function createDevOnDemandState() {
+  return {
+    enabled: false,
+    distDir: void 0,
+    compiledFiles: /* @__PURE__ */ new Set(),
+    generatedSchemas: /* @__PURE__ */ new Set(),
+    inFlightCompilations: /* @__PURE__ */ new Map(),
+    inFlightSchemaGenerations: /* @__PURE__ */ new Map()
+  };
+}
 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 (!fs14.existsSync(sourceAbsPath)) {
@@ -4933,17 +4948,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 = path16.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
@@ -4953,10 +4976,17 @@ function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
   return path16.resolve(rootDir, dist, jsRel);
 }
 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 = path16.resolve(rootDir, routeFilePath);
@@ -4965,7 +4995,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);
@@ -4974,9 +5004,17 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   }
   const sourceRelPath = path16.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();
@@ -5003,27 +5041,25 @@ function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
   return path16.resolve(rootDir, srcRel);
 }
 function setDevOnDemandEnabled(enabled) {
-  devOnDemandEnabled = enabled;
+  state.enabled = enabled;
 }
 function isDevOnDemandEnabled() {
-  return devOnDemandEnabled;
+  return state.enabled;
 }
 function setDevDist(dist) {
-  devDistDir = dist;
+  state.distDir = dist;
 }
 function getDevDist() {
-  return devDistDir;
+  return state.distDir;
 }
-var compiledFiles, generatedSchemas, devOnDemandEnabled, devDistDir;
+var state;
 var init_compileOnDemand = __esm({
   "src/cli/compileOnDemand.ts"() {
     "use strict";
     init_compileDevRoutes();
     init_generateSchemaFiles();
     init_generateSchemaFiles();
-    compiledFiles = /* @__PURE__ */ new Set();
-    generatedSchemas = /* @__PURE__ */ new Set();
-    devOnDemandEnabled = false;
+    state = createDevOnDemandState();
   }
 });
 
@@ -5177,6 +5213,164 @@ var init_sse = __esm({
   }
 });
 
+// src/errors/FaapiError.ts
+var FaapiError;
+var init_FaapiError = __esm({
+  "src/errors/FaapiError.ts"() {
+    "use strict";
+    FaapiError = class extends Error {
+      constructor(code, message, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = "FaapiError";
+      }
+      code;
+      statusCode;
+    };
+  }
+});
+
+// src/errors/httpErrors.ts
+function deriveStatusCode(issues) {
+  const has400 = issues.some((i) => i.code === "INVALID_FORMAT" || i.code === "MISSING_FIELD");
+  return has400 ? 400 : 422;
+}
+var ValidationError, RouteNotFoundError, MethodNotAllowedError, InternalError, PayloadTooLargeError;
+var init_httpErrors = __esm({
+  "src/errors/httpErrors.ts"() {
+    "use strict";
+    init_FaapiError();
+    ValidationError = class extends FaapiError {
+      constructor(message, issues) {
+        super("VALIDATION_ERROR", message, deriveStatusCode(issues));
+        this.issues = issues;
+        this.name = "ValidationError";
+      }
+      issues;
+    };
+    RouteNotFoundError = class extends FaapiError {
+      constructor(path23) {
+        super("ROUTE_NOT_FOUND", `Route not found: ${path23}`, 404);
+        this.name = "RouteNotFoundError";
+      }
+    };
+    MethodNotAllowedError = class extends FaapiError {
+      constructor(method, path23, allowedMethods) {
+        super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path23}`, 405);
+        this.allowedMethods = allowedMethods;
+        this.name = "MethodNotAllowedError";
+      }
+      allowedMethods;
+    };
+    InternalError = class extends FaapiError {
+      constructor(message) {
+        super("INTERNAL_ERROR", message, 500);
+        this.name = "InternalError";
+      }
+    };
+    PayloadTooLargeError = class extends FaapiError {
+      constructor(maxSize) {
+        super("PAYLOAD_TOO_LARGE", `Request body exceeds size limit of ${maxSize} bytes`, 413);
+        this.name = "PayloadTooLargeError";
+      }
+    };
+  }
+});
+
+// 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);
+}
+var init_responseFormatter = __esm({
+  "src/response/responseFormatter.ts"() {
+    "use strict";
+    init_FaapiError();
+    init_httpErrors();
+  }
+});
+
 // src/runtime/createContext.ts
 function parseCookies(cookieHeader) {
   const cookies = /* @__PURE__ */ new Map();
@@ -5237,11 +5431,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" };
@@ -5277,18 +5467,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 独立无关联
@@ -5296,18 +5490,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;
@@ -5320,6 +5503,7 @@ var init_createContext = __esm({
   "src/runtime/createContext.ts"() {
     "use strict";
     init_sse();
+    init_responseFormatter();
   }
 });
 
@@ -5387,65 +5571,6 @@ var init_parseMultipart = __esm({
   }
 });
 
-// src/errors/FaapiError.ts
-var FaapiError;
-var init_FaapiError = __esm({
-  "src/errors/FaapiError.ts"() {
-    "use strict";
-    FaapiError = class extends Error {
-      constructor(code, message, statusCode) {
-        super(message);
-        this.code = code;
-        this.statusCode = statusCode;
-        this.name = "FaapiError";
-      }
-      code;
-      statusCode;
-    };
-  }
-});
-
-// src/errors/httpErrors.ts
-function deriveStatusCode(issues) {
-  const has400 = issues.some((i) => i.code === "INVALID_FORMAT" || i.code === "MISSING_FIELD");
-  return has400 ? 400 : 422;
-}
-var ValidationError, RouteNotFoundError, MethodNotAllowedError, InternalError;
-var init_httpErrors = __esm({
-  "src/errors/httpErrors.ts"() {
-    "use strict";
-    init_FaapiError();
-    ValidationError = class extends FaapiError {
-      constructor(message, issues) {
-        super("VALIDATION_ERROR", message, deriveStatusCode(issues));
-        this.issues = issues;
-        this.name = "ValidationError";
-      }
-      issues;
-    };
-    RouteNotFoundError = class extends FaapiError {
-      constructor(path23) {
-        super("ROUTE_NOT_FOUND", `Route not found: ${path23}`, 404);
-        this.name = "RouteNotFoundError";
-      }
-    };
-    MethodNotAllowedError = class extends FaapiError {
-      constructor(method, path23, allowedMethods) {
-        super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path23}`, 405);
-        this.allowedMethods = allowedMethods;
-        this.name = "MethodNotAllowedError";
-      }
-      allowedMethods;
-    };
-    InternalError = class extends FaapiError {
-      constructor(message) {
-        super("INTERNAL_ERROR", message, 500);
-        this.name = "InternalError";
-      }
-    };
-  }
-});
-
 // src/runtime/resolveInput.ts
 async function resolveInput(method, request) {
   const inputType = getInputTypeForMethod(method);
@@ -5639,7 +5764,9 @@ function clearAgentRegistry() {
   registry2 = /* @__PURE__ */ new Map();
 }
 function listAgents() {
-  return Array.from(registry2.values());
+  const merged = /* @__PURE__ */ new Map();
+  for (const agent of registry2.values()) merged.set(agent.name, agent);
+  return Array.from(merged.values());
 }
 var registry2;
 var init_agentRegistry = __esm({
@@ -5738,10 +5865,7 @@ var init_injectParams = __esm({
 
 // 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;
@@ -5830,6 +5954,7 @@ var init_invokeHandler = __esm({
   "src/runtime/invokeHandler.ts"() {
     "use strict";
     init_toResponse();
+    init_responseFormatter();
     init_injectParams();
   }
 });
@@ -6160,55 +6285,10 @@ var init_logger = __esm({
 });
 
 // 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" }
-  });
-}
 var init_formatErrorResponse = __esm({
   "src/errors/formatErrorResponse.ts"() {
     "use strict";
-    init_FaapiError();
-    init_httpErrors();
+    init_responseFormatter();
   }
 });
 
@@ -6225,9 +6305,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" } }),
@@ -6456,25 +6536,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();
+      }
     }
   });
 }
@@ -6555,21 +6661,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 = path18.resolve(rootDir, route.filePath);
@@ -6599,37 +6711,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);
   }
 }
 var DEFAULT_BODY_LIMIT;
@@ -6755,6 +6874,18 @@ var init_loadPlugins = __esm({
   }
 });
 
+// src/injection/skillRegistry.ts
+function clearSkillRegistry() {
+  registry3 = /* @__PURE__ */ new Map();
+}
+var registry3;
+var init_skillRegistry = __esm({
+  "src/injection/skillRegistry.ts"() {
+    "use strict";
+    registry3 = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/cli/createAppCore.ts
 import fs17 from "fs";
 import path19 from "path";
@@ -6875,10 +7006,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) {
@@ -6980,6 +7109,7 @@ async function createAppBase(options) {
       }
       clearToolRegistry();
       clearAgentRegistry();
+      clearSkillRegistry();
       clearAgentHandleFactory();
       if (!server.listening) {
         app.server = null;
@@ -7031,6 +7161,7 @@ var init_createAppCore = __esm({
     init_importWithCacheBust();
     init_toolRegistry();
     init_agentRegistry();
+    init_skillRegistry();
     init_agentHandle();
     DEFAULT_DIST = "dist";
     DEFAULT_PORT = 3e3;