@easynet/agent-tool 1.0.1 → 1.0.2

package/dist/{chunk-BM4EVYI5.js → chunk-PJ4RUBZL.js}

@@ -1,14 +1,15 @@
+import { DEFAULT_OUTPUT_SCHEMA } from './chunk-5SWSNVMI.js';
+import { LANGCHAIN_DIR_NAME, LANGCHAIN_KIND, MCP_KIND } from './chunk-Q7KPGWC6.js';
 import * as fs3 from 'fs/promises';
-import { readdir, readFile } from 'fs/promises';
-import * as path5 from 'path';
+import { readdir, readFile, access, stat } from 'fs/promises';
+import * as path9 from 'path';
 import { join, extname, relative, basename } from 'path';
 import * as fs2 from 'fs';
 import * as ts2 from 'typescript';
 import yaml from 'js-yaml';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { spawn } from 'child_process';
 
-// src/codegen/init.ts
 var TEMPLATES = {
   "package.json": `{
   "name": "my-mcp-tools",
@@ -92,12 +93,12 @@ Edit \`src/tools/*.ts\` (add \`@tool\` JSDoc) and/or \`skills/*/SKILL.md\`, then
 `
 };
 async function initProject(options = {}) {
-  const targetPath = path5.resolve(options.targetPath ?? process.cwd());
+  const targetPath = path9.resolve(options.targetPath ?? process.cwd());
   const filesCreated = [];
   await fs3.mkdir(targetPath, { recursive: true });
   for (const [relPath, content] of Object.entries(TEMPLATES)) {
-    const fullPath = path5.join(targetPath, relPath);
-    await fs3.mkdir(path5.dirname(fullPath), { recursive: true });
+    const fullPath = path9.join(targetPath, relPath);
+    await fs3.mkdir(path9.dirname(fullPath), { recursive: true });
     try {
       await fs3.access(fullPath);
       if (relPath === "package.json") continue;
@@ -113,7 +114,7 @@ async function findDirsContainingFile(rootPath, fileName) {
   await collectDirsWithFile(rootPath, fileName, found);
   return found;
 }
-async function collectDirsWithFile(dir, fileName, found) {
+async function collectDirsWithFile(dir, fileName, acc) {
   let entries;
   try {
     const e = await readdir(dir, { withFileTypes: true });
@@ -125,22 +126,16 @@ async function collectDirsWithFile(dir, fileName, found) {
   } catch {
     return;
   }
-  if (entries.some((x) => x.isFile && x.name === fileName)) {
-    found.push(dir);
-  }
+  if (entries.some((x) => x.isFile && x.name === fileName)) acc.push(dir);
   for (const entry of entries) {
-    if (!entry.isDirectory || entry.name === "node_modules" || entry.name.startsWith(".")) {
-      continue;
-    }
-    await collectDirsWithFile(join(dir, entry.name), fileName, found);
+    if (!entry.isDirectory || entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+    await collectDirsWithFile(join(dir, entry.name), fileName, acc);
   }
 }
 function pathToToolName(sourcePath, programName) {
   const normalized = sourcePath.replace(/\\/g, "/").replace(/\.(ts|tsx|js|mjs|json)$/i, "");
   const segments = normalized.split("/").filter(Boolean);
-  if (segments.length === 0) return programName;
-  const pathPart = segments.join(".");
-  return `${pathPart}.${programName}`;
+  return segments.length === 0 ? programName : `${segments.join(".")}.${programName}`;
 }
 function buildOutputSchemaFromReturnType(node, typeChecker, onWarn) {
   const sig = typeChecker.getSignatureFromDeclaration(node);
@@ -235,19 +230,60 @@ function typeToJsonSchema(type, typeChecker, onWarn) {
   return { type: "object" };
 }
 
-// src/codegen/scan/scanner.ts
+// src/tools/function/types.ts
+var FUNCTION_KIND = "function";
+
+// src/tools/skill/types.ts
+var SKILL_KIND = "skill";
+var SKILL_DIR_NAME = "skill";
+
+// src/tools/n8n/types.ts
+var N8N_KIND = "n8n";
+
+// src/tools/mcp/mcpSpecToToolSpec.ts
+var DEFAULT_OUTPUT = { type: "object", additionalProperties: true };
+function mcpSpecToToolSpec(spec, projectPath) {
+  const base = {
+    name: spec.name,
+    version: "1.0.0",
+    kind: spec.kind,
+    description: spec.description,
+    inputSchema: spec.inputSchema ?? DEFAULT_OUTPUT,
+    outputSchema: "outputSchema" in spec && spec.outputSchema ? spec.outputSchema : DEFAULT_OUTPUT_SCHEMA,
+    capabilities: [],
+    _meta: spec._meta,
+    ...spec.kind === N8N_KIND && "webhookUrl" in spec && spec.webhookUrl ? { endpoint: spec.webhookUrl } : {}
+  };
+  if (spec.kind === FUNCTION_KIND && "sourcePath" in spec && "exportName" in spec) {
+    base._meta = {
+      ...base._meta,
+      sourcePath: spec.sourcePath,
+      exportName: spec.exportName,
+      ...projectPath && { projectPath }
+    };
+  }
+  if (spec.kind === SKILL_KIND && "sourcePath" in spec && projectPath) {
+    base._meta = { ...base._meta, sourcePath: spec.sourcePath, projectPath };
+  }
+  if (spec.kind === N8N_KIND && "sourcePath" in spec && projectPath) {
+    base._meta = { ...base._meta, sourcePath: spec.sourcePath, projectPath };
+  }
+  return base;
+}
+
+// src/tools/function/scanner.ts
 var TOOL_TAG = "@tool";
 var EFFECT_VALUES = ["none", "local_write", "external_write", "destructive"];
 function scanForTools(options) {
-  const projectPath = path5.resolve(options.projectPath);
-  const tsconfigPath = options.tsconfigPath ?? path5.join(projectPath, "tsconfig.json");
+  const projectPath = path9.resolve(options.projectPath);
+  const tsconfigPath = options.tsconfigPath ?? path9.join(projectPath, "tsconfig.json");
   const include = options.include ?? ["**/*.ts"];
   const errors = [];
   const warnings = [];
   let config;
-  let configPathResolved = path5.resolve(projectPath, tsconfigPath);
+  let configPathResolved = path9.resolve(projectPath, tsconfigPath);
   if (!fs2.existsSync(configPathResolved)) {
-    configPathResolved = path5.join(projectPath, "tsconfig.json");
+    configPathResolved = path9.join(projectPath, "tsconfig.json");
   }
   if (fs2.existsSync(configPathResolved)) {
     const configFile = ts2.readConfigFile(configPathResolved, ts2.sys.readFile);
@@ -258,7 +294,7 @@ function scanForTools(options) {
     const parsed = ts2.parseJsonConfigFileContent(
       configFile.config,
       ts2.sys,
-      path5.dirname(configPathResolved)
+      path9.dirname(configPathResolved)
     );
     if (parsed.errors.length) {
       for (const e of parsed.errors) {
@@ -287,7 +323,7 @@ function scanForTools(options) {
   for (const sourceFile of program.getSourceFiles()) {
     const fileName = sourceFile.fileName;
     if (fileName.includes("node_modules") || fileName.endsWith(".d.ts")) continue;
-    if (!config.fileNames.some((f) => path5.resolve(f) === path5.resolve(fileName))) continue;
+    if (!config.fileNames.some((f) => path9.resolve(f) === path9.resolve(fileName))) continue;
     ts2.forEachChild(sourceFile, (node) => {
       const decl = getExportedFunctionDeclaration(node);
       if (!decl) return;
@@ -306,10 +342,10 @@ function scanForTools(options) {
       const { schema } = buildInputSchemaFromParams(func, typeChecker, onWarn);
       const inputSchema = Object.keys(schema.properties ?? {}).length > 0 ? schema : { type: "object", properties: {} };
       const outputSchema = buildOutputSchemaFromReturnType(func, typeChecker, onWarn);
-      const sourcePath = path5.relative(projectPath, fileName) || path5.basename(fileName);
+      const sourcePath = path9.relative(projectPath, fileName) || path9.basename(fileName);
       const toolName = pathToToolName(sourcePath, name);
       specs.push({
-        kind: "function",
+        kind: FUNCTION_KIND,
         name: toolName,
         description: description || humanize(name),
         inputSchema,
@@ -326,20 +362,20 @@ function resolveGlob(projectPath, patterns) {
   const result = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (f) => {
-    const abs = path5.resolve(f);
+    const abs = path9.resolve(f);
     if (f.endsWith(".ts") && !f.endsWith(".d.ts") && !seen.has(abs)) {
       seen.add(abs);
       result.push(abs);
     }
   };
   for (const p of patterns) {
-    const full = path5.join(projectPath, p);
+    const full = path9.join(projectPath, p);
     if (full.includes("*")) {
       const baseDir = full.replace(/\*\*\/.*$/, "").replace(/\*.*$/, "").replace(/\/?$/, "") || ".";
-      const dir = path5.resolve(projectPath, baseDir);
+      const dir = path9.resolve(projectPath, baseDir);
       if (fs2.existsSync(dir)) walk(dir, add);
     } else {
-      const resolved = path5.resolve(projectPath, full);
+      const resolved = path9.resolve(projectPath, full);
       if (fs2.existsSync(resolved)) {
         if (fs2.statSync(resolved).isFile()) add(resolved);
         else walk(resolved, add);
@@ -347,14 +383,14 @@ function resolveGlob(projectPath, patterns) {
     }
   }
   if (result.length > 0) return result;
-  const srcDir = path5.join(projectPath, "src");
+  const srcDir = path9.join(projectPath, "src");
   if (fs2.existsSync(srcDir)) return walkCollect(srcDir);
   return [];
 }
 function walkCollect(dir) {
   const out = [];
   walk(dir, (fullPath) => {
-    if (fullPath.endsWith(".ts") && !fullPath.endsWith(".d.ts")) out.push(path5.resolve(fullPath));
+    if (fullPath.endsWith(".ts") && !fullPath.endsWith(".d.ts")) out.push(path9.resolve(fullPath));
   });
   return out;
 }
@@ -363,7 +399,7 @@ function walk(dir, visit) {
   try {
     const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const e of entries) {
-      const full = path5.join(dir, e.name);
+      const full = path9.join(dir, e.name);
       if (e.isDirectory() && !SKIP_DIRS.has(e.name)) walk(full, visit);
       else if (e.isFile()) visit(full);
     }
@@ -463,12 +499,26 @@ function getEffect(host) {
 function humanize(name) {
   return name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
 }
+function scan(projectPath, options = {}) {
+  const root = path9.resolve(projectPath);
+  const result = scanForTools({
+    projectPath: root,
+    include: options.include ?? ["**/*.ts"],
+    tsconfigPath: options.tsconfigPath
+  });
+  const specs = result.specs.map((s) => mcpSpecToToolSpec(s, root));
+  return Promise.resolve({
+    specs,
+    errors: result.errors,
+    warnings: result.warnings
+  });
+}
 
-// src/discovery/load/SkillManifest.ts
+// src/tools/skill/SkillManifest.ts
 var SkillManifestError = class extends Error {
-  constructor(path8, field, message) {
-    super(`SKILL.md error in ${path8}: ${message}`);
-    this.path = path8;
+  constructor(path12, field, message) {
+    super(`SKILL.md error in ${path12}: ${message}`);
+    this.path = path12;
     this.field = field;
     this.name = "SkillManifestError";
   }
@@ -722,36 +772,38 @@ async function loadSkillDefinition(dirPath) {
     skillMdPath
   };
 }
-
-// src/discovery/errors.ts
-var DiscoveryError = class extends Error {
-  /** Absolute path to the tool directory that caused the error */
-  toolDir;
-  /** Phase in which the error occurred */
-  phase;
-  /** The underlying cause */
-  cause;
-  constructor(toolDir, phase, message, cause) {
-    super(`[${phase}] ${toolDir}: ${message}`);
-    this.name = "DiscoveryError";
-    this.toolDir = toolDir;
-    this.phase = phase;
-    this.cause = cause;
+var DEFAULT_EXTENSIONS = [".js", ".mjs"];
+async function resolveEntryPoint(dirPath, baseName, extensions = DEFAULT_EXTENSIONS) {
+  if (extensions.some((ext) => baseName.endsWith(ext))) {
+    const fullPath = join(dirPath, baseName);
+    await stat(fullPath);
+    return fullPath;
   }
-};
+  for (const ext of extensions) {
+    const fullPath = join(dirPath, `${baseName}${ext}`);
+    try {
+      await stat(fullPath);
+      return fullPath;
+    } catch {
+    }
+  }
+  throw new Error(
+    `Could not find entry point in ${dirPath}. Tried: ${extensions.map((e) => baseName + e).join(", ")}`
+  );
+}
 var defaultInputSchema = { type: "object", properties: {}, additionalProperties: true };
 async function scanForSkill(projectPath) {
-  const projectRoot = path5.resolve(projectPath);
+  const projectRoot = path9.resolve(projectPath);
   const dirs = await findDirsContainingFile(projectRoot, "SKILL.md");
   const skills = [];
   const errors = [];
   for (const dirPath of dirs) {
-    const relativePath = path5.relative(projectRoot, dirPath) || path5.basename(dirPath);
+    const relativePath = path9.relative(projectRoot, dirPath) || path9.basename(dirPath);
     try {
       const skillDef = await loadSkillDefinition(dirPath);
       const name = pathToToolName(relativePath, skillDef.frontmatter.name);
       skills.push({
-        kind: "skill",
+        kind: SKILL_KIND,
         name,
         description: skillDef.frontmatter.description,
         inputSchema: defaultInputSchema,
@@ -764,6 +816,15 @@ async function scanForSkill(projectPath) {
   }
   return { skills, errors };
 }
+async function scan2(projectPath, _options = {}) {
+  const root = path9.resolve(projectPath);
+  const result = await scanForSkill(root);
+  const specs = result.skills.map((s) => mcpSpecToToolSpec(s, root));
+  return {
+    specs,
+    errors: result.errors.map((e) => ({ file: e.dir, message: e.message }))
+  };
+}
 async function readWorkflowMeta(dirPath, workflowFileName = "workflow.json") {
   const workflowPath = join(dirPath, workflowFileName);
   let raw;
@@ -822,20 +883,20 @@ async function loadN8nTool(dirPath, manifest) {
   return { manifest, dirPath, workflowDef };
 }
 
-// src/codegen/scan/scanN8n.ts
+// src/tools/n8n/scanN8n.ts
 var defaultInputSchema2 = { type: "object", properties: {}, additionalProperties: true };
 async function scanForN8n(projectPath) {
-  const projectRoot = path5.resolve(projectPath);
+  const projectRoot = path9.resolve(projectPath);
   const dirs = await findDirsContainingFile(projectRoot, "workflow.json");
   const n8n = [];
   const errors = [];
   for (const dirPath of dirs) {
-    const relativePath = path5.relative(projectRoot, dirPath) || path5.basename(dirPath);
+    const relativePath = path9.relative(projectRoot, dirPath) || path9.basename(dirPath);
     try {
       const { name: wfName, description: wfDesc, webhookUrl } = await readWorkflowMeta(dirPath);
       const toolName = pathToToolName(relativePath, wfName);
       n8n.push({
-        kind: "n8n",
+        kind: N8N_KIND,
         name: toolName,
         description: wfDesc,
         inputSchema: defaultInputSchema2,
@@ -849,38 +910,683 @@ async function scanForN8n(projectPath) {
   }
   return { n8n, errors };
 }
+async function scan3(projectPath, _options = {}) {
+  const root = path9.resolve(projectPath);
+  const result = await scanForN8n(root);
+  const specs = result.n8n.map((s) => mcpSpecToToolSpec(s, root));
+  return {
+    specs,
+    errors: result.errors.map((e) => ({ file: e.dir, message: e.message }))
+  };
+}
+async function scan4(projectPath, options = {}) {
+  const root = path9.resolve(projectPath);
+  const namespace = options.namespace ?? "dir";
+  const errors = [];
+  const scanner = new DirectoryScanner({
+    roots: [root],
+    namespace,
+    extensions: options.extensions,
+    onError: (dir, err) => {
+      errors.push({ file: dir, message: err.message });
+      options.onError?.(dir, err);
+    }
+  });
+  let specs;
+  try {
+    specs = await scanner.scan();
+  } catch (err) {
+    errors.push({
+      file: root,
+      message: err instanceof Error ? err.message : String(err)
+    });
+    return { specs: [], errors };
+  }
+  const filtered = specs.filter((s) => s.kind === MCP_KIND);
+  return { specs: filtered, errors };
+}
+async function scan5(projectPath, options = {}) {
+  const root = path9.resolve(projectPath);
+  const namespace = options.namespace ?? "dir";
+  const errors = [];
+  const scanner = new DirectoryScanner({
+    roots: [root],
+    namespace,
+    extensions: options.extensions,
+    onError: (dir, err) => {
+      errors.push({ file: dir, message: err.message });
+      options.onError?.(dir, err);
+    }
+  });
+  let specs;
+  try {
+    specs = await scanner.scan();
+  } catch (err) {
+    errors.push({
+      file: root,
+      message: err instanceof Error ? err.message : String(err)
+    });
+    return { specs: [], errors };
+  }
+  const filtered = specs.filter((s) => s.kind === LANGCHAIN_KIND);
+  return { specs: filtered, errors };
+}
+async function loadLangChainTool(dirPath, manifest, extensions) {
+  let entryFile;
+  try {
+    entryFile = await resolveEntryPoint(
+      dirPath,
+      manifest.entryPoint ?? "index",
+      extensions
+    );
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Cannot find LangChain entry point`,
+      err
+    );
+  }
+  let mod;
+  try {
+    mod = await import(pathToFileURL(entryFile).href);
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to import ${entryFile}`,
+      err
+    );
+  }
+  const tool = mod.default ?? mod.tool ?? mod;
+  if (!tool || typeof tool.invoke !== "function") {
+    throw new DiscoveryError(
+      dirPath,
+      "validate",
+      `Entry point must export an object with invoke() method (LangChainToolLike)`
+    );
+  }
+  return { manifest, dirPath, impl: tool };
+}
+var DEFAULT_EXTENSIONS2 = [".js", ".mjs"];
+async function listSkillProgramFiles(dirPath, extensions = DEFAULT_EXTENSIONS2) {
+  let entries;
+  try {
+    const dirEntries = await readdir(dirPath, { withFileTypes: true });
+    entries = dirEntries.map((entry) => ({
+      name: entry.name,
+      isFile: entry.isFile()
+    }));
+  } catch {
+    return [];
+  }
+  return entries.filter((e) => e.isFile).map((e) => e.name).filter((name) => {
+    if (name.startsWith(".") || name.startsWith("_")) return false;
+    if (name.includes(".test.") || name.includes(".spec.")) return false;
+    return extensions.some((ext) => name.endsWith(ext));
+  }).sort((a, b) => {
+    if (a === "handler.js" || a === "index.js") return -1;
+    if (b === "handler.js" || b === "index.js") return 1;
+    return a.localeCompare(b);
+  });
+}
+function isLangChainLikeTool(val) {
+  return val != null && typeof val === "object" && "invoke" in val && typeof val.invoke === "function";
+}
+function isConstructable(val) {
+  return typeof val === "function" && typeof val.prototype === "object";
+}
+async function loadOneSkillProgram(dirPath, manifest, entryFile, skillDef, programKey, extensions) {
+  let impl;
+  try {
+    const fullPath = await resolveEntryPoint(dirPath, entryFile, extensions ?? [".js", ".mjs"]);
+    const mod = await import(pathToFileURL(fullPath).href);
+    const fn = mod.default ?? mod.handler ?? mod.Tool;
+    if (isLangChainLikeTool(fn)) {
+      impl = fn;
+    } else if (isConstructable(fn)) {
+      const instance = new fn();
+      if (isLangChainLikeTool(instance)) impl = instance;
+    } else if (typeof fn === "function") {
+      impl = fn;
+    }
+  } catch {
+  }
+  return {
+    manifest,
+    dirPath,
+    impl,
+    skillDefinition: skillDef,
+    programKey
+  };
+}
+async function loadSkillTools(dirPath, manifest, extensions) {
+  let skillDef;
+  try {
+    skillDef = await loadSkillDefinition(dirPath);
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to parse SKILL.md: ${err.message}`,
+      err
+    );
+  }
+  const programs = manifest.programs;
+  if (programs && typeof programs === "object" && Object.keys(programs).length > 0) {
+    const result = [];
+    for (const [programKey, entryFile2] of Object.entries(programs)) {
+      const loaded2 = await loadOneSkillProgram(
+        dirPath,
+        manifest,
+        entryFile2,
+        skillDef,
+        programKey,
+        extensions
+      );
+      result.push(loaded2);
+    }
+    return result;
+  }
+  const exts = extensions ?? DEFAULT_EXTENSIONS2;
+  const files = await listSkillProgramFiles(dirPath, exts);
+  if (files.length >= 2) {
+    const result = [];
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const programKey = i === 0 ? "default" : file.replace(/\.[^.]+$/, "");
+      const loaded2 = await loadOneSkillProgram(
+        dirPath,
+        manifest,
+        file,
+        skillDef,
+        programKey,
+        extensions
+      );
+      result.push(loaded2);
+    }
+    return result;
+  }
+  const entryFile = manifest.entryPoint ?? files[0] ?? "handler";
+  const loaded = await loadOneSkillProgram(
+    dirPath,
+    manifest,
+    entryFile,
+    skillDef,
+    void 0,
+    extensions
+  );
+  return [loaded];
+}
+async function listLangchainEntryFiles(dirPath, extensions) {
+  let entries;
+  try {
+    const dirEntries = await readdir(dirPath, { withFileTypes: true });
+    entries = dirEntries.map((entry) => ({
+      name: entry.name,
+      isFile: entry.isFile()
+    }));
+  } catch {
+    return [];
+  }
+  return entries.filter((e) => e.isFile).map((e) => e.name).filter((name) => {
+    if (name.startsWith(".") || name.startsWith("_")) return false;
+    if (name.endsWith(".d.ts")) return false;
+    if (name.includes(".test.") || name.includes(".spec.")) return false;
+    return extensions.some((ext) => name.endsWith(ext));
+  });
+}
+async function loadLangChainToolsFromDir(dirPath, dirName, manifest, strict, namespace, extensions, langchainDirName, toSpec, onError) {
+  const entryFiles = await listLangchainEntryFiles(dirPath, extensions);
+  if (entryFiles.length === 0) {
+    if (strict) {
+      throw new DiscoveryError(dirPath, "load", "No LangChain entry files found");
+    }
+    return [];
+  }
+  const specs = [];
+  const useDirNameForSingle = dirName !== langchainDirName;
+  for (const entryFile of entryFiles) {
+    const fileManifest = { ...manifest, entryPoint: entryFile };
+    try {
+      const loaded = await loadLangChainTool(dirPath, fileManifest, extensions);
+      const fileBase = basename(entryFile).replace(/\.[^.]+$/, "");
+      const nameHint = entryFiles.length === 1 && useDirNameForSingle ? dirName : fileBase;
+      specs.push(toSpec(loaded, nameHint, dirPath, namespace));
+    } catch (error) {
+      const err = error;
+      if (err instanceof DiscoveryError && err.phase === "validate") {
+        if (strict) throw err;
+        continue;
+      }
+      onError?.(join(dirPath, entryFile), err);
+      if (strict) throw err;
+    }
+  }
+  return specs;
+}
+
+// src/tools/mcp/directoryApply.ts
+function applyLoadedToSpec(spec, loaded, _manifest, _defaultDirName, _namespace) {
+  if (loaded.mcpConfig?.url) spec.endpoint = loaded.mcpConfig.url;
+  spec.impl = loaded.mcpConfig;
+}
+var directoryMarker = {
+  kind: "mcp",
+  markerFile: "mcp.json",
+  defaultEntryPoint: "mcp.json"
+};
+
+// src/tools/langchain/directoryApply.ts
+function applyLoadedToSpec2(spec, loaded, manifest, _defaultDirName, namespace) {
+  spec.impl = loaded.impl;
+  if (!manifest.name && loaded.impl) {
+    const toolName = loaded.impl.name;
+    if (toolName) spec.name = `${namespace}/${toolName}`;
+  }
+  if (!manifest.description && loaded.impl) {
+    const d = loaded.impl.description;
+    if (d) spec.description = d;
+  }
+  if (!manifest.inputSchema && loaded.impl) {
+    const schema = loaded.impl.schema;
+    if (schema) spec.inputSchema = schema;
+  }
+}
+
+// src/tools/skill/directoryApply.ts
+function applyLoadedToSpec3(spec, loaded, manifest, defaultDirName, namespace) {
+  const skillDef = loaded.skillDefinition;
+  if (skillDef) {
+    spec.name = manifest.name ?? skillDef.frontmatter.name;
+    spec.description = skillDef.frontmatter.description;
+    if (loaded.programKey === "default") {
+      spec.name = `${namespace}/${defaultDirName}`;
+    } else if (loaded.programKey) {
+      spec.name = `${namespace}/${defaultDirName}/${loaded.programKey}`;
+    }
+    const impl = loaded.impl;
+    if (impl && typeof impl === "object" && typeof impl.invoke === "function") {
+      if (impl.description != null && impl.description !== "")
+        spec.description = impl.description;
+      if (impl.schema != null && typeof impl.schema === "object")
+        spec.inputSchema = impl.schema;
+    }
+    spec.impl = { ...skillDef, handler: loaded.impl };
+  } else {
+    spec.impl = loaded.impl;
+  }
+}
+var directoryMarker2 = {
+  kind: "skill",
+  markerFile: "SKILL.md",
+  defaultEntryPoint: "handler"
+};
+
+// src/tools/n8n/directoryApply.ts
+function applyLoadedToSpec4(spec, loaded, manifest, _defaultDirName, _namespace) {
+  const workflow = loaded.workflowDef;
+  if (workflow?.id) spec.resourceId = String(workflow.id);
+  if (!manifest.description && workflow) {
+    const d = workflow.description ?? workflow.meta?.description ?? (typeof workflow.name === "string" ? workflow.name : void 0);
+    if (d) spec.description = d;
+  }
+  spec.impl = loaded.workflowDef;
+}
+var directoryMarker3 = {
+  kind: "n8n",
+  markerFile: "workflow.json",
+  defaultEntryPoint: "workflow.json"
+};
 
-// src/codegen/scan/scanTools.ts
+// src/tools/discoveryFactory.ts
+var DiscoveryError = class extends Error {
+  toolDir;
+  phase;
+  cause;
+  constructor(toolDir, phase, message, cause) {
+    super(`[${phase}] ${toolDir}: ${message}`);
+    this.name = "DiscoveryError";
+    this.toolDir = toolDir;
+    this.phase = phase;
+    this.cause = cause;
+  }
+};
+var DIRECTORY_KINDS = ["mcp", "langchain", "skill", "n8n"];
+var DIRECTORY_DISCOVERABLE_KINDS = DIRECTORY_KINDS;
+var DIRECTORY_KIND_MARKERS = [
+  directoryMarker2,
+  directoryMarker3,
+  directoryMarker
+];
+var DIRECTORY_LOADERS = {
+  mcp: async (dirPath, manifest) => [await loadMCPTool(dirPath, manifest)],
+  langchain: async (dirPath, manifest, ext) => [await loadLangChainTool(dirPath, manifest, ext)],
+  skill: (dirPath, manifest, ext) => loadSkillTools(dirPath, manifest, ext),
+  n8n: async (dirPath, manifest) => [await loadN8nTool(dirPath, manifest)]
+};
+function getDirectoryLoader(kind) {
+  const loader = DIRECTORY_LOADERS[kind];
+  if (!loader) {
+    throw new DiscoveryError("", "manifest", `Unknown directory tool kind: "${kind}"`);
+  }
+  return loader;
+}
+function applyDirectoryLoadedToSpec(spec, loaded, manifest, defaultDirName, namespace) {
+  switch (manifest.kind) {
+    case "mcp":
+      return applyLoadedToSpec(spec, loaded);
+    case "langchain":
+      return applyLoadedToSpec2(spec, loaded, manifest, defaultDirName, namespace);
+    case "skill":
+      return applyLoadedToSpec3(spec, loaded, manifest, defaultDirName, namespace);
+    case "n8n":
+      return applyLoadedToSpec4(spec, loaded, manifest);
+  }
+}
+async function discoverTools(type, projectPath, options = {}) {
+  const root = path9.resolve(projectPath);
+  switch (type) {
+    case "function":
+      return scan(root, options);
+    case "skill":
+      return scan2(root, options);
+    case "n8n":
+      return scan3(root, options);
+    case "mcp":
+      return scan4(root, options);
+    case "langchain":
+      return scan5(root, options);
+    default: {
+      const _ = type;
+      return _;
+    }
+  }
+}
+var DEFAULT_EXTENSIONS3 = [".js", ".mjs"];
+var DirectoryScanner = class {
+  roots;
+  extensions;
+  onError;
+  constructor(options) {
+    const defaultNamespace = options.namespace ?? "dir";
+    this.roots = options.roots.map((root) => {
+      if (typeof root === "string") {
+        return { path: root, namespace: defaultNamespace };
+      }
+      return {
+        path: root.path,
+        namespace: root.namespace ?? defaultNamespace
+      };
+    });
+    this.extensions = options.extensions ?? DEFAULT_EXTENSIONS3;
+    this.onError = options.onError;
+  }
+  async scan() {
+    const specs = [];
+    for (const root of this.roots) {
+      const rootSpecs = await this.scanRoot(root.path, root.namespace);
+      specs.push(...rootSpecs);
+    }
+    return specs;
+  }
+  async scanRoot(rootPath, namespace) {
+    return this.scanRecursive(rootPath, namespace);
+  }
+  async scanRecursive(dirPath, namespace) {
+    const specs = [];
+    let dirEntries;
+    try {
+      const entries = await readdir(dirPath, { withFileTypes: true });
+      dirEntries = entries.map((entry) => ({
+        name: entry.name,
+        isDirectory: entry.isDirectory()
+      }));
+    } catch (error) {
+      this.onError?.(dirPath, error);
+      return specs;
+    }
+    const dirName = basename(dirPath);
+    try {
+      const loadedSpecs = await this.loadToolDir(dirPath, dirName, namespace);
+      if (loadedSpecs.length > 0) specs.push(...loadedSpecs);
+    } catch (error) {
+      this.onError?.(dirPath, error);
+    }
+    for (const entry of dirEntries) {
+      if (!entry.isDirectory) continue;
+      const childPath = join(dirPath, entry.name);
+      try {
+        const childSpecs = await this.scanRecursive(childPath, namespace);
+        specs.push(...childSpecs);
+      } catch (error) {
+        this.onError?.(childPath, error);
+      }
+    }
+    return specs;
+  }
+  async loadToolDir(dirPath, dirName, namespace) {
+    const manifestPath = join(dirPath, "tool.json");
+    let manifestRaw;
+    try {
+      manifestRaw = await readFile(manifestPath, "utf-8");
+    } catch {
+      const inferred = await this.inferManifest(dirPath, dirName);
+      if (!inferred) return [];
+      if (inferred.kind === "langchain") {
+        if (inferred.entryPoint) {
+          const loaded3 = await loadLangChainTool(dirPath, inferred, this.extensions);
+          return [this.toToolSpec(loaded3, dirName, dirPath, namespace)];
+        }
+        return loadLangChainToolsFromDir(
+          dirPath,
+          dirName,
+          inferred,
+          false,
+          namespace,
+          this.extensions,
+          LANGCHAIN_DIR_NAME,
+          (loaded3, nameHint, dp, ns) => this.toToolSpec(loaded3, nameHint, dp, ns),
+          this.onError
+        );
+      }
+      if (inferred.kind === "skill") {
+        const loadedList = await loadSkillTools(dirPath, inferred, this.extensions);
+        return loadedList.map(
+          (loaded3) => this.toToolSpec(loaded3, dirName, dirPath, namespace)
+        );
+      }
+      const loaded2 = await this.loadByKind(dirPath, inferred);
+      return [this.toToolSpec(loaded2, dirName, dirPath, namespace)];
+    }
+    let manifest;
+    try {
+      manifest = JSON.parse(manifestRaw);
+    } catch (err) {
+      throw new DiscoveryError(dirPath, "manifest", "Invalid JSON in tool.json", err);
+    }
+    if (!manifest.kind) {
+      throw new DiscoveryError(dirPath, "manifest", `tool.json must have a "kind" field`);
+    }
+    if (manifest.enabled === false) return [];
+    if (manifest.kind === "langchain") {
+      if (manifest.entryPoint) {
+        const loaded2 = await loadLangChainTool(dirPath, manifest, this.extensions);
+        return [this.toToolSpec(loaded2, dirName, dirPath, namespace)];
+      }
+      return loadLangChainToolsFromDir(
+        dirPath,
+        dirName,
+        manifest,
+        true,
+        namespace,
+        this.extensions,
+        LANGCHAIN_DIR_NAME,
+        (loaded2, nameHint, dp, ns) => this.toToolSpec(loaded2, nameHint, dp, ns),
+        this.onError
+      );
+    }
+    if (manifest.kind === "skill") {
+      const loadedList = await loadSkillTools(dirPath, manifest, this.extensions);
+      return loadedList.map(
+        (loaded2) => this.toToolSpec(loaded2, dirName, dirPath, namespace)
+      );
+    }
+    const loaded = await this.loadByKind(dirPath, manifest);
+    return [this.toToolSpec(loaded, dirName, dirPath, namespace)];
+  }
+  async inferManifest(dirPath, dirName) {
+    const kinds = [];
+    for (const m of DIRECTORY_KIND_MARKERS) {
+      if (await this.fileExists(join(dirPath, m.markerFile))) kinds.push(m.kind);
+    }
+    const isLangchainDir = dirName === LANGCHAIN_DIR_NAME;
+    const hasLangchain = isLangchainDir ? (await listLangchainEntryFiles(dirPath, this.extensions)).length > 0 : dirName !== SKILL_DIR_NAME && await this.hasEntryPoint(dirPath, "index");
+    if (hasLangchain) kinds.push("langchain");
+    if (kinds.length === 0) return null;
+    if (kinds.length > 1) {
+      throw new DiscoveryError(
+        dirPath,
+        "manifest",
+        `Ambiguous tool kind (found ${kinds.join(", ")}). Add tool.json to disambiguate.`
+      );
+    }
+    const kind = kinds[0];
+    const manifest = { kind };
+    const marker = DIRECTORY_KIND_MARKERS.find((m) => m.kind === kind);
+    if (marker) {
+      manifest.entryPoint = marker.defaultEntryPoint;
+    }
+    if (kind === "langchain" && !isLangchainDir) manifest.entryPoint = "index";
+    return manifest;
+  }
+  async fileExists(path12) {
+    try {
+      await access(path12);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async hasEntryPoint(dirPath, baseName) {
+    try {
+      await resolveEntryPoint(dirPath, baseName, this.extensions);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async loadByKind(dirPath, manifest) {
+    const kind = manifest.kind;
+    const loader = getDirectoryLoader(kind);
+    const result = await loader(dirPath, manifest, this.extensions);
+    const list = Array.isArray(result) ? result : [result];
+    if (list.length === 0) {
+      throw new DiscoveryError(dirPath, "load", "No tools loaded", new Error("empty"));
+    }
+    return list[0];
+  }
+  toToolSpec(loaded, dirName, dirPath, namespace) {
+    const { manifest } = loaded;
+    const kindDirNames = new Set(DIRECTORY_DISCOVERABLE_KINDS);
+    const parentName = basename(join(dirPath, ".."));
+    const isKindDir = kindDirNames.has(dirName);
+    const defaultDirName = isKindDir ? parentName : dirName;
+    const inferredName = isKindDir ? `${namespace}/${defaultDirName}-${dirName}` : `${namespace}/${defaultDirName}`;
+    const name = manifest.name ?? inferredName;
+    const spec = this.buildBaseSpec(manifest, name, dirName);
+    applyDirectoryLoadedToSpec(spec, loaded, manifest, defaultDirName, namespace);
+    return spec;
+  }
+  buildBaseSpec(manifest, name, dirName) {
+    return {
+      name,
+      version: manifest.version ?? "1.0.0",
+      kind: manifest.kind,
+      description: manifest.description ?? `${manifest.kind} tool: ${dirName}`,
+      tags: manifest.tags,
+      inputSchema: manifest.inputSchema ?? { type: "object", additionalProperties: true },
+      outputSchema: manifest.outputSchema ?? { type: "object", additionalProperties: true },
+      capabilities: manifest.capabilities ?? [],
+      costHints: manifest.costHints
+    };
+  }
+};
+
+// src/tools/mcp/MCPLoader.ts
+function isCursorFormat(obj) {
+  return typeof obj === "object" && obj !== null && "mcpServers" in obj && typeof obj.mcpServers === "object" && obj.mcpServers !== null;
+}
+function extractMCPConfig(parsed, toolName) {
+  if (isCursorFormat(parsed)) {
+    const servers = parsed.mcpServers;
+    const keys = Object.keys(servers);
+    if (keys.length === 0) {
+      return {};
+    }
+    const name = toolName && keys.includes(toolName) ? toolName : keys[0];
+    return servers[name];
+  }
+  return parsed;
+}
+async function loadMCPTool(dirPath, manifest) {
+  const mcpPath = join(dirPath, manifest.entryPoint ?? "mcp.json");
+  let raw;
+  try {
+    raw = await readFile(mcpPath, "utf-8");
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to read MCP config: ${mcpPath}`,
+      err
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Invalid JSON in ${mcpPath}`,
+      err
+    );
+  }
+  const baseName = manifest.name?.split("/").pop();
+  const config = extractMCPConfig(parsed, baseName);
+  if (!config.command && !config.url) {
+    throw new DiscoveryError(
+      dirPath,
+      "validate",
+      `mcp.json must have either "command" or "url" field`
+    );
+  }
+  return { manifest, dirPath, mcpConfig: config };
+}
 async function scanForAllTools(projectPath, options = {}) {
   const include = options.include ?? ["**/*.ts"];
   const tsconfigPath = options.tsconfigPath;
   const includeN8n = options.includeN8n === true;
-  const [functionResult, skillResult, n8nResult] = await Promise.all([
-    Promise.resolve(scanForTools({ projectPath, include, tsconfigPath })),
-    scanForSkill(projectPath),
-    includeN8n ? scanForN8n(projectPath) : Promise.resolve({ n8n: [], errors: [] })
+  const opts = { include, tsconfigPath };
+  const results = await Promise.all([
+    discoverTools("function", projectPath, opts),
+    discoverTools("skill", projectPath, opts),
+    ...includeN8n ? [discoverTools("n8n", projectPath, opts)] : []
   ]);
-  const specs = [
-    ...functionResult.specs,
-    ...skillResult.skills,
-    ...n8nResult.n8n
-  ];
-  const errors = [
-    ...functionResult.errors,
-    ...skillResult.errors.map((e) => ({ file: e.dir, message: e.message })),
-    ...includeN8n ? n8nResult.errors.map((e) => ({ file: e.dir, message: e.message })) : []
-  ];
-  const warnings = [...functionResult.warnings];
+  const specs = results.flatMap((r) => r.specs);
+  const errors = results.flatMap((r) => r.errors);
+  const warnings = results.flatMap((r) => r.warnings ?? []);
   return { specs, errors, warnings };
 }
-var __dirname$1 = path5.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path9.dirname(fileURLToPath(import.meta.url));
 async function loadTemplate(name) {
   for (const dir of [
-    path5.join(__dirname$1, "templates"),
-    path5.join(__dirname$1, "..", "templates")
+    path9.join(__dirname$1, "templates"),
+    path9.join(__dirname$1, "..", "templates")
   ]) {
     try {
-      return await fs3.readFile(path5.join(dir, name), "utf-8");
+      return await fs3.readFile(path9.join(dir, name), "utf-8");
     } catch {
       continue;
     }
@@ -895,14 +1601,14 @@ var TEMPLATE_NAMES = {
 };
 function buildToolIndexCases(specs, fromGeneratedToProject) {
   return specs.map((s) => {
-    const modPath = path5.join(fromGeneratedToProject, s.sourcePath).replace(/\\/g, "/");
-    return `    case "${s.name}": return (await import("${modPath}")).${s.exportName};`;
+    const modPath = path9.join(fromGeneratedToProject, s._meta.sourcePath).replace(/\\/g, "/");
+    return `    case "${s.name}": return (await import("${modPath}")).${s._meta.exportName};`;
   }).join("\n");
 }
 function buildSkillInvokerCases(specs, fromGeneratedToProject) {
   return specs.map((s) => {
-    const handlerPath = path5.join(fromGeneratedToProject, s.sourcePath, "handler").replace(/\\/g, "/");
-    const descEscaped = s.description.replace(/"/g, '\\"');
+    const handlerPath = path9.join(fromGeneratedToProject, s._meta.sourcePath, "handler").replace(/\\/g, "/");
+    const descEscaped = (s.description ?? "").replace(/"/g, '\\"');
     return `    case "${s.name}": {
       const mod = await import("${handlerPath}.js").catch(() => import("${handlerPath}.mjs"));
       const fn = mod.default ?? mod.handler;
@@ -915,7 +1621,8 @@ function buildSkillInvokerCases(specs, fromGeneratedToProject) {
 }
 function buildN8nInvokerCases(specs) {
   return specs.map((s) => {
-    const url = s.webhookUrl ? `"${s.webhookUrl}"` : "process.env.N8N_WEBHOOK_" + s.name.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase() + " ?? null";
+    const webhookUrl = s.endpoint;
+    const url = webhookUrl ? `"${webhookUrl}"` : "process.env.N8N_WEBHOOK_" + s.name.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase() + " ?? null";
     return `    case "${s.name}": {
       const url = ${url};
       if (!url) throw new Error("n8n webhook not configured for ${s.name}. Set N8N_WEBHOOK_* or add webhook to workflow.");
@@ -928,32 +1635,39 @@ function buildN8nInvokerCases(specs) {
 async function generate(options) {
   const { specs, outDir, projectPath } = options;
   await fs3.mkdir(outDir, { recursive: true });
-  const functionSpecs = specs.filter((s) => s.kind === "function");
-  const skillSpecs = specs.filter((s) => s.kind === "skill");
-  const n8nSpecs = specs.filter((s) => s.kind === "n8n");
+  const functionSpecs = specs.filter(
+    (s) => s.kind === FUNCTION_KIND && s._meta?.sourcePath != null && s._meta?.exportName != null
+  );
+  const skillSpecs = specs.filter(
+    (s) => s.kind === SKILL_KIND && s._meta?.sourcePath != null
+  );
+  const n8nSpecs = specs.filter((s) => s.kind === N8N_KIND);
   const toolSpecsJson = specs.map((s) => ({
     kind: s.kind,
     name: s.name,
     description: s.description,
     inputSchema: s.inputSchema,
-    ...s.kind === "function" && {
+    ...s.kind === FUNCTION_KIND && s._meta?.sourcePath != null && s._meta?.exportName != null && {
       outputSchema: s.outputSchema ?? { type: "object", additionalProperties: true },
-      sourcePath: s.sourcePath,
-      exportName: s.exportName
+      sourcePath: s._meta.sourcePath,
+      exportName: s._meta.exportName
     },
     _meta: s._meta,
-    ...s.kind === "skill" && { sourcePath: s.sourcePath },
-    ...s.kind === "n8n" && { sourcePath: s.sourcePath, webhookUrl: s.webhookUrl }
+    ...s.kind === SKILL_KIND && s._meta?.sourcePath != null && { sourcePath: s._meta.sourcePath },
+    ...s.kind === N8N_KIND && {
+      sourcePath: s._meta?.sourcePath,
+      webhookUrl: s.endpoint
+    }
   }));
   await fs3.writeFile(
-    path5.join(outDir, "tool-specs.json"),
+    path9.join(outDir, "tool-specs.json"),
     JSON.stringify(toolSpecsJson, null, 2),
     "utf-8"
   );
-  const configJson = { projectPath: path5.resolve(projectPath) };
-  await fs3.writeFile(path5.join(outDir, "config.json"), JSON.stringify(configJson, null, 2), "utf-8");
-  const rel = path5.relative(outDir, projectPath) || ".";
-  const fromGeneratedToProject = rel.split(path5.sep).length ? rel : ".";
+  const configJson = { projectPath: path9.resolve(projectPath) };
+  await fs3.writeFile(path9.join(outDir, "config.json"), JSON.stringify(configJson, null, 2), "utf-8");
+  const rel = path9.relative(outDir, projectPath) || ".";
+  const fromGeneratedToProject = rel.split(path9.sep).length ? rel : ".";
   const [mcpServerTemplate, toolIndexTemplate, skillInvokerTemplate, n8nInvokerTemplate] = await Promise.all([
     loadTemplate(TEMPLATE_NAMES.mcpServer),
     loadTemplate(TEMPLATE_NAMES.toolIndex),
@@ -961,21 +1675,21 @@ async function generate(options) {
     loadTemplate(TEMPLATE_NAMES.n8nInvoker)
   ]);
   const toolIndexTs = toolIndexTemplate.replace("{{CASES}}", buildToolIndexCases(functionSpecs, fromGeneratedToProject));
-  await fs3.writeFile(path5.join(outDir, "tool-index.ts"), toolIndexTs, "utf-8");
+  await fs3.writeFile(path9.join(outDir, "tool-index.ts"), toolIndexTs, "utf-8");
   const skillCases = buildSkillInvokerCases(skillSpecs, fromGeneratedToProject);
   const skillDefaultCase = skillSpecs.length === 0 ? "default: throw new Error('Unknown skill: ' + name);" : 'default: throw new Error("Unknown skill: " + name);';
   const skillInvokerTs = skillInvokerTemplate.replace("{{CASES}}", skillCases).replace("{{DEFAULT_CASE}}", skillDefaultCase);
-  await fs3.writeFile(path5.join(outDir, "skill-invoker.ts"), skillInvokerTs, "utf-8");
+  await fs3.writeFile(path9.join(outDir, "skill-invoker.ts"), skillInvokerTs, "utf-8");
   const n8nCases = buildN8nInvokerCases(n8nSpecs);
   const n8nDefaultCase = n8nSpecs.length === 0 ? "default: throw new Error('Unknown n8n tool: ' + name);" : 'default: throw new Error("Unknown n8n tool: " + name);';
   const n8nInvokerTs = n8nInvokerTemplate.replace("{{CASES}}", n8nCases).replace("{{DEFAULT_CASE}}", n8nDefaultCase);
-  await fs3.writeFile(path5.join(outDir, "n8n-invoker.ts"), n8nInvokerTs, "utf-8");
-  await fs3.writeFile(path5.join(outDir, "mcp-server.ts"), mcpServerTemplate, "utf-8");
+  await fs3.writeFile(path9.join(outDir, "n8n-invoker.ts"), n8nInvokerTs, "utf-8");
+  await fs3.writeFile(path9.join(outDir, "mcp-server.ts"), mcpServerTemplate, "utf-8");
   const mcpJson = {
     command: "npx",
-    args: ["-y", "tsx", path5.join(outDir, "mcp-server.ts")]
+    args: ["-y", "tsx", path9.join(outDir, "mcp-server.ts")]
   };
-  await fs3.writeFile(path5.join(outDir, "mcp.json"), JSON.stringify(mcpJson, null, 2), "utf-8");
+  await fs3.writeFile(path9.join(outDir, "mcp.json"), JSON.stringify(mcpJson, null, 2), "utf-8");
   const packageJson = {
     name: "function-tools-mcp",
     version: "1.0.0",
@@ -989,17 +1703,17 @@ async function generate(options) {
       tsx: ">=4.0.0"
     }
   };
-  await fs3.writeFile(path5.join(outDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf-8");
+  await fs3.writeFile(path9.join(outDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf-8");
   return {
-    entryPath: path5.join(outDir, "mcp-server.ts"),
-    mcpJsonPath: path5.join(outDir, "mcp.json")
+    entryPath: path9.join(outDir, "mcp-server.ts"),
+    mcpJsonPath: path9.join(outDir, "mcp.json")
   };
 }
 
-// src/codegen/build.ts
+// src/api/expose/mcp-build/build.ts
 async function buildMcpPackage(options = {}) {
-  const projectPath = path5.resolve(options.projectPath ?? process.cwd());
-  const outDir = path5.resolve(projectPath, options.outDir ?? "dist");
+  const projectPath = path9.resolve(options.projectPath ?? process.cwd());
+  const outDir = path9.resolve(projectPath, options.outDir ?? "dist");
   const include = options.include ?? ["**/*.ts"];
   const tsconfigPath = options.tsconfigPath;
   const scanResult = await scanForAllTools(projectPath, {
@@ -1033,12 +1747,12 @@ var buildFunctionToTool = buildMcpPackage;
 async function runMcpServer(options = {}) {
   const base = options.path ?? process.cwd();
   const candidates = [
-    path5.join(base, "mcp-server.ts"),
-    path5.join(base, "mcp-server.js"),
-    path5.join(base, "dist", "mcp-server.ts"),
-    path5.join(base, "dist", "mcp-server.js"),
-    path5.join(base, "generated", "mcp-server.ts"),
-    path5.join(base, "generated", "mcp-server.js")
+    path9.join(base, "mcp-server.ts"),
+    path9.join(base, "mcp-server.js"),
+    path9.join(base, "dist", "mcp-server.ts"),
+    path9.join(base, "dist", "mcp-server.js"),
+    path9.join(base, "generated", "mcp-server.ts"),
+    path9.join(base, "generated", "mcp-server.js")
   ];
   let entry = "";
   for (const p of candidates) {
@@ -1054,8 +1768,8 @@ async function runMcpServer(options = {}) {
       `MCP entrypoint not found. Run "agent-tool build" first, or pass --path to a directory containing mcp-server.ts. Tried: ${candidates.join(", ")}`
     );
   }
-  const dir = path5.dirname(entry);
-  const child = spawn("npx", ["-y", "tsx", path5.basename(entry)], {
+  const dir = path9.dirname(entry);
+  const child = spawn("npx", ["-y", "tsx", path9.basename(entry)], {
     cwd: dir,
     stdio: ["pipe", "pipe", "inherit"],
     shell: false
@@ -1064,6 +1778,6 @@ async function runMcpServer(options = {}) {
 }
 var runGeneratedMCP = runMcpServer;
 
-export { DiscoveryError, SkillManifestError, buildFunctionToTool, buildMcpPackage, initProject, loadN8nTool, loadSkillDefinition, parseSkillMd, runGeneratedMCP, runMcpServer, scanForTools, scanSkillResources, validateFrontmatter };
-//# sourceMappingURL=chunk-BM4EVYI5.js.map
-//# sourceMappingURL=chunk-BM4EVYI5.js.map
+export { DirectoryScanner, DiscoveryError, SkillManifestError, buildFunctionToTool, buildMcpPackage, initProject, loadMCPTool, loadSkillDefinition, parseSkillMd, runGeneratedMCP, runMcpServer, scan, scanForTools, scanSkillResources, validateFrontmatter };
+//# sourceMappingURL=chunk-PJ4RUBZL.js.map
+//# sourceMappingURL=chunk-PJ4RUBZL.js.map