@easynet/agent-tool 1.0.59 → 1.0.61

package/dist/{chunk-A5C2MUNA.js → chunk-NVT4X4CB.js}

@@ -1,10 +1,11 @@
-import { ToolRegistry, createTaggedError, withRetry } from './chunk-FCYBA7PR.js';
-import { normalizeToolName, DEFAULT_OUTPUT_SCHEMA } from './chunk-ODEHUAR4.js';
 import { enrichSpecWithCanonicalSchema } from './chunk-NTWOVFEY.js';
-import * as fs from 'fs';
+import { MCP_KIND, DirectoryScanner } from './chunk-YRFUGA3C.js';
+import { setSandboxValidationEnabled } from './chunk-QXQ4477T.js';
+import { ToolRegistry } from './chunk-WUMLZERG.js';
+import { createTaggedError, withRetry } from './chunk-RZTTO5MQ.js';
+import { normalizeToolName } from './chunk-ODEHUAR4.js';
 import { readFileSync, existsSync, statSync } from 'fs';
-import * as path from 'path';
-import { resolve, dirname, join, normalize, basename, isAbsolute, extname, relative } from 'path';
+import { resolve, dirname, join, isAbsolute, basename } from 'path';
 import { parseYamlContent, resolveConfigPath } from '@easynet/agent-common';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
@@ -12,11 +13,8 @@ import { bulkhead, circuitBreaker, handleAll, ConsecutiveBreaker } from 'cockati
 import { EventEmitter } from 'eventemitter3';
 import { v4 } from 'uuid';
 import pTimeout from 'p-timeout';
-import { realpath, access, readdir, readFile, stat } from 'fs/promises';
-import * as ts2 from 'typescript';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
-import yaml from 'js-yaml';
 import { resolveLatestVersionFromRegistry, ensurePackageInCache, getPackageEntryPath, importFromCache } from '@easynet/agent-common/npm';
 import { createServer } from 'http';
 
@@ -197,13 +195,13 @@ function expandToolDescriptorsToRegistryNames(descriptors, registryNames) {
         out.push(s);
         continue;
       }
-      const path7 = parseToolPath(s);
-      if (path7) {
-        const packagePrefix = path7.protocol === "npm" ? npmDescriptorToPackagePrefix(s) : path7.protocol === "file" ? fileDescriptorToPackagePrefix(s) : "";
+      const path = parseToolPath(s);
+      if (path) {
+        const packagePrefix = path.protocol === "npm" ? npmDescriptorToPackagePrefix(s) : path.protocol === "file" ? fileDescriptorToPackagePrefix(s) : "";
         const prefixWithDot = packagePrefix ? packagePrefix + "." : "";
         if (prefixWithDot) {
-          if (path7.toolName) {
-            const suffix = "." + path7.toolName;
+          if (path.toolName) {
+            const suffix = "." + path.toolName;
             for (const r of registryNames) {
               if (r.startsWith(prefixWithDot) && r.endsWith(suffix) && !seen.has(r)) {
                 seen.add(r);
@@ -232,9 +230,9 @@ function resolveToolDescriptor(descriptor) {
   return s;
 }
 function fileDescriptorToPackagePrefix(descriptor) {
-  const path7 = parseToolPath(descriptor.trim());
-  if (!path7 || path7.protocol !== "file") return "";
-  const pathPart = `${path7.scope}/${path7.packageWithVersion}`;
+  const path = parseToolPath(descriptor.trim());
+  if (!path || path.protocol !== "file") return "";
+  const pathPart = `${path.scope}/${path.packageWithVersion}`;
   const normalized = normalizeToolName(pathPart);
   if (!normalized) return "";
   return normalizeToolName("file." + normalized);
@@ -534,17 +532,17 @@ var PolicyEngine = class {
    */
   extractStringValues(args, keyPatterns) {
     const results = [];
-    const walk2 = (obj) => {
+    const walk = (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)) {
-          walk2(val);
+          walk(val);
         }
       }
     };
-    walk2(args);
+    walk(args);
     return results;
   }
 };
@@ -729,30 +727,30 @@ function summarizeValue(value, maxLen) {
 }
 function extractUrls(obj) {
   const urls = [];
-  const walk2 = (val) => {
+  const walk = (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)) {
-        walk2(v);
+        walk(v);
       }
     }
   };
-  walk2(obj);
+  walk(obj);
   return urls.slice(0, 10);
 }
 function extractFilePaths(obj) {
   const paths = [];
-  const walk2 = (val) => {
+  const walk = (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)) {
-        walk2(v);
+        walk(v);
       }
     }
   };
-  walk2(obj);
+  walk(obj);
   return paths.slice(0, 10);
 }
 var EventLog = class {
@@ -1719,1563 +1717,6 @@ function buildInputSchemaHint(inputSchema) {
   if (names.length === 0) return null;
   return `This tool expects input property ${names.length === 1 ? `'${names[0]}'` : `one of [${names.map((n) => `'${n}'`).join(", ")}]`}. Use the exact property names from the tool schema.`;
 }
-var sandboxValidationEnabled = false;
-function setSandboxValidationEnabled(enabled) {
-  sandboxValidationEnabled = enabled;
-}
-async function resolveSandboxedPath2(inputPath, sandboxRoot) {
-  let normalizedRoot;
-  try {
-    normalizedRoot = await realpath(resolve(sandboxRoot));
-  } catch {
-    normalizedRoot = normalize(resolve(sandboxRoot));
-  }
-  const resolved = resolve(normalizedRoot, inputPath);
-  let real;
-  try {
-    await access(resolved);
-    real = await realpath(resolved);
-  } catch {
-    const parentDir = dirname(resolved);
-    let realParent;
-    try {
-      await access(parentDir);
-      realParent = await realpath(parentDir);
-    } catch {
-      realParent = normalize(parentDir);
-    }
-    real = resolve(realParent, basename(resolved));
-  }
-  if (sandboxValidationEnabled && !isWithinRoot(real, normalizedRoot)) {
-    throw createTaggedError(
-      "PATH_OUTSIDE_SANDBOX",
-      `Path "${inputPath}" resolves to "${real}" which is outside sandbox "${normalizedRoot}"`,
-      { inputPath, resolvedPath: real, sandboxRoot: normalizedRoot }
-    );
-  }
-  return real;
-}
-function isWithinRoot(path7, root) {
-  const normalizedPath = normalize(path7);
-  const normalizedRoot = 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 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(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.TypeFlags.String) return { type: "string" };
-  if (flags & ts2.TypeFlags.Number) return { type: "number" };
-  if (flags & ts2.TypeFlags.Boolean) return { type: "boolean" };
-  if (flags & ts2.TypeFlags.BooleanLiteral) return { type: "boolean" };
-  if (flags & ts2.TypeFlags.Null) return { type: "null" };
-  if (flags & ts2.TypeFlags.Undefined || flags & ts2.TypeFlags.Void) return {};
-  if (flags & ts2.TypeFlags.Any || flags & ts2.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.TypeFlags.Undefined) && !(t.flags & ts2.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.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.TypeFlags.BooleanLiteral)) {
-        allBooleanLiterals = false;
-        break;
-      }
-    }
-    if (allBooleanLiterals) return { type: "boolean" };
-  }
-  if (flags & ts2.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.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 : 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.resolve(options.projectPath);
-  const tsconfigPath = options.tsconfigPath ?? path.join(projectPath, "tsconfig.json");
-  const include = options.include ?? ["**/*.ts"];
-  const errors = [];
-  const warnings = [];
-  let config;
-  let configPathResolved = path.resolve(projectPath, tsconfigPath);
-  if (!fs.existsSync(configPathResolved)) {
-    configPathResolved = path.join(projectPath, "tsconfig.json");
-  }
-  if (fs.existsSync(configPathResolved)) {
-    const configFile = ts2.readConfigFile(configPathResolved, ts2.sys.readFile);
-    if (configFile.error) {
-      errors.push({ file: configPathResolved, message: String(configFile.error.messageText) });
-      return { specs: [], errors, warnings };
-    }
-    const parsed = ts2.parseJsonConfigFileContent(
-      configFile.config,
-      ts2.sys,
-      path.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.ScriptTarget.ES2022,
-        module: ts2.ModuleKind.ESNext,
-        moduleResolution: ts2.ModuleResolutionKind.NodeNext,
-        strict: true,
-        skipLibCheck: true,
-        noEmit: true
-      },
-      fileNames: resolveGlob(projectPath, include),
-      errors: []
-    };
-  }
-  const program = ts2.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.resolve(f) === path.resolve(fileName))) continue;
-    ts2.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.relative(projectPath, fileName) || path.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.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.join(projectPath, p);
-    if (full.includes("*")) {
-      const baseDir = full.replace(/\*\*\/.*$/, "").replace(/\*.*$/, "").replace(/\/?$/, "") || ".";
-      const dir = path.resolve(projectPath, baseDir);
-      if (fs.existsSync(dir)) walk(dir, add);
-    } else {
-      const resolved = path.resolve(projectPath, full);
-      if (fs.existsSync(resolved)) {
-        if (fs.statSync(resolved).isFile()) add(resolved);
-        else walk(resolved, add);
-      }
-    }
-  }
-  if (result.length > 0) return result;
-  const srcDir = path.join(projectPath, "src");
-  if (fs.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.resolve(fullPath));
-  });
-  return out;
-}
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "generated", "dist"]);
-function walk(dir, visit) {
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const e of entries) {
-      const full = path.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.isFunctionDeclaration(node) && node.name) {
-    const exported = (ts2.getModifiers(node) ?? []).some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
-    if (exported) return { func: node, name: node.name.getText() };
-    return null;
-  }
-  if (ts2.isVariableStatement(node)) {
-    const exported = (ts2.getModifiers(node) ?? []).some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
-    if (!exported) return null;
-    for (const decl of node.declarationList.declarations) {
-      let init = decl.initializer;
-      while (init && (ts2.isParenthesizedExpression(init) || ts2.isAsExpression(init)))
-        init = init.expression;
-      if (init && ts2.isArrowFunction(init)) {
-        const name = decl.name.getText();
-        return { func: init, name };
-      }
-      if (init && ts2.isFunctionExpression(init)) {
-        const name = decl.name.getText();
-        return { func: init, name };
-      }
-    }
-  }
-  return null;
-}
-function getJSDocHost(node) {
-  const parent = node.parent;
-  if (ts2.isVariableDeclaration(parent)) {
-    const gp = parent.parent;
-    if (ts2.isVariableDeclarationList(gp) && gp.parent && ts2.isVariableStatement(gp.parent)) return gp.parent;
-  }
-  return node;
-}
-function getJSDocComments(host) {
-  const all = ts2.getJSDocCommentsAndTags(host);
-  return all.filter((t) => ts2.isJSDoc(t));
-}
-function hasToolTag(host) {
-  const tags = ts2.getJSDocTags(host);
-  for (const tag of tags) {
-    const name = tag.tagName?.getText() ?? "";
-    if (name === "tool") return true;
-  }
-  const all = ts2.getJSDocCommentsAndTags(host);
-  for (const t of all) {
-    if (ts2.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.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.getJSDocCommentsAndTags(host);
-  for (const t of all) {
-    if (ts2.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.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 = 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(", ")}`
-  );
-}
-
-// 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.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 readdir(currentPath, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    const fullPath = 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 = extname(entry.name).toLowerCase();
-      const relPath = 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 = join(dirPath, "SKILL.md");
-  let content;
-  try {
-    content = await 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.resolve(projectPath);
-  const dirs = await findDirsContainingFile(projectRoot, "SKILL.md");
-  const skills = [];
-  const errors = [];
-  for (const dirPath of dirs) {
-    const relativePath = path.relative(projectRoot, dirPath) || path.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.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;
-  try {
-    raw = await 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 || 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.resolve(projectPath);
-  const dirs = await findDirsContainingFile(projectRoot, "workflow.json");
-  const n8n = [];
-  const errors = [];
-  for (const dirPath of dirs) {
-    const relativePath = path.relative(projectRoot, dirPath) || path.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.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.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.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;
-}
-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 };
-}
-
-// 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.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(path7) {
-    try {
-      await 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 = 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/api/runtimeFromConfig.ts
 var requireFromPackage = createRequire(import.meta.url);
@@ -3472,11 +1913,11 @@ function parseNpmDescriptor(entry) {
 }
 function loadExtensionFromFileDescriptorSync(descriptor, configFilePath, stepLog) {
   const entryStr = descriptor.trim();
-  const path7 = parseToolPath(entryStr);
-  if (!path7 || path7.protocol !== "file") return null;
+  const path = parseToolPath(entryStr);
+  if (!path || path.protocol !== "file") return null;
   const localPath = isAbsolute(configFilePath) ? configFilePath : resolve(process.cwd(), configFilePath);
   const configDir = dirname(localPath);
-  const pathPart = `${path7.scope}/${path7.packageWithVersion}`;
+  const pathPart = `${path.scope}/${path.packageWithVersion}`;
   const resolvedPath = resolve(configDir, pathPart);
   if (!existsSync(resolvedPath) || !statSync(resolvedPath).isDirectory()) return null;
   try {
@@ -3943,18 +2384,18 @@ var BodyParseError = class extends Error {
   }
 };
 function parseBody(req) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve3, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve10({});
+        resolve3({});
         return;
       }
       const parsed = safeParseToolArgs(raw);
       if (parsed.ok) {
-        resolve10(parsed.value);
+        resolve3(parsed.value);
         return;
       }
       reject(new BodyParseError("Invalid JSON body", parsed.hint));
@@ -4002,8 +2443,8 @@ function createOpenAPIHttpServer(runtime, options = {}) {
   const ctxFactory = options.execContextFactory ?? (() => ({ ...DEFAULT_CTX }));
   const server = createServer(async (req, res) => {
     const url = req.url ?? "/";
-    const path7 = url.split("?")[0] ?? "/";
-    const norm = basePath ? path7 === basePath ? "" : path7.replace(basePath, "") || "/" : path7;
+    const path = url.split("?")[0] ?? "/";
+    const norm = basePath ? path === basePath ? "" : path.replace(basePath, "") || "/" : path;
     try {
       if (req.method === "GET" && (norm === "/" || norm === "/swagger")) {
         const specPath = basePath ? `${basePath}/openapi.json` : "/openapi.json";
@@ -4112,13 +2553,13 @@ function createOpenAPIHttpServer(runtime, options = {}) {
   return server;
 }
 function listenOpenAPIHttpServer(server, options = {}) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve3, 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;
-      resolve10({ port: actualPort, host });
+      resolve3({ port: actualPort, host });
     });
     server.on("error", reject);
   });
@@ -4240,24 +2681,24 @@ function createMCPStreamableHttpHandler(runtimeOrConfig, options = {}) {
   })();
 }
 async function createMCPServerStreamableHttp(runtimeOrConfig, options = {}) {
-  const path7 = options.path ?? "/mcp";
+  const path = 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(path7, handler);
+  app.post(path, handler);
   return {
     app,
-    path: path7,
+    path,
     async listen(listenPort, listenHost) {
       const p = listenPort ?? port;
       const h = listenHost ?? host;
-      return new Promise((resolve10, reject) => {
+      return new Promise((resolve3, reject) => {
         const server = app.listen(p, h, () => {
           const addr = server.address();
           const actualPort = typeof addr === "object" && addr !== null && "port" in addr ? addr.port : p;
-          resolve10({ url: `http://${h}:${actualPort}${path7}`, port: actualPort });
+          resolve3({ url: `http://${h}:${actualPort}${path}`, port: actualPort });
         });
       });
     }
@@ -4269,6 +2710,6 @@ async function runMCPServerOverStdio(runtime, options = {}) {
   return result;
 }
 
-export { FUNCTION_KIND, LANGCHAIN_KIND, N8N_KIND, PTCRuntime, SKILL_KIND, createHttpService, createMCPServer, createMCPServerStreamableHttp, createMCPStreamableHttpHandler, createRuntimeFromConfig, createRuntimeFromConfigSync, discoverTools, expandToolDescriptorsToRegistryNames, fileDescriptorToPackagePrefix, findAndLoadToolConfig, getDisplayScope, isBarePackageDescriptor, loadToolConfig, npmDescriptorToPackagePrefixWithVersion, resolveSandboxedPath, resolveSandboxedPath2, resolveToolDescriptor, runMCPServerOverStdio, scan, scanForTools, setSandboxValidationEnabled };
-//# sourceMappingURL=chunk-A5C2MUNA.js.map
-//# sourceMappingURL=chunk-A5C2MUNA.js.map
+export { PTCRuntime, createHttpService, createMCPServer, createMCPServerStreamableHttp, createMCPStreamableHttpHandler, createRuntimeFromConfig, createRuntimeFromConfigSync, expandToolDescriptorsToRegistryNames, fileDescriptorToPackagePrefix, findAndLoadToolConfig, getDisplayScope, isBarePackageDescriptor, loadToolConfig, npmDescriptorToPackagePrefixWithVersion, resolveSandboxedPath, resolveToolDescriptor, runMCPServerOverStdio };
+//# sourceMappingURL=chunk-NVT4X4CB.js.map
+//# sourceMappingURL=chunk-NVT4X4CB.js.map