@botbotgo/kit 1.0.106

package/dist/chunk-4VKCWJHF.cjs

@@ -0,0 +1,3043 @@
+'use strict';
+
+var chunkAZUXVVGV_cjs = require('./chunk-AZUXVVGV.cjs');
+var chunkAGLGFQUW_cjs = require('./chunk-AGLGFQUW.cjs');
+var chunkJW4EMVTE_cjs = require('./chunk-JW4EMVTE.cjs');
+var chunkUUNG3GL3_cjs = require('./chunk-UUNG3GL3.cjs');
+var fs = require('fs');
+var path = require('path');
+var config = require('@botbotgo/common/config');
+var module$1 = require('module');
+var url = require('url');
+var Ajv = require('ajv');
+var addFormats = require('ajv-formats');
+var cockatiel = require('cockatiel');
+var eventemitter3 = require('eventemitter3');
+var uuid = require('uuid');
+var pTimeout = require('p-timeout');
+var child_process = require('child_process');
+var os = require('os');
+var express = require('express');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
+var pTimeout__default = /*#__PURE__*/_interopDefault(pTimeout);
+var express__default = /*#__PURE__*/_interopDefault(express);
+
+function normalizeMcpConfig(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const source = raw;
+  const out = {};
+  if (typeof source.name === "string" && source.name.trim()) out.name = source.name.trim();
+  if (typeof source.version === "string" && source.version.trim()) out.version = source.version.trim();
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normalizeOpenApiConfig(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const source = raw;
+  const out = {};
+  if (typeof source.host === "string" && source.host.trim()) out.host = source.host.trim();
+  if (typeof source.basePath === "string") out.basePath = source.basePath;
+  if (typeof source.title === "string" && source.title.trim()) out.title = source.title.trim();
+  if (typeof source.version === "string" && source.version.trim()) out.version = source.version.trim();
+  if (typeof source.port === "number" && Number.isFinite(source.port)) out.port = source.port;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normalizeToolSources(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const source = raw;
+  const out = {};
+  const customized = source.customized;
+  if (customized && typeof customized === "object" && !Array.isArray(customized)) {
+    const customizedSource = customized;
+    const descriptorGrouped = Object.keys(customizedSource).some((key) => /^(npm|file):/.test(key));
+    if (descriptorGrouped) {
+      for (const [sourceKey, sourceValue] of Object.entries(customizedSource)) {
+        if (!sourceValue || typeof sourceValue !== "object" || Array.isArray(sourceValue)) continue;
+        const toolMap = {};
+        for (const [toolName, toolValue] of Object.entries(sourceValue)) {
+          if (!toolValue || typeof toolValue !== "object" || Array.isArray(toolValue)) continue;
+          toolMap[toolName] = toolValue;
+        }
+        out[sourceKey] = toolMap;
+      }
+    } else {
+      const toolMap = {};
+      for (const [toolName, toolValue] of Object.entries(customizedSource)) {
+        if (!toolValue || typeof toolValue !== "object" || Array.isArray(toolValue)) continue;
+        toolMap[toolName] = toolValue;
+      }
+      if (Object.keys(toolMap).length > 0) out.self = toolMap;
+    }
+  }
+  for (const [sourceKey, sourceValue] of Object.entries(source)) {
+    if (sourceKey === "customized" || sourceKey === "deepagents") continue;
+    if (!sourceValue || typeof sourceValue !== "object" || Array.isArray(sourceValue)) continue;
+    const toolMap = {};
+    for (const [toolName, toolValue] of Object.entries(sourceValue)) {
+      if (!toolValue || typeof toolValue !== "object" || Array.isArray(toolValue)) continue;
+      toolMap[toolName] = toolValue;
+    }
+    out[sourceKey] = toolMap;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normalizePathSources(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const source = raw;
+  const out = {};
+  for (const [descriptor, value] of Object.entries(source)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      out[descriptor] = {};
+      continue;
+    }
+    out[descriptor] = value;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function loadToolConfig(toolYamlPath) {
+  const abs = path.resolve(toolYamlPath);
+  const raw = fs.readFileSync(abs, "utf8");
+  const parsed = config.parseYamlContent(raw, {
+    substituteEnv: false
+  });
+  if (!parsed || typeof parsed !== "object") return {};
+  const source = parsed.spec && typeof parsed.spec === "object" && !Array.isArray(parsed.spec) ? parsed.spec : parsed;
+  return {
+    sandboxedPath: typeof source.sandboxedPath === "string" ? source.sandboxedPath : void 0,
+    cacheDir: typeof source.cacheDir === "string" ? source.cacheDir : void 0,
+    toolPath: typeof source.toolPath === "string" ? source.toolPath : void 0,
+    skillPath: typeof source.skillPath === "string" ? source.skillPath : void 0,
+    paths: normalizePathSources(source.paths),
+    enableSandboxValidation: typeof source.enableSandboxValidation === "boolean" ? source.enableSandboxValidation : void 0,
+    allowedHosts: Array.isArray(source.allowedHosts) ? source.allowedHosts : void 0,
+    blockedHosts: Array.isArray(source.blockedHosts) ? source.blockedHosts : void 0,
+    blockedCidrs: Array.isArray(source.blockedCidrs) ? source.blockedCidrs : void 0,
+    tools: normalizeToolSources(source.tools),
+    mcp: normalizeMcpConfig(source.expose?.mcp ?? source.mcp),
+    openapi: normalizeOpenApiConfig(source.expose?.openapi ?? source.openapi)
+  };
+}
+function getToolSourceDescriptors(config, options) {
+  const includeSelf = options?.includeSelf ?? false;
+  return Object.keys(config.tools ?? {}).filter((key) => includeSelf || key !== "self");
+}
+function getPathSourceDescriptors(config) {
+  const fromPaths = Object.keys(config.paths ?? {});
+  if (fromPaths.length > 0) return fromPaths;
+  return getToolSourceDescriptors(config);
+}
+function resolveSandboxedPath(toolYamlPath, sandboxedPath) {
+  const configDir = path.dirname(path.resolve(toolYamlPath));
+  return config.resolveConfigPath(sandboxedPath, configDir, {
+    expandHome: true
+  });
+}
+function resolveCacheDir(toolYamlPath, cacheDir) {
+  const configDir = path.dirname(path.resolve(toolYamlPath));
+  return config.resolveConfigPath(cacheDir, configDir, {
+    expandHome: true
+  });
+}
+var CACHE_SUBDIR = ".agent/cache";
+function getCacheBaseFromToolConfig(toolYamlPath) {
+  const config = loadToolConfig(toolYamlPath);
+  if (config.cacheDir && typeof config.cacheDir === "string") {
+    return resolveCacheDir(toolYamlPath, config.cacheDir);
+  }
+  if (!config.sandboxedPath || typeof config.sandboxedPath !== "string") return void 0;
+  const sandboxRoot = resolveSandboxedPath(toolYamlPath, config.sandboxedPath);
+  return path.join(sandboxRoot, CACHE_SUBDIR);
+}
+function findAndLoadToolConfig(dir) {
+  const resolvedDir = path.resolve(dir);
+  const candidates = [path.join(resolvedDir, "tool.yaml"), path.join(resolvedDir, ".tool.yaml")];
+  for (const p of candidates) {
+    if (fs.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 = chunkJW4EMVTE_cjs.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 = chunkJW4EMVTE_cjs.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 = chunkJW4EMVTE_cjs.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 path2 = parseToolPath(s);
+      if (path2) {
+        const packagePrefix = path2.protocol === "npm" ? npmDescriptorToPackagePrefix(s) : path2.protocol === "file" ? fileDescriptorToPackagePrefix(s) : "";
+        const prefixWithDot = packagePrefix ? packagePrefix + "." : "";
+        if (prefixWithDot) {
+          if (path2.toolName) {
+            const suffix = "." + path2.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 = chunkJW4EMVTE_cjs.normalizeToolName(s);
+    add(name);
+  }
+  return out;
+}
+function resolveToolDescriptor(descriptor) {
+  const s = descriptor.trim();
+  return s;
+}
+function fileDescriptorToPackagePrefix(descriptor) {
+  const path2 = parseToolPath(descriptor.trim());
+  if (!path2 || path2.protocol !== "file") return "";
+  const pathPart = `${path2.scope}/${path2.packageWithVersion}`;
+  const normalized = chunkJW4EMVTE_cjs.normalizeToolName(pathPart);
+  if (!normalized) return "";
+  return chunkJW4EMVTE_cjs.normalizeToolName("file." + normalized);
+}
+function fileDescriptorToRegistryPrefix(descriptor) {
+  const prefix = fileDescriptorToPackagePrefix(descriptor);
+  return prefix ? prefix + "." : "";
+}
+var SchemaValidator = class {
+  ajv;
+  cache = /* @__PURE__ */ new Map();
+  constructor() {
+    this.ajv = new Ajv__default.default({
+      allErrors: true,
+      coerceTypes: true,
+      useDefaults: true,
+      removeAdditional: "failing",
+      strict: false
+    });
+    addFormats__default.default(this.ajv);
+  }
+  /**
+   * Validate data against a JSON Schema.
+   * Coerces types and applies defaults in-place.
+   */
+  validate(schema, data) {
+    const validate = this.getOrCompile(schema);
+    const cloned = structuredClone(data);
+    const valid = validate(cloned);
+    if (valid) {
+      return { valid: true, data: cloned };
+    }
+    return {
+      valid: false,
+      errors: validate.errors ?? void 0
+    };
+  }
+  /**
+   * Validate and return coerced data, or throw a descriptive error.
+   */
+  validateOrThrow(schema, data, context) {
+    const result = this.validate(schema, data);
+    if (!result.valid) {
+      const messages = (result.errors ?? []).map((e) => `${e.instancePath || "/"} ${e.message}`).join("; ");
+      throw new SchemaValidationError(
+        `${context}: ${messages}`,
+        result.errors ?? []
+      );
+    }
+    return result.data;
+  }
+  /**
+   * Apply default values from schema to data without full validation.
+   */
+  enrichDefaults(schema, data) {
+    const validate = this.getOrCompile(schema);
+    const cloned = structuredClone(data);
+    validate(cloned);
+    return cloned;
+  }
+  getOrCompile(schema) {
+    const normalized = this.normalizeSchema(schema);
+    const key = JSON.stringify(normalized);
+    let cached = this.cache.get(key);
+    if (!cached) {
+      cached = this.ajv.compile(normalized);
+      this.cache.set(key, cached);
+    }
+    return cached;
+  }
+  /** Ensure schema is AJV-compatible (required = string[], nullable handled via type). */
+  normalizeSchema(schema) {
+    return this.normalizeSchemaRec(schema);
+  }
+  normalizeSchemaRec(s) {
+    const out = {};
+    for (const [key, value] of Object.entries(s)) {
+      if (key === "required") {
+        const raw = value;
+        out.required = Array.isArray(raw) ? raw.filter((x) => typeof x === "string") : typeof raw === "string" ? [raw] : [];
+        continue;
+      }
+      if (key === "nullable") {
+        continue;
+      }
+      if (key === "properties" && value !== null && typeof value === "object") {
+        const props = {};
+        for (const [pk, pv] of Object.entries(value)) {
+          if (pv !== null && typeof pv === "object" && !Array.isArray(pv)) {
+            props[pk] = this.normalizeSchemaRec(pv);
+          } else {
+            props[pk] = pv;
+          }
+        }
+        out.properties = props;
+        continue;
+      }
+      if ((key === "items" || key === "additionalProperties") && value !== null && typeof value === "object" && !Array.isArray(value)) {
+        out[key] = this.normalizeSchemaRec(value);
+        continue;
+      }
+      if ((key === "oneOf" || key === "anyOf" || key === "allOf") && Array.isArray(value)) {
+        out[key] = value.map(
+          (item) => item !== null && typeof item === "object" && !Array.isArray(item) ? this.normalizeSchemaRec(item) : item
+        );
+        continue;
+      }
+      out[key] = value;
+    }
+    if (s.nullable === true) {
+      const existingType = out.type;
+      if (existingType === void 0) {
+        out.type = "object";
+      } else if (Array.isArray(existingType)) {
+        if (!existingType.includes("null")) out.type = [...existingType, "null"];
+      } else {
+        out.type = [existingType, "null"];
+      }
+    }
+    return out;
+  }
+};
+var SchemaValidationError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "SchemaValidationError";
+  }
+};
+
+// src/core/runtime/PolicyEngine.ts
+var PolicyEngine = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      requireExplicitDangerPermission: true,
+      deniedSqlPatterns: ["DROP\\s", "TRUNCATE\\s", "DELETE\\s+FROM\\s+\\w+\\s*$"],
+      ...config
+    };
+  }
+  /**
+   * Enforce all policy checks. Throws PolicyDeniedError if denied.
+   */
+  enforce(spec, args, ctx) {
+    const result = this.check(spec, args, ctx);
+    if (!result.allowed) {
+      throw new PolicyDeniedError(
+        result.reason ?? "Policy denied",
+        result.missingCapabilities
+      );
+    }
+  }
+  /**
+   * Check all policies without throwing.
+   */
+  check(spec, args, ctx) {
+    const capResult = this.checkCapabilities(spec, ctx);
+    if (!capResult.allowed) return capResult;
+    const paramResult = this.checkParameters(spec, args);
+    if (!paramResult.allowed) return paramResult;
+    return { allowed: true };
+  }
+  /**
+   * Check that context permissions cover tool capabilities.
+   */
+  checkCapabilities(spec, ctx) {
+    const missing = [];
+    for (const cap of spec.capabilities) {
+      if (cap === "danger:destructive") {
+        if (this.config.requireExplicitDangerPermission && !ctx.permissions.includes("danger:destructive")) {
+          missing.push(cap);
+        }
+      } else if (!ctx.permissions.includes(cap)) {
+        missing.push(cap);
+      }
+    }
+    if (missing.length > 0) {
+      return {
+        allowed: false,
+        reason: `Missing capabilities: ${missing.join(", ")}`,
+        missingCapabilities: missing
+      };
+    }
+    return { allowed: true };
+  }
+  /**
+   * Check parameter-level security constraints.
+   */
+  checkParameters(spec, args) {
+    if (!args || typeof args !== "object") return { allowed: true };
+    const argsObj = args;
+    if (spec.capabilities.includes("write:fs") && this.config.sandboxPaths) {
+      const pathResult = this.checkFilePaths(argsObj);
+      if (!pathResult.allowed) return pathResult;
+    }
+    if (spec.capabilities.includes("network") || spec.capabilities.includes("read:web")) {
+      const urlResult = this.checkUrls(argsObj);
+      if (!urlResult.allowed) return urlResult;
+    }
+    if (spec.capabilities.includes("write:db") || spec.capabilities.includes("read:db")) {
+      const sqlResult = this.checkSql(argsObj);
+      if (!sqlResult.allowed) return sqlResult;
+    }
+    if (spec.capabilities.includes("network") && this.config.allowedDomains) {
+      const domainResult = this.checkDomains(argsObj);
+      if (!domainResult.allowed) return domainResult;
+    }
+    return { allowed: true };
+  }
+  checkFilePaths(args) {
+    const paths = this.extractStringValues(args, ["path", "file", "filepath", "filename", "dir", "directory"]);
+    for (const p of paths) {
+      const normalized = p.replace(/\.\./g, "");
+      if (p.includes("..")) {
+        return {
+          allowed: false,
+          reason: `Path traversal detected: ${p}`
+        };
+      }
+      if (this.config.sandboxPaths && this.config.sandboxPaths.length > 0) {
+        const inSandbox = this.config.sandboxPaths.some(
+          (sp) => normalized.startsWith(sp)
+        );
+        if (!inSandbox) {
+          return {
+            allowed: false,
+            reason: `Path outside sandbox: ${p}. Allowed: ${this.config.sandboxPaths.join(", ")}`
+          };
+        }
+      }
+    }
+    return { allowed: true };
+  }
+  checkUrls(args) {
+    const urls = this.extractStringValues(args, ["url", "endpoint", "href", "uri"]);
+    for (const url of urls) {
+      if (this.config.urlDenylist) {
+        for (const pattern of this.config.urlDenylist) {
+          if (new RegExp(pattern, "i").test(url)) {
+            return {
+              allowed: false,
+              reason: `URL denied by policy: ${url}`
+            };
+          }
+        }
+      }
+      if (this.config.urlAllowlist && this.config.urlAllowlist.length > 0) {
+        const allowed = this.config.urlAllowlist.some(
+          (pattern) => new RegExp(pattern, "i").test(url)
+        );
+        if (!allowed) {
+          return {
+            allowed: false,
+            reason: `URL not in allowlist: ${url}`
+          };
+        }
+      }
+    }
+    return { allowed: true };
+  }
+  checkSql(args) {
+    const sqls = this.extractStringValues(args, ["sql", "query", "statement"]);
+    for (const sql of sqls) {
+      if (this.config.deniedSqlPatterns) {
+        for (const pattern of this.config.deniedSqlPatterns) {
+          if (new RegExp(pattern, "i").test(sql)) {
+            return {
+              allowed: false,
+              reason: `SQL pattern denied: ${sql.slice(0, 50)}...`
+            };
+          }
+        }
+      }
+    }
+    return { allowed: true };
+  }
+  checkDomains(args) {
+    const urls = this.extractStringValues(args, ["url", "endpoint", "href", "host", "domain"]);
+    for (const url of urls) {
+      try {
+        const hostname = url.includes("://") ? new URL(url).hostname : url;
+        if (this.config.allowedDomains && !this.config.allowedDomains.some(
+          (d) => hostname === d || hostname.endsWith(`.${d}`)
+        )) {
+          return {
+            allowed: false,
+            reason: `Domain not allowed: ${hostname}`
+          };
+        }
+      } catch {
+      }
+    }
+    return { allowed: true };
+  }
+  /**
+   * Extract string values from args matching given key patterns.
+   */
+  extractStringValues(args, keyPatterns) {
+    const results = [];
+    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)) {
+          walk(val);
+        }
+      }
+    };
+    walk(args);
+    return results;
+  }
+};
+var PolicyDeniedError = class extends Error {
+  constructor(message, missingCapabilities) {
+    super(message);
+    this.missingCapabilities = missingCapabilities;
+    this.name = "PolicyDeniedError";
+  }
+  kind = "POLICY_DENIED";
+};
+var RateLimiter = class {
+  constructor(maxCalls, windowMs) {
+    this.maxCalls = maxCalls;
+    this.windowMs = windowMs;
+  }
+  timestamps = [];
+  tryAcquire() {
+    const now = Date.now();
+    while (this.timestamps.length > 0 && this.timestamps[0] <= now - this.windowMs) {
+      this.timestamps.shift();
+    }
+    if (this.timestamps.length >= this.maxCalls) {
+      return false;
+    }
+    this.timestamps.push(now);
+    return true;
+  }
+  get remaining() {
+    const now = Date.now();
+    const active = this.timestamps.filter((t) => t > now - this.windowMs);
+    return Math.max(0, this.maxCalls - active.length);
+  }
+};
+var BudgetManager = class {
+  defaultTimeoutMs;
+  bulkheads = /* @__PURE__ */ new Map();
+  circuitBreakers = /* @__PURE__ */ new Map();
+  rateLimiters = /* @__PURE__ */ new Map();
+  options;
+  constructor(options = {}) {
+    this.options = options;
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? 3e4;
+  }
+  /**
+   * Get effective timeout for a tool invocation.
+   */
+  getTimeout(_toolName, contextTimeoutMs) {
+    return contextTimeoutMs ?? this.defaultTimeoutMs;
+  }
+  /**
+   * Check rate limit for a tool. Returns true if allowed.
+   */
+  checkRateLimit(toolName) {
+    if (!this.options.rateLimit) return true;
+    let limiter = this.rateLimiters.get(toolName);
+    if (!limiter) {
+      limiter = new RateLimiter(
+        this.options.rateLimit.maxCalls,
+        this.options.rateLimit.windowMs
+      );
+      this.rateLimiters.set(toolName, limiter);
+    }
+    return limiter.tryAcquire();
+  }
+  /**
+   * Get or create a bulkhead (concurrency limiter) for a tool.
+   */
+  getBulkhead(toolName) {
+    if (!this.options.maxConcurrency) return void 0;
+    let bh = this.bulkheads.get(toolName);
+    if (!bh) {
+      bh = cockatiel.bulkhead(this.options.maxConcurrency, 0);
+      this.bulkheads.set(toolName, bh);
+    }
+    return bh;
+  }
+  /**
+   * Get or create a circuit breaker for a tool.
+   */
+  getCircuitBreaker(toolName) {
+    if (!this.options.circuitBreaker) return void 0;
+    let breaker = this.circuitBreakers.get(toolName);
+    if (!breaker) {
+      breaker = cockatiel.circuitBreaker(cockatiel.handleAll, {
+        breaker: new cockatiel.ConsecutiveBreaker(this.options.circuitBreaker.threshold),
+        halfOpenAfter: this.options.circuitBreaker.halfOpenAfterMs
+      });
+      this.circuitBreakers.set(toolName, breaker);
+    }
+    return breaker;
+  }
+  /**
+   * Execute a function within budget constraints (bulkhead + circuit breaker).
+   */
+  async execute(toolName, fn) {
+    const bh = this.getBulkhead(toolName);
+    const breaker = this.getCircuitBreaker(toolName);
+    let wrapped = fn;
+    if (breaker) {
+      const prevWrapped = wrapped;
+      wrapped = () => breaker.execute(() => prevWrapped());
+    }
+    if (bh) {
+      const prevWrapped = wrapped;
+      wrapped = () => bh.execute(() => prevWrapped());
+    }
+    return wrapped();
+  }
+  /**
+   * Reset all policies for a tool (useful for testing).
+   */
+  reset(toolName) {
+    this.bulkheads.delete(toolName);
+    this.circuitBreakers.delete(toolName);
+    this.rateLimiters.delete(toolName);
+  }
+  /**
+   * Reset all policies globally.
+   */
+  resetAll() {
+    this.bulkheads.clear();
+    this.circuitBreakers.clear();
+    this.rateLimiters.clear();
+  }
+};
+
+// src/core/runtime/Evidence.ts
+function buildEvidence(options) {
+  const { spec, args, result, ctx, durationMs } = options;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const evidence = [];
+  evidence.push({
+    type: "tool",
+    ref: `${spec.name}@${spec.version}`,
+    summary: summarizeToolCall(spec, args, result, durationMs),
+    createdAt: now
+  });
+  if (result && typeof result === "object") {
+    const urls = extractUrls(result);
+    for (const url of urls) {
+      evidence.push({
+        type: "url",
+        ref: url,
+        summary: `Output URL from ${spec.name}`,
+        createdAt: now
+      });
+    }
+    const files = extractFilePaths(result);
+    for (const file of files) {
+      evidence.push({
+        type: "file",
+        ref: file,
+        summary: `Output file from ${spec.name}`,
+        createdAt: now
+      });
+    }
+  }
+  if (durationMs !== void 0 && durationMs > 0) {
+    evidence.push({
+      type: "metric",
+      ref: `latency:${spec.name}`,
+      summary: `Completed in ${durationMs}ms (request: ${ctx.requestId})`,
+      createdAt: now
+    });
+  }
+  return evidence;
+}
+function summarizeToolCall(spec, args, result, durationMs) {
+  const argKeys = args && typeof args === "object" ? Object.keys(args).join(", ") : "none";
+  const duration = durationMs ? ` in ${durationMs}ms` : "";
+  const resultPreview = summarizeValue(result, 100);
+  return `${spec.kind}:${spec.name} called with [${argKeys}]${duration} \u2192 ${resultPreview}`;
+}
+function summarizeValue(value, maxLen) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "string") {
+    return value.length > maxLen ? value.slice(0, maxLen) + "..." : value;
+  }
+  const str = JSON.stringify(value);
+  return str.length > maxLen ? str.slice(0, maxLen) + "..." : str;
+}
+function extractUrls(obj) {
+  const urls = [];
+  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)) {
+        walk(v);
+      }
+    }
+  };
+  walk(obj);
+  return urls.slice(0, 10);
+}
+function extractFilePaths(obj) {
+  const paths = [];
+  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)) {
+        walk(v);
+      }
+    }
+  };
+  walk(obj);
+  return paths.slice(0, 10);
+}
+var EventLog = class {
+  entries = [];
+  seq = 0;
+  maxEntries;
+  emitter = new eventemitter3.EventEmitter();
+  constructor(options = {}) {
+    this.maxEntries = options.maxEntries ?? 1e4;
+  }
+  /**
+   * Append an event to the log.
+   */
+  append(event) {
+    const entry = { seq: ++this.seq, event };
+    this.entries.push(entry);
+    if (this.entries.length > this.maxEntries) {
+      this.entries.shift();
+    }
+    this.emitter.emit("event", entry);
+    this.emitter.emit(event.type, entry);
+    return entry;
+  }
+  /**
+   * Subscribe to all events.
+   */
+  on(listener) {
+    this.emitter.on("event", listener);
+    return () => this.emitter.off("event", listener);
+  }
+  /**
+   * Subscribe to events of a specific type.
+   */
+  onType(type, listener) {
+    this.emitter.on(type, listener);
+    return () => this.emitter.off(type, listener);
+  }
+  /**
+   * Query events by filter.
+   */
+  query(filter) {
+    let results = this.entries;
+    if (filter.since !== void 0) {
+      results = results.filter((e) => e.seq > filter.since);
+    }
+    if (filter.type) {
+      results = results.filter((e) => e.event.type === filter.type);
+    }
+    if (filter.toolName) {
+      results = results.filter((e) => e.event.toolName === filter.toolName);
+    }
+    if (filter.requestId) {
+      results = results.filter((e) => e.event.requestId === filter.requestId);
+    }
+    if (filter.limit) {
+      results = results.slice(-filter.limit);
+    }
+    return results;
+  }
+  /**
+   * Get all entries.
+   */
+  getAll() {
+    return this.entries;
+  }
+  /**
+   * Get entry count.
+   */
+  get size() {
+    return this.entries.length;
+  }
+  /**
+   * Clear all entries (for testing).
+   */
+  clear() {
+    this.entries.length = 0;
+    this.seq = 0;
+  }
+};
+
+// src/utils/log.ts
+function summarizeForLog(value, maxLen = 220) {
+  const raw = typeof value === "string" ? value : value == null ? "" : (() => {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  })();
+  const compact = raw.replace(/\s+/g, " ").trim();
+  if (!compact) return "(empty)";
+  return compact.length > maxLen ? `${compact.slice(0, maxLen)}...` : compact;
+}
+
+// src/observability/Logger.ts
+var LEVEL_ORDER = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4,
+  trace: 5
+};
+function createLogger(options = {}) {
+  const resolved = resolveDebugOptions(options);
+  const log = (level, message, meta) => {
+    if (!resolved.enabled) return;
+    if (LEVEL_ORDER[level] > LEVEL_ORDER[resolved.level]) return;
+    const prefix = `[${resolved.prefix}]`;
+    const levelTag = `[${level.toUpperCase()}]`;
+    const metaText = meta ? ` ${safeStringify(meta, 1e3)}` : "";
+    switch (level) {
+      case "error":
+        console.error(`${prefix} ${levelTag} ${message}${metaText}`);
+        break;
+      case "warn":
+        console.warn(`${prefix} ${levelTag} ${message}${metaText}`);
+        break;
+      case "info":
+        console.info(`${prefix} ${levelTag} ${message}${metaText}`);
+        break;
+      default:
+        console.log(`${prefix} ${levelTag} ${message}${metaText}`);
+        break;
+    }
+  };
+  return {
+    options: resolved,
+    isEnabled: (level) => resolved.enabled && LEVEL_ORDER[level] <= LEVEL_ORDER[resolved.level],
+    error: (message, meta) => log("error", message, meta),
+    warn: (message, meta) => log("warn", message, meta),
+    info: (message, meta) => log("info", message, meta),
+    debug: (message, meta) => log("debug", message, meta),
+    trace: (message, meta) => log("trace", message, meta)
+  };
+}
+function resolveDebugOptions(options = {}) {
+  const envLevel = parseEnvLogLevel();
+  const enabledFromEnv = envLevel !== void 0 && envLevel !== "silent";
+  const enabled = options.enabled ?? enabledFromEnv ?? false;
+  const level = options.level ?? envLevel ?? (enabled ? "debug" : "silent");
+  return {
+    enabled,
+    level,
+    includeArgs: options.includeArgs ?? false,
+    includeResults: options.includeResults ?? false,
+    includeRaw: options.includeRaw ?? false,
+    logEvents: options.logEvents ?? false,
+    prefix: options.prefix ?? "agent-tool"
+  };
+}
+function sanitizeForLog(value, maxLen = 500) {
+  const str = safeStringify(value, maxLen);
+  return str.replace(
+    /"(password|token|secret|key|auth)":\s*"[^"]*"/gi,
+    '"$1":"[REDACTED]"'
+  );
+}
+function safeStringify(value, maxLen) {
+  try {
+    const json = JSON.stringify(value);
+    if (!json) return String(value);
+    return json.length > maxLen ? `${json.slice(0, maxLen)}...` : json;
+  } catch {
+    const fallback = String(value);
+    return fallback.length > maxLen ? `${fallback.slice(0, maxLen)}...` : fallback;
+  }
+}
+function parseEnvLogLevel() {
+  const raw = process.env.TOOLHUB_LOG_LEVEL ?? process.env.TOOLHUB_DEBUG ?? process.env.DEBUG;
+  if (!raw) return void 0;
+  const value = raw.trim().toLowerCase();
+  if (!value || value === "0" || value === "false" || value === "off") {
+    return "silent";
+  }
+  if (value.includes("trace")) return "trace";
+  if (value.includes("debug") || value === "1" || value === "true" || value === "yes") {
+    return "debug";
+  }
+  if (value.includes("info")) return "info";
+  if (value.includes("warn")) return "warn";
+  if (value.includes("error")) return "error";
+  if (value.includes("silent")) return "silent";
+  return "debug";
+}
+
+// src/observability/Metrics.ts
+var Metrics = class {
+  counters = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  defaultBuckets = [
+    5,
+    10,
+    25,
+    50,
+    100,
+    250,
+    500,
+    1e3,
+    2500,
+    5e3,
+    1e4
+  ];
+  /**
+   * Increment a counter.
+   */
+  increment(name, labels = {}, value = 1) {
+    const key = this.makeKey(name, labels);
+    this.counters.set(key, (this.counters.get(key) ?? 0) + value);
+  }
+  /**
+   * Record a value in a histogram.
+   */
+  observe(name, labels, value) {
+    const key = this.makeKey(name, labels);
+    let hist = this.histograms.get(key);
+    if (!hist) {
+      hist = { count: 0, sum: 0, values: [] };
+      this.histograms.set(key, hist);
+    }
+    hist.count++;
+    hist.sum += value;
+    hist.values.push(value);
+  }
+  /**
+   * Get a counter value.
+   */
+  getCounter(name, labels = {}) {
+    return this.counters.get(this.makeKey(name, labels)) ?? 0;
+  }
+  /**
+   * Get histogram stats.
+   */
+  getHistogram(name, labels) {
+    const key = this.makeKey(name, labels);
+    const hist = this.histograms.get(key);
+    if (!hist) return void 0;
+    const buckets = /* @__PURE__ */ new Map();
+    for (const bound of this.defaultBuckets) {
+      buckets.set(bound, hist.values.filter((v) => v <= bound).length);
+    }
+    return { name, labels, count: hist.count, sum: hist.sum, buckets };
+  }
+  /**
+   * Get all counter values.
+   */
+  getAllCounters() {
+    const results = [];
+    for (const [key, value] of this.counters) {
+      const { name, labels } = this.parseKey(key);
+      results.push({ name, labels, value });
+    }
+    return results;
+  }
+  /**
+   * Get all histogram values.
+   */
+  getAllHistograms() {
+    const results = [];
+    for (const [key, hist] of this.histograms) {
+      const { name, labels } = this.parseKey(key);
+      const buckets = /* @__PURE__ */ new Map();
+      for (const bound of this.defaultBuckets) {
+        buckets.set(bound, hist.values.filter((v) => v <= bound).length);
+      }
+      results.push({ name, labels, count: hist.count, sum: hist.sum, buckets });
+    }
+    return results;
+  }
+  /**
+   * Record standard tool invocation metrics.
+   */
+  recordInvocation(toolName, ok, durationMs) {
+    this.increment("tool_invocations_total", {
+      toolName,
+      ok: String(ok)
+    });
+    this.observe("tool_latency_ms", { toolName }, durationMs);
+  }
+  /**
+   * Record a retry event.
+   */
+  recordRetry(toolName) {
+    this.increment("tool_retries_total", { toolName });
+  }
+  /**
+   * Record a policy denial.
+   */
+  recordPolicyDenied(toolName, reason) {
+    this.increment("policy_denied_total", { toolName, reason });
+  }
+  /**
+   * Reset all metrics (for testing).
+   */
+  reset() {
+    this.counters.clear();
+    this.histograms.clear();
+  }
+  makeKey(name, labels) {
+    const sortedLabels = Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join(",");
+    return `${name}{${sortedLabels}}`;
+  }
+  parseKey(key) {
+    const match = key.match(/^(.+?)\{(.*)\}$/);
+    if (!match) return { name: key, labels: {} };
+    const labels = {};
+    if (match[2]) {
+      for (const part of match[2].split(",")) {
+        const [k, v] = part.split("=");
+        if (k && v !== void 0) labels[k] = v;
+      }
+    }
+    return { name: match[1], labels };
+  }
+};
+var Tracing = class {
+  spans = /* @__PURE__ */ new Map();
+  traceSpans = /* @__PURE__ */ new Map();
+  // traceId → spanIds
+  /**
+   * Start a new span.
+   */
+  startSpan(options) {
+    const span = {
+      spanId: uuid.v4(),
+      traceId: options.traceId ?? uuid.v4(),
+      parentSpanId: options.parentSpanId,
+      name: options.name,
+      startTime: Date.now(),
+      status: "in_progress",
+      attributes: options.attributes ?? {},
+      events: []
+    };
+    this.spans.set(span.spanId, span);
+    const traceList = this.traceSpans.get(span.traceId) ?? [];
+    traceList.push(span.spanId);
+    this.traceSpans.set(span.traceId, traceList);
+    return span;
+  }
+  /**
+   * End a span and calculate duration.
+   */
+  endSpan(spanId, status = "ok") {
+    const span = this.spans.get(spanId);
+    if (!span) return void 0;
+    span.endTime = Date.now();
+    span.durationMs = span.endTime - span.startTime;
+    span.status = status;
+    return span;
+  }
+  /**
+   * Add an event to a span.
+   */
+  addEvent(spanId, name, attributes) {
+    const span = this.spans.get(spanId);
+    if (!span) return;
+    span.events.push({ name, timestamp: Date.now(), attributes });
+  }
+  /**
+   * Set attributes on a span.
+   */
+  setAttributes(spanId, attributes) {
+    const span = this.spans.get(spanId);
+    if (!span) return;
+    Object.assign(span.attributes, attributes);
+  }
+  /**
+   * Get a span by ID.
+   */
+  getSpan(spanId) {
+    return this.spans.get(spanId);
+  }
+  /**
+   * Get all spans for a trace.
+   */
+  getTrace(traceId) {
+    const spanIds = this.traceSpans.get(traceId) ?? [];
+    return spanIds.map((id) => this.spans.get(id)).filter((s) => s !== void 0);
+  }
+  /**
+   * Create a child span from a parent.
+   */
+  createChildSpan(parentSpanId, name, attributes) {
+    const parent = this.spans.get(parentSpanId);
+    if (!parent) return void 0;
+    return this.startSpan({
+      name,
+      traceId: parent.traceId,
+      parentSpanId: parent.spanId,
+      attributes
+    });
+  }
+  /**
+   * Clear all traces (for testing).
+   */
+  clear() {
+    this.spans.clear();
+    this.traceSpans.clear();
+  }
+};
+function resolveTool(toolName, registry) {
+  const key = chunkJW4EMVTE_cjs.normalizeToolName(toolName);
+  const spec = registry.get(key);
+  if (spec) {
+    return spec;
+  }
+  const suffixMatches = registry.snapshot().filter((candidate) => candidate.name.endsWith(`.${key}`));
+  const uniqueSuffixMatch = suffixMatches[0];
+  if (suffixMatches.length === 1 && uniqueSuffixMatch !== void 0) {
+    return uniqueSuffixMatch;
+  }
+  throw chunkAGLGFQUW_cjs.createTaggedError(
+    "TOOL_NOT_FOUND",
+    `Tool not found: ${toolName}`,
+    { availableTools: registry.snapshot().slice(0, 20).map((s) => s.name) }
+  );
+}
+var INPUT_ALIASES = {
+  q: "query"
+};
+function normalizeInputAliases(spec, args) {
+  if (args == null || typeof args !== "object" || Array.isArray(args)) {
+    return args;
+  }
+  const required = getRequiredKeys(spec.inputSchema);
+  const obj = args;
+  let changed = false;
+  const out = { ...obj };
+  for (const [aliasKey, canonicalKey] of Object.entries(INPUT_ALIASES)) {
+    if (required.includes(canonicalKey) && (out[canonicalKey] === void 0 || out[canonicalKey] === "") && out[aliasKey] !== void 0 && out[aliasKey] !== "") {
+      out[canonicalKey] = out[aliasKey];
+      delete out[aliasKey];
+      changed = true;
+    }
+  }
+  return changed ? out : args;
+}
+function validateInput(spec, args, validator) {
+  try {
+    return validator.validateOrThrow(
+      spec.inputSchema,
+      args,
+      `Input validation failed for ${spec.name}`
+    );
+  } catch (error) {
+    if (error instanceof SchemaValidationError) {
+      const requiredKeys = getRequiredKeys(spec.inputSchema);
+      const passedKeys = args != null && typeof args === "object" && !Array.isArray(args) ? Object.keys(args) : [];
+      throw chunkAGLGFQUW_cjs.createTaggedError("INPUT_SCHEMA_INVALID", error.message, {
+        errors: error.errors,
+        schema: spec.inputSchema,
+        requiredKeys: requiredKeys.length ? requiredKeys : void 0,
+        passedKeys: passedKeys.length ? passedKeys : void 0,
+        hint: requiredKeys.length > 0 ? `Expected input property ${requiredKeys.length === 1 ? `'${requiredKeys[0]}'` : `[${requiredKeys.map((k) => `'${k}'`).join(", ")}]`}. You passed: ${passedKeys.length ? passedKeys.map((k) => `'${k}'`).join(", ") : "none"}. Use the exact property names from the tool schema.` : void 0
+      });
+    }
+    throw error;
+  }
+}
+function getRequiredKeys(schema) {
+  const s = schema;
+  const raw = s.required;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((k) => typeof k === "string");
+}
+function enrichDefaults(spec, args, validator) {
+  return validator.enrichDefaults(spec.inputSchema, args);
+}
+function enforcePolicy(spec, args, ctx, deps) {
+  try {
+    deps.policy.enforce(spec, args, ctx);
+  } catch (error) {
+    if (error instanceof PolicyDeniedError) {
+      const event = {
+        type: "POLICY_DENIED",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId: ctx.requestId,
+        taskId: ctx.taskId,
+        toolName: spec.name,
+        traceId: ctx.traceId,
+        userId: ctx.userId,
+        reason: error.message,
+        missingCapabilities: error.missingCapabilities?.map(String)
+      };
+      deps.eventLog.append(event);
+      deps.metrics.recordPolicyDenied(spec.name, error.message);
+    }
+    throw error;
+  }
+}
+var HITL_GATED_SIDE_EFFECTS = ["external_write", "destructive"];
+async function requireHumanApproval(spec, args, ctx, deps) {
+  const sideEffect = spec._meta?.hitl?.sideEffect ?? "none";
+  if (!HITL_GATED_SIDE_EFFECTS.includes(sideEffect)) return;
+  const onApproval = deps.onApprovalRequired;
+  if (!onApproval) return;
+  const baseEvent = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: ctx.requestId,
+    taskId: ctx.taskId,
+    toolName: spec.name,
+    traceId: ctx.traceId,
+    userId: ctx.userId
+  };
+  const requested = {
+    ...baseEvent,
+    type: "HITL_APPROVAL_REQUESTED",
+    sideEffect
+  };
+  deps.eventLog.append(requested);
+  deps.logger.trace("hitl.requested", { tool: spec.name, sideEffect, requestId: ctx.requestId });
+  let approved;
+  try {
+    approved = await onApproval(spec, args, ctx);
+  } catch (err) {
+    deps.eventLog.append({
+      ...baseEvent,
+      type: "HITL_APPROVAL_DENIED",
+      sideEffect,
+      reason: err instanceof Error ? err.message : String(err)
+    });
+    throw chunkAGLGFQUW_cjs.createTaggedError(
+      "HITL_DENIED",
+      `Human denied approval for ${spec.name} (${sideEffect})`,
+      { reason: err instanceof Error ? err.message : String(err) }
+    );
+  }
+  if (approved === false) {
+    deps.eventLog.append({
+      ...baseEvent,
+      type: "HITL_APPROVAL_DENIED",
+      sideEffect,
+      reason: "User rejected"
+    });
+    throw chunkAGLGFQUW_cjs.createTaggedError("HITL_DENIED", `Human denied approval for ${spec.name} (${sideEffect})`);
+  }
+  deps.eventLog.append({
+    ...baseEvent,
+    type: "HITL_APPROVAL_GRANTED",
+    sideEffect
+  });
+  deps.logger.trace("hitl.granted", { tool: spec.name, sideEffect, requestId: ctx.requestId });
+}
+async function executeWithBudget(spec, args, ctx, spanId, deps) {
+  const adapter = deps.adaptersByToolName.get(spec.name) ?? deps.adapters.get(spec.kind);
+  if (!adapter) {
+    throw chunkAGLGFQUW_cjs.createTaggedError(
+      "TOOL_NOT_FOUND",
+      `No adapter registered for kind: ${spec.kind}`
+    );
+  }
+  const timeoutMs = deps.budget.getTimeout(
+    spec.name,
+    ctx.budget?.timeoutMs
+  );
+  const maxRetries = ctx.budget?.maxRetries ?? deps.defaultMaxRetries ?? 2;
+  const executeFn = async () => {
+    return deps.budget.execute(spec.name, async () => {
+      deps.tracing.addEvent(spanId, "execute_start");
+      deps.logger.trace("execute.start", {
+        tool: spec.name,
+        requestId: ctx.requestId,
+        timeoutMs,
+        maxRetries
+      });
+      const result = await adapter.invoke(spec, args, ctx);
+      deps.tracing.addEvent(spanId, "execute_end");
+      deps.logger.trace("execute.end", {
+        tool: spec.name,
+        requestId: ctx.requestId
+      });
+      return result;
+    });
+  };
+  const retryFn = () => chunkAGLGFQUW_cjs.withRetry(executeFn, {
+    maxRetries,
+    onRetry: (error, attempt) => {
+      deps.metrics.recordRetry(spec.name);
+      const event = {
+        type: "RETRY",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId: ctx.requestId,
+        taskId: ctx.taskId,
+        toolName: spec.name,
+        traceId: ctx.traceId,
+        userId: ctx.userId,
+        attempt,
+        maxRetries,
+        reason: error.message
+      };
+      deps.eventLog.append(event);
+      deps.tracing.addEvent(spanId, "retry", { attempt, reason: error.message });
+    }
+  });
+  try {
+    return await pTimeout__default.default(retryFn(), {
+      milliseconds: timeoutMs,
+      message: `Tool ${spec.name} timed out after ${timeoutMs}ms`
+    });
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("timed out")) {
+      throw chunkAGLGFQUW_cjs.createTaggedError("TIMEOUT", error.message);
+    }
+    throw error;
+  }
+}
+function validateOutput(spec, result, validator) {
+  try {
+    return validator.validateOrThrow(
+      spec.outputSchema,
+      result,
+      `Output validation failed for ${spec.name}`
+    );
+  } catch (error) {
+    if (error instanceof SchemaValidationError) {
+      throw chunkAGLGFQUW_cjs.createTaggedError("OUTPUT_SCHEMA_INVALID", error.message, {
+        errors: error.errors
+      });
+    }
+    throw error;
+  }
+}
+
+// src/core/runtime/PTCRuntimeObservability.ts
+function emitToolCalled(intent, ctx, deps) {
+  const event = {
+    type: "TOOL_CALLED",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: ctx.requestId,
+    taskId: ctx.taskId,
+    toolName: intent.tool,
+    traceId: ctx.traceId,
+    userId: ctx.userId,
+    argsSummary: sanitizeArgs(intent.args),
+    purpose: intent.purpose,
+    idempotencyKey: intent.idempotencyKey
+  };
+  deps.eventLog.append(event);
+}
+function recordSuccess(spec, durationMs, _evidence, spanId, deps) {
+  deps.metrics.recordInvocation(spec.name, true, durationMs);
+  deps.tracing.setAttributes(spanId, {
+    "tool.duration_ms": durationMs,
+    "tool.ok": true
+  });
+  deps.tracing.endSpan(spanId, "ok");
+}
+function handleError(error, intent, ctx, durationMs, spanId, deps) {
+  const kind = error?.kind ?? "UPSTREAM_ERROR";
+  const message = error instanceof Error ? error.message : String(error);
+  const details = error?.details;
+  deps.metrics.recordInvocation(intent.tool, false, durationMs);
+  deps.tracing.setAttributes(spanId, {
+    "tool.duration_ms": durationMs,
+    "tool.ok": false,
+    "tool.error_kind": kind
+  });
+  deps.tracing.endSpan(spanId, "error");
+  const event = {
+    type: "TOOL_RESULT",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: ctx.requestId,
+    taskId: ctx.taskId,
+    toolName: intent.tool,
+    traceId: ctx.traceId,
+    userId: ctx.userId,
+    ok: false,
+    durationMs,
+    resultSummary: message,
+    evidence: [],
+    error: { kind, message, details }
+  };
+  deps.eventLog.append(event);
+  deps.logger.warn("invoke.error", {
+    tool: intent.tool,
+    requestId: ctx.requestId,
+    taskId: ctx.taskId,
+    traceId: ctx.traceId,
+    kind,
+    message,
+    durationMs,
+    details: deps.logger.options.includeResults ? summarizeForLog(details) : void 0
+  });
+  return {
+    ok: false,
+    evidence: [],
+    error: { kind, message, details }
+  };
+}
+function sanitizeArgs(args) {
+  if (!args) return "{}";
+  return sanitizeForLog(args);
+}
+
+// src/core/runtime/PTCRuntime.ts
+var PTCRuntime = class {
+  registry;
+  adapters = /* @__PURE__ */ new Map();
+  adaptersByToolName = /* @__PURE__ */ new Map();
+  validator;
+  policy;
+  budget;
+  eventLog;
+  metrics;
+  tracing;
+  config;
+  logger;
+  constructor(options = {}) {
+    this.config = options.config ?? {};
+    this.registry = options.registry ?? new chunkAGLGFQUW_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);
+    this.eventLog = options.eventLog ?? new EventLog();
+    this.metrics = options.metrics ?? new Metrics();
+    this.tracing = options.tracing ?? new Tracing();
+    this.logger = createLogger({ ...this.config.debug, prefix: "PTCRuntime" });
+    if (this.logger.options.logEvents) {
+      this.eventLog.on((entry) => {
+        const event = entry.event;
+        this.logger.debug("event", {
+          seq: entry.seq,
+          type: event.type,
+          toolName: event.toolName,
+          requestId: event.requestId,
+          taskId: event.taskId,
+          ok: "ok" in event ? event.ok : void 0
+        });
+      });
+    }
+  }
+  /**
+   * Register an adapter for a tool kind.
+   */
+  registerAdapter(adapter) {
+    this.adapters.set(adapter.kind, adapter);
+  }
+  /**
+   * Bind an adapter to exact tool keys (full package path + tool path).
+   * This avoids collisions when multiple extensions share the same kind.
+   */
+  registerAdapterForTools(toolNames, adapter) {
+    for (const name of toolNames) {
+      this.adaptersByToolName.set(name, adapter);
+    }
+  }
+  /**
+   * Get an adapter by kind (e.g. "mcp"). Use to set MCP client via adapter.setClient().
+   */
+  getAdapter(kind) {
+    return this.adapters.get(kind);
+  }
+  /**
+   * Get the tool registry.
+   */
+  getRegistry() {
+    return this.registry;
+  }
+  /**
+   * Get the event log.
+   */
+  getEventLog() {
+    return this.eventLog;
+  }
+  /**
+   * Get the metrics collector.
+   */
+  getMetrics() {
+    return this.metrics;
+  }
+  /**
+   * Get the tracing system.
+   */
+  getTracing() {
+    return this.tracing;
+  }
+  /**
+   * Invoke a tool through the PTC pipeline.
+   * Never throws - always returns a structured ToolResult.
+   */
+  async invoke(intent, ctx) {
+    const startTime = Date.now();
+    const span = this.beginInvokeSpan(intent, ctx);
+    const observability = this.getObservabilityDeps();
+    emitToolCalled(intent, ctx, observability);
+    try {
+      const pipeline = await this.runInvokePipeline(intent, ctx, span.spanId);
+      if (pipeline.dryRun) {
+        return this.buildDryRunResult(pipeline.spec, pipeline.enrichedArgs, ctx, startTime, span.spanId);
+      }
+      return this.buildInvokeSuccessResult(pipeline, ctx, startTime, span.spanId, observability);
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      return handleError(error, intent, ctx, durationMs, span.spanId, observability);
+    }
+  }
+  /**
+   * Search for tools in the registry.
+   */
+  searchTools(query, filters) {
+    return this.registry.search({
+      text: query,
+      kind: filters?.kind,
+      capabilities: filters?.capabilities,
+      tags: filters?.tags
+    });
+  }
+  /**
+   * Get the schema for a tool.
+   */
+  getToolSchema(toolName) {
+    const spec = this.registry.get(toolName);
+    if (!spec) return void 0;
+    return { input: spec.inputSchema, output: spec.outputSchema };
+  }
+  // --- Helper Methods ---
+  getPipelineDeps() {
+    return {
+      registry: this.registry,
+      adapters: this.adapters,
+      adaptersByToolName: this.adaptersByToolName,
+      validator: this.validator,
+      policy: this.policy,
+      budget: this.budget,
+      eventLog: this.eventLog,
+      metrics: this.metrics,
+      tracing: this.tracing,
+      logger: this.logger,
+      defaultMaxRetries: this.config.defaultMaxRetries,
+      onApprovalRequired: this.config.onApprovalRequired
+    };
+  }
+  getObservabilityDeps() {
+    return {
+      eventLog: this.eventLog,
+      metrics: this.metrics,
+      tracing: this.tracing,
+      logger: this.logger
+    };
+  }
+  beginInvokeSpan(intent, ctx) {
+    if (this.logger.isEnabled("debug")) {
+      this.logger.debug("invoke.start", {
+        tool: intent.tool,
+        requestId: ctx.requestId,
+        taskId: ctx.taskId,
+        traceId: ctx.traceId,
+        purpose: intent.purpose,
+        args: this.logger.options.includeArgs ? sanitizeForLog(intent.args) : void 0
+      });
+    }
+    return this.tracing.startSpan({
+      name: `tool:${intent.tool}`,
+      traceId: ctx.traceId,
+      attributes: {
+        "tool.name": intent.tool,
+        "tool.purpose": intent.purpose,
+        requestId: ctx.requestId,
+        taskId: ctx.taskId
+      }
+    });
+  }
+  async runInvokePipeline(intent, ctx, spanId) {
+    const spec = resolveTool(intent.tool, this.registry);
+    this.tracing.addEvent(spanId, "resolved", { kind: spec.kind, version: spec.version });
+    const normalizedArgs = normalizeInputAliases(spec, intent.args);
+    const validatedArgs = validateInput(spec, normalizedArgs, this.validator);
+    const enrichedArgs = enrichDefaults(spec, validatedArgs, this.validator);
+    enforcePolicy(spec, enrichedArgs, ctx, this.getPipelineDeps());
+    if (!this.budget.checkRateLimit(spec.name)) {
+      throw chunkAGLGFQUW_cjs.createTaggedError("BUDGET_EXCEEDED", `Rate limit exceeded for tool: ${spec.name}`);
+    }
+    await requireHumanApproval(spec, enrichedArgs, ctx, {
+      onApprovalRequired: this.config.onApprovalRequired,
+      eventLog: this.eventLog,
+      logger: this.logger
+    });
+    if (ctx.dryRun) return { spec, enrichedArgs, dryRun: true };
+    const execution = await executeWithBudget(spec, enrichedArgs, ctx, spanId, this.getPipelineDeps());
+    return { spec, enrichedArgs, dryRun: false, result: execution.result, raw: execution.raw };
+  }
+  buildInvokeSuccessResult(pipeline, ctx, startTime, spanId, observability) {
+    const toolError = asToolReturnedError(pipeline.result);
+    if (toolError) {
+      const hint = buildInputSchemaHint(pipeline.spec.inputSchema);
+      throw chunkAGLGFQUW_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."
+      });
+    }
+    const validatedOutput = validateOutput(pipeline.spec, pipeline.result, this.validator);
+    const toolFeedback = asToolReturnedFeedback(validatedOutput);
+    const durationMs = Date.now() - startTime;
+    const builtEvidence = buildEvidence({
+      spec: pipeline.spec,
+      args: pipeline.enrichedArgs,
+      result: validatedOutput,
+      raw: pipeline.raw,
+      ctx,
+      durationMs
+    });
+    const adapterEvidence = getAdapterEvidence(pipeline.raw);
+    const evidence = [...adapterEvidence, ...builtEvidence];
+    recordSuccess(pipeline.spec, durationMs, evidence, spanId, observability);
+    if (this.logger.isEnabled("debug")) {
+      this.logger.debug("invoke.ok", {
+        tool: pipeline.spec.name,
+        durationMs,
+        result: this.logger.options.includeResults ? summarizeForLog(validatedOutput) : void 0,
+        raw: this.logger.options.includeRaw ? summarizeForLog(pipeline.raw) : void 0
+      });
+    }
+    return {
+      ok: true,
+      result: validatedOutput,
+      feedback: toolFeedback ?? void 0,
+      evidence,
+      raw: this.config.includeRaw !== false ? pipeline.raw : void 0
+    };
+  }
+  buildDryRunResult(spec, args, _ctx, startTime, spanId) {
+    this.tracing.endSpan(spanId, "ok");
+    return {
+      ok: true,
+      result: {
+        dryRun: true,
+        tool: spec.name,
+        kind: spec.kind,
+        args,
+        capabilities: spec.capabilities
+      },
+      evidence: [
+        {
+          type: "tool",
+          ref: `${spec.name}@${spec.version}`,
+          summary: `Dry-run: would execute ${spec.kind}:${spec.name}`,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ]
+    };
+  }
+};
+function getAdapterEvidence(raw) {
+  if (!raw || typeof raw !== "object") return [];
+  const value = raw.evidence;
+  return Array.isArray(value) ? value : [];
+}
+function asToolReturnedError(result) {
+  if (result == null || typeof result !== "object" || Array.isArray(result)) {
+    return null;
+  }
+  const r = result;
+  const msg = r.error;
+  if (typeof msg !== "string" || !msg.trim()) {
+    return null;
+  }
+  return { message: msg.trim(), details: r.details };
+}
+function asToolReturnedFeedback(result) {
+  if (result == null || typeof result !== "object" || Array.isArray(result)) return null;
+  const rec = result;
+  const feedbackRaw = rec.feedback;
+  if (!feedbackRaw || typeof feedbackRaw !== "object" || Array.isArray(feedbackRaw)) return null;
+  const feedback = feedbackRaw;
+  const status = typeof feedback.status === "string" ? feedback.status.trim() : "";
+  const allowed = /* @__PURE__ */ new Set(["resolved", "needs_retry", "needs_input", "blocked"]);
+  if (!allowed.has(status)) return null;
+  const message = typeof feedback.message === "string" ? feedback.message.trim() : "";
+  if (!message) return null;
+  return {
+    status,
+    message,
+    hint: typeof feedback.hint === "string" ? feedback.hint : void 0,
+    suggested_intent_patch: feedback.suggested_intent_patch && typeof feedback.suggested_intent_patch === "object" && !Array.isArray(feedback.suggested_intent_patch) ? feedback.suggested_intent_patch : void 0,
+    suggested_tool_args: feedback.suggested_tool_args && typeof feedback.suggested_tool_args === "object" && !Array.isArray(feedback.suggested_tool_args) ? feedback.suggested_tool_args : void 0
+  };
+}
+function buildInputSchemaHint(inputSchema) {
+  const schema = inputSchema;
+  const required = schema.required;
+  if (!Array.isArray(required) || required.length === 0) {
+    return null;
+  }
+  const names = required.filter((k) => typeof k === "string");
+  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 versionCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 5 * 60 * 1e3;
+function resolveNpmPackageVersion(packageName, tag, options = {}) {
+  const cacheKey = packageName;
+  const cached = versionCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return cached.version;
+  }
+  try {
+    const spec = tag ? `${packageName}@${tag}` : packageName;
+    const out = child_process.execFileSync("npm", ["view", spec, "version"], {
+      cwd: options.cwd ?? process.cwd(),
+      encoding: "utf-8",
+      timeout: options.timeoutMs ?? 8e3,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const version = out?.trim() ?? null;
+    if (version) {
+      versionCache.set(cacheKey, { version, timestamp: Date.now() });
+    }
+    return version;
+  } catch {
+    return null;
+  }
+}
+function resolveLatestVersionFromRegistry(packageName, options = {}) {
+  const version = resolveNpmPackageVersion(packageName, void 0, options);
+  if (!version) {
+    throw new Error(`Failed to resolve latest version for ${packageName}`);
+  }
+  return version;
+}
+
+// src/utils/npmCache.ts
+var DEFAULT_CACHE_BASE = path.join(os.homedir(), ".agent", "cache");
+function isLatestRequest(version) {
+  const normalized = (version ?? "").trim().toLowerCase();
+  return normalized === "" || normalized === "latest";
+}
+function getCachedPackageVersion(cacheDir) {
+  const pkgPath = path.join(cacheDir, "package.json");
+  if (!fs.existsSync(pkgPath)) return void 0;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    return typeof pkg.version === "string" ? pkg.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function packagePathSegments(name) {
+  const withoutScope = name.replace(/^@/, "");
+  return withoutScope.split("/").filter(Boolean);
+}
+function resolveCacheDir2(cacheBase, packageName, version) {
+  const segments = packagePathSegments(packageName);
+  return path.join(cacheBase, ...segments, version);
+}
+function ensurePackageInCache(packageName, version = "latest", options = {}) {
+  const cacheBase = options.cacheBase ?? DEFAULT_CACHE_BASE;
+  const cwd = options.cwd ?? process.cwd();
+  const resolvedVersion = isLatestRequest(version) ? resolveLatestVersionFromRegistry(packageName, { cwd }) : version;
+  const cacheDir = resolveCacheDir2(cacheBase, packageName, resolvedVersion);
+  const packageJsonPath = path.join(cacheDir, "package.json");
+  const nodeModulesPath = path.join(cacheDir, "node_modules");
+  if (fs.existsSync(packageJsonPath) && fs.existsSync(nodeModulesPath)) {
+    const cachedVersion = getCachedPackageVersion(cacheDir);
+    if (cachedVersion === resolvedVersion) {
+      options.afterInstall?.(cacheDir, packageName);
+      return cacheDir;
+    }
+    fs.rmSync(cacheDir, { recursive: true, force: true });
+  }
+  const packDest = path.join(cacheBase, ".pack-tmp", packageName.replace(/@/g, "").replace(/\//g, "_"));
+  fs.mkdirSync(packDest, { recursive: true });
+  try {
+    child_process.execSync(`npm pack ${packageName}@${resolvedVersion} --pack-destination "${packDest}"`, {
+      cwd,
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    const files = fs.readdirSync(packDest);
+    const tgz = files.find((file) => file.endsWith(".tgz"));
+    if (!tgz) throw new Error(`npm pack did not produce a .tgz in ${packDest}`);
+    const extractDir = path.join(packDest, "extract");
+    fs.mkdirSync(extractDir, { recursive: true });
+    child_process.execSync(`tar -xzf "${path.join(packDest, tgz)}" -C "${extractDir}"`, {
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    const extractedPackage = path.join(extractDir, "package");
+    if (!fs.existsSync(extractedPackage)) {
+      throw new Error(`Extracted tarball did not contain "package" dir in ${extractDir}`);
+    }
+    fs.mkdirSync(path.join(cacheDir, ".."), { recursive: true });
+    if (fs.existsSync(cacheDir)) fs.rmSync(cacheDir, { recursive: true, force: true });
+    fs.renameSync(extractedPackage, cacheDir);
+    const npmInstallTimeout = 12e4;
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        child_process.execSync("npm install --prefer-offline --no-audit --no-fund", {
+          cwd: cacheDir,
+          stdio: "pipe",
+          encoding: "utf-8",
+          timeout: npmInstallTimeout
+        });
+        break;
+      } catch (error) {
+        if (attempt >= maxAttempts) {
+          const lastError = error instanceof Error ? error : new Error(String(error));
+          throw new Error(`npm install in cache failed after ${maxAttempts} attempts: ${lastError.message}`);
+        }
+        const delayMs = 5e3 * attempt;
+        const deadline = Date.now() + delayMs;
+        while (Date.now() < deadline) {
+        }
+      }
+    }
+    options.afterInstall?.(cacheDir, packageName);
+    return cacheDir;
+  } finally {
+    if (fs.existsSync(packDest)) fs.rmSync(packDest, { recursive: true, force: true });
+  }
+}
+function getPackageEntryPath(packageRoot) {
+  const pkgPath = path.join(packageRoot, "package.json");
+  if (!fs.existsSync(pkgPath)) throw new Error(`No package.json in ${packageRoot}`);
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  const main = pkg.main ?? "dist/index.js";
+  const entryPath = path.join(packageRoot, main);
+  if (!fs.existsSync(entryPath)) throw new Error(`Entry not found: ${entryPath}`);
+  return entryPath;
+}
+async function importFromCache(packageRoot) {
+  const entryPath = getPackageEntryPath(packageRoot);
+  const fileUrl = url.pathToFileURL(entryPath).href;
+  return import(
+    /* @vite-ignore */
+    fileUrl
+  );
+}
+var requireFromPackage = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-4VKCWJHF.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"));
+  if (fs.existsSync(path.join(cwd, "tool.yaml"))) return module$1.createRequire(path.join(cwd, "tool.yaml"));
+  return null;
+}
+function findNearestPackageJson(startDir) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    const pkg = path.join(dir, "package.json");
+    if (fs.existsSync(pkg)) return pkg;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+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 = fs.readFileSync(pkgJsonPath, "utf-8");
+      const pkg = JSON.parse(json);
+      return pkg.version ?? null;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function hasInvokeFunction(value) {
+  return value != null && typeof value === "object" && "invoke" in value && typeof value.invoke === "function";
+}
+function normalizeToolOutput(output) {
+  if (output != null && typeof output === "object" && "result" in output) {
+    const o = output;
+    const evidence = Array.isArray(o.evidence) ? o.evidence : void 0;
+    return evidence ? { result: o.result, raw: { evidence } } : { result: o.result };
+  }
+  return { result: output };
+}
+function createLocalDirectoryAdapter(kind) {
+  return {
+    kind,
+    async invoke(spec, args, ctx) {
+      if (spec.kind === "skill") {
+        const impl = spec.impl;
+        if (hasInvokeFunction(impl)) {
+          const out2 = await impl.invoke(args);
+          return normalizeToolOutput(out2);
+        }
+        const handler = typeof impl?.handler === "function" ? impl.handler : typeof spec.impl === "function" ? spec.impl : void 0;
+        if (typeof handler !== "function") {
+          throw new Error(`Local skill ${spec.name} has no executable handler`);
+        }
+        const out = await handler(args, {
+          requestId: ctx.requestId,
+          taskId: ctx.taskId,
+          skill: {
+            name: impl?.frontmatter?.name ?? spec.name,
+            description: impl?.frontmatter?.description ?? spec.description ?? "",
+            instructions: impl?.instructions ?? "",
+            resources: [],
+            readResource: async () => "",
+            getResourcesByType: () => [],
+            dirPath: impl?.dirPath ?? ""
+          }
+        });
+        return normalizeToolOutput(out);
+      }
+      if (spec.kind === "langchain") {
+        if (!hasInvokeFunction(spec.impl)) {
+          throw new Error(`Local langchain tool ${spec.name} missing invoke()`);
+        }
+        const out = await spec.impl.invoke(args);
+        return normalizeToolOutput(out);
+      }
+      if (spec.kind === "n8n") {
+        if (!spec.endpoint) {
+          throw new Error(`Local n8n tool ${spec.name} missing endpoint/webhook URL`);
+        }
+        const res = await fetch(spec.endpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(args ?? {})
+        });
+        if (!res.ok) {
+          throw new Error(`n8n request failed (${res.status})`);
+        }
+        const text = await res.text();
+        if (!text.trim()) return { result: {} };
+        try {
+          return { result: JSON.parse(text) };
+        } catch {
+          return { result: text };
+        }
+      }
+      if (spec.kind === "function") {
+        const meta = spec._meta;
+        if (!meta?.sourcePath || !meta?.exportName || !meta?.projectPath) {
+          throw new Error(`Local function ${spec.name} missing sourcePath/exportName/projectPath`);
+        }
+        const source = path.resolve(meta.projectPath, meta.sourcePath);
+        const mod = await import(url.pathToFileURL(source).href);
+        const fn = mod[meta.exportName];
+        if (typeof fn !== "function") {
+          throw new Error(`Local function ${spec.name} export "${meta.exportName}" is not a function`);
+        }
+        const out = await fn(args);
+        return normalizeToolOutput(out);
+      }
+      throw new Error(`Local directory tool kind not supported for invoke: ${spec.kind}`);
+    }
+  };
+}
+function createPrefixingRegistry(registry, prefix) {
+  return {
+    register(spec) {
+      registry.register({
+        ...spec,
+        name: prefix + chunkJW4EMVTE_cjs.normalizeToolName(spec.name)
+      });
+    },
+    bulkRegister(specs) {
+      specs.forEach((s) => this.register(s));
+    },
+    unregister(name) {
+      return registry.unregister(name);
+    },
+    get(name) {
+      return registry.get(name);
+    },
+    has(name) {
+      return registry.has(name);
+    },
+    search(query) {
+      return registry.search(query);
+    },
+    list() {
+      return registry.list();
+    },
+    get size() {
+      return registry.size;
+    },
+    snapshot() {
+      return registry.snapshot();
+    },
+    clear() {
+      return registry.clear();
+    }
+  };
+}
+function parseNpmDescriptor(entry) {
+  if (typeof entry !== "string" || !entry.startsWith("npm:")) return null;
+  const rest = entry.slice(4).trim();
+  const at = rest.indexOf("@", 1);
+  if (at < 0) return { packageName: rest, version: "latest" };
+  const packageName = rest.slice(0, at);
+  const version = rest.slice(at + 1).split("#")[0]?.trim() || "latest";
+  return { packageName, version };
+}
+
+// src/api/runtimeFromConfig.types.ts
+var DEFAULT_EXTENSION_PACKAGES = [];
+
+// src/api/runtimeFromConfig.ts
+var requireFromPackage2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-4VKCWJHF.cjs', document.baseURI).href)));
+function resolveEffectiveCoreTools(options) {
+  if (options.coreTools) return options.coreTools;
+  if (options.configFilePath) return {};
+  return void 0;
+}
+function resolveFileDescriptorPath(descriptor, configFilePath) {
+  const parsed = parseToolPath(descriptor.trim());
+  if (!parsed || parsed.protocol !== "file") return null;
+  const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
+  const configDir = path.dirname(localPath);
+  return path.resolve(configDir, `${parsed.scope}/${parsed.packageWithVersion}`);
+}
+function getRegisterFn(mod) {
+  return mod?.register ?? mod?.registerCoreTools;
+}
+function loadExtensionFromNodeModules() {
+  const projectRequire = getProjectRequire();
+  const requirers = [requireFromPackage2];
+  if (projectRequire) requirers.push(projectRequire);
+  for (const req of requirers) {
+    for (const pkg of DEFAULT_EXTENSION_PACKAGES) {
+      try {
+        const mod = req(pkg);
+        const fn = getRegisterFn(mod);
+        if (typeof fn === "function") return { register: fn, packageName: pkg };
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+function loadExtensionFromFileDescriptorSync(descriptor, configFilePath, stepLog) {
+  const entryStr = descriptor.trim();
+  const path2 = parseToolPath(entryStr);
+  if (!path2 || path2.protocol !== "file") return null;
+  const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
+  const configDir = path.dirname(localPath);
+  const pathPart = `${path2.scope}/${path2.packageWithVersion}`;
+  const resolvedPath = path.resolve(configDir, pathPart);
+  if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isDirectory()) return null;
+  try {
+    const entryPath = getPackageEntryPath(resolvedPath);
+    const req = module$1.createRequire(path.join(resolvedPath, "package.json"));
+    const mod = req(entryPath);
+    const fn = getRegisterFn(mod);
+    if (typeof fn === "function") {
+      if (stepLog) stepLog(`Loaded local extension from ${resolvedPath}`);
+      return { register: fn, descriptor: entryStr, resolvedVersion: "local", packageRoot: resolvedPath };
+    }
+  } catch (error) {
+    if (stepLog) {
+      stepLog(`Failed to load local extension from ${resolvedPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return null;
+}
+async function loadExtensionFromFileDescriptorAsync(descriptor, configFilePath, stepLog) {
+  const entryStr = descriptor.trim();
+  const path2 = parseToolPath(entryStr);
+  if (!path2 || path2.protocol !== "file") return null;
+  const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
+  const configDir = path.dirname(localPath);
+  const pathPart = `${path2.scope}/${path2.packageWithVersion}`;
+  const resolvedPath = path.resolve(configDir, pathPart);
+  if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isDirectory()) return null;
+  try {
+    const entryPath = getPackageEntryPath(resolvedPath);
+    const mod = await import(url.pathToFileURL(entryPath).href);
+    const fn = getRegisterFn(mod);
+    if (typeof fn === "function") {
+      if (stepLog) stepLog(`Loaded local extension from ${resolvedPath} (async import)`);
+      return { register: fn, descriptor: entryStr, resolvedVersion: "local", packageRoot: resolvedPath };
+    }
+  } catch (error) {
+    if (stepLog) {
+      stepLog(`Failed to load local extension from ${resolvedPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return null;
+}
+function loadExtensionForDescriptorSync(descriptor, configFilePath, stepLog) {
+  const entryStr = descriptor.trim();
+  const parsed = parseNpmDescriptor(entryStr);
+  if (!parsed) return null;
+  const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
+  const configDir = path.dirname(localPath);
+  const packageJsonPath = findNearestPackageJson(configDir);
+  const configRequire = packageJsonPath ? module$1.createRequire(packageJsonPath) : null;
+  const npmCwd = packageJsonPath ? path.dirname(packageJsonPath) : configDir;
+  if (configRequire) {
+    try {
+      const mod = configRequire(parsed.packageName);
+      const fn = getRegisterFn(mod);
+      if (typeof fn === "function") {
+        const installed = getInstalledPackageVersionFromRequire(parsed.packageName, configRequire);
+        const requested = parsed.version === "latest" || !parsed.version?.trim() ? null : parsed.version;
+        const resolvedVersion = requested ?? installed ?? resolveLatestVersionFromRegistry(parsed.packageName, { cwd: npmCwd });
+        if (installed === resolvedVersion) {
+          if (stepLog) stepLog(`Loaded ${parsed.packageName}@${resolvedVersion} from node_modules`);
+          const pkgRoot = path.dirname(configRequire.resolve(`${parsed.packageName}/package.json`));
+          return { register: fn, descriptor: entryStr, resolvedVersion, packageRoot: pkgRoot };
+        }
+      }
+    } catch {
+    }
+  }
+  const cacheBase = getCacheBaseFromToolConfig(localPath);
+  const cacheOptions = cacheBase ? [{ cacheBase, cwd: npmCwd }, { cwd: npmCwd }] : [{ cwd: npmCwd }];
+  for (const opts of cacheOptions) {
+    try {
+      const cacheDir = ensurePackageInCache(parsed.packageName, parsed.version, opts);
+      if (stepLog) stepLog(`Loaded ${parsed.packageName} from cache: ${cacheDir}`);
+      const entryPath = getPackageEntryPath(cacheDir);
+      const req = module$1.createRequire(path.join(cacheDir, "package.json"));
+      const mod = req(entryPath);
+      const fn = getRegisterFn(mod);
+      if (typeof fn === "function") {
+        const resolvedVersion = path.basename(cacheDir);
+        return { register: fn, descriptor: entryStr, resolvedVersion, packageRoot: cacheDir };
+      }
+      break;
+    } catch {
+      if (cacheBase && "cacheBase" in opts) continue;
+      break;
+    }
+  }
+  return null;
+}
+function loadAllExtensionsFromToolYamlSync(configFilePath, stepLog) {
+  const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
+  if (!fs.existsSync(localPath)) return [];
+  const config = loadToolConfig(localPath);
+  const tools = getPathSourceDescriptors(config);
+  if (!Array.isArray(tools) || tools.length === 0) return [];
+  if (stepLog) stepLog("Loading extensions from tool.yaml (npm + file)");
+  const loaded = [];
+  for (const entry of tools) {
+    const entryStr = String(entry).trim();
+    if (entryStr.startsWith("npm:")) {
+      const result = loadExtensionForDescriptorSync(entryStr, configFilePath, stepLog);
+      if (result) loaded.push(result);
+    } else if (entryStr.startsWith("file:")) {
+      const result = loadExtensionFromFileDescriptorSync(entryStr, configFilePath, stepLog);
+      if (result) loaded.push(result);
+    }
+  }
+  return loaded;
+}
+function getInstalledPackageVersionFromRequire(packageName, req) {
+  try {
+    const pkgJsonPath = req.resolve(`${packageName}/package.json`);
+    const json = fs.readFileSync(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(json);
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function loadExtensionForDescriptorAsync(descriptor, configFilePath, stepLog) {
+  const syncResult = loadExtensionForDescriptorSync(descriptor, configFilePath, stepLog);
+  if (syncResult) return syncResult;
+  const entryStr = descriptor.trim();
+  const parsed = parseNpmDescriptor(entryStr);
+  if (!parsed) return null;
+  const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
+  const configDir = path.dirname(localPath);
+  const packageJsonPath = findNearestPackageJson(configDir);
+  const configRequire = packageJsonPath ? module$1.createRequire(packageJsonPath) : null;
+  const npmCwd = packageJsonPath ? path.dirname(packageJsonPath) : configDir;
+  if (configRequire) {
+    try {
+      const installed = getInstalledPackageVersionFromRequire(parsed.packageName, configRequire);
+      const requested = parsed.version === "latest" || !parsed.version?.trim() ? null : parsed.version;
+      const resolvedVersion = requested ?? installed ?? resolveLatestVersionFromRegistry(parsed.packageName, { cwd: npmCwd });
+      if (installed === resolvedVersion) {
+        const pkgJsonResolved = configRequire.resolve(`${parsed.packageName}/package.json`);
+        const packageRoot = path.dirname(pkgJsonResolved);
+        const entryPath = getPackageEntryPath(packageRoot);
+        const mod = await import(url.pathToFileURL(entryPath).href);
+        const fn = getRegisterFn(mod);
+        if (typeof fn === "function") {
+          if (stepLog) stepLog(`Loaded ${parsed.packageName}@${resolvedVersion} from node_modules (async import)`);
+          return { register: fn, descriptor: entryStr, resolvedVersion, packageRoot };
+        }
+      }
+    } catch {
+    }
+  }
+  const cacheBase = getCacheBaseFromToolConfig(localPath);
+  const cacheOptions = cacheBase ? [{ cacheBase, cwd: npmCwd }, { cwd: npmCwd }] : [{ cwd: npmCwd }];
+  for (const opts of cacheOptions) {
+    try {
+      const cacheDir = ensurePackageInCache(parsed.packageName, parsed.version, opts);
+      if (stepLog) stepLog(`Loaded ${parsed.packageName} from cache (async): ${cacheDir}`);
+      const mod = await importFromCache(cacheDir);
+      const fn = getRegisterFn(mod);
+      if (typeof fn === "function") {
+        const resolvedVersion = path.basename(cacheDir);
+        return { register: fn, descriptor: entryStr, resolvedVersion, packageRoot: cacheDir };
+      }
+      break;
+    } catch {
+      if (cacheBase && "cacheBase" in opts) continue;
+      break;
+    }
+  }
+  return null;
+}
+async function loadLocalDirectoryForFileDescriptor(descriptor, configFilePath, stepLog) {
+  const resolvedPath = resolveFileDescriptorPath(descriptor, configFilePath);
+  if (!resolvedPath || !fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isDirectory()) return null;
+  if (fs.existsSync(path.join(resolvedPath, "package.json"))) return null;
+  const scanErrors = [];
+  const scanner = new chunkAZUXVVGV_cjs.DirectoryScanner({
+    roots: [{ path: resolvedPath, namespace: "local" }],
+    onError: (toolDir, error) => scanErrors.push(`${toolDir}: ${error.message}`)
+  });
+  const specs = await scanner.scan();
+  if (scanErrors.length > 0 && stepLog) {
+    stepLog(`Local directory scan (${descriptor}) reported ${scanErrors.length} error(s)`);
+  }
+  if (specs.length === 0) return null;
+  if (stepLog) {
+    stepLog(`Loaded ${specs.length} local tool(s) from ${descriptor}`);
+  }
+  return {
+    specs,
+    descriptor: descriptor.trim(),
+    resolvedVersion: "local"
+  };
+}
+async function loadAllExtensionsFromToolYamlAsync(configFilePath, stepLog) {
+  const localPath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
+  if (!fs.existsSync(localPath)) return [];
+  const config = loadToolConfig(localPath);
+  const tools = getPathSourceDescriptors(config);
+  if (!Array.isArray(tools) || tools.length === 0) return [];
+  if (stepLog) stepLog("Loading extensions from tool.yaml (async)");
+  const loaded = [];
+  for (const entry of tools) {
+    const entryStr = String(entry).trim();
+    if (entryStr.startsWith("npm:")) {
+      const result = await loadExtensionForDescriptorAsync(entryStr, configFilePath, stepLog);
+      if (result) loaded.push(result);
+    } else if (entryStr.startsWith("file:")) {
+      const result = await loadExtensionFromFileDescriptorAsync(entryStr, configFilePath, stepLog);
+      if (result) {
+        loaded.push(result);
+      } else {
+        const local = await loadLocalDirectoryForFileDescriptor(entryStr, configFilePath, stepLog);
+        if (local) loaded.push(local);
+      }
+    }
+  }
+  return loaded;
+}
+function createRuntimeFromConfigSync(options = {}) {
+  const registry = new chunkAGLGFQUW_cjs.ToolRegistry();
+  const stepLog = options.stepLog;
+  const effectiveCoreTools = resolveEffectiveCoreTools(options);
+  chunkAGLGFQUW_cjs.setSandboxValidationEnabled(effectiveCoreTools?.enableSandboxValidation === true);
+  if (effectiveCoreTools !== void 0) {
+    if (options.configFilePath) {
+      const all = loadAllExtensionsFromToolYamlSync(options.configFilePath, stepLog);
+      if (all.length > 0) {
+        if (stepLog) stepLog(`Registered ${all.length} extension(s) from tool.yaml`);
+        const runtime3 = new PTCRuntime({ registry });
+        for (const ext of all) {
+          const before = new Set(registry.snapshot().map((s) => s.name));
+          const prefix = ext.descriptor.startsWith("file:") ? fileDescriptorToRegistryPrefix(ext.descriptor) : npmDescriptorToRegistryPrefix(ext.descriptor, ext.resolvedVersion);
+          const reg = createPrefixingRegistry(registry, prefix ?? "");
+          const adapter = ext.register(reg, effectiveCoreTools);
+          runtime3.registerAdapter(adapter);
+          const registeredNow = registry.snapshot().map((s) => s.name).filter((name) => !before.has(name));
+          runtime3.registerAdapterForTools(registeredNow, adapter);
+        }
+        return { runtime: runtime3, registry };
+      }
+    }
+    if (stepLog) stepLog("Trying extension from node_modules");
+    const extensionNode = loadExtensionFromNodeModules();
+    if (extensionNode) {
+      if (stepLog) stepLog("Registered extension from node_modules");
+      const descriptor = `npm:${extensionNode.packageName}`;
+      const resolvedVersion = getInstalledPackageVersion(extensionNode.packageName) ?? resolveLatestVersionFromRegistry(extensionNode.packageName);
+      const before = new Set(registry.snapshot().map((s) => s.name));
+      const prefix = npmDescriptorToRegistryPrefix(descriptor, resolvedVersion);
+      const reg = createPrefixingRegistry(registry, prefix ?? "");
+      const coreAdapter = extensionNode.register(reg, effectiveCoreTools);
+      const runtime3 = new PTCRuntime({ registry });
+      runtime3.registerAdapter(coreAdapter);
+      const registeredNow = registry.snapshot().map((s) => s.name).filter((name) => !before.has(name));
+      runtime3.registerAdapterForTools(registeredNow, coreAdapter);
+      return { runtime: runtime3, registry };
+    }
+    const runtime2 = new PTCRuntime({ registry });
+    return { runtime: runtime2, registry };
+  }
+  const runtime = new PTCRuntime({ registry });
+  return { runtime, registry };
+}
+async function createRuntimeFromConfig(options = {}) {
+  const effectiveCoreTools = resolveEffectiveCoreTools(options);
+  chunkAGLGFQUW_cjs.setSandboxValidationEnabled(effectiveCoreTools?.enableSandboxValidation === true);
+  if (effectiveCoreTools !== 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 chunkAGLGFQUW_cjs.ToolRegistry();
+      const runtime = new PTCRuntime({ registry });
+      for (const ext of all) {
+        const before = new Set(registry.snapshot().map((s) => s.name));
+        const prefix = ext.descriptor.startsWith("file:") ? fileDescriptorToRegistryPrefix(ext.descriptor) : npmDescriptorToRegistryPrefix(ext.descriptor, ext.resolvedVersion);
+        const reg = createPrefixingRegistry(registry, prefix ?? "");
+        if ("register" in ext) {
+          const adapter = ext.register(reg, effectiveCoreTools);
+          runtime.registerAdapter(adapter);
+          const registeredNow = registry.snapshot().map((s) => s.name).filter((name) => !before.has(name));
+          runtime.registerAdapterForTools(registeredNow, adapter);
+        } else {
+          reg.bulkRegister(ext.specs);
+          const registeredNow = registry.snapshot().map((s) => s.name).filter((name) => !before.has(name));
+          const byKind = /* @__PURE__ */ new Map();
+          for (const toolName of registeredNow) {
+            const spec = registry.get(toolName);
+            if (!spec) continue;
+            const list = byKind.get(spec.kind) ?? [];
+            list.push(toolName);
+            byKind.set(spec.kind, list);
+          }
+          for (const [kind, names] of byKind.entries()) {
+            const adapter = createLocalDirectoryAdapter(kind);
+            runtime.registerAdapter(adapter);
+            runtime.registerAdapterForTools(names, adapter);
+          }
+        }
+      }
+      return { runtime, registry };
+    }
+  }
+  return createRuntimeFromConfigSync(options);
+}
+
+// src/core/runtime/toolObservation.ts
+var PTC_FEEDBACK_MARKER = "__PTC_FEEDBACK__:";
+function tryStringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractObservationText(value) {
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  const nested = record.result;
+  if (nested && typeof nested === "object" && typeof nested.output === "string") {
+    return nested.output;
+  }
+  if (typeof record.output === "string") return record.output;
+  return null;
+}
+function encodeFeedback(feedback, includeFeedbackMarker) {
+  if (!includeFeedbackMarker || !feedback) return "";
+  return `${PTC_FEEDBACK_MARKER}${tryStringify(feedback)}
+`;
+}
+function toToolObservationText(result, opts = {}) {
+  const includeFeedbackMarker = opts.includeFeedbackMarker === true;
+  if (result.ok) {
+    const prefix = encodeFeedback(result.feedback, includeFeedbackMarker);
+    if (typeof result.result === "string") return `${prefix}${result.result}`;
+    const observation = extractObservationText(result.result);
+    if (observation != null) return `${prefix}${observation}`;
+    return `${prefix}${tryStringify(result.result)}`;
+  }
+  const err = result.error;
+  const message = err?.message ?? "Tool failed";
+  const details = err?.details;
+  return tryStringify(details != null ? { error: message, kind: err?.kind, details } : { error: message, kind: err?.kind });
+}
+
+// src/api/expose/mcpServer.ts
+var DEFAULT_CTX = {
+  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 chunkJW4EMVTE_cjs.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_CTX }));
+  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: chunkAZUXVVGV_cjs.MCP_KIND },
+          ctx
+        );
+        if (result.ok) {
+          return { content: [{ type: "text", text: toToolObservationText(result) }] };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: toToolObservationText(result)
+            }
+          ],
+          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 path2 = 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(path2, handler);
+  return {
+    app,
+    path: path2,
+    async listen(listenPort, listenHost) {
+      const p = listenPort ?? port;
+      const h = listenHost ?? host;
+      return new Promise((resolve4) => {
+        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}${path2}`, port: actualPort });
+        });
+      });
+    }
+  };
+}
+async function runMCPServerOverStdio(runtime, options = {}) {
+  const result = await createMCPServer(runtime, options);
+  await result.connectStdio();
+  return result;
+}
+
+// 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(chunkUUNG3GL3_cjs.enrichSpecWithCanonicalSchema);
+  const prefix = basePath ? `${basePath}/` : "/";
+  const paths = createBasePaths(prefix);
+  const schemaEntries = addPerToolPaths(specs, prefix, paths);
+  return {
+    openapi: "3.0.3",
+    info: { title, version },
+    paths,
+    components: {
+      schemas: Object.fromEntries(schemaEntries)
+    }
+  };
+}
+function createToolNamesSchema() {
+  return {
+    type: "object",
+    required: ["tools"],
+    properties: {
+      tools: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            description: { type: "string" },
+            kind: { type: "string" }
+          }
+        }
+      }
+    }
+  };
+}
+function createInvokeRequestBodySchema() {
+  return {
+    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
+      }
+    }
+  };
+}
+function createBasePaths(prefix) {
+  return {
+    [`${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: createToolNamesSchema() } }
+          }
+        }
+      }
+    },
+    [`${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: createInvokeRequestBodySchema() } }
+        },
+        responses: {
+          "200": { description: "Tool result", content: { "application/json": { schema: resultSchema } } },
+          "400": { description: "Bad request", content: { "application/json": { schema: errorSchema } } }
+        }
+      }
+    }
+  };
+}
+function addPerToolPaths(specs, prefix, paths) {
+  const schemaEntries = [];
+  for (const spec of specs) {
+    const key = toolSchemaKey(spec.name);
+    schemaEntries.push([key, spec.inputSchema]);
+    paths[`${prefix}invoke/${toolNameToSlug(spec.name)}`] = createPerToolPathSpec(spec, key);
+  }
+  return schemaEntries;
+}
+function createPerToolPathSpec(spec, key) {
+  return {
+    post: {
+      summary: spec.description ?? spec.name,
+      description: `Invoke tool \`${spec.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 } }
+        }
+      }
+    }
+  };
+}
+
+// src/api/expose/openapiHttp.ts
+var DEFAULT_CTX2 = {
+  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"
+  ]
+};
+var BodyParseError = class extends Error {
+  hint;
+  constructor(message, hint) {
+    super(message);
+    this.name = "BodyParseError";
+    this.hint = hint;
+  }
+};
+function safeParseToolArgs(raw) {
+  const text = String(raw ?? "").trim();
+  if (!text) return { ok: true, value: {} };
+  const firstBrace = text.indexOf("{");
+  if (firstBrace === -1) {
+    return {
+      ok: false,
+      hint: 'Tool arguments must be a single JSON object. Do not prepend explanations. Example: itermRunCommandInSession({"command":"df -h"})'
+    };
+  }
+  let jsonText = text.slice(firstBrace);
+  const lastBrace = jsonText.lastIndexOf("}");
+  if (lastBrace !== -1) jsonText = jsonText.slice(0, lastBrace + 1);
+  try {
+    return { ok: true, value: JSON.parse(jsonText) };
+  } catch {
+    return {
+      ok: false,
+      hint: "Tool arguments must be valid JSON: double-quoted keys/strings, no comments or trailing commas."
+    };
+  }
+}
+function sendJson(res, status, data) {
+  res.status(status).json(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 parseBodyFromExpress(raw) {
+  if (raw == null) return {};
+  if (typeof raw === "object") return raw;
+  const text = Buffer.isBuffer(raw) ? raw.toString("utf-8") : String(raw);
+  const parsed = safeParseToolArgs(text);
+  if (parsed.ok) return parsed.value;
+  throw new BodyParseError("Invalid JSON body", parsed.hint);
+}
+function sendBadJsonBody(res, err) {
+  const hint = err instanceof BodyParseError ? err.hint : void 0;
+  sendJson(res, 400, {
+    ok: false,
+    error: "Invalid JSON body",
+    kind: "BAD_REQUEST",
+    ...hint ? { hint } : {}
+  });
+}
+async function invokeAndSend(runtime, ctx, res, tool, args) {
+  const result = await runtime.invoke({ tool, 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
+  });
+}
+function buildSpec(runtime, basePath) {
+  return toolsToOpenAPISpec(runtime.getRegistry(), {
+    title: "Tool API",
+    version: "1.0.0",
+    basePath: basePath || void 0
+  });
+}
+function registerSpecRoutes(router, runtime, basePath) {
+  const sendSpec = (_req, res) => {
+    sendJson(res, 200, buildSpec(runtime, basePath));
+  };
+  const sendSwagger = (_req, res) => {
+    const specPath = basePath ? `${basePath}/openapi.json` : "/openapi.json";
+    res.type("text/html; charset=utf-8").send(swaggerUiHtml(specPath));
+  };
+  router.get("/", sendSwagger);
+  router.get("/swagger", sendSwagger);
+  router.get("/openapi.json", sendSpec);
+  router.get("/spec", sendSpec);
+}
+function registerToolRoutes(router, runtime, ctxFactory) {
+  router.get("/tools", async (_req, res, next) => {
+    try {
+      const { enrichSpecWithCanonicalSchema: enrichSpecWithCanonicalSchema2 } = await import('./canonicalCoreSchemas-TY7NCWCC.cjs');
+      const tools = runtime.getRegistry().snapshot().map(enrichSpecWithCanonicalSchema2).map((s) => ({
+        name: s.name,
+        description: s.description,
+        kind: s.kind,
+        inputSchema: s.inputSchema
+      }));
+      sendJson(res, 200, { tools });
+    } catch (error) {
+      next(error);
+    }
+  });
+  router.post("/invoke", async (req, res) => {
+    let body = null;
+    try {
+      body = parseBodyFromExpress(req.body);
+    } catch (err) {
+      sendBadJsonBody(res, err);
+      return;
+    }
+    const tool = body.tool;
+    if (typeof tool !== "string" || !tool.trim()) {
+      sendJson(res, 400, { error: "Missing or invalid 'tool' in body", kind: "BAD_REQUEST" });
+      return;
+    }
+    await invokeAndSend(runtime, ctxFactory(req), res, tool.trim(), body.args ?? {});
+  });
+  router.post("/invoke/:slug", async (req, res) => {
+    let args;
+    try {
+      args = parseBodyFromExpress(req.body);
+    } catch (err) {
+      sendBadJsonBody(res, err);
+      return;
+    }
+    await invokeAndSend(runtime, ctxFactory(req), res, slugToToolName(req.params?.slug ?? ""), args);
+  });
+}
+function mountRouter(app, router, basePath) {
+  if (basePath) {
+    app.use(basePath, router);
+    return;
+  }
+  app.use(router);
+}
+function registerErrorHandlers(app) {
+  app.use((req, res) => {
+    sendJson(res, 404, { error: "Not found", path: req.url ?? "/" });
+  });
+  app.use((err, _req, res, _next) => {
+    const message = err instanceof Error ? err.message : String(err);
+    sendJson(res, 500, { error: message, kind: "INTERNAL_ERROR" });
+  });
+}
+function patchListenDefaults(app, options) {
+  const originalListen = app.listen.bind(app);
+  const defaultPort = options.port;
+  const defaultHost = options.host;
+  app.listen = ((...args) => {
+    if (args.length === 0) {
+      return originalListen(defaultPort ?? 0, defaultHost ?? "localhost");
+    }
+    if (args.length === 1 && typeof args[0] === "function") {
+      return originalListen(defaultPort ?? 0, defaultHost ?? "localhost", args[0]);
+    }
+    return originalListen(...args);
+  });
+}
+function createOpenAPIHttpServer(runtime, options = {}) {
+  const app = express__default.default();
+  const router = express__default.default.Router();
+  const basePath = (options.basePath ?? "").replace(/\/$/, "");
+  const ctxFactory = options.execContextFactory ?? (() => ({ ...DEFAULT_CTX2 }));
+  app.use(express__default.default.text({ type: "*/*" }));
+  registerSpecRoutes(router, runtime, basePath);
+  registerToolRoutes(router, runtime, ctxFactory);
+  mountRouter(app, router, basePath);
+  registerErrorHandlers(app);
+  patchListenDefaults(app, options);
+  return app;
+}
+function listenOpenAPIHttpServer(app, options = {}) {
+  return new Promise((resolve4, reject) => {
+    const port = options.port ?? 0;
+    const host = options.host ?? "localhost";
+    const httpServer = app.listen(port, host, () => {
+      const addr = httpServer.address();
+      const actualPort = typeof addr === "object" && addr?.port != null ? addr.port : port;
+      resolve4({ port: actualPort, host, httpServer });
+    });
+    httpServer.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
+  });
+  let activeHttpServer = null;
+  return {
+    server,
+    openApiSpec,
+    listen: async (listenOpts) => {
+      const { port, host, httpServer } = await listenOpenAPIHttpServer(server, listenOpts);
+      activeHttpServer = httpServer;
+      return { port, host };
+    },
+    close: async () => {
+      if (!activeHttpServer) return;
+      await new Promise((resolve4, reject) => {
+        activeHttpServer.close((err) => err ? reject(err) : resolve4());
+      });
+      activeHttpServer = null;
+    }
+  };
+}
+
+exports.createHttpService = createHttpService;
+exports.createMCPServerStreamableHttp = createMCPServerStreamableHttp;
+exports.createRuntimeFromConfig = createRuntimeFromConfig;
+exports.ensurePackageInCache = ensurePackageInCache;
+exports.expandToolDescriptorsToRegistryNames = expandToolDescriptorsToRegistryNames;
+exports.fileDescriptorToPackagePrefix = fileDescriptorToPackagePrefix;
+exports.findAndLoadToolConfig = findAndLoadToolConfig;
+exports.getCacheBaseFromToolConfig = getCacheBaseFromToolConfig;
+exports.getDisplayScope = getDisplayScope;
+exports.getPathSourceDescriptors = getPathSourceDescriptors;
+exports.getToolSourceDescriptors = getToolSourceDescriptors;
+exports.isBarePackageDescriptor = isBarePackageDescriptor;
+exports.loadToolConfig = loadToolConfig;
+exports.npmDescriptorToPackagePrefix = npmDescriptorToPackagePrefix;
+exports.parseNpmDescriptor = parseNpmDescriptor;
+exports.parseToolPath = parseToolPath;
+exports.resolveLatestVersionFromRegistry = resolveLatestVersionFromRegistry;
+exports.resolveSandboxedPath = resolveSandboxedPath;
+exports.resolveToolDescriptor = resolveToolDescriptor;
+exports.runMCPServerOverStdio = runMCPServerOverStdio;
+exports.toToolObservationText = toToolObservationText;
+//# sourceMappingURL=chunk-4VKCWJHF.cjs.map
+//# sourceMappingURL=chunk-4VKCWJHF.cjs.map