@easynet/agent-tool 1.0.45 → 1.0.47

package/dist/{chunk-JH6TWGP4.js → chunk-2ZPDD7ZO.js}

@@ -1,18 +1,243 @@
 import { ToolRegistry, createTaggedError, withRetry } from './chunk-ZRHPGW7W.js';
 import { normalizeToolName } from './chunk-KDB3MY2H.js';
+import { enrichSpecWithCanonicalSchema } from './chunk-NTWOVFEY.js';
+import { readFileSync, existsSync, statSync } from 'fs';
+import { resolve, dirname, join, normalize, basename, isAbsolute } from 'path';
+import { parseYamlContent, resolveConfigPath } from '@easynet/agent-common';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
 import { bulkhead, circuitBreaker, handleAll, ConsecutiveBreaker } from 'cockatiel';
 import { EventEmitter } from 'eventemitter3';
 import { v4 } from 'uuid';
 import pTimeout from 'p-timeout';
-import { resolve, normalize, dirname, basename, join, isAbsolute } from 'path';
 import { realpath, access } from 'fs/promises';
-import { readFileSync, existsSync, statSync } from 'fs';
-import { parseYamlContent, resolveConfigPath, resolveLatestVersionFromRegistry, ensurePackageInCache, getPackageEntryPath, importFromCache } from '@easynet/agent-common';
-export { ensurePackageInCache, getPackageEntryPath, importFromCache, resolveLatestVersionFromRegistry } from '@easynet/agent-common';
 import { createRequire } from 'module';
+import { resolveLatestVersionFromRegistry, ensurePackageInCache, getPackageEntryPath, importFromCache } from '@easynet/agent-common/npm';
+import { createServer } from 'http';
+
+function loadToolConfig(toolYamlPath) {
+  const abs = resolve(toolYamlPath);
+  const raw = readFileSync(abs, "utf8");
+  const parsed = parseYamlContent(raw, {
+    substituteEnv: false
+  });
+  if (!parsed || typeof parsed !== "object") return {};
+  const toolsBlock = parsed.tools;
+  if (toolsBlock != null && typeof toolsBlock === "object" && !Array.isArray(toolsBlock)) {
+    const toolDefaults = toolsBlock.defaults != null && typeof toolsBlock.defaults === "object" && !Array.isArray(toolsBlock.defaults) ? toolsBlock.defaults : void 0;
+    const packageToolDefaults2 = toolsBlock.packages != null && typeof toolsBlock.packages === "object" && !Array.isArray(toolsBlock.packages) ? toolsBlock.packages : void 0;
+    const list2 = Array.isArray(toolsBlock.list) && toolsBlock.list.length > 0 ? toolsBlock.list : void 0;
+    return {
+      tools: list2 ?? (packageToolDefaults2 ? Object.keys(packageToolDefaults2) : void 0),
+      sandboxedPath: typeof toolsBlock.sandboxedPath === "string" ? toolsBlock.sandboxedPath : parsed.sandboxedPath,
+      enableSandboxValidation: typeof toolsBlock.enableSandboxValidation === "boolean" ? toolsBlock.enableSandboxValidation : parsed.enableSandboxValidation,
+      allowedHosts: Array.isArray(toolsBlock.allowedHosts) ? toolsBlock.allowedHosts : parsed.allowedHosts,
+      blockedHosts: Array.isArray(toolsBlock.blockedHosts) ? toolsBlock.blockedHosts : parsed.blockedHosts,
+      blockedCidrs: Array.isArray(toolsBlock.blockedCidrs) ? toolsBlock.blockedCidrs : parsed.blockedCidrs,
+      toolDefaults,
+      packageToolDefaults: packageToolDefaults2
+    };
+  }
+  const packageToolDefaults = typeof parsed.packageToolDefaults === "object" && !Array.isArray(parsed.packageToolDefaults) ? parsed.packageToolDefaults : void 0;
+  const list = Array.isArray(parsed.tools) && parsed.tools.length > 0 ? parsed.tools : void 0;
+  return {
+    tools: list ?? (packageToolDefaults ? Object.keys(packageToolDefaults) : void 0),
+    sandboxedPath: parsed.sandboxedPath,
+    enableSandboxValidation: typeof parsed.enableSandboxValidation === "boolean" ? parsed.enableSandboxValidation : void 0,
+    allowedHosts: Array.isArray(parsed.allowedHosts) ? parsed.allowedHosts : void 0,
+    blockedHosts: Array.isArray(parsed.blockedHosts) ? parsed.blockedHosts : void 0,
+    blockedCidrs: Array.isArray(parsed.blockedCidrs) ? parsed.blockedCidrs : void 0,
+    toolDefaults: typeof parsed.toolDefaults === "object" && !Array.isArray(parsed.toolDefaults) ? parsed.toolDefaults : void 0,
+    packageToolDefaults
+  };
+}
+function resolveSandboxedPath(toolYamlPath, sandboxedPath) {
+  const configDir = dirname(resolve(toolYamlPath));
+  return resolveConfigPath(sandboxedPath, configDir, {
+    expandHome: true
+  });
+}
+var CACHE_SUBDIR = ".agent/cache";
+function getCacheBaseFromToolConfig(toolYamlPath) {
+  const config = loadToolConfig(toolYamlPath);
+  if (!config.sandboxedPath || typeof config.sandboxedPath !== "string") return void 0;
+  const sandboxRoot = resolveSandboxedPath(toolYamlPath, config.sandboxedPath);
+  return join(sandboxRoot, CACHE_SUBDIR);
+}
+function findAndLoadToolConfig(dir) {
+  const resolvedDir = resolve(dir);
+  const candidates = [join(resolvedDir, "tool.yaml"), join(resolvedDir, ".tool.yaml")];
+  for (const p of candidates) {
+    if (existsSync(p)) {
+      const config = loadToolConfig(p);
+      return { ...config, configPath: p };
+    }
+  }
+  return {};
+}
 
+// src/tools/util/toolDescriptor.ts
+var TOOL_PATH_REGEX = /^([a-z][a-z0-9-]*):([^/]+)\/([^#]+)(#(.+))?$/;
+function isToolPath(descriptor) {
+  return TOOL_PATH_REGEX.test(descriptor.trim());
+}
+function isBarePackageDescriptor(descriptor) {
+  const parsed = parseToolPath(descriptor.trim());
+  return parsed !== null && parsed.toolName === "";
+}
+function parseToolPath(descriptor) {
+  const s = descriptor.trim();
+  const m = s.match(TOOL_PATH_REGEX);
+  if (!m || m[1] === void 0 || m[2] === void 0 || m[3] === void 0) return null;
+  return {
+    protocol: m[1],
+    scope: m[2],
+    packageWithVersion: m[3],
+    toolName: m[5] ?? ""
+  };
+}
+function npmDescriptorToRegistryPrefix(descriptor, resolvedVersion) {
+  const s = descriptor.trim();
+  if (typeof s !== "string" || !s.startsWith("npm:")) return "";
+  const rest = s.slice(4).trim();
+  const hashIdx = rest.indexOf("#");
+  const beforeHash = hashIdx < 0 ? rest : rest.slice(0, hashIdx);
+  const lastAt = beforeHash.lastIndexOf("@");
+  const scopeAndPackage = lastAt <= 0 ? beforeHash : beforeHash.slice(0, lastAt);
+  let version = lastAt <= 0 ? "latest" : beforeHash.slice(lastAt + 1).trim() || "latest";
+  if (version === "latest" || !version) {
+    const resolved = (resolvedVersion ?? "").trim();
+    if (resolved !== "" && resolved.toLowerCase() !== "latest") {
+      version = resolved;
+    } else {
+      throw new Error(
+        `Registry prefix requires a concrete version when descriptor uses latest (${descriptor}). Resolve version from registry (e.g. resolveLatestVersionFromRegistry) and pass as resolvedVersion.`
+      );
+    }
+  }
+  if (!version || version.toLowerCase() === "latest") {
+    throw new Error(
+      `Registry never uses "latest"; pass resolved concrete version for npm descriptor: ${descriptor}`
+    );
+  }
+  const slashIdx = scopeAndPackage.indexOf("/");
+  const scope = slashIdx < 0 ? scopeAndPackage : scopeAndPackage.slice(0, slashIdx).replace(/^@/, "");
+  const pkg = slashIdx < 0 ? "" : scopeAndPackage.slice(slashIdx + 1);
+  const segment = [scope, pkg, version].filter(Boolean).join(".");
+  const normalized = normalizeToolName(segment);
+  if (!normalized) return "";
+  return "npm." + normalized + ".";
+}
+function npmDescriptorToPackagePrefix(descriptor) {
+  const s = descriptor.trim();
+  if (typeof s !== "string" || !s.startsWith("npm:")) return "";
+  const rest = s.slice(4).trim();
+  const hashIdx = rest.indexOf("#");
+  const beforeHash = hashIdx < 0 ? rest : rest.slice(0, hashIdx);
+  const lastAt = beforeHash.lastIndexOf("@");
+  const scopeAndPackage = lastAt <= 0 ? beforeHash : beforeHash.slice(0, lastAt);
+  const slashIdx = scopeAndPackage.indexOf("/");
+  const scope = slashIdx < 0 ? scopeAndPackage : scopeAndPackage.slice(0, slashIdx).replace(/^@/, "");
+  const pkg = slashIdx < 0 ? "" : scopeAndPackage.slice(slashIdx + 1);
+  const segment = [scope, pkg].filter(Boolean).join(".");
+  const normalized = normalizeToolName(segment);
+  if (!normalized) return "";
+  return "npm." + normalized;
+}
+function npmDescriptorToPackagePrefixWithVersion(descriptor) {
+  const s = descriptor.trim();
+  if (typeof s !== "string" || !s.startsWith("npm:")) return "";
+  const rest = s.slice(4).trim();
+  const hashIdx = rest.indexOf("#");
+  const beforeHash = hashIdx < 0 ? rest : rest.slice(0, hashIdx);
+  const lastAt = beforeHash.lastIndexOf("@");
+  const scopeAndPackage = lastAt <= 0 ? beforeHash : beforeHash.slice(0, lastAt);
+  const version = lastAt <= 0 ? "" : beforeHash.slice(lastAt + 1).trim();
+  const slashIdx = scopeAndPackage.indexOf("/");
+  const scope = slashIdx < 0 ? scopeAndPackage : scopeAndPackage.slice(0, slashIdx).replace(/^@/, "");
+  const pkg = slashIdx < 0 ? "" : scopeAndPackage.slice(slashIdx + 1);
+  const segment = [scope, pkg, version].filter(Boolean).join(".");
+  const normalized = normalizeToolName(segment);
+  if (!normalized) return "";
+  return "npm." + normalized;
+}
+function getDisplayScope(registryName, _kind, _toolVersion) {
+  const i = registryName.indexOf(".");
+  return i < 0 ? registryName : registryName.slice(0, i);
+}
+function expandToolDescriptorsToRegistryNames(descriptors, registryNames) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  function add(name) {
+    const key = normalizeToolName(name);
+    if (registryNames.includes(key) && !seen.has(key)) {
+      seen.add(key);
+      out.push(key);
+      return;
+    }
+    const matched = registryNames.filter((r) => r === key || r.endsWith("." + key));
+    for (const m of matched) {
+      if (!seen.has(m)) {
+        seen.add(m);
+        out.push(m);
+      }
+    }
+  }
+  for (const d of descriptors) {
+    const s = d.trim();
+    if (!s) continue;
+    if (isToolPath(s)) {
+      if (registryNames.includes(s) && !seen.has(s)) {
+        seen.add(s);
+        out.push(s);
+        continue;
+      }
+      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 (path.toolName) {
+            const suffix = "." + path.toolName;
+            for (const r of registryNames) {
+              if (r.startsWith(prefixWithDot) && r.endsWith(suffix) && !seen.has(r)) {
+                seen.add(r);
+                out.push(r);
+              }
+            }
+          } else {
+            for (const r of registryNames) {
+              if (r.startsWith(prefixWithDot) && !seen.has(r)) {
+                seen.add(r);
+                out.push(r);
+              }
+            }
+          }
+        }
+      }
+      continue;
+    }
+    const name = normalizeToolName(s);
+    add(name);
+  }
+  return out;
+}
+function resolveToolDescriptor(descriptor) {
+  const s = descriptor.trim();
+  return s;
+}
+function fileDescriptorToPackagePrefix(descriptor) {
+  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 "file." + normalized;
+}
+function fileDescriptorToRegistryPrefix(descriptor) {
+  const prefix = fileDescriptorToPackagePrefix(descriptor);
+  return prefix ? prefix + "." : "";
+}
 var SchemaValidator = class {
   ajv;
   cache = /* @__PURE__ */ new Map();
@@ -1482,7 +1707,7 @@ var sandboxValidationEnabled = false;
 function setSandboxValidationEnabled(enabled) {
   sandboxValidationEnabled = enabled;
 }
-async function resolveSandboxedPath(inputPath, sandboxRoot) {
+async function resolveSandboxedPath2(inputPath, sandboxRoot) {
   let normalizedRoot;
   try {
     normalizedRoot = await realpath(resolve(sandboxRoot));
@@ -1520,278 +1745,30 @@ function isWithinRoot(path, root) {
   return normalizedPath === normalizedRoot || normalizedPath.startsWith(normalizedRoot + "/");
 }
 
-// src/tools/util/toolDescriptor.ts
-var TOOL_PATH_REGEX = /^([a-z][a-z0-9-]*):([^/]+)\/([^#]+)(#(.+))?$/;
-function isToolPath(descriptor) {
-  return TOOL_PATH_REGEX.test(descriptor.trim());
+// src/api/runtimeFromConfig.ts
+var requireFromPackage = createRequire(import.meta.url);
+function getProjectRequire() {
+  const cwd = process.cwd();
+  if (existsSync(join(cwd, "package.json"))) return createRequire(join(cwd, "package.json"));
+  if (existsSync(join(cwd, "tool.yaml"))) return createRequire(join(cwd, "tool.yaml"));
+  return null;
 }
-function isBarePackageDescriptor(descriptor) {
-  const parsed = parseToolPath(descriptor.trim());
-  return parsed !== null && parsed.toolName === "";
-}
-function parseToolPath(descriptor) {
-  const s = descriptor.trim();
-  const m = s.match(TOOL_PATH_REGEX);
-  if (!m || m[1] === void 0 || m[2] === void 0 || m[3] === void 0) return null;
-  return {
-    protocol: m[1],
-    scope: m[2],
-    packageWithVersion: m[3],
-    toolName: m[5] ?? ""
-  };
-}
-function npmDescriptorToRegistryPrefix(descriptor, resolvedVersion) {
-  const s = descriptor.trim();
-  if (typeof s !== "string" || !s.startsWith("npm:")) return "";
-  const rest = s.slice(4).trim();
-  const hashIdx = rest.indexOf("#");
-  const beforeHash = hashIdx < 0 ? rest : rest.slice(0, hashIdx);
-  const lastAt = beforeHash.lastIndexOf("@");
-  const scopeAndPackage = lastAt <= 0 ? beforeHash : beforeHash.slice(0, lastAt);
-  let version = lastAt <= 0 ? "latest" : beforeHash.slice(lastAt + 1).trim() || "latest";
-  if (version === "latest" || !version) {
-    const resolved = (resolvedVersion ?? "").trim();
-    if (resolved !== "" && resolved.toLowerCase() !== "latest") {
-      version = resolved;
-    } else {
-      throw new Error(
-        `Registry prefix requires a concrete version when descriptor uses latest (${descriptor}). Resolve version from registry (e.g. resolveLatestVersionFromRegistry) and pass as resolvedVersion.`
-      );
-    }
-  }
-  if (!version || version.toLowerCase() === "latest") {
-    throw new Error(
-      `Registry never uses "latest"; pass resolved concrete version for npm descriptor: ${descriptor}`
-    );
-  }
-  const slashIdx = scopeAndPackage.indexOf("/");
-  const scope = slashIdx < 0 ? scopeAndPackage : scopeAndPackage.slice(0, slashIdx).replace(/^@/, "");
-  const pkg = slashIdx < 0 ? "" : scopeAndPackage.slice(slashIdx + 1);
-  const segment = [scope, pkg, version].filter(Boolean).join(".");
-  const normalized = normalizeToolName(segment);
-  if (!normalized) return "";
-  return "npm." + normalized + ".";
-}
-function npmDescriptorToPackagePrefix(descriptor) {
-  const s = descriptor.trim();
-  if (typeof s !== "string" || !s.startsWith("npm:")) return "";
-  const rest = s.slice(4).trim();
-  const hashIdx = rest.indexOf("#");
-  const beforeHash = hashIdx < 0 ? rest : rest.slice(0, hashIdx);
-  const lastAt = beforeHash.lastIndexOf("@");
-  const scopeAndPackage = lastAt <= 0 ? beforeHash : beforeHash.slice(0, lastAt);
-  const slashIdx = scopeAndPackage.indexOf("/");
-  const scope = slashIdx < 0 ? scopeAndPackage : scopeAndPackage.slice(0, slashIdx).replace(/^@/, "");
-  const pkg = slashIdx < 0 ? "" : scopeAndPackage.slice(slashIdx + 1);
-  const segment = [scope, pkg].filter(Boolean).join(".");
-  const normalized = normalizeToolName(segment);
-  if (!normalized) return "";
-  return "npm." + normalized;
-}
-function npmDescriptorToPackagePrefixWithVersion(descriptor) {
-  const s = descriptor.trim();
-  if (typeof s !== "string" || !s.startsWith("npm:")) return "";
-  const rest = s.slice(4).trim();
-  const hashIdx = rest.indexOf("#");
-  const beforeHash = hashIdx < 0 ? rest : rest.slice(0, hashIdx);
-  const lastAt = beforeHash.lastIndexOf("@");
-  const scopeAndPackage = lastAt <= 0 ? beforeHash : beforeHash.slice(0, lastAt);
-  const version = lastAt <= 0 ? "" : beforeHash.slice(lastAt + 1).trim();
-  const slashIdx = scopeAndPackage.indexOf("/");
-  const scope = slashIdx < 0 ? scopeAndPackage : scopeAndPackage.slice(0, slashIdx).replace(/^@/, "");
-  const pkg = slashIdx < 0 ? "" : scopeAndPackage.slice(slashIdx + 1);
-  const segment = [scope, pkg, version].filter(Boolean).join(".");
-  const normalized = normalizeToolName(segment);
-  if (!normalized) return "";
-  return "npm." + normalized;
-}
-function isNpmToolDescriptor(descriptor) {
-  return isToolPath(descriptor) && parseToolPath(descriptor)?.protocol === "npm";
-}
-function parseNpmToolDescriptor(descriptor) {
-  const parsed = parseToolPath(descriptor);
-  if (!parsed || parsed.protocol !== "npm") return null;
-  return {
-    fullPackage: `${parsed.scope}/${parsed.packageWithVersion}`,
-    toolPath: parsed.toolName
-  };
-}
-function getDisplayScope(registryName, _kind, _toolVersion) {
-  const i = registryName.indexOf(".");
-  return i < 0 ? registryName : registryName.slice(0, i);
-}
-function resolveNpmToolDescriptor(descriptor) {
-  return null;
-}
-function expandToolDescriptorsToRegistryNames(descriptors, registryNames) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  function add(name) {
-    const key = normalizeToolName(name);
-    if (registryNames.includes(key) && !seen.has(key)) {
-      seen.add(key);
-      out.push(key);
-      return;
-    }
-    const matched = registryNames.filter((r) => r === key || r.endsWith("." + key));
-    for (const m of matched) {
-      if (!seen.has(m)) {
-        seen.add(m);
-        out.push(m);
-      }
-    }
-  }
-  for (const d of descriptors) {
-    const s = d.trim();
-    if (!s) continue;
-    if (isToolPath(s)) {
-      if (registryNames.includes(s) && !seen.has(s)) {
-        seen.add(s);
-        out.push(s);
-        continue;
-      }
-      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 (path.toolName) {
-            const suffix = "." + path.toolName;
-            for (const r of registryNames) {
-              if (r.startsWith(prefixWithDot) && r.endsWith(suffix) && !seen.has(r)) {
-                seen.add(r);
-                out.push(r);
-              }
-            }
-          } else {
-            for (const r of registryNames) {
-              if (r.startsWith(prefixWithDot) && !seen.has(r)) {
-                seen.add(r);
-                out.push(r);
-              }
-            }
-          }
-        }
-      }
-      continue;
-    }
-    const name = normalizeToolName(s);
-    add(name);
-  }
-  return out;
-}
-function resolveToolDescriptor(descriptor) {
-  const s = descriptor.trim();
-  return s;
-}
-function normalizeToolList(descriptors) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const d of descriptors) {
-    if (typeof d !== "string" || !d.trim()) continue;
-    const name = resolveToolDescriptor(d);
-    if (!seen.has(name)) {
-      seen.add(name);
-      out.push(name);
-    }
-  }
-  return out;
-}
-function fileDescriptorToPackagePrefix(descriptor) {
-  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 "file." + normalized;
-}
-function fileDescriptorToRegistryPrefix(descriptor) {
-  const prefix = fileDescriptorToPackagePrefix(descriptor);
-  return prefix ? prefix + "." : "";
-}
-function loadToolConfig(toolYamlPath) {
-  const abs = resolve(toolYamlPath);
-  const raw = readFileSync(abs, "utf8");
-  const parsed = parseYamlContent(raw, {
-    substituteEnv: false
-  });
-  if (!parsed || typeof parsed !== "object") return {};
-  const toolsBlock = parsed.tools;
-  if (toolsBlock != null && typeof toolsBlock === "object" && !Array.isArray(toolsBlock)) {
-    const toolDefaults = toolsBlock.defaults != null && typeof toolsBlock.defaults === "object" && !Array.isArray(toolsBlock.defaults) ? toolsBlock.defaults : void 0;
-    const packageToolDefaults2 = toolsBlock.packages != null && typeof toolsBlock.packages === "object" && !Array.isArray(toolsBlock.packages) ? toolsBlock.packages : void 0;
-    const list2 = Array.isArray(toolsBlock.list) && toolsBlock.list.length > 0 ? toolsBlock.list : void 0;
-    return {
-      tools: list2 ?? (packageToolDefaults2 ? Object.keys(packageToolDefaults2) : void 0),
-      sandboxedPath: typeof toolsBlock.sandboxedPath === "string" ? toolsBlock.sandboxedPath : parsed.sandboxedPath,
-      enableSandboxValidation: typeof toolsBlock.enableSandboxValidation === "boolean" ? toolsBlock.enableSandboxValidation : parsed.enableSandboxValidation,
-      allowedHosts: Array.isArray(toolsBlock.allowedHosts) ? toolsBlock.allowedHosts : parsed.allowedHosts,
-      blockedHosts: Array.isArray(toolsBlock.blockedHosts) ? toolsBlock.blockedHosts : parsed.blockedHosts,
-      blockedCidrs: Array.isArray(toolsBlock.blockedCidrs) ? toolsBlock.blockedCidrs : parsed.blockedCidrs,
-      toolDefaults,
-      packageToolDefaults: packageToolDefaults2
-    };
-  }
-  const packageToolDefaults = typeof parsed.packageToolDefaults === "object" && !Array.isArray(parsed.packageToolDefaults) ? parsed.packageToolDefaults : void 0;
-  const list = Array.isArray(parsed.tools) && parsed.tools.length > 0 ? parsed.tools : void 0;
-  return {
-    tools: list ?? (packageToolDefaults ? Object.keys(packageToolDefaults) : void 0),
-    sandboxedPath: parsed.sandboxedPath,
-    enableSandboxValidation: typeof parsed.enableSandboxValidation === "boolean" ? parsed.enableSandboxValidation : void 0,
-    allowedHosts: Array.isArray(parsed.allowedHosts) ? parsed.allowedHosts : void 0,
-    blockedHosts: Array.isArray(parsed.blockedHosts) ? parsed.blockedHosts : void 0,
-    blockedCidrs: Array.isArray(parsed.blockedCidrs) ? parsed.blockedCidrs : void 0,
-    toolDefaults: typeof parsed.toolDefaults === "object" && !Array.isArray(parsed.toolDefaults) ? parsed.toolDefaults : void 0,
-    packageToolDefaults
-  };
-}
-function resolveSandboxedPath2(toolYamlPath, sandboxedPath) {
-  const configDir = dirname(resolve(toolYamlPath));
-  return resolveConfigPath(sandboxedPath, configDir, {
-    expandHome: true
-  });
-}
-var CACHE_SUBDIR = ".agent/cache";
-function getCacheBaseFromToolConfig(toolYamlPath) {
-  const config = loadToolConfig(toolYamlPath);
-  if (!config.sandboxedPath || typeof config.sandboxedPath !== "string") return void 0;
-  const sandboxRoot = resolveSandboxedPath2(toolYamlPath, config.sandboxedPath);
-  return join(sandboxRoot, CACHE_SUBDIR);
-}
-function findAndLoadToolConfig(dir) {
-  const resolvedDir = resolve(dir);
-  const candidates = [join(resolvedDir, "tool.yaml"), join(resolvedDir, ".tool.yaml")];
-  for (const p of candidates) {
-    if (existsSync(p)) {
-      const config = loadToolConfig(p);
-      return { ...config, configPath: p };
-    }
-  }
-  return {};
-}
-var requireFromPackage = createRequire(import.meta.url);
-function getProjectRequire() {
-  const cwd = process.cwd();
-  if (existsSync(join(cwd, "package.json"))) return createRequire(join(cwd, "package.json"));
-  if (existsSync(join(cwd, "tool.yaml"))) return createRequire(join(cwd, "tool.yaml"));
-  return null;
-}
-var DEFAULT_EXTENSION_PACKAGES = [];
-function getInstalledPackageVersion(packageName) {
-  const projectRequire = getProjectRequire();
-  const requirers = [requireFromPackage];
-  if (projectRequire) requirers.push(projectRequire);
-  for (const req of requirers) {
-    try {
-      const pkgJsonPath = req.resolve(`${packageName}/package.json`);
-      const json = readFileSync(pkgJsonPath, "utf-8");
-      const pkg = JSON.parse(json);
-      return pkg.version ?? null;
-    } catch {
-      continue;
-    }
-  }
-  return null;
+var DEFAULT_EXTENSION_PACKAGES = [];
+function getInstalledPackageVersion(packageName) {
+  const projectRequire = getProjectRequire();
+  const requirers = [requireFromPackage];
+  if (projectRequire) requirers.push(projectRequire);
+  for (const req of requirers) {
+    try {
+      const pkgJsonPath = req.resolve(`${packageName}/package.json`);
+      const json = readFileSync(pkgJsonPath, "utf-8");
+      const pkg = JSON.parse(json);
+      return pkg.version ?? null;
+    } catch {
+      continue;
+    }
+  }
+  return null;
 }
 function getRegisterFn(mod) {
   return mod?.register ?? mod?.registerCoreTools;
@@ -2060,13 +2037,479 @@ async function createRuntimeFromConfig(options = {}) {
   return createRuntimeFromConfigSync(options);
 }
 
+// src/api/expose/openapi.ts
+function toolNameToSlug(name) {
+  return name.replace(/\./g, "~");
+}
+function slugToToolName(slug) {
+  return slug.replace(/~/g, ".");
+}
+function toolSchemaKey(name) {
+  return `Tool_${name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+}
+var resultSchema = {
+  type: "object",
+  properties: {
+    result: { description: "Tool return value", additionalProperties: true }
+  }
+};
+var errorSchema = {
+  type: "object",
+  properties: {
+    error: { type: "string" },
+    kind: { type: "string" },
+    details: { type: "object", additionalProperties: true }
+  }
+};
+function toolsToOpenAPISpec(registry, options = {}) {
+  const title = options.title ?? "Tool API";
+  const version = options.version ?? "1.0.0";
+  const basePath = (options.basePath ?? "").replace(/\/$/, "");
+  const specs = registry.snapshot().map(enrichSpecWithCanonicalSchema);
+  const toolNamesSchema = {
+    type: "object",
+    required: ["tools"],
+    properties: {
+      tools: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            description: { type: "string" },
+            kind: { type: "string" }
+          }
+        }
+      }
+    }
+  };
+  const invokeRequestBody = {
+    type: "object",
+    required: ["tool", "args"],
+    properties: {
+      tool: { type: "string", description: "Tool name (e.g. from GET /tools)" },
+      args: {
+        type: "object",
+        description: "Tool arguments (schema per tool; use per-tool paths for typed schema)",
+        additionalProperties: true
+      }
+    }
+  };
+  const prefix = basePath ? `${basePath}/` : "/";
+  const paths = {
+    [`${prefix}tools`]: {
+      get: {
+        summary: "List tools",
+        description: "Returns all registered tool names and descriptions.",
+        operationId: "listTools",
+        responses: {
+          "200": {
+            description: "List of tools",
+            content: {
+              "application/json": {
+                schema: toolNamesSchema
+              }
+            }
+          }
+        }
+      }
+    },
+    [`${prefix}invoke`]: {
+      post: {
+        summary: "Invoke a tool (generic)",
+        description: "Call any tool by name with body { tool, args }. For typed schemas use POST /invoke/{toolSlug}.",
+        operationId: "invokeTool",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: invokeRequestBody
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Tool result",
+            content: { "application/json": { schema: resultSchema } }
+          },
+          "400": {
+            description: "Bad request",
+            content: { "application/json": { schema: errorSchema } }
+          }
+        }
+      }
+    }
+  };
+  const schemaEntries = [];
+  for (const s of specs) {
+    const key = toolSchemaKey(s.name);
+    schemaEntries.push([key, s.inputSchema]);
+    const slug = toolNameToSlug(s.name);
+    paths[`${prefix}invoke/${slug}`] = {
+      post: {
+        summary: s.description ?? s.name,
+        description: `Invoke tool \`${s.name}\`. Request body is the tool's arguments (JSON Schema below).`,
+        operationId: `invoke_${key}`,
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: { $ref: `#/components/schemas/${key}` }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Tool result",
+            content: { "application/json": { schema: resultSchema } }
+          },
+          "400": {
+            description: "Bad request (invalid args or tool error)",
+            content: { "application/json": { schema: errorSchema } }
+          }
+        }
+      }
+    };
+  }
+  return {
+    openapi: "3.0.3",
+    info: { title, version },
+    paths,
+    components: {
+      schemas: Object.fromEntries(schemaEntries)
+    }
+  };
+}
+
+// src/api/expose/openapiHttp.ts
+var DEFAULT_CTX = {
+  requestId: `http-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+  taskId: `task-${Date.now()}`,
+  permissions: [
+    "read:web",
+    "read:fs",
+    "write:fs",
+    "read:db",
+    "write:db",
+    "network",
+    "workflow",
+    "danger:destructive"
+  ]
+};
+function parseBody(req) {
+  return new Promise((resolve4, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf-8");
+      if (!raw.trim()) {
+        resolve4({});
+        return;
+      }
+      try {
+        resolve4(JSON.parse(raw));
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function sendJson(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function swaggerUiHtml(specUrl) {
+  const specUrlEscaped = specUrl.replace(/"/g, "&quot;");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Tool API \u2013 Swagger UI</title>
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js" crossorigin></script>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-standalone-preset.js" crossorigin></script>
+  <script>
+    window.onload = function() {
+      window.ui = SwaggerUIBundle({
+        url: "${specUrlEscaped}",
+        dom_id: "#swagger-ui",
+        deepLinking: true,
+        presets: [
+          SwaggerUIBundle.presets.apis,
+          SwaggerUIStandalonePreset
+        ],
+        layout: "StandaloneLayout"
+      });
+    };
+  </script>
+</body>
+</html>`;
+}
+function createOpenAPIHttpServer(runtime, options = {}) {
+  const basePath = (options.basePath ?? "").replace(/\/$/, "");
+  const ctxFactory = options.execContextFactory ?? (() => ({ ...DEFAULT_CTX }));
+  const server = createServer(async (req, res) => {
+    const url = req.url ?? "/";
+    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";
+        const html = swaggerUiHtml(specPath);
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(html);
+        return;
+      }
+      if (req.method === "GET" && (norm === "/openapi.json" || norm === "/spec")) {
+        const spec = toolsToOpenAPISpec(runtime.getRegistry(), {
+          title: "Tool API",
+          version: "1.0.0",
+          basePath: basePath || void 0
+        });
+        sendJson(res, 200, spec);
+        return;
+      }
+      if (req.method === "GET" && norm === "/tools") {
+        const { enrichSpecWithCanonicalSchema: enrichSpecWithCanonicalSchema2 } = await import('./canonicalCoreSchemas-PHGTNPN5.js');
+        const specs = runtime.getRegistry().snapshot().map(enrichSpecWithCanonicalSchema2);
+        const tools = specs.map((s) => ({
+          name: s.name,
+          description: s.description,
+          kind: s.kind,
+          inputSchema: s.inputSchema
+        }));
+        sendJson(res, 200, { tools });
+        return;
+      }
+      if (req.method === "POST" && norm === "/invoke") {
+        const body = await parseBody(req);
+        const tool = body?.tool;
+        const args = body?.args ?? {};
+        if (typeof tool !== "string" || !tool.trim()) {
+          sendJson(res, 400, { error: "Missing or invalid 'tool' in body", kind: "BAD_REQUEST" });
+          return;
+        }
+        const ctx = ctxFactory(req);
+        const result = await runtime.invoke(
+          { tool: tool.trim(), args, purpose: "openapi" },
+          ctx
+        );
+        if (result.ok) {
+          sendJson(res, 200, { result: result.result });
+          return;
+        }
+        sendJson(res, 400, {
+          error: result.error?.message ?? "Tool failed",
+          kind: result.error?.kind,
+          details: result.error?.details
+        });
+        return;
+      }
+      if (req.method === "POST" && norm.startsWith("/invoke/") && norm.length > "/invoke/".length) {
+        const slug = norm.slice("/invoke/".length);
+        const toolName = slugToToolName(slug);
+        let args;
+        try {
+          args = await parseBody(req);
+        } catch {
+          sendJson(res, 400, { error: "Invalid JSON body", kind: "BAD_REQUEST" });
+          return;
+        }
+        const ctx = ctxFactory(req);
+        const result = await runtime.invoke(
+          { tool: toolName, args: args ?? {}, purpose: "openapi" },
+          ctx
+        );
+        if (result.ok) {
+          sendJson(res, 200, { result: result.result });
+          return;
+        }
+        sendJson(res, 400, {
+          error: result.error?.message ?? "Tool failed",
+          kind: result.error?.kind,
+          details: result.error?.details
+        });
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found", path: norm }));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      sendJson(res, 500, { error: message, kind: "INTERNAL_ERROR" });
+    }
+  });
+  return server;
+}
+function listenOpenAPIHttpServer(server, options = {}) {
+  return new Promise((resolve4, reject) => {
+    const port = options.port ?? 0;
+    const host = options.host ?? "localhost";
+    server.listen(port, host, () => {
+      const addr = server.address();
+      const actualPort = typeof addr === "object" && addr?.port != null ? addr.port : port;
+      resolve4({ port: actualPort, host });
+    });
+    server.on("error", reject);
+  });
+}
+async function createHttpService(runtimeOrConfig, options = {}) {
+  const runtime = "invoke" in runtimeOrConfig && typeof runtimeOrConfig.invoke === "function" ? runtimeOrConfig : (await createRuntimeFromConfig(runtimeOrConfig)).runtime;
+  const server = createOpenAPIHttpServer(runtime, options);
+  const openApiSpec = toolsToOpenAPISpec(runtime.getRegistry(), {
+    title: options.title ?? "Tool API",
+    version: options.version ?? "1.0.0",
+    basePath: options.basePath
+  });
+  return {
+    server,
+    openApiSpec,
+    listen: (listenOpts) => listenOpenAPIHttpServer(server, listenOpts)
+  };
+}
+
 // src/tools/mcp/types.ts
 var MCP_KIND = "mcp";
 
+// src/api/expose/mcpServer.ts
+var DEFAULT_CTX2 = {
+  requestId: `mcp-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+  taskId: `task-${Date.now()}`,
+  permissions: [
+    "read:web",
+    "read:fs",
+    "write:fs",
+    "read:db",
+    "write:db",
+    "network",
+    "workflow",
+    "danger:destructive"
+  ]
+};
+function toMcpToolName(registryName) {
+  return normalizeToolName(registryName);
+}
+async function createMcpServerWithTools(runtime, options) {
+  const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
+  const name = options.name ?? "agent-tool";
+  const version = options.version ?? "1.0.0";
+  const ctxFactory = options.execContextFactory ?? (() => ({ ...DEFAULT_CTX2 }));
+  const server = new McpServer({ name, version });
+  const registry = runtime.getRegistry();
+  const specs = registry.snapshot();
+  for (const spec of specs) {
+    const mcpName = toMcpToolName(spec.name);
+    server.registerTool(
+      mcpName,
+      {
+        description: spec.description ?? `Tool: ${spec.name}`,
+        inputSchema: spec.inputSchema,
+        _meta: spec._meta
+      },
+      async (args) => {
+        const ctx = ctxFactory();
+        const result = await runtime.invoke(
+          { tool: spec.name, args: args ?? {}, purpose: MCP_KIND },
+          ctx
+        );
+        if (result.ok) {
+          return { content: [{ type: "text", text: JSON.stringify(result.result) }] };
+        }
+        const err = result.error;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ error: err?.message ?? "Tool failed", kind: err?.kind })
+            }
+          ],
+          isError: true
+        };
+      }
+    );
+  }
+  return { server };
+}
+async function createMCPServer(runtimeOrConfig, options = {}) {
+  const runtime = "invoke" in runtimeOrConfig && typeof runtimeOrConfig.invoke === "function" ? runtimeOrConfig : (await createRuntimeFromConfig(runtimeOrConfig)).runtime;
+  const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+  const { server } = await createMcpServerWithTools(runtime, options);
+  return {
+    server,
+    async connectStdio() {
+      const transport = new StdioServerTransport();
+      await server.connect(transport);
+    }
+  };
+}
+function createMCPStreamableHttpHandler(runtimeOrConfig, options = {}) {
+  if ("invoke" in runtimeOrConfig && typeof runtimeOrConfig.invoke === "function") {
+    const runtime = runtimeOrConfig;
+    return async function streamableHttpHandler(req, res, parsedBody) {
+      const { StreamableHTTPServerTransport } = await import('@modelcontextprotocol/sdk/server/streamableHttp.js');
+      const { server } = await createMcpServerWithTools(runtime, options);
+      const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+      await server.connect(transport);
+      const onClose = () => {
+        transport.close().catch(() => {
+        });
+        server.close().catch(() => {
+        });
+        res.removeListener("close", onClose);
+        res.removeListener("finish", onClose);
+      };
+      res.once("close", onClose);
+      res.once("finish", onClose);
+      await transport.handleRequest(
+        req,
+        res,
+        parsedBody
+      );
+    };
+  }
+  return (async () => {
+    const { runtime } = await createRuntimeFromConfig(runtimeOrConfig);
+    return createMCPStreamableHttpHandler(runtime, options);
+  })();
+}
+async function createMCPServerStreamableHttp(runtimeOrConfig, options = {}) {
+  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(path, handler);
+  return {
+    app,
+    path,
+    async listen(listenPort, listenHost) {
+      const p = listenPort ?? port;
+      const h = listenHost ?? host;
+      return new Promise((resolve4, reject) => {
+        const server = app.listen(p, h, () => {
+          const addr = server.address();
+          const actualPort = typeof addr === "object" && addr !== null && "port" in addr ? addr.port : p;
+          resolve4({ url: `http://${h}:${actualPort}${path}`, port: actualPort });
+        });
+      });
+    }
+  };
+}
+async function runMCPServerOverStdio(runtime, options = {}) {
+  const result = await createMCPServer(runtime, options);
+  await result.connectStdio();
+  return result;
+}
+
 // src/tools/langchain/types.ts
 var LANGCHAIN_KIND = "langchain";
 var LANGCHAIN_DIR_NAME = "langchain";
 
-export { BudgetManager, EventLog, LANGCHAIN_DIR_NAME, LANGCHAIN_KIND, MCP_KIND, Metrics, PTCRuntime, PolicyDeniedError, PolicyEngine, SchemaValidationError, SchemaValidator, Tracing, buildEvidence, createLogger, createRuntimeFromConfig, createRuntimeFromConfigSync, expandToolDescriptorsToRegistryNames, fileDescriptorToPackagePrefix, findAndLoadToolConfig, getDisplayScope, isBarePackageDescriptor, isNpmToolDescriptor, loadToolConfig, normalizeToolList, npmDescriptorToPackagePrefixWithVersion, npmDescriptorToRegistryPrefix, parseNpmToolDescriptor, resolveNpmToolDescriptor, resolveSandboxedPath, resolveSandboxedPath2, resolveToolDescriptor, sanitizeForLog, setSandboxValidationEnabled, summarizeForLog };
-//# sourceMappingURL=chunk-JH6TWGP4.js.map
-//# sourceMappingURL=chunk-JH6TWGP4.js.map
+export { LANGCHAIN_DIR_NAME, LANGCHAIN_KIND, MCP_KIND, PTCRuntime, createHttpService, createMCPServer, createMCPServerStreamableHttp, createMCPStreamableHttpHandler, createRuntimeFromConfig, createRuntimeFromConfigSync, expandToolDescriptorsToRegistryNames, fileDescriptorToPackagePrefix, findAndLoadToolConfig, getDisplayScope, isBarePackageDescriptor, loadToolConfig, npmDescriptorToPackagePrefixWithVersion, resolveSandboxedPath, resolveSandboxedPath2, resolveToolDescriptor, runMCPServerOverStdio, setSandboxValidationEnabled };
+//# sourceMappingURL=chunk-2ZPDD7ZO.js.map
+//# sourceMappingURL=chunk-2ZPDD7ZO.js.map