@easynet/agent-tool 1.0.54 → 1.0.55

package/dist/{chunk-WFPHIYB6.cjs → chunk-D2T3NTFN.cjs}

@@ -13,17 +13,41 @@ var eventemitter3 = require('eventemitter3');
 var uuid = require('uuid');
 var pTimeout = require('p-timeout');
 var promises = require('fs/promises');
+var ts2 = require('typescript');
 var module$1 = require('module');
 var url = require('url');
+var yaml = require('js-yaml');
 var npm = require('@easynet/agent-common/npm');
 var http = require('http');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
 var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
 var pTimeout__default = /*#__PURE__*/_interopDefault(pTimeout);
+var ts2__namespace = /*#__PURE__*/_interopNamespace(ts2);
+var yaml__default = /*#__PURE__*/_interopDefault(yaml);
 
 function loadToolConfig(toolYamlPath) {
   const abs = path.resolve(toolYamlPath);
@@ -202,13 +226,13 @@ function expandToolDescriptorsToRegistryNames(descriptors, registryNames) {
         out.push(s);
         continue;
       }
-      const path = parseToolPath(s);
-      if (path) {
-        const packagePrefix = path.protocol === "npm" ? npmDescriptorToPackagePrefix(s) : path.protocol === "file" ? fileDescriptorToPackagePrefix(s) : "";
+      const path7 = parseToolPath(s);
+      if (path7) {
+        const packagePrefix = path7.protocol === "npm" ? npmDescriptorToPackagePrefix(s) : path7.protocol === "file" ? fileDescriptorToPackagePrefix(s) : "";
         const prefixWithDot = packagePrefix ? packagePrefix + "." : "";
         if (prefixWithDot) {
-          if (path.toolName) {
-            const suffix = "." + path.toolName;
+          if (path7.toolName) {
+            const suffix = "." + path7.toolName;
             for (const r of registryNames) {
               if (r.startsWith(prefixWithDot) && r.endsWith(suffix) && !seen.has(r)) {
                 seen.add(r);
@@ -237,9 +261,9 @@ function resolveToolDescriptor(descriptor) {
   return s;
 }
 function fileDescriptorToPackagePrefix(descriptor) {
-  const path = parseToolPath(descriptor.trim());
-  if (!path || path.protocol !== "file") return "";
-  const pathPart = `${path.scope}/${path.packageWithVersion}`;
+  const path7 = parseToolPath(descriptor.trim());
+  if (!path7 || path7.protocol !== "file") return "";
+  const pathPart = `${path7.scope}/${path7.packageWithVersion}`;
   const normalized = chunkQEJF3KDV_cjs.normalizeToolName(pathPart);
   if (!normalized) return "";
   return "file." + normalized;
@@ -539,17 +563,17 @@ var PolicyEngine = class {
    */
   extractStringValues(args, keyPatterns) {
     const results = [];
-    const walk = (obj) => {
+    const walk2 = (obj) => {
       for (const [key, val] of Object.entries(obj)) {
         const lowerKey = key.toLowerCase();
         if (typeof val === "string" && keyPatterns.some((p) => lowerKey.includes(p))) {
           results.push(val);
         } else if (val && typeof val === "object" && !Array.isArray(val)) {
-          walk(val);
+          walk2(val);
         }
       }
     };
-    walk(args);
+    walk2(args);
     return results;
   }
 };
@@ -734,30 +758,30 @@ function summarizeValue(value, maxLen) {
 }
 function extractUrls(obj) {
   const urls = [];
-  const walk = (val) => {
+  const walk2 = (val) => {
     if (typeof val === "string" && /^https?:\/\//i.test(val)) {
       urls.push(val);
     } else if (val && typeof val === "object") {
       for (const v of Object.values(val)) {
-        walk(v);
+        walk2(v);
       }
     }
   };
-  walk(obj);
+  walk2(obj);
   return urls.slice(0, 10);
 }
 function extractFilePaths(obj) {
   const paths = [];
-  const walk = (val) => {
+  const walk2 = (val) => {
     if (typeof val === "string" && (val.startsWith("/") || val.startsWith("./")) && val.includes(".")) {
       paths.push(val);
     } else if (val && typeof val === "object") {
       for (const v of Object.values(val)) {
-        walk(v);
+        walk2(v);
       }
     }
   };
-  walk(obj);
+  walk2(obj);
   return paths.slice(0, 10);
 }
 var EventLog = class {
@@ -1760,14 +1784,1530 @@ async function resolveSandboxedPath2(inputPath, sandboxRoot) {
   }
   return real;
 }
-function isWithinRoot(path$1, root) {
-  const normalizedPath = path.normalize(path$1);
+function isWithinRoot(path7, root) {
+  const normalizedPath = path.normalize(path7);
   const normalizedRoot = path.normalize(root);
   return normalizedPath === normalizedRoot || normalizedPath.startsWith(normalizedRoot + "/");
 }
+async function findDirsContainingFile(rootPath, fileName) {
+  const found = [];
+  await collectDirsWithFile(rootPath, fileName, found);
+  return found;
+}
+async function collectDirsWithFile(dir, fileName, acc) {
+  let entries;
+  try {
+    const e = await promises.readdir(dir, { withFileTypes: true });
+    entries = e.map((x) => ({
+      name: x.name,
+      isDirectory: x.isDirectory(),
+      isFile: x.isFile()
+    }));
+  } catch {
+    return;
+  }
+  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(path.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);
+  return segments.length === 0 ? programName : `${segments.join(".")}.${programName}`;
+}
+function buildOutputSchemaFromReturnType(node, typeChecker, onWarn) {
+  const sig = typeChecker.getSignatureFromDeclaration(node);
+  if (!sig) {
+    onWarn?.("Could not get signature for return type, using object");
+    return { type: "object", additionalProperties: true };
+  }
+  let returnType = typeChecker.getReturnTypeOfSignature(sig);
+  if (returnType.getSymbol?.()?.getName() === "Promise") {
+    const typeArgs = returnType.typeArguments;
+    if (typeArgs?.[0]) returnType = typeArgs[0];
+  }
+  const schema = typeToJsonSchema(returnType, typeChecker, onWarn);
+  const hasProps = typeof schema === "object" && schema.type === "object" && Object.keys(schema.properties ?? {}).length > 0;
+  return hasProps ? schema : { type: "object", additionalProperties: true };
+}
+function buildInputSchemaFromParams(node, typeChecker, onWarn) {
+  const properties = {};
+  const required = [];
+  if (!node.parameters.length) {
+    return { schema: { type: "object", properties: {} }, required: [] };
+  }
+  for (const param of node.parameters) {
+    const name = param.name.getText();
+    if (name.startsWith("_") && name.length <= 2) continue;
+    const sym = param.symbol;
+    const paramType = sym ? typeChecker.getTypeOfSymbolAtLocation(sym, param) : typeChecker.getTypeAtLocation(param);
+    const isOptional = !!param.questionToken || param.initializer !== void 0;
+    const propSchema = typeToJsonSchema(paramType, typeChecker, onWarn);
+    properties[name] = propSchema;
+    if (!isOptional) required.push(name);
+  }
+  const paramNames = Object.keys(properties);
+  if (paramNames.length === 1) {
+    const soleName = paramNames[0];
+    const inner = properties[soleName];
+    if (inner && typeof inner === "object" && inner.type === "object" && inner.properties && typeof inner.properties === "object") {
+      return {
+        schema: {
+          type: "object",
+          properties: inner.properties,
+          ...Array.isArray(inner.required) && inner.required.length > 0 ? { required: inner.required } : {},
+          ...inner.additionalProperties !== void 0 ? { additionalProperties: inner.additionalProperties } : {}
+        },
+        required: inner.required ?? []
+      };
+    }
+  }
+  return {
+    schema: {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    },
+    required
+  };
+}
+function typeToJsonSchema(type, typeChecker, onWarn) {
+  const flags = type.flags;
+  if (flags & ts2__namespace.TypeFlags.String) return { type: "string" };
+  if (flags & ts2__namespace.TypeFlags.Number) return { type: "number" };
+  if (flags & ts2__namespace.TypeFlags.Boolean) return { type: "boolean" };
+  if (flags & ts2__namespace.TypeFlags.BooleanLiteral) return { type: "boolean" };
+  if (flags & ts2__namespace.TypeFlags.Null) return { type: "null" };
+  if (flags & ts2__namespace.TypeFlags.Undefined || flags & ts2__namespace.TypeFlags.Void) return {};
+  if (flags & ts2__namespace.TypeFlags.Any || flags & ts2__namespace.TypeFlags.Unknown) {
+    onWarn?.(`Unsupported type: any/unknown, using empty schema`);
+    return {};
+  }
+  if (type.isUnion?.()) {
+    const union = type;
+    const types = union.types;
+    const withoutUndef = types.filter(
+      (t) => !(t.flags & ts2__namespace.TypeFlags.Undefined) && !(t.flags & ts2__namespace.TypeFlags.Void)
+    );
+    if (withoutUndef.length === 1) return typeToJsonSchema(withoutUndef[0], typeChecker, onWarn);
+    if (withoutUndef.length === 0) return {};
+    const stringEnumValues = [];
+    let allStringLiterals = true;
+    for (const t of withoutUndef) {
+      if (t.flags & ts2__namespace.TypeFlags.StringLiteral) {
+        const lit = t;
+        if (typeof lit.value === "string") stringEnumValues.push(lit.value);
+      } else {
+        allStringLiterals = false;
+        break;
+      }
+    }
+    if (allStringLiterals && stringEnumValues.length > 0) {
+      return { type: "string", enum: [...new Set(stringEnumValues)] };
+    }
+    let allBooleanLiterals = true;
+    for (const t of withoutUndef) {
+      if (!(t.flags & ts2__namespace.TypeFlags.BooleanLiteral)) {
+        allBooleanLiterals = false;
+        break;
+      }
+    }
+    if (allBooleanLiterals) return { type: "boolean" };
+  }
+  if (flags & ts2__namespace.TypeFlags.StringLiteral) {
+    const lit = type;
+    if (typeof lit.value === "string") {
+      return { type: "string", enum: [lit.value] };
+    }
+    return { type: "string" };
+  }
+  if (typeChecker.isArrayType(type)) {
+    const typeRef = type;
+    const typeArgs = typeRef.typeArguments;
+    const itemType = typeArgs?.[0];
+    const items = itemType ? typeToJsonSchema(itemType, typeChecker, onWarn) : {};
+    return { type: "array", items: Object.keys(items).length ? items : {} };
+  }
+  const str = typeChecker.typeToString(type);
+  if (str === "string") return { type: "string" };
+  if (str === "number") return { type: "number" };
+  if (str === "boolean") return { type: "boolean" };
+  if (str.endsWith("[]")) {
+    const inner = str.slice(0, -2).trim();
+    const itemType = inner === "string" ? { type: "string" } : inner === "number" ? { type: "number" } : {};
+    return { type: "array", items: itemType };
+  }
+  if (type.getProperties && type.getProperties().length >= 0) {
+    const props = type.getProperties();
+    const properties = {};
+    const required = [];
+    for (const p of props) {
+      const decl = p.valueDeclaration;
+      const propType = decl ? typeChecker.getTypeAtLocation(decl) : typeChecker.getTypeOfSymbolAtLocation(p, p.valueDeclaration);
+      const optional = decl && ts2__namespace.isPropertySignature(decl) ? !!decl.questionToken : false;
+      properties[p.name] = typeToJsonSchema(propType, typeChecker, onWarn);
+      if (!optional) required.push(p.name);
+    }
+    return { type: "object", properties, ...required.length ? { required } : {} };
+  }
+  onWarn?.(`Unsupported type: ${str}, using object`);
+  return { type: "object" };
+}
+
+// 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 : chunkQEJF3KDV_cjs.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 = path__namespace.resolve(options.projectPath);
+  const tsconfigPath = options.tsconfigPath ?? path__namespace.join(projectPath, "tsconfig.json");
+  const include = options.include ?? ["**/*.ts"];
+  const errors = [];
+  const warnings = [];
+  let config;
+  let configPathResolved = path__namespace.resolve(projectPath, tsconfigPath);
+  if (!fs__namespace.existsSync(configPathResolved)) {
+    configPathResolved = path__namespace.join(projectPath, "tsconfig.json");
+  }
+  if (fs__namespace.existsSync(configPathResolved)) {
+    const configFile = ts2__namespace.readConfigFile(configPathResolved, ts2__namespace.sys.readFile);
+    if (configFile.error) {
+      errors.push({ file: configPathResolved, message: String(configFile.error.messageText) });
+      return { specs: [], errors, warnings };
+    }
+    const parsed = ts2__namespace.parseJsonConfigFileContent(
+      configFile.config,
+      ts2__namespace.sys,
+      path__namespace.dirname(configPathResolved)
+    );
+    if (parsed.errors.length) {
+      for (const e of parsed.errors) {
+        errors.push({ file: e.file?.fileName ?? "tsconfig", message: String(e.messageText) });
+      }
+      return { specs: [], errors, warnings };
+    }
+    config = parsed;
+  } else {
+    config = {
+      options: {
+        target: ts2__namespace.ScriptTarget.ES2022,
+        module: ts2__namespace.ModuleKind.ESNext,
+        moduleResolution: ts2__namespace.ModuleResolutionKind.NodeNext,
+        strict: true,
+        skipLibCheck: true,
+        noEmit: true
+      },
+      fileNames: resolveGlob(projectPath, include),
+      errors: []
+    };
+  }
+  const program = ts2__namespace.createProgram(config.fileNames, config.options);
+  const typeChecker = program.getTypeChecker();
+  const specs = [];
+  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) => path__namespace.resolve(f) === path__namespace.resolve(fileName))) continue;
+    ts2__namespace.forEachChild(sourceFile, (node) => {
+      const decl = getExportedFunctionDeclaration(node);
+      if (!decl) return;
+      const func = decl.func;
+      const name = decl.name;
+      if (!name) return;
+      const host = getJSDocHost(func);
+      if (!hasToolTag(host)) return;
+      const jsDoc = getJSDocComments(host);
+      const description = getDescription(jsDoc);
+      if (!description) {
+        warnings.push({ file: fileName, message: `Tool ${name}: missing description, using humanized name` });
+      }
+      const sideEffect = getEffect(host);
+      const onWarn = (msg) => warnings.push({ file: fileName, message: `${name}: ${msg}` });
+      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 = path__namespace.relative(projectPath, fileName) || path__namespace.basename(fileName);
+      const toolName = pathToToolName(sourcePath, name);
+      specs.push({
+        kind: FUNCTION_KIND,
+        name: toolName,
+        description: description || humanize(name),
+        inputSchema,
+        outputSchema,
+        _meta: { hitl: { sideEffect } },
+        sourcePath,
+        exportName: name
+      });
+    });
+  }
+  return { specs, errors, warnings };
+}
+function resolveGlob(projectPath, patterns) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (f) => {
+    const abs = path__namespace.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 = path__namespace.join(projectPath, p);
+    if (full.includes("*")) {
+      const baseDir = full.replace(/\*\*\/.*$/, "").replace(/\*.*$/, "").replace(/\/?$/, "") || ".";
+      const dir = path__namespace.resolve(projectPath, baseDir);
+      if (fs__namespace.existsSync(dir)) walk(dir, add);
+    } else {
+      const resolved = path__namespace.resolve(projectPath, full);
+      if (fs__namespace.existsSync(resolved)) {
+        if (fs__namespace.statSync(resolved).isFile()) add(resolved);
+        else walk(resolved, add);
+      }
+    }
+  }
+  if (result.length > 0) return result;
+  const srcDir = path__namespace.join(projectPath, "src");
+  if (fs__namespace.existsSync(srcDir)) return walkCollect(srcDir);
+  return [];
+}
+function walkCollect(dir) {
+  const out = [];
+  walk(dir, (fullPath) => {
+    if (fullPath.endsWith(".ts") && !fullPath.endsWith(".d.ts")) out.push(path__namespace.resolve(fullPath));
+  });
+  return out;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "generated", "dist"]);
+function walk(dir, visit) {
+  try {
+    const entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = path__namespace.join(dir, e.name);
+      if (e.isDirectory() && !SKIP_DIRS.has(e.name)) walk(full, visit);
+      else if (e.isFile()) visit(full);
+    }
+  } catch {
+  }
+}
+function getExportedFunctionDeclaration(node, _sourceFile) {
+  if (ts2__namespace.isFunctionDeclaration(node) && node.name) {
+    const exported = (ts2__namespace.getModifiers(node) ?? []).some((m) => m.kind === ts2__namespace.SyntaxKind.ExportKeyword);
+    if (exported) return { func: node, name: node.name.getText() };
+    return null;
+  }
+  if (ts2__namespace.isVariableStatement(node)) {
+    const exported = (ts2__namespace.getModifiers(node) ?? []).some((m) => m.kind === ts2__namespace.SyntaxKind.ExportKeyword);
+    if (!exported) return null;
+    for (const decl of node.declarationList.declarations) {
+      let init = decl.initializer;
+      while (init && (ts2__namespace.isParenthesizedExpression(init) || ts2__namespace.isAsExpression(init)))
+        init = init.expression;
+      if (init && ts2__namespace.isArrowFunction(init)) {
+        const name = decl.name.getText();
+        return { func: init, name };
+      }
+      if (init && ts2__namespace.isFunctionExpression(init)) {
+        const name = decl.name.getText();
+        return { func: init, name };
+      }
+    }
+  }
+  return null;
+}
+function getJSDocHost(node) {
+  const parent = node.parent;
+  if (ts2__namespace.isVariableDeclaration(parent)) {
+    const gp = parent.parent;
+    if (ts2__namespace.isVariableDeclarationList(gp) && gp.parent && ts2__namespace.isVariableStatement(gp.parent)) return gp.parent;
+  }
+  return node;
+}
+function getJSDocComments(host) {
+  const all = ts2__namespace.getJSDocCommentsAndTags(host);
+  return all.filter((t) => ts2__namespace.isJSDoc(t));
+}
+function hasToolTag(host) {
+  const tags = ts2__namespace.getJSDocTags(host);
+  for (const tag of tags) {
+    const name = tag.tagName?.getText() ?? "";
+    if (name === "tool") return true;
+  }
+  const all = ts2__namespace.getJSDocCommentsAndTags(host);
+  for (const t of all) {
+    if (ts2__namespace.isJSDoc(t)) {
+      const full = t.getFullText();
+      if (full.includes(TOOL_TAG)) return true;
+    }
+  }
+  return false;
+}
+function getDescription(jsDocs, fallbackName) {
+  for (const doc of jsDocs) {
+    const comment = doc.comment;
+    if (typeof comment === "string") {
+      const first = comment.split(/\n/)[0]?.trim() ?? "";
+      if (first && !first.startsWith("@")) return first;
+    }
+    if (Array.isArray(comment)) {
+      const first = comment[0];
+      if (first && typeof first === "object" && "text" in first) {
+        const t = first.text.trim();
+        if (t && !t.startsWith("@")) return t;
+      }
+    }
+    const full = doc.getFullText();
+    const match = full.match(/\*\s*@tool\s+(.+?)(?=\n|$|\*\/)/s);
+    if (match?.[1]) return match[1].trim();
+  }
+  return "";
+}
+function getEffect(host) {
+  const tags = ts2__namespace.getJSDocTags(host);
+  for (const tag of tags) {
+    const name = tag.tagName?.getText() ?? "";
+    if (name === "effect") {
+      const comment = tag.comment;
+      const v = (typeof comment === "string" ? comment : "").trim().toLowerCase();
+      if (EFFECT_VALUES.includes(v)) return v;
+    }
+  }
+  const all = ts2__namespace.getJSDocCommentsAndTags(host);
+  for (const t of all) {
+    if (ts2__namespace.isJSDoc(t)) {
+      const full = t.getFullText();
+      const match = full.match(/\*\s*@effect\s+(\w+)/);
+      if (match && EFFECT_VALUES.includes(match[1])) return match[1];
+    }
+  }
+  return "none";
+}
+function humanize(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+}
+function scan(projectPath, options = {}) {
+  const root = path__namespace.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
+  });
+}
+var DEFAULT_EXTENSIONS = [".js", ".mjs"];
+async function resolveEntryPoint(dirPath, baseName, extensions = DEFAULT_EXTENSIONS) {
+  if (extensions.some((ext) => baseName.endsWith(ext))) {
+    const fullPath = path.join(dirPath, baseName);
+    await promises.stat(fullPath);
+    return fullPath;
+  }
+  for (const ext of extensions) {
+    const fullPath = path.join(dirPath, `${baseName}${ext}`);
+    try {
+      await promises.stat(fullPath);
+      return fullPath;
+    } catch {
+    }
+  }
+  throw new Error(
+    `Could not find entry point in ${dirPath}. Tried: ${extensions.map((e) => baseName + e).join(", ")}`
+  );
+}
+
+// src/tools/skill/SkillManifest.ts
+var SkillManifestError = class extends Error {
+  constructor(path7, field, message) {
+    super(`SKILL.md error in ${path7}: ${message}`);
+    this.path = path7;
+    this.field = field;
+    this.name = "SkillManifestError";
+  }
+};
+var NAME_PATTERN = /^[a-z0-9-]+$/;
+var NAME_MAX_LENGTH = 64;
+var DESCRIPTION_MAX_LENGTH = 1024;
+var COMPATIBILITY_MAX_LENGTH = 500;
+var RESERVED_WORDS = ["anthropic", "claude"];
+var XML_TAG_PATTERN = /<\/?[a-zA-Z][^>]*>/;
+function validateFrontmatter(fm, filePath) {
+  if (!fm.name || typeof fm.name !== "string") {
+    throw new SkillManifestError(filePath, "name", "name is required");
+  }
+  if (fm.name.length > NAME_MAX_LENGTH) {
+    throw new SkillManifestError(
+      filePath,
+      "name",
+      `name must be at most ${NAME_MAX_LENGTH} characters (got ${fm.name.length})`
+    );
+  }
+  if (!NAME_PATTERN.test(fm.name)) {
+    throw new SkillManifestError(
+      filePath,
+      "name",
+      "name must contain only lowercase letters, numbers, and hyphens"
+    );
+  }
+  if (fm.name.startsWith("-") || fm.name.endsWith("-")) {
+    throw new SkillManifestError(
+      filePath,
+      "name",
+      "name must not start or end with a hyphen"
+    );
+  }
+  if (fm.name.includes("--")) {
+    throw new SkillManifestError(
+      filePath,
+      "name",
+      "name must not contain consecutive hyphens"
+    );
+  }
+  if (XML_TAG_PATTERN.test(fm.name)) {
+    throw new SkillManifestError(filePath, "name", "name cannot contain XML tags");
+  }
+  for (const reserved of RESERVED_WORDS) {
+    if (fm.name.includes(reserved)) {
+      throw new SkillManifestError(
+        filePath,
+        "name",
+        `name cannot contain reserved word "${reserved}"`
+      );
+    }
+  }
+  if (!fm.description || typeof fm.description !== "string") {
+    throw new SkillManifestError(
+      filePath,
+      "description",
+      "description is required and must be non-empty"
+    );
+  }
+  if (fm.description.length > DESCRIPTION_MAX_LENGTH) {
+    throw new SkillManifestError(
+      filePath,
+      "description",
+      `description must be at most ${DESCRIPTION_MAX_LENGTH} characters (got ${fm.description.length})`
+    );
+  }
+  if (XML_TAG_PATTERN.test(fm.description)) {
+    throw new SkillManifestError(
+      filePath,
+      "description",
+      "description cannot contain XML tags"
+    );
+  }
+  if (fm.compatibility != null && typeof fm.compatibility === "string") {
+    if (fm.compatibility.length > COMPATIBILITY_MAX_LENGTH) {
+      throw new SkillManifestError(
+        filePath,
+        "compatibility",
+        `compatibility must be at most ${COMPATIBILITY_MAX_LENGTH} characters (got ${fm.compatibility.length})`
+      );
+    }
+  }
+}
+
+// src/tools/skill/SkillMdParser.ts
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".py",
+  ".js",
+  ".mjs",
+  ".ts",
+  ".sh",
+  ".bash",
+  ".rb",
+  ".go"
+]);
+var INSTRUCTION_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown", ".txt"]);
+var EXCLUDED_FILES = /* @__PURE__ */ new Set(["SKILL.md", "tool.json"]);
+function parseSkillMd(content, filePath) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) {
+    throw new SkillManifestError(
+      filePath,
+      "frontmatter",
+      "SKILL.md must start with YAML frontmatter (---)"
+    );
+  }
+  const endIndex = trimmed.indexOf("\n---", 3);
+  if (endIndex === -1) {
+    throw new SkillManifestError(
+      filePath,
+      "frontmatter",
+      "SKILL.md frontmatter is not closed (missing closing ---)"
+    );
+  }
+  const yamlBlock = trimmed.slice(4, endIndex).trim();
+  const body = trimmed.slice(endIndex + 4).trim();
+  let raw;
+  try {
+    const parsed = yaml__default.default.load(yamlBlock);
+    if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new SkillManifestError(
+        filePath,
+        "frontmatter",
+        "YAML frontmatter must be an object (key: value)"
+      );
+    }
+    raw = parsed;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new SkillManifestError(
+      filePath,
+      "frontmatter",
+      `Invalid YAML frontmatter: ${message}`
+    );
+  }
+  const name = stringField(raw, "name", filePath);
+  const description = stringField(raw, "description", filePath);
+  if (!name || !description) {
+    throw new SkillManifestError(
+      filePath,
+      "frontmatter",
+      !name ? "name is required" : "description is required"
+    );
+  }
+  const license = stringField(raw, "license");
+  const compatibility = stringField(raw, "compatibility");
+  const allowedTools = stringField(raw, "allowed-tools");
+  const metadata = normalizeMetadata(raw.metadata);
+  const frontmatter = {
+    name,
+    description,
+    ...license && { license },
+    ...compatibility && { compatibility },
+    ...allowedTools && { allowedTools },
+    ...metadata && Object.keys(metadata).length > 0 && { metadata }
+  };
+  validateFrontmatter(frontmatter, filePath);
+  return { frontmatter, instructions: body };
+}
+function stringField(raw, key, filePath) {
+  const v = raw[key];
+  if (v == null) return "";
+  if (typeof v === "string") return v;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  if (Array.isArray(v)) {
+    return v.map((x) => typeof x === "string" ? x : String(x)).join("\n");
+  }
+  if (filePath) {
+    throw new SkillManifestError(
+      filePath,
+      "frontmatter",
+      `Frontmatter field "${key}" must be a string, number, boolean, or array`
+    );
+  }
+  return String(v);
+}
+function normalizeMetadata(val) {
+  if (val == null) return void 0;
+  if (typeof val === "object" && !Array.isArray(val)) {
+    const out = {};
+    for (const [k, v] of Object.entries(val)) {
+      if (typeof k === "string" && v !== void 0 && v !== null) {
+        out[k] = typeof v === "object" ? JSON.stringify(v) : String(v);
+      }
+    }
+    return Object.keys(out).length ? out : void 0;
+  }
+  if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+    return { value: String(val) };
+  }
+  return void 0;
+}
+async function scanSkillResources(dirPath) {
+  const resources = [];
+  await scanDir(dirPath, dirPath, resources);
+  return resources;
+}
+async function scanDir(basePath, currentPath, resources) {
+  let entries;
+  try {
+    entries = await promises.readdir(currentPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(currentPath, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      await scanDir(basePath, fullPath, resources);
+    } else if (entry.isFile()) {
+      if (EXCLUDED_FILES.has(entry.name)) {
+        continue;
+      }
+      const ext = path.extname(entry.name).toLowerCase();
+      const relPath = path.relative(basePath, fullPath);
+      resources.push({
+        relativePath: relPath,
+        absolutePath: fullPath,
+        extension: ext,
+        type: inferResourceType(ext)
+      });
+    }
+  }
+}
+function inferResourceType(ext) {
+  if (CODE_EXTENSIONS.has(ext)) return "code";
+  if (INSTRUCTION_EXTENSIONS.has(ext)) return "instructions";
+  return "data";
+}
+async function loadSkillDefinition(dirPath) {
+  const skillMdPath = path.join(dirPath, "SKILL.md");
+  let content;
+  try {
+    content = await promises.readFile(skillMdPath, "utf-8");
+  } catch (err) {
+    throw new SkillManifestError(
+      skillMdPath,
+      "file",
+      `Cannot read SKILL.md: ${err.message}`
+    );
+  }
+  const { frontmatter, instructions } = parseSkillMd(content, skillMdPath);
+  const resources = await scanSkillResources(dirPath);
+  return {
+    frontmatter,
+    instructions,
+    resources,
+    dirPath,
+    skillMdPath
+  };
+}
+
+// src/tools/skill/scanSkill.ts
+var defaultInputSchema = { type: "object", properties: {}, additionalProperties: true };
+async function scanForSkill(projectPath) {
+  const projectRoot = path__namespace.resolve(projectPath);
+  const dirs = await findDirsContainingFile(projectRoot, "SKILL.md");
+  const skills = [];
+  const errors = [];
+  for (const dirPath of dirs) {
+    const relativePath = path__namespace.relative(projectRoot, dirPath) || path__namespace.basename(dirPath);
+    try {
+      const skillDef = await loadSkillDefinition(dirPath);
+      const name = pathToToolName(relativePath, skillDef.frontmatter.name);
+      skills.push({
+        kind: SKILL_KIND,
+        name,
+        description: skillDef.frontmatter.description,
+        inputSchema: defaultInputSchema,
+        _meta: { hitl: { sideEffect: "none" } },
+        sourcePath: relativePath.replace(/\\/g, "/")
+      });
+    } catch (err) {
+      errors.push({ dir: relativePath, message: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { skills, errors };
+}
+async function scan2(projectPath, _options = {}) {
+  const root = path__namespace.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 = path.join(dirPath, workflowFileName);
+  let raw;
+  try {
+    raw = await promises.readFile(workflowPath, "utf-8");
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to read workflow: ${workflowPath}`,
+      err
+    );
+  }
+  let workflowDef;
+  try {
+    workflowDef = JSON.parse(raw);
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Invalid JSON in ${workflowPath}`,
+      err
+    );
+  }
+  if (!workflowDef.nodes || !Array.isArray(workflowDef.nodes)) {
+    throw new DiscoveryError(
+      dirPath,
+      "validate",
+      `workflow.json must have a "nodes" array`
+    );
+  }
+  const meta = workflowDef.meta;
+  const name = workflowDef.name || meta?.name || path.basename(dirPath);
+  const description = workflowDef.description || meta?.description || `n8n workflow: ${name}`;
+  let webhookUrl;
+  const nodes = workflowDef.nodes;
+  if (Array.isArray(nodes)) {
+    const webhookNode = nodes.find(
+      (n) => n.type === "n8n-nodes-base.webhook" || n.type?.includes("webhook")
+    );
+    if (webhookNode?.parameters && typeof webhookNode.parameters === "object") {
+      const params = webhookNode.parameters;
+      const pathVal = params.path ?? params.webhookPath;
+      if (typeof pathVal === "string" && pathVal.startsWith("http")) {
+        webhookUrl = pathVal;
+      }
+    }
+  }
+  return { name, description, webhookUrl, workflowDef };
+}
+async function loadN8nTool(dirPath, manifest) {
+  const { workflowDef } = await readWorkflowMeta(
+    dirPath,
+    manifest.entryPoint ?? "workflow.json"
+  );
+  return { manifest, dirPath, workflowDef };
+}
+
+// src/tools/n8n/scanN8n.ts
+var defaultInputSchema2 = { type: "object", properties: {}, additionalProperties: true };
+async function scanForN8n(projectPath) {
+  const projectRoot = path__namespace.resolve(projectPath);
+  const dirs = await findDirsContainingFile(projectRoot, "workflow.json");
+  const n8n = [];
+  const errors = [];
+  for (const dirPath of dirs) {
+    const relativePath = path__namespace.relative(projectRoot, dirPath) || path__namespace.basename(dirPath);
+    try {
+      const { name: wfName, description: wfDesc, webhookUrl } = await readWorkflowMeta(dirPath);
+      const toolName = pathToToolName(relativePath, wfName);
+      n8n.push({
+        kind: N8N_KIND,
+        name: toolName,
+        description: wfDesc,
+        inputSchema: defaultInputSchema2,
+        _meta: { hitl: { sideEffect: "external_write" } },
+        sourcePath: relativePath.replace(/\\/g, "/"),
+        webhookUrl
+      });
+    } catch (err) {
+      errors.push({ dir: relativePath, message: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { n8n, errors };
+}
+async function scan3(projectPath, _options = {}) {
+  const root = path__namespace.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 }))
+  };
+}
+
+// src/tools/mcp/types.ts
+var MCP_KIND = "mcp";
+
+// src/tools/mcp/scanner.ts
+async function scan4(projectPath, options = {}) {
+  const root = path__namespace.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 };
+}
+
+// src/tools/langchain/types.ts
+var LANGCHAIN_KIND = "langchain";
+var LANGCHAIN_DIR_NAME = "langchain";
+
+// src/tools/langchain/scanner.ts
+async function scan5(projectPath, options = {}) {
+  const root = path__namespace.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(url.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 promises.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(url.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 promises.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 = path.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?.(path.join(dirPath, entryFile), err);
+      if (strict) throw err;
+    }
+  }
+  return specs;
+}
+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 = path.join(dirPath, manifest.entryPoint ?? "mcp.json");
+  let raw;
+  try {
+    raw = await promises.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 };
+}
+
+// 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/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 = path__namespace.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 promises.readdir(dirPath, { withFileTypes: true });
+      dirEntries = entries.map((entry) => ({
+        name: entry.name,
+        isDirectory: entry.isDirectory()
+      }));
+    } catch (error) {
+      this.onError?.(dirPath, error);
+      return specs;
+    }
+    const dirName = path.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 = path.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 = path.join(dirPath, "tool.json");
+    let manifestRaw;
+    try {
+      manifestRaw = await promises.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(path.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(path7) {
+    try {
+      await promises.access(path7);
+      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 = path.basename(path.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/api/runtimeFromConfig.ts
-var requireFromPackage = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-WFPHIYB6.cjs', document.baseURI).href)));
+var requireFromPackage = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-D2T3NTFN.cjs', document.baseURI).href)));
 function getProjectRequire() {
   const cwd = process.cwd();
   if (fs.existsSync(path.join(cwd, "package.json"))) return module$1.createRequire(path.join(cwd, "package.json"));
@@ -1801,6 +3341,98 @@ function getInstalledPackageVersion(packageName) {
   }
   return null;
 }
+function hasInvokeFunction(value) {
+  return value != null && typeof value === "object" && "invoke" in value && typeof value.invoke === "function";
+}
+function normalizeToolOutput(output) {
+  if (output != null && typeof output === "object" && "result" in output) {
+    const o = output;
+    const evidence = Array.isArray(o.evidence) ? o.evidence : void 0;
+    return evidence ? { result: o.result, raw: { evidence } } : { result: o.result };
+  }
+  return { result: output };
+}
+function createLocalDirectoryAdapter(kind) {
+  return {
+    kind,
+    async invoke(spec, args, ctx) {
+      if (spec.kind === "skill") {
+        const impl = spec.impl;
+        if (hasInvokeFunction(impl)) {
+          const out2 = await impl.invoke(args);
+          return normalizeToolOutput(out2);
+        }
+        const handler = typeof impl?.handler === "function" ? impl.handler : typeof spec.impl === "function" ? spec.impl : void 0;
+        if (typeof handler !== "function") {
+          throw new Error(`Local skill ${spec.name} has no executable handler`);
+        }
+        const out = await handler(args, {
+          requestId: ctx.requestId,
+          taskId: ctx.taskId,
+          skill: {
+            name: impl?.frontmatter?.name ?? spec.name,
+            description: impl?.frontmatter?.description ?? spec.description ?? "",
+            instructions: impl?.instructions ?? "",
+            resources: [],
+            readResource: async () => "",
+            getResourcesByType: () => [],
+            dirPath: impl?.dirPath ?? ""
+          }
+        });
+        return normalizeToolOutput(out);
+      }
+      if (spec.kind === "langchain") {
+        if (!hasInvokeFunction(spec.impl)) {
+          throw new Error(`Local langchain tool ${spec.name} missing invoke()`);
+        }
+        const out = await spec.impl.invoke(args);
+        return normalizeToolOutput(out);
+      }
+      if (spec.kind === "n8n") {
+        if (!spec.endpoint) {
+          throw new Error(`Local n8n tool ${spec.name} missing endpoint/webhook URL`);
+        }
+        const res = await fetch(spec.endpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(args ?? {})
+        });
+        if (!res.ok) {
+          throw new Error(`n8n request failed (${res.status})`);
+        }
+        const text = await res.text();
+        if (!text.trim()) return { result: {} };
+        try {
+          return { result: JSON.parse(text) };
+        } catch {
+          return { result: text };
+        }
+      }
+      if (spec.kind === "function") {
+        const meta = spec._meta;
+        if (!meta?.sourcePath || !meta?.exportName || !meta?.projectPath) {
+          throw new Error(`Local function ${spec.name} missing sourcePath/exportName/projectPath`);
+        }
+        const source = path.resolve(meta.projectPath, meta.sourcePath);
+        const mod = await import(url.pathToFileURL(source).href);
+        const fn = mod[meta.exportName];
+        if (typeof fn !== "function") {
+          throw new Error(`Local function ${spec.name} export "${meta.exportName}" is not a function`);
+        }
+        const out = await fn(args);
+        return normalizeToolOutput(out);
+      }
+      throw new Error(`Local directory tool kind not supported for invoke: ${spec.kind}`);
+    }
+  };
+}
+function resolveFileDescriptorPath(descriptor, configFilePath) {
+  const parsed = parseToolPath(descriptor.trim());
+  if (!parsed || parsed.protocol !== "file") return null;
+  const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
+  const configDir = path.dirname(localPath);
+  return path.resolve(configDir, `${parsed.scope}/${parsed.packageWithVersion}`);
+}
 function getRegisterFn(mod) {
   return mod?.register ?? mod?.registerCoreTools;
 }
@@ -1869,11 +3501,11 @@ function parseNpmDescriptor(entry) {
 }
 function loadExtensionFromFileDescriptorSync(descriptor, configFilePath, stepLog) {
   const entryStr = descriptor.trim();
-  const path$1 = parseToolPath(entryStr);
-  if (!path$1 || path$1.protocol !== "file") return null;
+  const path7 = parseToolPath(entryStr);
+  if (!path7 || path7.protocol !== "file") return null;
   const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
   const configDir = path.dirname(localPath);
-  const pathPart = `${path$1.scope}/${path$1.packageWithVersion}`;
+  const pathPart = `${path7.scope}/${path7.packageWithVersion}`;
   const resolvedPath = path.resolve(configDir, pathPart);
   if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isDirectory()) return null;
   try {
@@ -2016,6 +3648,29 @@ async function loadExtensionForDescriptorAsync(descriptor, configFilePath, stepL
   }
   return null;
 }
+async function loadLocalDirectoryForFileDescriptor(descriptor, configFilePath, stepLog) {
+  const resolvedPath = resolveFileDescriptorPath(descriptor, configFilePath);
+  if (!resolvedPath || !fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isDirectory()) return null;
+  if (fs.existsSync(path.join(resolvedPath, "package.json"))) return null;
+  const scanErrors = [];
+  const scanner = new DirectoryScanner({
+    roots: [{ path: resolvedPath, namespace: "local" }],
+    onError: (toolDir, error) => scanErrors.push(`${toolDir}: ${error.message}`)
+  });
+  const specs = await scanner.scan();
+  if (scanErrors.length > 0 && stepLog) {
+    stepLog(`Local directory scan (${descriptor}) reported ${scanErrors.length} error(s)`);
+  }
+  if (specs.length === 0) return null;
+  if (stepLog) {
+    stepLog(`Loaded ${specs.length} local tool(s) from ${descriptor}`);
+  }
+  return {
+    specs,
+    descriptor: descriptor.trim(),
+    resolvedVersion: "local"
+  };
+}
 async function loadAllExtensionsFromToolYamlAsync(configFilePath, stepLog) {
   const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
   if (!fs.existsSync(localPath)) return [];
@@ -2031,7 +3686,12 @@ async function loadAllExtensionsFromToolYamlAsync(configFilePath, stepLog) {
       if (result) loaded.push(result);
     } else if (entryStr.startsWith("file:")) {
       const result = loadExtensionFromFileDescriptorSync(entryStr, configFilePath, stepLog);
-      if (result) loaded.push(result);
+      if (result) {
+        loaded.push(result);
+      } else {
+        const local = await loadLocalDirectoryForFileDescriptor(entryStr, configFilePath, stepLog);
+        if (local) loaded.push(local);
+      }
     }
   }
   return loaded;
@@ -2092,10 +3752,28 @@ async function createRuntimeFromConfig(options = {}) {
         const before = new Set(registry.snapshot().map((s) => s.name));
         const prefix = ext.descriptor.startsWith("file:") ? fileDescriptorToRegistryPrefix(ext.descriptor) : npmDescriptorToRegistryPrefix(ext.descriptor, ext.resolvedVersion);
         const reg = createPrefixingRegistry(registry, prefix ?? "");
-        const adapter = ext.register(reg, options.coreTools);
-        runtime.registerAdapter(adapter);
-        const registeredNow = registry.snapshot().map((s) => s.name).filter((name) => !before.has(name));
-        runtime.registerAdapterForTools(registeredNow, adapter);
+        if ("register" in ext) {
+          const adapter = ext.register(reg, options.coreTools);
+          runtime.registerAdapter(adapter);
+          const registeredNow = registry.snapshot().map((s) => s.name).filter((name) => !before.has(name));
+          runtime.registerAdapterForTools(registeredNow, adapter);
+        } else {
+          reg.bulkRegister(ext.specs);
+          const registeredNow = registry.snapshot().map((s) => s.name).filter((name) => !before.has(name));
+          const byKind = /* @__PURE__ */ new Map();
+          for (const toolName of registeredNow) {
+            const spec = registry.get(toolName);
+            if (!spec) continue;
+            const list = byKind.get(spec.kind) ?? [];
+            list.push(toolName);
+            byKind.set(spec.kind, list);
+          }
+          for (const [kind, names] of byKind.entries()) {
+            const adapter = createLocalDirectoryAdapter(kind);
+            runtime.registerAdapter(adapter);
+            runtime.registerAdapterForTools(names, adapter);
+          }
+        }
       }
       return { runtime, registry };
     }
@@ -2263,17 +3941,17 @@ var DEFAULT_CTX = {
   ]
 };
 function parseBody(req) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve10, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve4({});
+        resolve10({});
         return;
       }
       try {
-        resolve4(JSON.parse(raw));
+        resolve10(JSON.parse(raw));
       } catch {
         reject(new Error("Invalid JSON body"));
       }
@@ -2321,8 +3999,8 @@ function createOpenAPIHttpServer(runtime, options = {}) {
   const ctxFactory = options.execContextFactory ?? (() => ({ ...DEFAULT_CTX }));
   const server = http.createServer(async (req, res) => {
     const url = req.url ?? "/";
-    const path = url.split("?")[0] ?? "/";
-    const norm = basePath ? path === basePath ? "" : path.replace(basePath, "") || "/" : path;
+    const path7 = url.split("?")[0] ?? "/";
+    const norm = basePath ? path7 === basePath ? "" : path7.replace(basePath, "") || "/" : path7;
     try {
       if (req.method === "GET" && (norm === "/" || norm === "/swagger")) {
         const specPath = basePath ? `${basePath}/openapi.json` : "/openapi.json";
@@ -2412,13 +4090,13 @@ function createOpenAPIHttpServer(runtime, options = {}) {
   return server;
 }
 function listenOpenAPIHttpServer(server, options = {}) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve10, reject) => {
     const port = options.port ?? 0;
     const host = options.host ?? "localhost";
     server.listen(port, host, () => {
       const addr = server.address();
       const actualPort = typeof addr === "object" && addr?.port != null ? addr.port : port;
-      resolve4({ port: actualPort, host });
+      resolve10({ port: actualPort, host });
     });
     server.on("error", reject);
   });
@@ -2438,9 +4116,6 @@ async function createHttpService(runtimeOrConfig, options = {}) {
   };
 }
 
-// src/tools/mcp/types.ts
-var MCP_KIND = "mcp";
-
 // src/api/expose/mcpServer.ts
 var DEFAULT_CTX2 = {
   requestId: `mcp-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
@@ -2543,24 +4218,24 @@ function createMCPStreamableHttpHandler(runtimeOrConfig, options = {}) {
   })();
 }
 async function createMCPServerStreamableHttp(runtimeOrConfig, options = {}) {
-  const path = options.path ?? "/mcp";
+  const path7 = options.path ?? "/mcp";
   const host = options.host ?? "127.0.0.1";
   const port = options.port ?? 3e3;
   const { createMcpExpressApp } = await import('@modelcontextprotocol/sdk/server/express.js');
   const handler = "invoke" in runtimeOrConfig && typeof runtimeOrConfig.invoke === "function" ? createMCPStreamableHttpHandler(runtimeOrConfig, options) : await createMCPStreamableHttpHandler(runtimeOrConfig, options);
   const app = createMcpExpressApp({ host });
-  app.post(path, handler);
+  app.post(path7, handler);
   return {
     app,
-    path,
+    path: path7,
     async listen(listenPort, listenHost) {
       const p = listenPort ?? port;
       const h = listenHost ?? host;
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve10, reject) => {
         const server = app.listen(p, h, () => {
           const addr = server.address();
           const actualPort = typeof addr === "object" && addr !== null && "port" in addr ? addr.port : p;
-          resolve4({ url: `http://${h}:${actualPort}${path}`, port: actualPort });
+          resolve10({ url: `http://${h}:${actualPort}${path7}`, port: actualPort });
         });
       });
     }
@@ -2572,20 +4247,18 @@ async function runMCPServerOverStdio(runtime, options = {}) {
   return result;
 }
 
-// src/tools/langchain/types.ts
-var LANGCHAIN_KIND = "langchain";
-var LANGCHAIN_DIR_NAME = "langchain";
-
-exports.LANGCHAIN_DIR_NAME = LANGCHAIN_DIR_NAME;
+exports.FUNCTION_KIND = FUNCTION_KIND;
 exports.LANGCHAIN_KIND = LANGCHAIN_KIND;
-exports.MCP_KIND = MCP_KIND;
+exports.N8N_KIND = N8N_KIND;
 exports.PTCRuntime = PTCRuntime;
+exports.SKILL_KIND = SKILL_KIND;
 exports.createHttpService = createHttpService;
 exports.createMCPServer = createMCPServer;
 exports.createMCPServerStreamableHttp = createMCPServerStreamableHttp;
 exports.createMCPStreamableHttpHandler = createMCPStreamableHttpHandler;
 exports.createRuntimeFromConfig = createRuntimeFromConfig;
 exports.createRuntimeFromConfigSync = createRuntimeFromConfigSync;
+exports.discoverTools = discoverTools;
 exports.expandToolDescriptorsToRegistryNames = expandToolDescriptorsToRegistryNames;
 exports.fileDescriptorToPackagePrefix = fileDescriptorToPackagePrefix;
 exports.findAndLoadToolConfig = findAndLoadToolConfig;
@@ -2597,6 +4270,8 @@ exports.resolveSandboxedPath = resolveSandboxedPath;
 exports.resolveSandboxedPath2 = resolveSandboxedPath2;
 exports.resolveToolDescriptor = resolveToolDescriptor;
 exports.runMCPServerOverStdio = runMCPServerOverStdio;
+exports.scan = scan;
+exports.scanForTools = scanForTools;
 exports.setSandboxValidationEnabled = setSandboxValidationEnabled;
-//# sourceMappingURL=chunk-WFPHIYB6.cjs.map
-//# sourceMappingURL=chunk-WFPHIYB6.cjs.map
+//# sourceMappingURL=chunk-D2T3NTFN.cjs.map
+//# sourceMappingURL=chunk-D2T3NTFN.cjs.map