@easynet/agent-tool 1.0.59 → 1.0.61

package/dist/{chunk-JXYANBTH.cjs → chunk-HK4GTFTQ.cjs}

@@ -1,8 +1,11 @@
 'use strict';
 
-var chunkWQMHMPNC_cjs = require('./chunk-WQMHMPNC.cjs');
-var chunkQEJF3KDV_cjs = require('./chunk-QEJF3KDV.cjs');
 var chunkUUNG3GL3_cjs = require('./chunk-UUNG3GL3.cjs');
+var chunkOG5ZSXQ5_cjs = require('./chunk-OG5ZSXQ5.cjs');
+var chunkZDSZHEQU_cjs = require('./chunk-ZDSZHEQU.cjs');
+var chunkPYCCJF7C_cjs = require('./chunk-PYCCJF7C.cjs');
+var chunkXPGHS4W7_cjs = require('./chunk-XPGHS4W7.cjs');
+var chunkQEJF3KDV_cjs = require('./chunk-QEJF3KDV.cjs');
 var fs = require('fs');
 var path = require('path');
 var agentCommon = require('@easynet/agent-common');
@@ -12,42 +15,17 @@ var cockatiel = require('cockatiel');
 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);
@@ -226,13 +204,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);
@@ -261,9 +239,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 = chunkQEJF3KDV_cjs.normalizeToolName(pathPart);
   if (!normalized) return "";
   return chunkQEJF3KDV_cjs.normalizeToolName("file." + normalized);
@@ -563,17 +541,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;
   }
 };
@@ -758,30 +736,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 {
@@ -1191,7 +1169,7 @@ function resolveTool(toolName, registry) {
   const key = chunkQEJF3KDV_cjs.normalizeToolName(toolName);
   const spec = registry.get(key);
   if (!spec) {
-    throw chunkWQMHMPNC_cjs.createTaggedError(
+    throw chunkXPGHS4W7_cjs.createTaggedError(
       "TOOL_NOT_FOUND",
       `Tool not found: ${toolName}`,
       { availableTools: registry.snapshot().slice(0, 20).map((s) => s.name) }
@@ -1230,7 +1208,7 @@ function validateInput(spec, args, validator) {
     if (error instanceof SchemaValidationError) {
       const requiredKeys = getRequiredKeys(spec.inputSchema);
       const passedKeys = args != null && typeof args === "object" && !Array.isArray(args) ? Object.keys(args) : [];
-      throw chunkWQMHMPNC_cjs.createTaggedError("INPUT_SCHEMA_INVALID", error.message, {
+      throw chunkXPGHS4W7_cjs.createTaggedError("INPUT_SCHEMA_INVALID", error.message, {
         errors: error.errors,
         schema: spec.inputSchema,
         requiredKeys: requiredKeys.length ? requiredKeys : void 0,
@@ -1303,7 +1281,7 @@ async function requireHumanApproval(spec, args, ctx, deps) {
       sideEffect,
       reason: err instanceof Error ? err.message : String(err)
     });
-    throw chunkWQMHMPNC_cjs.createTaggedError(
+    throw chunkXPGHS4W7_cjs.createTaggedError(
       "HITL_DENIED",
       `Human denied approval for ${spec.name} (${sideEffect})`,
       { reason: err instanceof Error ? err.message : String(err) }
@@ -1316,7 +1294,7 @@ async function requireHumanApproval(spec, args, ctx, deps) {
       sideEffect,
       reason: "User rejected"
     });
-    throw chunkWQMHMPNC_cjs.createTaggedError("HITL_DENIED", `Human denied approval for ${spec.name} (${sideEffect})`);
+    throw chunkXPGHS4W7_cjs.createTaggedError("HITL_DENIED", `Human denied approval for ${spec.name} (${sideEffect})`);
   }
   deps.eventLog.append({
     ...baseEvent,
@@ -1328,7 +1306,7 @@ async function requireHumanApproval(spec, args, ctx, deps) {
 async function executeWithBudget(spec, args, ctx, spanId, deps) {
   const adapter = deps.adaptersByToolName.get(spec.name) ?? deps.adapters.get(spec.kind);
   if (!adapter) {
-    throw chunkWQMHMPNC_cjs.createTaggedError(
+    throw chunkXPGHS4W7_cjs.createTaggedError(
       "TOOL_NOT_FOUND",
       `No adapter registered for kind: ${spec.kind}`
     );
@@ -1356,7 +1334,7 @@ async function executeWithBudget(spec, args, ctx, spanId, deps) {
       return result;
     });
   };
-  const retryFn = () => chunkWQMHMPNC_cjs.withRetry(executeFn, {
+  const retryFn = () => chunkXPGHS4W7_cjs.withRetry(executeFn, {
     maxRetries,
     onRetry: (error, attempt) => {
       deps.metrics.recordRetry(spec.name);
@@ -1383,7 +1361,7 @@ async function executeWithBudget(spec, args, ctx, spanId, deps) {
     });
   } catch (error) {
     if (error instanceof Error && error.message.includes("timed out")) {
-      throw chunkWQMHMPNC_cjs.createTaggedError("TIMEOUT", error.message);
+      throw chunkXPGHS4W7_cjs.createTaggedError("TIMEOUT", error.message);
     }
     throw error;
   }
@@ -1397,7 +1375,7 @@ function validateOutput(spec, result, validator) {
     );
   } catch (error) {
     if (error instanceof SchemaValidationError) {
-      throw chunkWQMHMPNC_cjs.createTaggedError("OUTPUT_SCHEMA_INVALID", error.message, {
+      throw chunkXPGHS4W7_cjs.createTaggedError("OUTPUT_SCHEMA_INVALID", error.message, {
         errors: error.errors
       });
     }
@@ -1491,7 +1469,7 @@ var PTCRuntime = class {
   logger;
   constructor(options = {}) {
     this.config = options.config ?? {};
-    this.registry = options.registry ?? new chunkWQMHMPNC_cjs.ToolRegistry();
+    this.registry = options.registry ?? new chunkPYCCJF7C_cjs.ToolRegistry();
     this.validator = options.validator ?? new SchemaValidator();
     this.policy = options.policy ?? new PolicyEngine(this.config.policy);
     this.budget = options.budget ?? new BudgetManager(this.config.budget);
@@ -1601,7 +1579,7 @@ var PTCRuntime = class {
         tracing: this.tracing
       });
       if (!this.budget.checkRateLimit(spec.name)) {
-        throw chunkWQMHMPNC_cjs.createTaggedError(
+        throw chunkXPGHS4W7_cjs.createTaggedError(
           "BUDGET_EXCEEDED",
           `Rate limit exceeded for tool: ${spec.name}`
         );
@@ -1624,7 +1602,7 @@ var PTCRuntime = class {
       const toolError = asToolReturnedError(result);
       if (toolError) {
         const hint = buildInputSchemaHint(spec.inputSchema);
-        throw chunkWQMHMPNC_cjs.createTaggedError("UPSTREAM_ERROR", toolError.message, {
+        throw chunkXPGHS4W7_cjs.createTaggedError("UPSTREAM_ERROR", toolError.message, {
           ...toolError.details && typeof toolError.details === "object" && !Array.isArray(toolError.details) ? toolError.details : {},
           hint: hint ?? "Check the tool's input schema for required property names."
         });
@@ -1748,1566 +1726,9 @@ 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 promises.realpath(path.resolve(sandboxRoot));
-  } catch {
-    normalizedRoot = path.normalize(path.resolve(sandboxRoot));
-  }
-  const resolved = path.resolve(normalizedRoot, inputPath);
-  let real;
-  try {
-    await promises.access(resolved);
-    real = await promises.realpath(resolved);
-  } catch {
-    const parentDir = path.dirname(resolved);
-    let realParent;
-    try {
-      await promises.access(parentDir);
-      realParent = await promises.realpath(parentDir);
-    } catch {
-      realParent = path.normalize(parentDir);
-    }
-    real = path.resolve(realParent, path.basename(resolved));
-  }
-  if (sandboxValidationEnabled && !isWithinRoot(real, normalizedRoot)) {
-    throw chunkWQMHMPNC_cjs.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 = 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-JXYANBTH.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-HK4GTFTQ.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"));
@@ -3501,11 +1922,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$1 = parseToolPath(entryStr);
+  if (!path$1 || path$1.protocol !== "file") return null;
   const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
   const configDir = path.dirname(localPath);
-  const pathPart = `${path7.scope}/${path7.packageWithVersion}`;
+  const pathPart = `${path$1.scope}/${path$1.packageWithVersion}`;
   const resolvedPath = path.resolve(configDir, pathPart);
   if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isDirectory()) return null;
   try {
@@ -3653,7 +2074,7 @@ async function loadLocalDirectoryForFileDescriptor(descriptor, configFilePath, s
   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({
+  const scanner = new chunkOG5ZSXQ5_cjs.DirectoryScanner({
     roots: [{ path: resolvedPath, namespace: "local" }],
     onError: (toolDir, error) => scanErrors.push(`${toolDir}: ${error.message}`)
   });
@@ -3697,9 +2118,9 @@ async function loadAllExtensionsFromToolYamlAsync(configFilePath, stepLog) {
   return loaded;
 }
 function createRuntimeFromConfigSync(options = {}) {
-  const registry = new chunkWQMHMPNC_cjs.ToolRegistry();
+  const registry = new chunkPYCCJF7C_cjs.ToolRegistry();
   const stepLog = options.stepLog;
-  setSandboxValidationEnabled(options.coreTools?.enableSandboxValidation === true);
+  chunkZDSZHEQU_cjs.setSandboxValidationEnabled(options.coreTools?.enableSandboxValidation === true);
   if (options.coreTools !== void 0) {
     if (options.configFilePath) {
       const all = loadAllExtensionsFromToolYamlSync(options.configFilePath, stepLog);
@@ -3741,12 +2162,12 @@ function createRuntimeFromConfigSync(options = {}) {
   return { runtime, registry };
 }
 async function createRuntimeFromConfig(options = {}) {
-  setSandboxValidationEnabled(options.coreTools?.enableSandboxValidation === true);
+  chunkZDSZHEQU_cjs.setSandboxValidationEnabled(options.coreTools?.enableSandboxValidation === true);
   if (options.coreTools !== void 0 && options.configFilePath) {
     const all = await loadAllExtensionsFromToolYamlAsync(options.configFilePath, options.stepLog);
     if (all.length > 0) {
       if (options.stepLog) options.stepLog(`Registered ${all.length} extension(s) from tool.yaml`);
-      const registry = new chunkWQMHMPNC_cjs.ToolRegistry();
+      const registry = new chunkPYCCJF7C_cjs.ToolRegistry();
       const runtime = new PTCRuntime({ registry });
       for (const ext of all) {
         const before = new Set(registry.snapshot().map((s) => s.name));
@@ -3972,18 +2393,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));
@@ -4031,8 +2452,8 @@ function createOpenAPIHttpServer(runtime, options = {}) {
   const ctxFactory = options.execContextFactory ?? (() => ({ ...DEFAULT_CTX }));
   const server = http.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";
@@ -4141,13 +2562,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);
   });
@@ -4205,7 +2626,7 @@ async function createMcpServerWithTools(runtime, options) {
       async (args) => {
         const ctx = ctxFactory();
         const result = await runtime.invoke(
-          { tool: spec.name, args: args ?? {}, purpose: MCP_KIND },
+          { tool: spec.name, args: args ?? {}, purpose: chunkOG5ZSXQ5_cjs.MCP_KIND },
           ctx
         );
         if (result.ok) {
@@ -4269,24 +2690,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 });
         });
       });
     }
@@ -4298,18 +2719,13 @@ async function runMCPServerOverStdio(runtime, options = {}) {
   return result;
 }
 
-exports.FUNCTION_KIND = FUNCTION_KIND;
-exports.LANGCHAIN_KIND = LANGCHAIN_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;
@@ -4318,11 +2734,7 @@ exports.isBarePackageDescriptor = isBarePackageDescriptor;
 exports.loadToolConfig = loadToolConfig;
 exports.npmDescriptorToPackagePrefixWithVersion = npmDescriptorToPackagePrefixWithVersion;
 exports.resolveSandboxedPath = resolveSandboxedPath;
-exports.resolveSandboxedPath2 = resolveSandboxedPath2;
 exports.resolveToolDescriptor = resolveToolDescriptor;
 exports.runMCPServerOverStdio = runMCPServerOverStdio;
-exports.scan = scan;
-exports.scanForTools = scanForTools;
-exports.setSandboxValidationEnabled = setSandboxValidationEnabled;
-//# sourceMappingURL=chunk-JXYANBTH.cjs.map
-//# sourceMappingURL=chunk-JXYANBTH.cjs.map
+//# sourceMappingURL=chunk-HK4GTFTQ.cjs.map
+//# sourceMappingURL=chunk-HK4GTFTQ.cjs.map