@faapi/faapi 5.1.0 → 5.3.0

package/dist/cli/index.js

@@ -115,6 +115,7 @@ var init_readTsconfig = __esm({
 });
 
 // src/cli/aliasPlugin.ts
+import ts2 from "typescript";
 import path3 from "path";
 import fs3 from "fs";
 function toProdImportPath(sourceFile, importer) {
@@ -145,7 +146,14 @@ function resolveRelativeSpecifier(importer, specifier) {
   const importerDir = path3.dirname(importer);
   const base = path3.resolve(importerDir, specifier);
   if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
-    return fs3.existsSync(base) ? base : null;
+    if (fs3.existsSync(base)) return base;
+    if (base.endsWith(".js")) {
+      for (const ext of [".ts", ".tsx", ".jsx"]) {
+        const file = base.slice(0, -3) + ext;
+        if (fs3.existsSync(file)) return file;
+      }
+    }
+    return null;
   }
   if (/\.(ts|tsx|jsx)$/.test(specifier)) {
     return fs3.existsSync(base) ? base : null;
@@ -161,8 +169,18 @@ function resolveRelativeSpecifier(importer, specifier) {
   return null;
 }
 function createAliasPlugin(config, options) {
-  const SPEC_RE2 = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
   const appDirAbs = options?.rootDir ? toRealPath(path3.resolve(options.rootDir, APP_DIR)) : null;
+  const probeCandidateFile = (candidate) => {
+    for (const ext of SOURCE_EXTS) {
+      const file = candidate + ext;
+      if (fs3.existsSync(file)) return file;
+    }
+    for (const indexExt of INDEX_EXTS) {
+      const file = candidate + indexExt;
+      if (fs3.existsSync(file)) return file;
+    }
+    return null;
+  };
   return {
     name: "faapi-alias",
     setup(build) {
@@ -175,64 +193,103 @@ function createAliasPlugin(config, options) {
         }
         const importer = args.path;
         const importerOutsideAppDir = appDirAbs ? !isInsideDir(importer, appDirAbs) : false;
-        let modified = false;
-        const newSource = source.replace(SPEC_RE2, (full, prefix, quote, specifier) => {
+        const sourceFile = ts2.createSourceFile(importer, source, ts2.ScriptTarget.Latest, false);
+        const literals = [];
+        const visit = (node) => {
+          if (ts2.isImportDeclaration(node)) {
+            if (!node.importClause?.isTypeOnly && node.moduleSpecifier) {
+              if (ts2.isStringLiteral(node.moduleSpecifier)) literals.push(node.moduleSpecifier);
+            }
+          } else if (ts2.isExportDeclaration(node)) {
+            if (!node.isTypeOnly && node.moduleSpecifier) {
+              if (ts2.isStringLiteral(node.moduleSpecifier)) literals.push(node.moduleSpecifier);
+            }
+          } else if (ts2.isCallExpression(node) && node.expression.kind === ts2.SyntaxKind.ImportKeyword && node.arguments[0] && ts2.isStringLiteral(node.arguments[0])) {
+            literals.push(node.arguments[0]);
+          }
+          ts2.forEachChild(node, visit);
+        };
+        ts2.forEachChild(sourceFile, visit);
+        const replacements = [];
+        const unresolvable = [];
+        for (const lit of literals) {
+          const specifier = lit.text;
           if (specifier.startsWith("/") || specifier.startsWith("file:") || specifier.startsWith("node:")) {
-            return full;
+            continue;
           }
           if (specifier.startsWith("./") || specifier.startsWith("../")) {
             const resolved = resolveRelativeSpecifier(importer, specifier);
-            if (resolved) {
-              if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
-                return full;
-              }
-              if (appDirAbs && importerOutsideAppDir && isInsideDir(resolved, appDirAbs)) {
-                modified = true;
-                return `${prefix}${quote}${toProdImportFromImporter(
-                  importer,
-                  options.rootDir,
-                  toStrippedProdImportPath(resolved, options.rootDir)
-                )}${quote}`;
-              }
-              modified = true;
-              return `${prefix}${quote}${toProdImportPath(resolved, importer)}${quote}`;
+            if (!resolved) {
+              unresolvable.push(lit);
+              continue;
             }
-            return full;
-          }
-          const candidates = resolveAlias(specifier, config);
-          for (const candidate of candidates) {
-            for (const ext of SOURCE_EXTS) {
-              const file = candidate + ext;
-              if (fs3.existsSync(file)) {
-                modified = true;
-                if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
-                  return `${prefix}${quote}${toProdImportFromImporter(
-                    importer,
-                    options.rootDir,
-                    toStrippedProdImportPath(file, options.rootDir)
-                  )}${quote}`;
-                }
-                return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
-              }
+            if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) continue;
+            let prodPath;
+            if (appDirAbs && importerOutsideAppDir && isInsideDir(resolved, appDirAbs)) {
+              prodPath = toProdImportFromImporter(
+                importer,
+                options.rootDir,
+                toStrippedProdImportPath(resolved, options.rootDir)
+              );
+            } else {
+              prodPath = toProdImportPath(resolved, importer);
             }
-            for (const indexExt of INDEX_EXTS) {
-              const file = candidate + indexExt;
-              if (fs3.existsSync(file)) {
-                modified = true;
-                if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
-                  return `${prefix}${quote}${toProdImportFromImporter(
-                    importer,
-                    options.rootDir,
-                    toStrippedProdImportPath(file, options.rootDir)
-                  )}${quote}`;
-                }
-                return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
-              }
+            const quote = source[lit.getStart(sourceFile)];
+            replacements.push({
+              start: lit.getStart(sourceFile),
+              end: lit.getEnd(),
+              text: quote + prodPath + quote
+            });
+            continue;
+          }
+          for (const candidate of resolveAlias(specifier, config)) {
+            const file = probeCandidateFile(candidate);
+            if (!file) continue;
+            let prodPath;
+            if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
+              prodPath = toProdImportFromImporter(
+                importer,
+                options.rootDir,
+                toStrippedProdImportPath(file, options.rootDir)
+              );
+            } else {
+              prodPath = toProdImportPath(file, importer);
             }
+            const quote = source[lit.getStart(sourceFile)];
+            replacements.push({
+              start: lit.getStart(sourceFile),
+              end: lit.getEnd(),
+              text: quote + prodPath + quote
+            });
+            break;
           }
-          return full;
-        });
-        if (!modified) return void 0;
+        }
+        if (unresolvable.length > 0) {
+          const lineStarts = sourceFile.getLineStarts();
+          return {
+            errors: unresolvable.map((lit) => {
+              const { line, character } = sourceFile.getLineAndCharacterOfPosition(
+                lit.getStart(sourceFile)
+              );
+              const lineEnd = line + 1 < lineStarts.length ? lineStarts[line + 1] : sourceFile.getEnd();
+              return {
+                text: `\u65E0\u6CD5\u89E3\u6790\u7684\u76F8\u5BF9\u5BFC\u5165 "${lit.text}"\u2014\u2014\u9879\u76EE\u5185\u4E0D\u5B58\u5728\u5BF9\u5E94\u6E90\u6587\u4EF6\uFF08faapi \u9010\u6587\u4EF6\u7F16\u8BD1\uFF08bundle: false\uFF09\u4E0D\u89E3\u6790\u4F9D\u8D56\uFF0C\u8BE5\u5BFC\u5165\u4F1A\u539F\u6837\u8FDB\u5165\u4EA7\u7269\uFF0C\u751F\u4EA7 Node ESM \u8FD0\u884C\u65F6\u62A5 ERR_MODULE_NOT_FOUND\uFF09\u3002\u8BF7\u4FEE\u6B63\u8DEF\u5F84\u6216\u8865\u5168\u540E\u7F00`,
+                location: {
+                  file: importer,
+                  line: line + 1,
+                  column: character,
+                  lineText: source.slice(lineStarts[line], lineEnd).replace(/\r?\n$/, "")
+                }
+              };
+            })
+          };
+        }
+        if (replacements.length === 0) return void 0;
+        replacements.sort((a, b) => b.start - a.start);
+        let newSource = source;
+        for (const r of replacements) {
+          newSource = newSource.slice(0, r.start) + r.text + newSource.slice(r.end);
+        }
         return { contents: newSource, loader: "default" };
       });
     }
@@ -653,8 +710,8 @@ var init_parseRouteFile = __esm({
 
 // src/utils/importWithCacheBust.ts
 import { pathToFileURL } from "url";
-function setLoadTimestamp(ts10) {
-  loadTs = ts10;
+function setLoadTimestamp(ts11) {
+  loadTs = ts11;
 }
 function getVitestImportActual() {
   const vi = globalThis.vi;
@@ -997,14 +1054,14 @@ var init_scanTools = __esm({
 });
 
 // src/ast/jsDocMetadata.ts
-import ts2 from "typescript";
+import ts3 from "typescript";
 function hasExportModifier(node) {
-  if (!ts2.canHaveModifiers(node)) return false;
-  const modifiers = ts2.getModifiers(node);
-  return !!modifiers?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
+  if (!ts3.canHaveModifiers(node)) return false;
+  const modifiers = ts3.getModifiers(node);
+  return !!modifiers?.some((m) => m.kind === ts3.SyntaxKind.ExportKeyword);
 }
 function getJSDocFromNode(node) {
-  const apiDocs = ts2.getJSDocCommentsAndTags(node).filter((entry) => ts2.isJSDoc(entry));
+  const apiDocs = ts3.getJSDocCommentsAndTags(node).filter((entry) => ts3.isJSDoc(entry));
   if (apiDocs.length > 0) return apiDocs[0];
   const directDocs = node.jsDoc;
   if (directDocs && directDocs.length > 0) return directDocs[0];
@@ -1035,7 +1092,7 @@ var init_jsDocMetadata = __esm({
 });
 
 // src/ast/extractToolMetadata.ts
-import ts3 from "typescript";
+import ts4 from "typescript";
 function extractToolMetadata(program, filePath, functionName, pathMeta) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return null;
@@ -1056,18 +1113,18 @@ function extractToolMetadata(program, filePath, functionName, pathMeta) {
 }
 function findExportedFunction(sourceFile, functionName) {
   let result = null;
-  ts3.forEachChild(sourceFile, (node) => {
+  ts4.forEachChild(sourceFile, (node) => {
     if (result) return;
-    if (ts3.isFunctionDeclaration(node) && hasExportModifier(node) && node.name?.text === functionName) {
+    if (ts4.isFunctionDeclaration(node) && hasExportModifier(node) && node.name?.text === functionName) {
       result = { fn: node, jsDocOwner: node };
       return;
     }
-    if (ts3.isVariableStatement(node) && hasExportModifier(node)) {
+    if (ts4.isVariableStatement(node) && hasExportModifier(node)) {
       for (const decl of node.declarationList.declarations) {
         if (result) break;
-        const nameText = ts3.isIdentifier(decl.name) ? decl.name.text : decl.name.getText(sourceFile);
+        const nameText = ts4.isIdentifier(decl.name) ? decl.name.text : decl.name.getText(sourceFile);
         if (nameText !== functionName || !decl.initializer) continue;
-        if (ts3.isArrowFunction(decl.initializer) || ts3.isFunctionExpression(decl.initializer)) {
+        if (ts4.isArrowFunction(decl.initializer) || ts4.isFunctionExpression(decl.initializer)) {
           result = { fn: decl.initializer, jsDocOwner: node };
         }
       }
@@ -1079,7 +1136,7 @@ function getFirstParamTypeName(fn, sourceFile) {
   const firstParam = fn.parameters[0];
   if (!firstParam) return void 0;
   if (!firstParam.type) return void 0;
-  if (!ts3.isTypeReferenceNode(firstParam.type)) return void 0;
+  if (!ts4.isTypeReferenceNode(firstParam.type)) return void 0;
   return firstParam.type.typeName.getText(sourceFile);
 }
 var init_extractToolMetadata = __esm({
@@ -1090,7 +1147,7 @@ var init_extractToolMetadata = __esm({
 });
 
 // src/ast/createProgram.ts
-import ts4 from "typescript";
+import ts5 from "typescript";
 import fs10 from "fs";
 import path10 from "path";
 function invalidateProgramCache() {
@@ -1116,16 +1173,16 @@ function parseTsConfig(tsconfigPath) {
   if (cached) return cached;
   const result = { fileNames: [] };
   try {
-    const configFile = ts4.readConfigFile(tsconfigPath, (p) => fs10.readFileSync(p, "utf-8"));
+    const configFile = ts5.readConfigFile(tsconfigPath, (p) => fs10.readFileSync(p, "utf-8"));
     if (configFile.error) {
       tsConfigCache.set(tsconfigPath, result);
       return result;
     }
     const config = configFile.config ?? {};
     const basePath = path10.dirname(tsconfigPath);
-    const parsed = ts4.parseJsonConfigFileContent(
+    const parsed = ts5.parseJsonConfigFileContent(
       config,
-      ts4.sys,
+      ts5.sys,
       basePath,
       /* existingOptions */
       void 0,
@@ -1190,9 +1247,9 @@ function createPrograms(filePaths) {
 function buildProgram(entryFiles, tsconfigPath) {
   const options = {
     strict: true,
-    target: ts4.ScriptTarget.ES2022,
-    module: ts4.ModuleKind.NodeNext,
-    moduleResolution: ts4.ModuleResolutionKind.NodeNext,
+    target: ts5.ScriptTarget.ES2022,
+    module: ts5.ModuleKind.NodeNext,
+    moduleResolution: ts5.ModuleResolutionKind.NodeNext,
     skipLibCheck: true,
     noEmit: true
   };
@@ -1213,7 +1270,7 @@ function buildProgram(entryFiles, tsconfigPath) {
       }
     }
   }
-  return ts4.createProgram(rootNames, options);
+  return ts5.createProgram(rootNames, options);
 }
 var programCache, tsConfigCache;
 var init_createProgram = __esm({
@@ -1225,86 +1282,86 @@ var init_createProgram = __esm({
 });
 
 // src/ast/resolveTypeNode.ts
-import ts5 from "typescript";
+import ts6 from "typescript";
 function setProgramContext(program) {
   currentProgram = program;
 }
 function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set(), bindings = /* @__PURE__ */ new Map()) {
   const kind = typeNode.kind;
   switch (kind) {
-    case ts5.SyntaxKind.StringKeyword:
+    case ts6.SyntaxKind.StringKeyword:
       return { kind: "string" };
-    case ts5.SyntaxKind.NumberKeyword:
+    case ts6.SyntaxKind.NumberKeyword:
       return { kind: "number" };
-    case ts5.SyntaxKind.BooleanKeyword:
+    case ts6.SyntaxKind.BooleanKeyword:
       return { kind: "boolean" };
-    case ts5.SyntaxKind.BigIntKeyword:
+    case ts6.SyntaxKind.BigIntKeyword:
       throw new SchemaExtractionError(
         typeNode.getText(),
         "bigint \u65E0\u6CD5\u901A\u8FC7 HTTP/JSON \u4F20\u8F93,\u8BF7\u6539\u7528 string \u6216 number"
       );
-    case ts5.SyntaxKind.SymbolKeyword:
+    case ts6.SyntaxKind.SymbolKeyword:
       throw new SchemaExtractionError(typeNode.getText(), "symbol \u65E0\u6CD5\u901A\u8FC7 HTTP/JSON \u4F20\u8F93");
-    case ts5.SyntaxKind.NullKeyword:
+    case ts6.SyntaxKind.NullKeyword:
       return { kind: "null" };
-    case ts5.SyntaxKind.UndefinedKeyword:
+    case ts6.SyntaxKind.UndefinedKeyword:
       return { kind: "undefined" };
-    case ts5.SyntaxKind.UnknownKeyword:
+    case ts6.SyntaxKind.UnknownKeyword:
       return { kind: "any" };
-    case ts5.SyntaxKind.AnyKeyword:
+    case ts6.SyntaxKind.AnyKeyword:
       throw new SchemaExtractionError(typeNode.getText(), "any \u4E0D\u652F\u6301\uFF0C\u8BF7\u4F7F\u7528 unknown \u8868\u793A\u4E0D\u6821\u9A8C");
-    case ts5.SyntaxKind.VoidKeyword:
+    case ts6.SyntaxKind.VoidKeyword:
       throw new SchemaExtractionError(typeNode.getText(), "void \u4E0D\u652F\u6301\u8FD0\u884C\u65F6\u6821\u9A8C");
-    case ts5.SyntaxKind.NeverKeyword:
+    case ts6.SyntaxKind.NeverKeyword:
       throw new SchemaExtractionError(typeNode.getText(), "never \u4E0D\u652F\u6301\u8FD0\u884C\u65F6\u6821\u9A8C");
-    case ts5.SyntaxKind.ObjectKeyword:
+    case ts6.SyntaxKind.ObjectKeyword:
       throw new SchemaExtractionError(
         typeNode.getText(),
         "object \u4E0D\u652F\u6301\uFF0C\u8BF7\u4F7F\u7528\u5177\u4F53\u5BF9\u8C61\u7C7B\u578B\u6216 unknown"
       );
   }
-  if (ts5.isLiteralTypeNode(typeNode)) {
+  if (ts6.isLiteralTypeNode(typeNode)) {
     const literal = typeNode.literal;
-    if (ts5.isStringLiteral(literal)) {
+    if (ts6.isStringLiteral(literal)) {
       return { kind: "literal", value: literal.text };
     }
-    if (ts5.isNumericLiteral(literal)) {
+    if (ts6.isNumericLiteral(literal)) {
       return { kind: "literal", value: Number(literal.text) };
     }
-    if (literal.kind === ts5.SyntaxKind.TrueKeyword) {
+    if (literal.kind === ts6.SyntaxKind.TrueKeyword) {
       return { kind: "literal", value: true };
     }
-    if (literal.kind === ts5.SyntaxKind.FalseKeyword) {
+    if (literal.kind === ts6.SyntaxKind.FalseKeyword) {
       return { kind: "literal", value: false };
     }
-    if (literal.kind === ts5.SyntaxKind.NullKeyword) {
+    if (literal.kind === ts6.SyntaxKind.NullKeyword) {
       return { kind: "null" };
     }
     throw new SchemaExtractionError(typeNode.getText(), "\u4E0D\u652F\u6301\u7684\u5B57\u9762\u91CF\u7C7B\u578B");
   }
-  if (ts5.isArrayTypeNode(typeNode)) {
+  if (ts6.isArrayTypeNode(typeNode)) {
     return {
       kind: "array",
       element: resolveTypeNode(typeNode.elementType, checker, visited, bindings)
     };
   }
-  if (ts5.isTupleTypeNode(typeNode)) {
+  if (ts6.isTupleTypeNode(typeNode)) {
     const elements = typeNode.elements.map((e) => {
-      if (ts5.isRestTypeNode(e)) {
+      if (ts6.isRestTypeNode(e)) {
         const inner = resolveTypeNode(e.type, checker, visited, bindings);
         if (inner.kind === "array") {
           return { type: inner.element, optional: false, rest: true };
         }
         return { type: inner, optional: false, rest: true };
       }
-      if (ts5.isNamedTupleMember(e)) {
+      if (ts6.isNamedTupleMember(e)) {
         return {
           type: resolveTypeNode(e.type, checker, visited, bindings),
           optional: !!e.questionToken,
           rest: false
         };
       }
-      if (ts5.isOptionalTypeNode(e)) {
+      if (ts6.isOptionalTypeNode(e)) {
         return {
           type: resolveTypeNode(e.type, checker, visited, bindings),
           optional: true,
@@ -1319,11 +1376,11 @@ function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set(),
     });
     return { kind: "tuple", elements };
   }
-  if (ts5.isUnionTypeNode(typeNode)) {
+  if (ts6.isUnionTypeNode(typeNode)) {
     const members = typeNode.types.map((t) => resolveTypeNode(t, checker, visited, bindings));
     return { kind: "union", members };
   }
-  if (ts5.isIntersectionTypeNode(typeNode)) {
+  if (ts6.isIntersectionTypeNode(typeNode)) {
     const propMap = /* @__PURE__ */ new Map();
     for (const t of typeNode.types) {
       const resolved = resolveTypeNode(t, checker, visited, bindings);
@@ -1353,19 +1410,19 @@ function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set(),
     }
     return { kind: "object", properties: [...propMap.values()] };
   }
-  if (ts5.isTypeLiteralNode(typeNode)) {
+  if (ts6.isTypeLiteralNode(typeNode)) {
     return resolveTypeLiteral(typeNode, checker, visited, bindings);
   }
-  if (ts5.isTypeOperatorNode(typeNode) && typeNode.operator === ts5.SyntaxKind.KeyOfKeyword) {
+  if (ts6.isTypeOperatorNode(typeNode) && typeNode.operator === ts6.SyntaxKind.KeyOfKeyword) {
     return resolveKeyOf(typeNode, checker);
   }
-  if (ts5.isTypeOperatorNode(typeNode) && typeNode.operator === ts5.SyntaxKind.ReadonlyKeyword) {
+  if (ts6.isTypeOperatorNode(typeNode) && typeNode.operator === ts6.SyntaxKind.ReadonlyKeyword) {
     return resolveTypeNode(typeNode.type, checker, visited, bindings);
   }
-  if (ts5.isTypeReferenceNode(typeNode)) {
+  if (ts6.isTypeReferenceNode(typeNode)) {
     return resolveTypeReference(typeNode, checker, visited, bindings);
   }
-  if (ts5.isExpressionWithTypeArguments(typeNode)) {
+  if (ts6.isExpressionWithTypeArguments(typeNode)) {
     return resolveTypeReference(
       {
         getText: () => typeNode.getText(),
@@ -1383,14 +1440,14 @@ function resolveTypeLiteral(typeNode, checker, visited = /* @__PURE__ */ new Set
   const properties = [];
   let catchall;
   for (const member of typeNode.members) {
-    if (ts5.isMethodSignature(member) || ts5.isGetAccessorDeclaration(member) || ts5.isSetAccessorDeclaration(member)) {
+    if (ts6.isMethodSignature(member) || ts6.isGetAccessorDeclaration(member) || ts6.isSetAccessorDeclaration(member)) {
       throw SchemaExtractionError.at(
         member,
         member.getText(),
         "\u5BF9\u8C61\u7C7B\u578B\u542B\u65B9\u6CD5\u7B7E\u540D\u6216\u5B58\u53D6\u5668,\u8FD0\u884C\u65F6 JSON \u6570\u636E\u65E0\u6CD5\u6821\u9A8C\u65B9\u6CD5\u2014\u2014\u8BF7\u6539\u7528\u5177\u4F53\u5C5E\u6027\u7C7B\u578B"
       );
     }
-    if (ts5.isPropertySignature(member) && member.name) {
+    if (ts6.isPropertySignature(member) && member.name) {
       const name = member.name.getText();
       const optional = !!member.questionToken;
       const type = member.type ? resolveTypeNode(member.type, checker, visited, bindings) : { kind: "any" };
@@ -1400,7 +1457,7 @@ function resolveTypeLiteral(typeNode, checker, visited = /* @__PURE__ */ new Set
         constraints.length > 0 ? { name, type, optional, constraints } : { name, type, optional }
       );
     }
-    if (ts5.isIndexSignatureDeclaration(member)) {
+    if (ts6.isIndexSignatureDeclaration(member)) {
       catchall = member.type ? resolveTypeNode(member.type, checker, visited, bindings) : { kind: "any" };
     }
   }
@@ -1580,11 +1637,11 @@ function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new S
   }
   visited.add(typeName);
   if (checker) {
-    const symbol = ts5.isIdentifier(typeNode.typeName) || ts5.isQualifiedName(typeNode.typeName) ? checker.getSymbolAtLocation(typeNode.typeName) : void 0;
+    const symbol = ts6.isIdentifier(typeNode.typeName) || ts6.isQualifiedName(typeNode.typeName) ? checker.getSymbolAtLocation(typeNode.typeName) : void 0;
     if (symbol) {
       const declaration = symbol.declarations?.[0];
       if (declaration) {
-        if (ts5.isInterfaceDeclaration(declaration)) {
+        if (ts6.isInterfaceDeclaration(declaration)) {
           return resolveInterfaceDeclaration(
             declaration,
             checker,
@@ -1593,7 +1650,7 @@ function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new S
             typeNode.typeArguments
           );
         }
-        if (ts5.isTypeAliasDeclaration(declaration)) {
+        if (ts6.isTypeAliasDeclaration(declaration)) {
           const declBindings = bindTypeParameters(
             declaration.typeParameters,
             typeNode.typeArguments,
@@ -1604,10 +1661,10 @@ function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new S
           );
           return resolveTypeNode(declaration.type, checker, visited, declBindings);
         }
-        if (ts5.isEnumDeclaration(declaration)) {
+        if (ts6.isEnumDeclaration(declaration)) {
           return resolveEnumDeclaration(declaration);
         }
-        if (ts5.isImportSpecifier(declaration) || ts5.isImportClause(declaration)) {
+        if (ts6.isImportSpecifier(declaration) || ts6.isImportClause(declaration)) {
           const resolved = resolveImportAlias(
             typeNode,
             symbol,
@@ -1649,10 +1706,10 @@ function resolveImportAlias(typeNode, symbol, checker, visited, bindings = /* @_
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased.declarations && aliased.declarations.length > 0) {
       const decl = aliased.declarations[0];
-      if (ts5.isInterfaceDeclaration(decl)) {
+      if (ts6.isInterfaceDeclaration(decl)) {
         return resolveInterfaceDeclaration(decl, checker, visited, bindings, typeArguments);
       }
-      if (ts5.isTypeAliasDeclaration(decl)) {
+      if (ts6.isTypeAliasDeclaration(decl)) {
         const declBindings = bindTypeParameters(
           decl.typeParameters,
           typeArguments,
@@ -1663,7 +1720,7 @@ function resolveImportAlias(typeNode, symbol, checker, visited, bindings = /* @_
         );
         return resolveTypeNode(decl.type, checker, visited, declBindings);
       }
-      if (ts5.isEnumDeclaration(decl)) {
+      if (ts6.isEnumDeclaration(decl)) {
         return resolveEnumDeclaration(decl);
       }
     }
@@ -1701,13 +1758,13 @@ function resolveImportAlias(typeNode, symbol, checker, visited, bindings = /* @_
 }
 function findTopLevelDecl(sourceFile, typeName) {
   let found = null;
-  ts5.forEachChild(sourceFile, (node) => {
+  ts6.forEachChild(sourceFile, (node) => {
     if (found) return;
-    if (ts5.isInterfaceDeclaration(node) && node.name.text === typeName) {
+    if (ts6.isInterfaceDeclaration(node) && node.name.text === typeName) {
       found = { kind: "interface", node };
-    } else if (ts5.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+    } else if (ts6.isTypeAliasDeclaration(node) && node.name.text === typeName) {
       found = { kind: "typeAlias", node };
-    } else if (ts5.isEnumDeclaration(node) && node.name.text === typeName) {
+    } else if (ts6.isEnumDeclaration(node) && node.name.text === typeName) {
       found = { kind: "enum", node };
     }
   });
@@ -1718,9 +1775,9 @@ function resolveEnumDeclaration(node) {
   let nextNumericValue = 0;
   for (const member of node.members) {
     if (member.initializer) {
-      if (ts5.isStringLiteral(member.initializer)) {
+      if (ts6.isStringLiteral(member.initializer)) {
         members.push({ kind: "literal", value: member.initializer.text });
-      } else if (ts5.isNumericLiteral(member.initializer)) {
+      } else if (ts6.isNumericLiteral(member.initializer)) {
         const num = Number(member.initializer.text);
         members.push({ kind: "literal", value: num });
         nextNumericValue = num + 1;
@@ -1750,7 +1807,7 @@ function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ ne
     node
   );
   for (const heritageClause of node.heritageClauses ?? []) {
-    if (heritageClause.token === ts5.SyntaxKind.ExtendsKeyword) {
+    if (heritageClause.token === ts6.SyntaxKind.ExtendsKeyword) {
       for (const expr of heritageClause.types) {
         const parentType = resolveTypeNode(expr, checker, visited, bindings);
         if (parentType.kind === "object") {
@@ -1762,14 +1819,14 @@ function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ ne
     }
   }
   for (const member of node.members) {
-    if (ts5.isMethodSignature(member) || ts5.isGetAccessorDeclaration(member) || ts5.isSetAccessorDeclaration(member)) {
+    if (ts6.isMethodSignature(member) || ts6.isGetAccessorDeclaration(member) || ts6.isSetAccessorDeclaration(member)) {
       throw SchemaExtractionError.at(
         member,
         member.getText(),
         "\u63A5\u53E3\u542B\u65B9\u6CD5\u7B7E\u540D\u6216\u5B58\u53D6\u5668,\u8FD0\u884C\u65F6 JSON \u6570\u636E\u65E0\u6CD5\u6821\u9A8C\u65B9\u6CD5\u2014\u2014\u8BF7\u6539\u7528\u5177\u4F53\u5C5E\u6027\u7C7B\u578B"
       );
     }
-    if (ts5.isPropertySignature(member) && member.name) {
+    if (ts6.isPropertySignature(member) && member.name) {
       const name = member.name.getText();
       const optional = !!member.questionToken;
       const type = member.type ? resolveTypeNode(member.type, checker, visited, bindings) : { kind: "any" };
@@ -1780,7 +1837,7 @@ function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ ne
         constraints.length > 0 ? { name, type, optional, constraints } : { name, type, optional }
       );
     }
-    if (ts5.isIndexSignatureDeclaration(member)) {
+    if (ts6.isIndexSignatureDeclaration(member)) {
       catchall = member.type ? resolveTypeNode(member.type, checker, visited, bindings) : { kind: "any" };
     }
   }
@@ -1790,7 +1847,7 @@ function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ ne
   return catchall !== void 0 ? { kind: "object", properties, catchall } : { kind: "object", properties };
 }
 function extractConstraintsFromJsDoc(node, fieldName) {
-  const jsDocs = ts5.getJSDocCommentsAndTags(node).filter((entry) => ts5.isJSDoc(entry));
+  const jsDocs = ts6.getJSDocCommentsAndTags(node).filter((entry) => ts6.isJSDoc(entry));
   if (jsDocs.length === 0) return [];
   const constraints = [];
   for (const jsDoc of jsDocs) {
@@ -1971,7 +2028,7 @@ var init_resolveTypeNode = __esm({
 });
 
 // src/ast/extractHandlerTypes.ts
-import ts6 from "typescript";
+import ts7 from "typescript";
 function extractTypeInfo(program, filePath, typeName) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return null;
@@ -1979,9 +2036,9 @@ function extractTypeInfo(program, filePath, typeName) {
   setProgramContext(program);
   try {
     let result = null;
-    ts6.forEachChild(sourceFile, (node) => {
+    ts7.forEachChild(sourceFile, (node) => {
       if (result) return;
-      if (ts6.isInterfaceDeclaration(node) && node.name.text === typeName) {
+      if (ts7.isInterfaceDeclaration(node) && node.name.text === typeName) {
         const visited = /* @__PURE__ */ new Set();
         visited.add(typeName);
         const runtimeType = withFileContext(
@@ -1996,7 +2053,7 @@ function extractTypeInfo(program, filePath, typeName) {
         };
         return;
       }
-      if (ts6.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+      if (ts7.isTypeAliasDeclaration(node) && node.name.text === typeName) {
         const visited = /* @__PURE__ */ new Set();
         visited.add(typeName);
         const runtimeType = withFileContext(
@@ -2106,7 +2163,7 @@ var init_schemaName = __esm({
 });
 
 // src/injection/resolveInjection.ts
-import ts7 from "typescript";
+import ts8 from "typescript";
 function resolveInjection(fn) {
   const cached = injectionCache.get(fn);
   if (cached) {
@@ -2127,53 +2184,53 @@ function resolveInjection(fn) {
   return items;
 }
 function extractParamsWithAst(fnStr) {
-  const sourceFile = ts7.createSourceFile(
+  const sourceFile = ts8.createSourceFile(
     "__faapi_injection__.ts",
     fnStr,
-    ts7.ScriptTarget.Latest,
+    ts8.ScriptTarget.Latest,
     true
   );
   const paramNames = [];
   function visit(node) {
-    if (ts7.isFunctionDeclaration(node) && node.parameters.length > 0) {
+    if (ts8.isFunctionDeclaration(node) && node.parameters.length > 0) {
       for (const param of node.parameters) {
         extractParamName(param, paramNames);
       }
       return;
     }
-    if ((ts7.isArrowFunction(node) || ts7.isFunctionExpression(node)) && node.parameters.length > 0) {
+    if ((ts8.isArrowFunction(node) || ts8.isFunctionExpression(node)) && node.parameters.length > 0) {
       for (const param of node.parameters) {
         extractParamName(param, paramNames);
       }
       return;
     }
-    ts7.forEachChild(node, visit);
+    ts8.forEachChild(node, visit);
   }
   visit(sourceFile);
   return paramNames.map((name) => ({ name }));
 }
 function extractParamName(param, names) {
   const name = param.name;
-  if (ts7.isIdentifier(name)) {
+  if (ts8.isIdentifier(name)) {
     names.push(name.text);
     return;
   }
-  if (ts7.isObjectBindingPattern(name)) {
+  if (ts8.isObjectBindingPattern(name)) {
     for (const element of name.elements) {
-      if (ts7.isBindingElement(element)) {
+      if (ts8.isBindingElement(element)) {
         const elemName = element.name;
-        if (ts7.isIdentifier(elemName)) {
+        if (ts8.isIdentifier(elemName)) {
           names.push(elemName.text);
         }
       }
     }
     return;
   }
-  if (ts7.isArrayBindingPattern(name)) {
+  if (ts8.isArrayBindingPattern(name)) {
     for (const element of name.elements) {
-      if (element && ts7.isBindingElement(element)) {
+      if (element && ts8.isBindingElement(element)) {
         const elemName = element.name;
-        if (ts7.isIdentifier(elemName)) {
+        if (ts8.isIdentifier(elemName)) {
           names.push(elemName.text);
         }
       }
@@ -2209,11 +2266,11 @@ var init_resolveInjection = __esm({
 });
 
 // src/injection/analyzeInjection.ts
-import ts8 from "typescript";
+import ts9 from "typescript";
 function analyzeInjectionInSourceFile(sourceFile, functionName) {
   const params = [];
-  ts8.forEachChild(sourceFile, (node) => {
-    if (ts8.isFunctionDeclaration(node) && node.name?.text === functionName) {
+  ts9.forEachChild(sourceFile, (node) => {
+    if (ts9.isFunctionDeclaration(node) && node.name?.text === functionName) {
       for (const param of node.parameters) {
         const paramMeta = analyzeParam(param, sourceFile);
         params.push(paramMeta);
@@ -2227,9 +2284,9 @@ function analyzeParam(param, sourceFile) {
   const type = PARAM_TYPE_MAP[name] || "unknown";
   const result = { name, type };
   if (param.type) {
-    if (ts8.isTypeReferenceNode(param.type)) {
+    if (ts9.isTypeReferenceNode(param.type)) {
       result.typeName = param.type.typeName.getText(sourceFile);
-    } else if (ts8.isTypeLiteralNode(param.type)) {
+    } else if (ts9.isTypeLiteralNode(param.type)) {
       result.schema = extractSchema(param.type, sourceFile);
     }
   }
@@ -2238,7 +2295,7 @@ function analyzeParam(param, sourceFile) {
 function extractSchema(typeNode, sourceFile) {
   const schema = [];
   for (const member of typeNode.members) {
-    if (ts8.isPropertySignature(member) && member.name && ts8.isIdentifier(member.name)) {
+    if (ts9.isPropertySignature(member) && member.name && ts9.isIdentifier(member.name)) {
       const propName = member.name.text;
       const optional = !!member.questionToken;
       const propType = member.type?.getText(sourceFile) || "unknown";
@@ -3005,7 +3062,7 @@ var init_scanAgents = __esm({
 });
 
 // src/ast/extractAgentMetadata.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 function extractAgentMetadata(program, filePath, pathMeta) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return null;
@@ -3014,7 +3071,7 @@ function extractAgentMetadata(program, filePath, pathMeta) {
     throw SchemaExtractionError.at(
       sourceFile,
       "config.systemPrompt",
-      "agent \u5FC5\u586B\u2014\u2014\u8BF7\u5728 config \u5757\u58F0\u660E\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF08\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u6216\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\uFF09",
+      "agent \u5FC5\u586B\u2014\u2014\u8BF7\u5728 config \u5757\u58F0\u660E\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF08\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u3001\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\u6216\u5176 + \u62FC\u63A5\uFF09",
       sourceFile
     );
   }
@@ -3048,23 +3105,23 @@ function extractAgentMetadata(program, filePath, pathMeta) {
 }
 function findConfigExport(sourceFile) {
   let result = null;
-  ts9.forEachChild(sourceFile, (node) => {
+  ts10.forEachChild(sourceFile, (node) => {
     if (result) return;
-    if (ts9.isVariableStatement(node) && hasExportModifier(node)) {
+    if (ts10.isVariableStatement(node) && hasExportModifier(node)) {
       for (const decl of node.declarationList.declarations) {
         if (result) break;
-        const nameText = ts9.isIdentifier(decl.name) ? decl.name.text : "";
+        const nameText = ts10.isIdentifier(decl.name) ? decl.name.text : "";
         if (nameText !== "config" || !decl.initializer) continue;
-        if (ts9.isObjectLiteralExpression(decl.initializer)) {
+        if (ts10.isObjectLiteralExpression(decl.initializer)) {
           result = { jsDocOwner: node, objectLiteral: decl.initializer };
-        } else if (ts9.isArrowFunction(decl.initializer)) {
+        } else if (ts10.isArrowFunction(decl.initializer)) {
           result = { jsDocOwner: node, objectLiteral: getReturnObjectLiteral(decl.initializer) };
         } else {
           result = { jsDocOwner: node, objectLiteral: null };
         }
       }
     }
-    if (ts9.isFunctionDeclaration(node) && hasExportModifier(node) && node.name?.text === "config") {
+    if (ts10.isFunctionDeclaration(node) && hasExportModifier(node) && node.name?.text === "config") {
       const returnObj = getReturnObjectLiteral(node);
       result = { jsDocOwner: node, objectLiteral: returnObj };
     }
@@ -3074,12 +3131,12 @@ function findConfigExport(sourceFile) {
 function getReturnObjectLiteral(fn) {
   const body = fn.body;
   if (!body) return null;
-  if (ts9.isObjectLiteralExpression(body)) {
+  if (ts10.isObjectLiteralExpression(body)) {
     return body;
   }
-  if (ts9.isBlock(body)) {
+  if (ts10.isBlock(body)) {
     for (const stmt of body.statements) {
-      if (ts9.isReturnStatement(stmt) && stmt.expression && ts9.isObjectLiteralExpression(stmt.expression)) {
+      if (ts10.isReturnStatement(stmt) && stmt.expression && ts10.isObjectLiteralExpression(stmt.expression)) {
         return stmt.expression;
       }
     }
@@ -3093,8 +3150,8 @@ function extractConfigFields(objLit, sourceFile) {
   let model;
   let maxTurns;
   for (const prop of objLit.properties) {
-    if (ts9.isSpreadAssignment(prop)) continue;
-    if (!ts9.isPropertyAssignment(prop)) {
+    if (ts10.isSpreadAssignment(prop)) continue;
+    if (!ts10.isPropertyAssignment(prop)) {
       throw SchemaExtractionError.at(
         prop,
         "config",
@@ -3135,19 +3192,26 @@ function extractConfigFields(objLit, sourceFile) {
     throw SchemaExtractionError.at(
       objLit,
       "config.systemPrompt",
-      "agent \u5FC5\u586B\u2014\u2014\u8BF7\u5728 config \u5757\u58F0\u660E\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF08\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u6216\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\uFF09",
+      "agent \u5FC5\u586B\u2014\u2014\u8BF7\u5728 config \u5757\u58F0\u660E\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF08\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u3001\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\u6216\u5176 + \u62FC\u63A5\uFF09",
       sourceFile
     );
   }
   return { systemPrompt, tools, agents, model, maxTurns };
 }
 function getPropertyName(name) {
-  if (ts9.isIdentifier(name)) return name.text;
-  if (ts9.isStringLiteral(name)) return name.text;
+  if (ts10.isIdentifier(name)) return name.text;
+  if (ts10.isStringLiteral(name)) return name.text;
   return null;
 }
 function extractStringValue(expr) {
   if (isStringLikeLiteral(expr)) return expr.text;
+  if (ts10.isBinaryExpression(expr) && expr.operatorToken.kind === ts10.SyntaxKind.PlusToken) {
+    const left = extractStringValue(expr.left);
+    if (left === void 0) return void 0;
+    const right = extractStringValue(expr.right);
+    if (right === void 0) return void 0;
+    return left + right;
+  }
   return void 0;
 }
 function requireStringValue(prop, fieldName, sourceFile) {
@@ -3156,7 +3220,7 @@ function requireStringValue(prop, fieldName, sourceFile) {
     throw SchemaExtractionError.at(
       prop.initializer,
       `config.${fieldName}`,
-      "\u4EC5\u652F\u6301\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u6216\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\uFF08\u542B\u63D2\u503C\u7684\u6A21\u677F\u5B57\u7B26\u4E32/\u53D8\u91CF\u5F15\u7528\u65E0\u6CD5\u9759\u6001\u6C42\u503C\uFF09",
+      "\u4EC5\u652F\u6301\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u3001\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\u6216\u5176 + \u62FC\u63A5\uFF08\u542B\u63D2\u503C\u7684\u6A21\u677F\u5B57\u7B26\u4E32/\u53D8\u91CF\u5F15\u7528/\u6570\u5B57\u65E0\u6CD5\u9759\u6001\u6C42\u503C\u4E3A\u5B57\u7B26\u4E32\uFF09",
       sourceFile
     );
   }
@@ -3168,7 +3232,7 @@ function requireStringArrayValue(prop, fieldName, sourceFile) {
     throw SchemaExtractionError.at(
       prop.initializer,
       `config.${fieldName}`,
-      "\u4EC5\u652F\u6301\u5168\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u6570\u7EC4\uFF08\u5143\u7D20\u4E3A\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u6216\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\uFF09",
+      "\u4EC5\u652F\u6301\u5168\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u6570\u7EC4\uFF08\u5143\u7D20\u4E3A\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u3001\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\u6216\u5176 + \u62FC\u63A5\uFF09",
       sourceFile
     );
   }
@@ -3187,21 +3251,22 @@ function requireNumberValue(prop, fieldName, sourceFile) {
   return value;
 }
 function extractNumberValue(expr) {
-  if (ts9.isNumericLiteral(expr)) {
+  if (ts10.isNumericLiteral(expr)) {
     const num = Number(expr.text);
     return Number.isNaN(num) ? void 0 : num;
   }
   return void 0;
 }
 function isStringLikeLiteral(node) {
-  return ts9.isStringLiteral(node) || ts9.isNoSubstitutionTemplateLiteral(node);
+  return ts10.isStringLiteral(node) || ts10.isNoSubstitutionTemplateLiteral(node);
 }
 function extractStringArrayValue(expr) {
-  if (!ts9.isArrayLiteralExpression(expr)) return void 0;
+  if (!ts10.isArrayLiteralExpression(expr)) return void 0;
   const values = [];
   for (const element of expr.elements) {
-    if (!isStringLikeLiteral(element)) return void 0;
-    values.push(element.text);
+    const value = extractStringValue(element);
+    if (value === void 0) return void 0;
+    values.push(value);
   }
   return values;
 }