@easynet/agent-tool 1.0.0

package/dist/index.cjs

@@ -0,0 +1,3014 @@
+'use strict';
+
+var chunkZ7TGIG77_cjs = require('./chunk-Z7TGIG77.cjs');
+var chunk3YLVPZRJ_cjs = require('./chunk-3YLVPZRJ.cjs');
+var chunkP3UEAZHK_cjs = require('./chunk-P3UEAZHK.cjs');
+var Ajv = require('ajv');
+var addFormats = require('ajv-formats');
+var cockatiel = require('cockatiel');
+var eventemitter3 = require('eventemitter3');
+var uuid = require('uuid');
+var pRetry = require('p-retry');
+var pTimeout = require('p-timeout');
+var agentToolBuiltinTools = require('@easynet/agent-tool-builtin-tools');
+var agentToolExampleTools = require('@easynet/agent-tool-example-tools');
+var promises = require('fs/promises');
+var path = require('path');
+var url = require('url');
+var tools = require('@langchain/core/tools');
+var fs = require('fs');
+var yaml = require('js-yaml');
+var agentLlm = require('@easynet/agent-llm');
+
+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 pRetry__default = /*#__PURE__*/_interopDefault(pRetry);
+var pTimeout__default = /*#__PURE__*/_interopDefault(pTimeout);
+var yaml__default = /*#__PURE__*/_interopDefault(yaml);
+
+// src/registry/ToolRegistry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  tagIndex = /* @__PURE__ */ new Map();
+  // tag → tool names
+  kindIndex = /* @__PURE__ */ new Map();
+  // kind → tool names
+  /**
+   * Register a single tool spec.
+   * Overwrites if same name already exists.
+   */
+  register(spec) {
+    this.validateSpec(spec);
+    this.tools.set(spec.name, spec);
+    this.indexTool(spec);
+  }
+  /**
+   * Register multiple tool specs at once.
+   */
+  bulkRegister(specs) {
+    for (const spec of specs) {
+      this.register(spec);
+    }
+  }
+  /**
+   * Unregister a tool by name.
+   */
+  unregister(name) {
+    const spec = this.tools.get(name);
+    if (!spec) return false;
+    this.tools.delete(name);
+    this.deindexTool(spec);
+    return true;
+  }
+  /**
+   * Get a tool spec by name.
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Check if a tool exists.
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * Search tools by query.
+   */
+  search(query) {
+    let candidates;
+    if (query.kind) {
+      const names = this.kindIndex.get(query.kind);
+      if (!names || names.size === 0) return [];
+      candidates = [...names].map((n) => this.tools.get(n)).filter((s) => s !== void 0);
+    } else {
+      candidates = [...this.tools.values()];
+    }
+    if (query.tags && query.tags.length > 0) {
+      candidates = candidates.filter(
+        (spec) => query.tags.some((tag) => spec.tags?.includes(tag))
+      );
+    }
+    if (query.capabilities && query.capabilities.length > 0) {
+      candidates = candidates.filter(
+        (spec) => query.capabilities.every((cap) => spec.capabilities.includes(cap))
+      );
+    }
+    if (query.text) {
+      const lower = query.text.toLowerCase();
+      candidates = candidates.filter(
+        (spec) => spec.name.toLowerCase().includes(lower) || spec.description?.toLowerCase().includes(lower) || spec.tags?.some((t) => t.toLowerCase().includes(lower))
+      );
+    }
+    return candidates;
+  }
+  /**
+   * List all registered tool names.
+   */
+  list() {
+    return [...this.tools.keys()];
+  }
+  /**
+   * Get count of registered tools.
+   */
+  get size() {
+    return this.tools.size;
+  }
+  /**
+   * Export a snapshot of all registered tools (for debugging/routing).
+   */
+  snapshot() {
+    return [...this.tools.values()];
+  }
+  /**
+   * Clear all registered tools.
+   */
+  clear() {
+    this.tools.clear();
+    this.tagIndex.clear();
+    this.kindIndex.clear();
+  }
+  validateSpec(spec) {
+    if (!spec.name) throw new Error("ToolSpec.name is required");
+    if (!spec.version) throw new Error("ToolSpec.version is required");
+    if (!spec.kind) throw new Error("ToolSpec.kind is required");
+    if (!spec.inputSchema) throw new Error("ToolSpec.inputSchema is required");
+    if (!spec.outputSchema) throw new Error("ToolSpec.outputSchema is required");
+    if (!spec.capabilities) throw new Error("ToolSpec.capabilities is required");
+  }
+  indexTool(spec) {
+    let kindSet = this.kindIndex.get(spec.kind);
+    if (!kindSet) {
+      kindSet = /* @__PURE__ */ new Set();
+      this.kindIndex.set(spec.kind, kindSet);
+    }
+    kindSet.add(spec.name);
+    if (spec.tags) {
+      for (const tag of spec.tags) {
+        let tagSet = this.tagIndex.get(tag);
+        if (!tagSet) {
+          tagSet = /* @__PURE__ */ new Set();
+          this.tagIndex.set(tag, tagSet);
+        }
+        tagSet.add(spec.name);
+      }
+    }
+  }
+  deindexTool(spec) {
+    this.kindIndex.get(spec.kind)?.delete(spec.name);
+    if (spec.tags) {
+      for (const tag of spec.tags) {
+        this.tagIndex.get(tag)?.delete(spec.name);
+      }
+    }
+  }
+};
+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/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/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/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 summarizeForLog(value, maxLen = 200) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") {
+    return value.length > maxLen ? `${value.slice(0, maxLen)}...` : value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return `Array(${value.length})`;
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    const shown = keys.slice(0, 5).join(", ");
+    return `Object(keys: ${shown}${keys.length > 5 ? ", ..." : ""})`;
+  }
+  return String(value);
+}
+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();
+  }
+};
+var NON_RETRYABLE_ERRORS = /* @__PURE__ */ new Set([
+  "TOOL_NOT_FOUND",
+  "INPUT_SCHEMA_INVALID",
+  "POLICY_DENIED",
+  "HITL_DENIED",
+  "OUTPUT_SCHEMA_INVALID",
+  "PATH_OUTSIDE_SANDBOX",
+  "FILE_TOO_LARGE",
+  "HTTP_DISALLOWED_HOST",
+  "HTTP_TOO_LARGE"
+]);
+function isRetryable(error) {
+  if (error instanceof Error) {
+    const kind = error.kind;
+    if (kind && NON_RETRYABLE_ERRORS.has(kind)) return false;
+  }
+  return true;
+}
+async function withRetry(fn, options = {}) {
+  const {
+    maxRetries = 2,
+    baseDelayMs = 1e3,
+    maxDelayMs = 1e4,
+    jitter = 0.1,
+    shouldRetry,
+    onRetry
+  } = options;
+  if (maxRetries <= 0) {
+    return fn();
+  }
+  const pRetryOptions = {
+    retries: maxRetries,
+    minTimeout: baseDelayMs,
+    maxTimeout: maxDelayMs,
+    randomize: true,
+    factor: 2,
+    onFailedAttempt: (error) => {
+      if (jitter > 0 && error.retriesLeft > 0) ;
+      if (shouldRetry && !shouldRetry(error)) {
+        throw error;
+      }
+      if (!isRetryable(error)) {
+        throw error;
+      }
+      onRetry?.(error, maxRetries - error.retriesLeft);
+    }
+  };
+  return pRetry__default.default(fn, pRetryOptions);
+}
+function createTaggedError(kind, message, details) {
+  const error = new Error(message);
+  error.kind = kind;
+  error.details = details;
+  return error;
+}
+function resolveTool(toolName, registry) {
+  const spec = registry.get(toolName);
+  if (!spec) {
+    throw createTaggedError(
+      "TOOL_NOT_FOUND",
+      `Tool not found: ${toolName}`,
+      { availableTools: registry.snapshot().slice(0, 20).map((s) => s.name) }
+    );
+  }
+  return spec;
+}
+function validateInput(spec, args, validator) {
+  try {
+    return validator.validateOrThrow(
+      spec.inputSchema,
+      args,
+      `Input validation failed for ${spec.name}`
+    );
+  } catch (error) {
+    if (error instanceof SchemaValidationError) {
+      throw createTaggedError("INPUT_SCHEMA_INVALID", error.message, {
+        errors: error.errors,
+        schema: spec.inputSchema
+      });
+    }
+    throw error;
+  }
+}
+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 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 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.adapters.get(spec.kind);
+  if (!adapter) {
+    throw 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 = () => 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 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 createTaggedError("OUTPUT_SCHEMA_INVALID", error.message, {
+        errors: error.errors
+      });
+    }
+    throw error;
+  }
+}
+
+// src/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/runtime/PTCRuntime.ts
+var PTCRuntime = class {
+  registry;
+  adapters = /* @__PURE__ */ new Map();
+  validator;
+  policy;
+  budget;
+  eventLog;
+  metrics;
+  tracing;
+  config;
+  logger;
+  constructor(options = {}) {
+    this.config = options.config ?? {};
+    this.registry = options.registry ?? new 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);
+  }
+  /**
+   * 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();
+    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
+      });
+    }
+    const span = 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
+      }
+    });
+    emitToolCalled(intent, ctx, this.getObservabilityDeps());
+    try {
+      const spec = resolveTool(intent.tool, this.registry);
+      this.tracing.addEvent(span.spanId, "resolved", {
+        kind: spec.kind,
+        version: spec.version
+      });
+      const validatedArgs = validateInput(spec, intent.args, this.validator);
+      const enrichedArgs = enrichDefaults(spec, validatedArgs, this.validator);
+      enforcePolicy(spec, enrichedArgs, ctx, {
+        policy: this.policy,
+        eventLog: this.eventLog,
+        metrics: this.metrics,
+        tracing: this.tracing
+      });
+      if (!this.budget.checkRateLimit(spec.name)) {
+        throw 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 this.buildDryRunResult(spec, enrichedArgs, ctx, startTime, span.spanId);
+      }
+      const { result, raw } = await executeWithBudget(
+        spec,
+        enrichedArgs,
+        ctx,
+        span.spanId,
+        this.getPipelineDeps()
+      );
+      const validatedOutput = validateOutput(spec, result, this.validator);
+      const durationMs = Date.now() - startTime;
+      const builtEvidence = buildEvidence({
+        spec,
+        args: enrichedArgs,
+        result: validatedOutput,
+        raw,
+        ctx,
+        durationMs
+      });
+      const adapterEvidence = raw && typeof raw === "object" && Array.isArray(raw.evidence) ? raw.evidence : [];
+      const evidence = [...adapterEvidence, ...builtEvidence];
+      recordSuccess(spec, durationMs, evidence, span.spanId, this.getObservabilityDeps());
+      if (this.logger.isEnabled("debug")) {
+        this.logger.debug("invoke.ok", {
+          tool: spec.name,
+          durationMs,
+          result: this.logger.options.includeResults ? summarizeForLog(validatedOutput) : void 0,
+          raw: this.logger.options.includeRaw ? summarizeForLog(raw) : void 0
+        });
+      }
+      return {
+        ok: true,
+        result: validatedOutput,
+        evidence,
+        raw: this.config.includeRaw !== false ? raw : void 0
+      };
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      return handleError(error, intent, ctx, durationMs, span.spanId, this.getObservabilityDeps());
+    }
+  }
+  /**
+   * 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,
+      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
+    };
+  }
+  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()
+        }
+      ]
+    };
+  }
+};
+
+// src/toolDescriptor.ts
+var NPM_TOOL_DESCRIPTOR_REGEX = /^npm:(@[\w.-]+\/[\w.-]+)#(.+)$/;
+function isNpmToolDescriptor(descriptor) {
+  return NPM_TOOL_DESCRIPTOR_REGEX.test(descriptor.trim());
+}
+function parseNpmToolDescriptor(descriptor) {
+  const s = descriptor.trim();
+  const m = s.match(NPM_TOOL_DESCRIPTOR_REGEX);
+  if (!m) return null;
+  return { fullPackage: m[1], toolPath: m[2] };
+}
+var KNOWN_PACKAGE_PREFIX = {
+  "@easynet/agent-tool-builtin-tools": "core/",
+  "@easynet/agent-tool-buildin-tools": "core/",
+  // alias (e.g. npm:@easynet/agent-tool-buildin#fs.readText)
+  "@easynet/agent-tool-buildin": "core/",
+  // shorthand
+  "@easynet/agent-tool-example-tools": "example/"
+};
+function resolveNpmToolDescriptor(descriptor) {
+  const parsed = parseNpmToolDescriptor(descriptor);
+  if (!parsed) return null;
+  const prefix = KNOWN_PACKAGE_PREFIX[parsed.fullPackage];
+  if (!prefix) return null;
+  const path = parsed.toolPath;
+  if (path.startsWith(prefix)) return path;
+  return prefix + path;
+}
+function resolveToolDescriptor(descriptor) {
+  const s = descriptor.trim();
+  const resolved = resolveNpmToolDescriptor(s);
+  if (resolved !== null) return resolved;
+  return s;
+}
+function normalizeToolList(descriptors) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const d of descriptors) {
+    if (typeof d !== "string" || !d.trim()) continue;
+    const name = resolveToolDescriptor(d);
+    if (!seen.has(name)) {
+      seen.add(name);
+      out.push(name);
+    }
+  }
+  return out;
+}
+function isCursorFormat(obj) {
+  return typeof obj === "object" && obj !== null && "mcpServers" in obj && typeof obj.mcpServers === "object" && obj.mcpServers !== null;
+}
+function extractMCPConfig(parsed, toolName) {
+  if (isCursorFormat(parsed)) {
+    const servers = parsed.mcpServers;
+    const keys = Object.keys(servers);
+    if (keys.length === 0) {
+      return {};
+    }
+    const name = toolName && keys.includes(toolName) ? toolName : keys[0];
+    return servers[name];
+  }
+  return parsed;
+}
+async function loadMCPTool(dirPath, manifest) {
+  const mcpPath = path.join(dirPath, manifest.entryPoint ?? "mcp.json");
+  let raw;
+  try {
+    raw = await promises.readFile(mcpPath, "utf-8");
+  } catch (err) {
+    throw new chunkZ7TGIG77_cjs.DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to read MCP config: ${mcpPath}`,
+      err
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new chunkZ7TGIG77_cjs.DiscoveryError(
+      dirPath,
+      "load",
+      `Invalid JSON in ${mcpPath}`,
+      err
+    );
+  }
+  const baseName = manifest.name?.split("/").pop();
+  const config = extractMCPConfig(parsed, baseName);
+  if (!config.command && !config.url) {
+    throw new chunkZ7TGIG77_cjs.DiscoveryError(
+      dirPath,
+      "validate",
+      `mcp.json must have either "command" or "url" field`
+    );
+  }
+  return { manifest, dirPath, mcpConfig: config };
+}
+var DEFAULT_EXTENSIONS = [".js", ".mjs"];
+async function resolveEntryPoint(dirPath, baseName, extensions = DEFAULT_EXTENSIONS) {
+  if (extensions.some((ext) => baseName.endsWith(ext))) {
+    const fullPath = path.join(dirPath, baseName);
+    await promises.stat(fullPath);
+    return fullPath;
+  }
+  for (const ext of extensions) {
+    const fullPath = path.join(dirPath, `${baseName}${ext}`);
+    try {
+      await promises.stat(fullPath);
+      return fullPath;
+    } catch {
+    }
+  }
+  throw new Error(
+    `Could not find entry point in ${dirPath}. Tried: ${extensions.map((e) => baseName + e).join(", ")}`
+  );
+}
+
+// src/discovery/load/LangChainLoader.ts
+async function loadLangChainTool(dirPath, manifest, extensions) {
+  let entryFile;
+  try {
+    entryFile = await resolveEntryPoint(
+      dirPath,
+      manifest.entryPoint ?? "index",
+      extensions
+    );
+  } catch (err) {
+    throw new chunkZ7TGIG77_cjs.DiscoveryError(
+      dirPath,
+      "load",
+      `Cannot find LangChain entry point`,
+      err
+    );
+  }
+  let mod;
+  try {
+    mod = await import(url.pathToFileURL(entryFile).href);
+  } catch (err) {
+    throw new chunkZ7TGIG77_cjs.DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to import ${entryFile}`,
+      err
+    );
+  }
+  const tool = mod.default ?? mod.tool ?? mod;
+  if (!tool || typeof tool.invoke !== "function") {
+    throw new chunkZ7TGIG77_cjs.DiscoveryError(
+      dirPath,
+      "validate",
+      `Entry point must export an object with invoke() method (LangChainToolLike)`
+    );
+  }
+  return { manifest, dirPath, impl: tool };
+}
+var DEFAULT_EXTENSIONS2 = [".js", ".mjs"];
+async function listSkillProgramFiles(dirPath, extensions = DEFAULT_EXTENSIONS2) {
+  let entries;
+  try {
+    const dirEntries = await promises.readdir(dirPath, { withFileTypes: true });
+    entries = dirEntries.map((entry) => ({
+      name: entry.name,
+      isFile: entry.isFile()
+    }));
+  } catch {
+    return [];
+  }
+  return entries.filter((e) => e.isFile).map((e) => e.name).filter((name) => {
+    if (name.startsWith(".") || name.startsWith("_")) return false;
+    if (name.includes(".test.") || name.includes(".spec.")) return false;
+    return extensions.some((ext) => name.endsWith(ext));
+  }).sort((a, b) => {
+    if (a === "handler.js" || a === "index.js") return -1;
+    if (b === "handler.js" || b === "index.js") return 1;
+    return a.localeCompare(b);
+  });
+}
+function isLangChainLikeTool(val) {
+  return val != null && typeof val === "object" && "invoke" in val && typeof val.invoke === "function";
+}
+function isConstructable(val) {
+  return typeof val === "function" && typeof val.prototype === "object";
+}
+async function loadOneSkillProgram(dirPath, manifest, entryFile, skillDef, programKey, extensions) {
+  let impl;
+  try {
+    const fullPath = await resolveEntryPoint(dirPath, entryFile, extensions ?? [".js", ".mjs"]);
+    const mod = await import(url.pathToFileURL(fullPath).href);
+    const fn = mod.default ?? mod.handler ?? mod.Tool;
+    if (isLangChainLikeTool(fn)) {
+      impl = fn;
+    } else if (isConstructable(fn)) {
+      const instance = new fn();
+      if (isLangChainLikeTool(instance)) impl = instance;
+    } else if (typeof fn === "function") {
+      impl = fn;
+    }
+  } catch {
+  }
+  return {
+    manifest,
+    dirPath,
+    impl,
+    skillDefinition: skillDef,
+    programKey
+  };
+}
+async function loadSkillTools(dirPath, manifest, extensions) {
+  let skillDef;
+  try {
+    skillDef = await chunkZ7TGIG77_cjs.loadSkillDefinition(dirPath);
+  } catch (err) {
+    throw new chunkZ7TGIG77_cjs.DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to parse SKILL.md: ${err.message}`,
+      err
+    );
+  }
+  const programs = manifest.programs;
+  if (programs && typeof programs === "object" && Object.keys(programs).length > 0) {
+    const result = [];
+    for (const [programKey, entryFile2] of Object.entries(programs)) {
+      const loaded2 = await loadOneSkillProgram(
+        dirPath,
+        manifest,
+        entryFile2,
+        skillDef,
+        programKey,
+        extensions
+      );
+      result.push(loaded2);
+    }
+    return result;
+  }
+  const exts = extensions ?? DEFAULT_EXTENSIONS2;
+  const files = await listSkillProgramFiles(dirPath, exts);
+  if (files.length >= 2) {
+    const result = [];
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const programKey = i === 0 ? "default" : file.replace(/\.[^.]+$/, "");
+      const loaded2 = await loadOneSkillProgram(
+        dirPath,
+        manifest,
+        file,
+        skillDef,
+        programKey,
+        extensions
+      );
+      result.push(loaded2);
+    }
+    return result;
+  }
+  const entryFile = manifest.entryPoint ?? files[0] ?? "handler";
+  const loaded = await loadOneSkillProgram(
+    dirPath,
+    manifest,
+    entryFile,
+    skillDef,
+    void 0,
+    extensions
+  );
+  return [loaded];
+}
+
+// src/discovery/scan/DirectoryScanner.ts
+var DEFAULT_EXTENSIONS3 = [".js", ".mjs"];
+var DirectoryScanner = class {
+  roots;
+  extensions;
+  onError;
+  constructor(options) {
+    const defaultNamespace = options.namespace ?? "dir";
+    this.roots = options.roots.map((root) => {
+      if (typeof root === "string") {
+        return { path: root, namespace: defaultNamespace };
+      }
+      return {
+        path: root.path,
+        namespace: root.namespace ?? defaultNamespace
+      };
+    });
+    this.extensions = options.extensions ?? DEFAULT_EXTENSIONS3;
+    this.onError = options.onError;
+  }
+  /**
+   * Scan all root directories and return discovered ToolSpecs.
+   * Errors in individual tool directories are reported via onError
+   * and do not prevent other tools from loading.
+   */
+  async scan() {
+    const specs = [];
+    for (const root of this.roots) {
+      const rootSpecs = await this.scanRoot(root.path, root.namespace);
+      specs.push(...rootSpecs);
+    }
+    return specs;
+  }
+  async scanRoot(rootPath, namespace) {
+    return this.scanRecursive(rootPath, namespace);
+  }
+  /**
+   * Recursively scan directories for tool definitions.
+   * Directories can be detected via tool.json or inferred markers.
+   */
+  async scanRecursive(dirPath, namespace) {
+    const specs = [];
+    let dirEntries;
+    try {
+      const entries = await promises.readdir(dirPath, { withFileTypes: true });
+      dirEntries = entries.map((entry) => ({
+        name: entry.name,
+        isDirectory: entry.isDirectory()
+      }));
+    } catch (error) {
+      this.onError?.(dirPath, error);
+      return specs;
+    }
+    const dirName = path.basename(dirPath);
+    try {
+      const loadedSpecs = await this.loadToolDir(dirPath, dirName, namespace);
+      if (loadedSpecs.length > 0) {
+        specs.push(...loadedSpecs);
+      }
+    } catch (error) {
+      this.onError?.(dirPath, error);
+    }
+    for (const entry of dirEntries) {
+      if (!entry.isDirectory) {
+        continue;
+      }
+      const childPath = path.join(dirPath, entry.name);
+      try {
+        const childSpecs = await this.scanRecursive(childPath, namespace);
+        specs.push(...childSpecs);
+      } catch (error) {
+        this.onError?.(childPath, error);
+      }
+    }
+    return specs;
+  }
+  async loadToolDir(dirPath, dirName, namespace) {
+    const manifestPath = path.join(dirPath, "tool.json");
+    let manifestRaw;
+    try {
+      manifestRaw = await promises.readFile(manifestPath, "utf-8");
+    } catch {
+      const inferred = await this.inferManifest(dirPath, dirName);
+      if (!inferred) {
+        return [];
+      }
+      if (inferred.kind === "langchain") {
+        if (inferred.entryPoint) {
+          const loaded3 = await loadLangChainTool(dirPath, inferred, this.extensions);
+          return [this.toToolSpec(loaded3, dirName, dirPath, namespace)];
+        }
+        return this.loadLangChainTools(dirPath, dirName, inferred, false, namespace);
+      }
+      if (inferred.kind === "skill") {
+        const loadedList = await loadSkillTools(dirPath, inferred, this.extensions);
+        return loadedList.map(
+          (loaded3) => this.toToolSpec(loaded3, dirName, dirPath, namespace)
+        );
+      }
+      const loaded2 = await this.loadByKind(dirPath, inferred);
+      return [this.toToolSpec(loaded2, dirName, dirPath, namespace)];
+    }
+    let manifest;
+    try {
+      manifest = JSON.parse(manifestRaw);
+    } catch (err) {
+      throw new chunkZ7TGIG77_cjs.DiscoveryError(
+        dirPath,
+        "manifest",
+        "Invalid JSON in tool.json",
+        err
+      );
+    }
+    if (!manifest.kind) {
+      throw new chunkZ7TGIG77_cjs.DiscoveryError(
+        dirPath,
+        "manifest",
+        `tool.json must have a "kind" field`
+      );
+    }
+    if (manifest.enabled === false) {
+      return [];
+    }
+    if (manifest.kind === "langchain") {
+      if (manifest.entryPoint) {
+        const loaded2 = await loadLangChainTool(dirPath, manifest, this.extensions);
+        return [this.toToolSpec(loaded2, dirName, dirPath, namespace)];
+      }
+      return this.loadLangChainTools(dirPath, dirName, manifest, true, namespace);
+    }
+    if (manifest.kind === "skill") {
+      const loadedList = await loadSkillTools(dirPath, manifest, this.extensions);
+      return loadedList.map(
+        (loaded2) => this.toToolSpec(loaded2, dirName, dirPath, namespace)
+      );
+    }
+    const loaded = await this.loadByKind(dirPath, manifest);
+    return [this.toToolSpec(loaded, dirName, dirPath, namespace)];
+  }
+  async inferManifest(dirPath, dirName) {
+    const hasSkill = await this.fileExists(path.join(dirPath, "SKILL.md"));
+    const hasN8n = await this.fileExists(path.join(dirPath, "workflow.json"));
+    const hasMcp = await this.fileExists(path.join(dirPath, "mcp.json"));
+    const isLangchainDir = dirName === "langchain";
+    const hasLangchain = isLangchainDir ? await this.hasLangchainFiles(dirPath) : dirName !== "skill" && await this.hasEntryPoint(dirPath, "index");
+    const kinds = [
+      hasSkill ? "skill" : null,
+      hasN8n ? "n8n" : null,
+      hasMcp ? "mcp" : null,
+      hasLangchain ? "langchain" : null
+    ].filter(Boolean);
+    if (kinds.length === 0) return null;
+    if (kinds.length > 1) {
+      throw new chunkZ7TGIG77_cjs.DiscoveryError(
+        dirPath,
+        "manifest",
+        `Ambiguous tool kind (found ${kinds.join(", ")}). Add tool.json to disambiguate.`
+      );
+    }
+    const kind = kinds[0];
+    const manifest = { kind };
+    if (kind === "n8n") manifest.entryPoint = "workflow.json";
+    if (kind === "mcp") manifest.entryPoint = "mcp.json";
+    if (kind === "langchain" && !isLangchainDir) manifest.entryPoint = "index";
+    if (kind === "skill") manifest.entryPoint = "handler";
+    return manifest;
+  }
+  async fileExists(path) {
+    try {
+      await promises.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async hasEntryPoint(dirPath, baseName) {
+    try {
+      await resolveEntryPoint(dirPath, baseName, this.extensions);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async hasLangchainFiles(dirPath) {
+    const entryFiles = await this.listLangchainEntryFiles(dirPath);
+    return entryFiles.length > 0;
+  }
+  async listLangchainEntryFiles(dirPath) {
+    let entries;
+    try {
+      const dirEntries = await promises.readdir(dirPath, { withFileTypes: true });
+      entries = dirEntries.map((entry) => ({
+        name: entry.name,
+        isFile: entry.isFile()
+      }));
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => entry.isFile).map((entry) => entry.name).filter((name) => {
+      if (name.startsWith(".") || name.startsWith("_")) return false;
+      if (name.endsWith(".d.ts")) return false;
+      if (name.includes(".test.") || name.includes(".spec.")) return false;
+      return this.extensions.some((ext) => name.endsWith(ext));
+    });
+  }
+  async loadByKind(dirPath, manifest) {
+    switch (manifest.kind) {
+      case "mcp":
+        return loadMCPTool(dirPath, manifest);
+      case "langchain":
+        return loadLangChainTool(dirPath, manifest, this.extensions);
+      case "skill": {
+        const list = await loadSkillTools(dirPath, manifest, this.extensions);
+        if (list.length === 0) {
+          throw new chunkZ7TGIG77_cjs.DiscoveryError(dirPath, "load", "No skill programs loaded", new Error("empty"));
+        }
+        return list[0];
+      }
+      case "n8n":
+        return chunkZ7TGIG77_cjs.loadN8nTool(dirPath, manifest);
+      default:
+        throw new chunkZ7TGIG77_cjs.DiscoveryError(
+          dirPath,
+          "manifest",
+          `Unknown tool kind: "${manifest.kind}"`
+        );
+    }
+  }
+  async loadLangChainTools(dirPath, dirName, manifest, strict, namespace) {
+    const entryFiles = await this.listLangchainEntryFiles(dirPath);
+    if (entryFiles.length === 0) {
+      if (strict) {
+        throw new chunkZ7TGIG77_cjs.DiscoveryError(
+          dirPath,
+          "load",
+          "No LangChain entry files found"
+        );
+      }
+      return [];
+    }
+    const specs = [];
+    const useDirNameForSingle = dirName !== "langchain";
+    for (const entryFile of entryFiles) {
+      const fileManifest = {
+        ...manifest,
+        entryPoint: entryFile
+      };
+      try {
+        const loaded = await loadLangChainTool(dirPath, fileManifest, this.extensions);
+        const fileBase = path.basename(entryFile).replace(/\.[^.]+$/, "");
+        const nameHint = entryFiles.length === 1 && useDirNameForSingle ? dirName : fileBase;
+        specs.push(this.toToolSpec(loaded, nameHint, dirPath, namespace));
+      } catch (error) {
+        const err = error;
+        if (err instanceof chunkZ7TGIG77_cjs.DiscoveryError && err.phase === "validate") {
+          if (strict) {
+            throw err;
+          }
+          continue;
+        }
+        this.onError?.(path.join(dirPath, entryFile), err);
+        if (strict) {
+          throw err;
+        }
+      }
+    }
+    return specs;
+  }
+  toToolSpec(loaded, dirName, dirPath, namespace) {
+    const { manifest } = loaded;
+    const kindDirNames = /* @__PURE__ */ new Set(["mcp", "langchain", "skill", "n8n"]);
+    const parentName = path.basename(path.join(dirPath, ".."));
+    const isKindDir = kindDirNames.has(dirName);
+    const defaultDirName = isKindDir ? parentName : dirName;
+    const inferredName = isKindDir ? `${namespace}/${defaultDirName}-${dirName}` : `${namespace}/${defaultDirName}`;
+    const name = manifest.name ?? inferredName;
+    const spec = this.buildBaseSpec(manifest, name, dirName);
+    this.applyKindSpecificFields(spec, loaded, manifest, defaultDirName, namespace);
+    return spec;
+  }
+  buildBaseSpec(manifest, name, dirName) {
+    return {
+      name,
+      version: manifest.version ?? "1.0.0",
+      kind: manifest.kind,
+      description: manifest.description ?? `${manifest.kind} tool: ${dirName}`,
+      tags: manifest.tags,
+      inputSchema: manifest.inputSchema ?? {
+        type: "object",
+        additionalProperties: true
+      },
+      outputSchema: manifest.outputSchema ?? {
+        type: "object",
+        additionalProperties: true
+      },
+      capabilities: manifest.capabilities ?? [],
+      costHints: manifest.costHints
+    };
+  }
+  applyKindSpecificFields(spec, loaded, manifest, defaultDirName, namespace) {
+    switch (manifest.kind) {
+      case "mcp":
+        if (loaded.mcpConfig?.url) {
+          spec.endpoint = loaded.mcpConfig.url;
+        }
+        spec.impl = loaded.mcpConfig;
+        break;
+      case "langchain":
+        spec.impl = loaded.impl;
+        if (!manifest.name) {
+          const toolName = loaded.impl?.name;
+          if (toolName) {
+            spec.name = `${namespace}/${toolName}`;
+          }
+        }
+        if (!manifest.description) {
+          const toolDescription = loaded.impl?.description;
+          if (toolDescription) {
+            spec.description = toolDescription;
+          }
+        }
+        if (!manifest.inputSchema && loaded.impl) {
+          const tool = loaded.impl;
+          if (tool.schema) {
+            spec.inputSchema = tool.schema;
+          }
+        }
+        break;
+      case "skill": {
+        if (loaded.skillDefinition) {
+          spec.name = manifest.name ?? loaded.skillDefinition.frontmatter.name;
+          spec.description = loaded.skillDefinition.frontmatter.description;
+          if (loaded.programKey === "default") {
+            spec.name = `${namespace}/${defaultDirName}`;
+          } else if (loaded.programKey) {
+            spec.name = `${namespace}/${defaultDirName}/${loaded.programKey}`;
+          }
+          const impl = loaded.impl;
+          if (impl && typeof impl === "object" && typeof impl.invoke === "function") {
+            if (impl.description != null && impl.description !== "") spec.description = impl.description;
+            if (impl.schema != null && typeof impl.schema === "object") spec.inputSchema = impl.schema;
+          }
+          spec.impl = {
+            ...loaded.skillDefinition,
+            handler: loaded.impl
+          };
+        } else {
+          spec.impl = loaded.impl;
+        }
+        break;
+      }
+      case "n8n": {
+        const workflow = loaded.workflowDef;
+        if (workflow?.id) {
+          spec.resourceId = String(workflow.id);
+        }
+        if (!manifest.description && workflow) {
+          const workflowDesc = workflow.description ?? workflow.meta?.description ?? (typeof workflow.name === "string" ? workflow.name : void 0);
+          if (workflowDesc) {
+            spec.description = workflowDesc;
+          }
+        }
+        spec.impl = loaded.workflowDef;
+        break;
+      }
+    }
+  }
+};
+
+// src/discovery/MCPProcessManager.ts
+var MCPProcessManager = class {
+  connections = /* @__PURE__ */ new Map();
+  /**
+   * Get connection info for an MCP tool based on its config.
+   * Caches the result by tool name.
+   */
+  getConnectionInfo(toolName, config) {
+    const cached = this.connections.get(toolName);
+    if (cached) return cached;
+    const info = config.url ? { type: "url", url: config.url } : {
+      type: "stdio",
+      command: config.command,
+      args: config.args,
+      env: config.env,
+      cwd: config.cwd
+    };
+    this.connections.set(toolName, info);
+    return info;
+  }
+  /**
+   * Remove cached connection info for a tool.
+   */
+  remove(toolName) {
+    return this.connections.delete(toolName);
+  }
+  /**
+   * Get all registered tool names.
+   */
+  getToolNames() {
+    return [...this.connections.keys()];
+  }
+  /**
+   * Clear all cached connection info.
+   */
+  dispose() {
+    this.connections.clear();
+  }
+};
+
+// src/mcp/MCPClientAdapter.ts
+function textFromCallToolResult(result) {
+  if (result.content?.length) {
+    const parts = result.content.filter((c) => c.type === "text" && c.text != null).map((c) => c.text);
+    if (parts.length) return parts.join("\n");
+  }
+  if (result.toolResult !== void 0) return JSON.stringify(result.toolResult);
+  return JSON.stringify(result);
+}
+var MCPClientAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  kind = "mcp";
+  async invoke(spec, args, _ctx) {
+    const params = args != null && typeof args === "object" && !Array.isArray(args) ? args : {};
+    const result = await this.client.callTool({ name: spec.name, arguments: params });
+    const text = textFromCallToolResult(result);
+    let resultValue = text;
+    try {
+      resultValue = JSON.parse(text);
+    } catch {
+    }
+    return { result: resultValue, raw: result };
+  }
+};
+
+// src/mcp/connectMCP.ts
+async function connectMCP(connectionInfo) {
+  if (connectionInfo.type !== "stdio" || !connectionInfo.command) {
+    throw new Error(
+      `MCP stdio requires connectionInfo.type "stdio" and command; got type=${connectionInfo.type}`
+    );
+  }
+  const { Client } = await import('@modelcontextprotocol/sdk/client');
+  const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
+  const serverParams = {
+    command: connectionInfo.command,
+    args: connectionInfo.args ?? [],
+    env: connectionInfo.env,
+    cwd: connectionInfo.cwd
+  };
+  const transport = new StdioClientTransport(serverParams);
+  const client = new Client({ name: "agent-tool", version: "1.0.0" });
+  await client.connect(transport);
+  return {
+    client,
+    transport
+  };
+}
+function mcpToolsToSpecs(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    version: "1.0.0",
+    kind: "mcp",
+    description: t.description ?? `MCP tool: ${t.name}`,
+    inputSchema: t.inputSchema ?? chunk3YLVPZRJ_cjs.DEFAULT_INPUT_SCHEMA,
+    outputSchema: chunk3YLVPZRJ_cjs.DEFAULT_OUTPUT_SCHEMA,
+    capabilities: []
+  }));
+}
+async function registerMCPToolsFromConfig(runtime, registry, options = {}) {
+  const configPath = options.configPath ?? process.env.MCP_CONFIG_PATH ?? path.join(process.cwd(), "mcp.json");
+  const dirPath = path.dirname(configPath);
+  const entryPoint = path.basename(configPath);
+  const toolName = options.toolName ?? "mcp";
+  const loaded = await loadMCPTool(dirPath, { kind: "mcp", name: toolName, entryPoint });
+  if (!loaded.mcpConfig) {
+    throw new Error("mcp.json must have command or url");
+  }
+  const manager = new MCPProcessManager();
+  const connectionInfo = manager.getConnectionInfo(toolName, loaded.mcpConfig);
+  const { client, transport } = await connectMCP(connectionInfo);
+  const { tools } = await client.listTools();
+  const specs = mcpToolsToSpecs(tools);
+  registry.bulkRegister(specs);
+  runtime.registerAdapter(new MCPClientAdapter(client));
+  return { transport };
+}
+var DEFAULT_CTX_FACTORY = () => ({
+  requestId: `lc-${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 LangChainToolsHub = class {
+  constructor(runtime, ctxFactory = DEFAULT_CTX_FACTORY) {
+    this.runtime = runtime;
+    this.ctxFactory = ctxFactory;
+  }
+  /**
+   * Returns all registered tools as LangChain tools (DynamicTool[]).
+   * Each tool invokes the runtime through the full pipeline (policy, HITL, etc.).
+   */
+  getLangChainTools() {
+    const registry = this.runtime.getRegistry();
+    const specs = registry.snapshot();
+    return specs.map((spec) => this.specToLangChainTool(spec));
+  }
+  /**
+   * Returns LangChain tools for a subset of tools (by name or query).
+   */
+  getLangChainToolsForNames(toolNames) {
+    const registry = this.runtime.getRegistry();
+    const set = new Set(toolNames);
+    const specs = registry.snapshot().filter((s) => set.has(s.name));
+    return specs.map((spec) => this.specToLangChainTool(spec));
+  }
+  specToLangChainTool(spec) {
+    const runtime = this.runtime;
+    const ctxFactory = this.ctxFactory;
+    return new tools.DynamicTool({
+      name: spec.name,
+      description: spec.description ?? `Tool: ${spec.name}`,
+      func: async (input) => {
+        const args = parseToolInput(input);
+        const intent = {
+          tool: spec.name,
+          args,
+          purpose: "langchain"
+        };
+        const ctx = ctxFactory();
+        const result = await runtime.invoke(intent, ctx);
+        if (result.ok) {
+          return typeof result.result === "string" ? result.result : JSON.stringify(result.result);
+        }
+        const err = result.error;
+        const message = err?.message ?? "Tool failed";
+        const details = err?.details;
+        return JSON.stringify(
+          details != null ? { error: message, details } : { error: message }
+        );
+      }
+    });
+  }
+};
+function parseToolInput(input) {
+  const s = input.trim();
+  if (!s) return {};
+  try {
+    const parsed = JSON.parse(s);
+    if (parsed != null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  const lastBrace = s.lastIndexOf("{");
+  if (lastBrace !== -1) {
+    try {
+      const parsed = JSON.parse(s.slice(lastBrace));
+      if (parsed != null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return {};
+}
+
+// src/llm/AgentLLMAdapter.ts
+function createAgentLLMAdapter(client) {
+  if (!client.chatWithTools) {
+    throw new Error(
+      `agent-llm client "${client.id}" does not support chatWithTools; ReAct agent requires tool-calling.`
+    );
+  }
+  return new AgentLLMAdapter(client);
+}
+var AgentLLMAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async chat(messages, options) {
+    const result = await this.client.chat(messages);
+    return { content: result.content, raw: result.usage ?? {} };
+  }
+  async chatWithTools(messages, tools, options) {
+    const agentLlmTools = tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.function.name,
+        description: t.function.description,
+        parameters: t.function.parameters
+      }
+    }));
+    const result = await this.client.chatWithTools(messages, agentLlmTools, {
+      timeoutMs: options?.timeoutMs
+    });
+    return {
+      message: result.message,
+      raw: result.usage ?? {}
+    };
+  }
+};
+var DEFAULT_ALLOWED_HOSTS = ["*"];
+var DEFAULT_SANDBOX_ROOT = process.cwd();
+function loadAgentConfig(configPath) {
+  const abs = path.resolve(configPath);
+  const raw = fs.readFileSync(abs, "utf8");
+  const parsed = yaml__default.default.load(raw);
+  if (!parsed || typeof parsed !== "object") return {};
+  return parsed;
+}
+function createRuntimeWithTools(options) {
+  const sandboxRoot = options.sandboxRoot ?? DEFAULT_SANDBOX_ROOT;
+  const allowedHosts = options.allowedHosts ?? DEFAULT_ALLOWED_HOSTS;
+  const registry = new ToolRegistry();
+  const coreConfig = { sandboxRoot, allowedHosts };
+  const coreAdapter = agentToolBuiltinTools.registerCoreTools(registry, coreConfig);
+  const exampleConfig = { sandboxRoot, allowedHosts };
+  const exampleAdapter = agentToolExampleTools.registerExampleTools(registry, exampleConfig);
+  const runtime = new PTCRuntime({ registry });
+  runtime.registerAdapter(coreAdapter);
+  runtime.registerAdapter(exampleAdapter);
+  return { runtime, coreAdapter, exampleAdapter };
+}
+async function runAgent(configPath, task, options) {
+  const config = loadAgentConfig(configPath);
+  const llmSection = config.llm ?? null;
+  const registry = agentLlm.createLLMRegistry({ llmSection });
+  const defaultId = registry.defaultId();
+  if (!defaultId) {
+    throw new Error(
+      "agent.yaml has no llm section or no LLM instances. Add an llm block (see agent.yaml.example)."
+    );
+  }
+  const client = registry.get(defaultId);
+  if (!client) {
+    throw new Error(`LLM "${defaultId}" not found in registry.`);
+  }
+  const adapter = createAgentLLMAdapter(client);
+  const sandboxRoot = options?.sandboxRoot ?? DEFAULT_SANDBOX_ROOT;
+  const allowedHosts = options?.allowedHosts ?? DEFAULT_ALLOWED_HOSTS;
+  const { runtime } = createRuntimeWithTools({ sandboxRoot, allowedHosts });
+  const ctxFactory = () => ({
+    requestId: `run-${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",
+      "exec"
+    ]
+  });
+  const hub = {
+    getRegistry: () => runtime.getRegistry(),
+    invokeTool: async (name, args) => {
+      const ctx = ctxFactory();
+      const result = await runtime.invoke(
+        { tool: name, args, purpose: "langchain" },
+        ctx
+      );
+      return result;
+    }
+  };
+  const agent = new chunkP3UEAZHK_cjs.ReActAgent(adapter, hub);
+  const toolNames = Array.isArray(config.tools) && config.tools.length > 0 ? normalizeToolList(config.tools) : void 0;
+  return agent.run(task, {
+    systemPrompt: options?.systemPrompt,
+    toolNames,
+    ...options?.runOptions
+  });
+}
+var PLACEHOLDER = "__REPORT_DATA__";
+function getReportTemplateDir() {
+  if (typeof __dirname !== "undefined") return __dirname;
+  return path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+}
+var DEFAULT_REPORT_TEMPLATE_PATH = (() => {
+  const dir = getReportTemplateDir();
+  const nextToModule = path.join(dir, "agent-report-template.html");
+  if (fs.existsSync(nextToModule)) return nextToModule;
+  return path.join(dir, "report", "agent-report-template.html");
+})();
+function generateAgentReport(data, options) {
+  const templatePath = options.templatePath ?? DEFAULT_REPORT_TEMPLATE_PATH;
+  const template = fs.readFileSync(templatePath, "utf8");
+  let json = JSON.stringify(data);
+  json = json.replace(/<\/script/gi, "<\\/script");
+  const html = template.replace(PLACEHOLDER, json);
+  const outPath = path.resolve(options.outputPath);
+  fs.writeFileSync(outPath, html, "utf8");
+  return outPath;
+}
+function serializeStepOutput(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") return value;
+  const v = value;
+  const out = {};
+  if (Array.isArray(v.messages)) {
+    out.messages = v.messages.map((m) => serializeMessage(m));
+  }
+  if (v.__state__ && typeof v.__state__ === "object") {
+    const state = v.__state__;
+    if (Array.isArray(state.messages)) {
+      out.messages = state.messages.map((m) => serializeMessage(m));
+    }
+  }
+  if (Object.keys(out).length === 0) {
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch {
+      return { _raw: String(value) };
+    }
+  }
+  return out;
+}
+function serializeMessage(msg) {
+  if (msg === null || typeof msg !== "object") return { content: String(msg) };
+  const m = msg;
+  const out = {
+    type: m.type ?? "message",
+    content: m.content ?? ""
+  };
+  if (m.tool_calls) out.tool_calls = m.tool_calls;
+  if (m.usage_metadata) out.usage_metadata = m.usage_metadata;
+  if (m.name) out.name = m.name;
+  return out;
+}
+function formatStepProgress(step) {
+  const parts = [`  [${step.stepIndex}] ${step.node}`];
+  if (step.toolCalls?.length) {
+    const toolParts = step.toolCalls.map((tc) => {
+      const argStr = tc.args && Object.keys(tc.args).length ? " " + JSON.stringify(tc.args) : "";
+      return `${tc.name}${argStr}`;
+    });
+    parts.push(`tools \u2192 ${toolParts.join("; ")}`);
+  }
+  if (step.usage) {
+    const inN = step.usage.input_tokens ?? 0;
+    const outN = step.usage.output_tokens ?? 0;
+    const total = step.usage.total_tokens ?? inN + outN;
+    parts.push(`tokens: in=${inN} out=${outN} total=${total}`);
+  }
+  return parts.join(" | ");
+}
+function buildStep(stepIndex, node, value) {
+  const v = value;
+  const messages = v?.messages ?? v?.__state__?.messages;
+  const lastMsg = Array.isArray(messages) ? messages.slice(-1)[0] : void 0;
+  const last = lastMsg;
+  const toolCalls = last?.tool_calls;
+  const usage = last?.usage_metadata;
+  return {
+    stepIndex,
+    node,
+    input: void 0,
+    // filled later from previous step's output
+    output: serializeStepOutput(value),
+    toolCalls: toolCalls?.map((tc) => ({ name: tc.name, args: tc.args ?? {} })),
+    usage: usage ? {
+      input_tokens: usage.input_tokens ?? usage.prompt_tokens,
+      output_tokens: usage.output_tokens ?? usage.completion_tokens,
+      total_tokens: usage.total_tokens
+    } : void 0
+  };
+}
+function isAiMessage(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  if (msg.type === "ai" || msg.type === "assistant") return true;
+  const getType = msg._getType;
+  if (typeof getType === "function" && getType.call(msg) === "ai") return true;
+  const lcId = msg.lc_id;
+  if (Array.isArray(lcId) && lcId[lcId.length - 1] === "AIMessage") return true;
+  return false;
+}
+function getMessageContent(msg) {
+  if (!msg || typeof msg !== "object") return "";
+  let c = msg.content ?? msg.kwargs?.content;
+  if (typeof c === "string") return c;
+  if (Array.isArray(c)) {
+    return c.map((p) => p && typeof p === "object" && "text" in p ? p.text : String(p)).filter(Boolean).join("");
+  }
+  return "";
+}
+function extractAiContent(msg) {
+  if (!msg || !isAiMessage(msg)) return "";
+  return getMessageContent(msg);
+}
+async function collectStreamSteps(stream, options) {
+  const steps = [];
+  let stepIndex = 0;
+  let lastAiContent = "";
+  for await (const chunk of stream) {
+    const nodeMap = Array.isArray(chunk) && chunk.length >= 2 && typeof chunk[chunk.length - 1] === "object" && chunk[chunk.length - 1] !== null && !Array.isArray(chunk[chunk.length - 1]) ? chunk[chunk.length - 1] : chunk;
+    for (const [node, value] of Object.entries(nodeMap)) {
+      if (value === void 0 || value === null) continue;
+      stepIndex += 1;
+      const step = buildStep(stepIndex, node, value);
+      steps.push(step);
+      options?.onStep?.(step);
+      const v = value;
+      const messages = v?.messages ?? v?.__state__?.messages;
+      const lastMsg = Array.isArray(messages) ? messages.slice(-1)[0] : void 0;
+      let content = extractAiContent(lastMsg);
+      if (!content && node === "agent" && lastMsg && typeof lastMsg === "object" && !("tool_call_id" in lastMsg && lastMsg.tool_call_id)) {
+        content = getMessageContent(lastMsg);
+      }
+      if (content) lastAiContent = content;
+    }
+  }
+  for (let i = 1; i < steps.length; i++) {
+    const prev = steps[i - 1];
+    const curr = steps[i];
+    if (prev && curr) curr.input = prev.output;
+  }
+  const first = steps[0];
+  if (first && first.input === void 0) {
+    first.input = { __info: "Initial state (see System and User Prompt above)" };
+  }
+  return { steps, lastAiContent };
+}
+async function runAgentWithReport(agent, input, options) {
+  const stream = await agent.stream(input, options.streamConfig ?? {});
+  const { steps, lastAiContent } = await collectStreamSteps(stream, { onStep: options.onStep });
+  let reportMarkdown = lastAiContent;
+  if (options.reportPath) {
+    const reportPath = path.resolve(options.reportPath);
+    if (fs.existsSync(reportPath)) {
+      reportMarkdown = fs.readFileSync(reportPath, "utf8");
+    }
+  }
+  let htmlPath;
+  if (options.htmlReportPath) {
+    htmlPath = generateAgentReport(
+      {
+        systemPrompt: options.systemPrompt,
+        userPrompt: options.userPrompt,
+        reportMarkdown,
+        steps
+      },
+      {
+        outputPath: options.htmlReportPath,
+        templatePath: options.templatePath
+      }
+    );
+  }
+  return { steps, reportMarkdown, htmlPath };
+}
+async function writeReportFromStream(stream, options) {
+  const { steps, lastAiContent } = await collectStreamSteps(stream, { onStep: options.onStep });
+  let reportMarkdown = lastAiContent;
+  if (options.reportPath) {
+    const reportPath = path.resolve(options.reportPath);
+    if (fs.existsSync(reportPath)) {
+      reportMarkdown = fs.readFileSync(reportPath, "utf8");
+    }
+  }
+  let htmlPath;
+  if (options.htmlReportPath) {
+    htmlPath = generateAgentReport(
+      {
+        systemPrompt: options.systemPrompt,
+        userPrompt: options.userPrompt,
+        reportMarkdown,
+        steps
+      },
+      {
+        outputPath: options.htmlReportPath,
+        templatePath: options.templatePath
+      }
+    );
+  }
+  return { steps, reportMarkdown, htmlPath };
+}
+
+Object.defineProperty(exports, "DiscoveryError", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.DiscoveryError; }
+});
+Object.defineProperty(exports, "SkillManifestError", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.SkillManifestError; }
+});
+Object.defineProperty(exports, "buildFunctionToTool", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.buildFunctionToTool; }
+});
+Object.defineProperty(exports, "buildMcpPackage", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.buildMcpPackage; }
+});
+Object.defineProperty(exports, "initProject", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.initProject; }
+});
+Object.defineProperty(exports, "loadSkillDefinition", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.loadSkillDefinition; }
+});
+Object.defineProperty(exports, "parseSkillMd", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.parseSkillMd; }
+});
+Object.defineProperty(exports, "runGeneratedMCP", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.runGeneratedMCP; }
+});
+Object.defineProperty(exports, "runMcpServer", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.runMcpServer; }
+});
+Object.defineProperty(exports, "scanForTools", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.scanForTools; }
+});
+Object.defineProperty(exports, "scanSkillResources", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.scanSkillResources; }
+});
+Object.defineProperty(exports, "validateFrontmatter", {
+  enumerable: true,
+  get: function () { return chunkZ7TGIG77_cjs.validateFrontmatter; }
+});
+Object.defineProperty(exports, "DEFAULT_INPUT_SCHEMA", {
+  enumerable: true,
+  get: function () { return chunk3YLVPZRJ_cjs.DEFAULT_INPUT_SCHEMA; }
+});
+Object.defineProperty(exports, "DEFAULT_OUTPUT_SCHEMA", {
+  enumerable: true,
+  get: function () { return chunk3YLVPZRJ_cjs.DEFAULT_OUTPUT_SCHEMA; }
+});
+Object.defineProperty(exports, "createToolSpec", {
+  enumerable: true,
+  get: function () { return chunk3YLVPZRJ_cjs.createToolSpec; }
+});
+Object.defineProperty(exports, "LangChainAgent", {
+  enumerable: true,
+  get: function () { return chunkP3UEAZHK_cjs.ReActAgent; }
+});
+Object.defineProperty(exports, "OpenAICompatibleClient", {
+  enumerable: true,
+  get: function () { return chunkP3UEAZHK_cjs.OpenAICompatibleClient; }
+});
+Object.defineProperty(exports, "ReActAgent", {
+  enumerable: true,
+  get: function () { return chunkP3UEAZHK_cjs.ReActAgent; }
+});
+Object.defineProperty(exports, "createOpenAICompatibleClient", {
+  enumerable: true,
+  get: function () { return chunkP3UEAZHK_cjs.createOpenAICompatibleClient; }
+});
+Object.defineProperty(exports, "CoreAdapter", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.CoreAdapter; }
+});
+Object.defineProperty(exports, "DEFAULT_CORE_TOOLS_CONFIG", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.DEFAULT_CORE_TOOLS_CONFIG; }
+});
+Object.defineProperty(exports, "deletePathSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.deletePathSpec; }
+});
+Object.defineProperty(exports, "downloadFileSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.downloadFileSpec; }
+});
+Object.defineProperty(exports, "duckduckgoSearchSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.duckduckgoSearchSpec; }
+});
+Object.defineProperty(exports, "fetchJsonSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.fetchJsonSpec; }
+});
+Object.defineProperty(exports, "fetchPageMainContentSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.fetchPageMainContentSpec; }
+});
+Object.defineProperty(exports, "fetchTextSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.fetchTextSpec; }
+});
+Object.defineProperty(exports, "hashTextSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.hashTextSpec; }
+});
+Object.defineProperty(exports, "headSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.headSpec; }
+});
+Object.defineProperty(exports, "isIpInBlockedCidrs", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.isIpInBlockedCidrs; }
+});
+Object.defineProperty(exports, "jsonSelectSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.jsonSelectSpec; }
+});
+Object.defineProperty(exports, "listDirSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.listDirSpec; }
+});
+Object.defineProperty(exports, "nowSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.nowSpec; }
+});
+Object.defineProperty(exports, "readTextSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.readTextSpec; }
+});
+Object.defineProperty(exports, "registerCoreTools", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.registerCoreTools; }
+});
+Object.defineProperty(exports, "resolveSandboxedPath", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.resolveSandboxedPath; }
+});
+Object.defineProperty(exports, "runCommandSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.runCommandSpec; }
+});
+Object.defineProperty(exports, "searchTextSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.searchTextSpec; }
+});
+Object.defineProperty(exports, "sha256Spec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.sha256Spec; }
+});
+Object.defineProperty(exports, "templateRenderSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.templateRenderSpec; }
+});
+Object.defineProperty(exports, "truncateSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.truncateSpec; }
+});
+Object.defineProperty(exports, "validateUrl", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.validateUrl; }
+});
+Object.defineProperty(exports, "writeTextSpec", {
+  enumerable: true,
+  get: function () { return agentToolBuiltinTools.writeTextSpec; }
+});
+Object.defineProperty(exports, "ExampleAdapter", {
+  enumerable: true,
+  get: function () { return agentToolExampleTools.ExampleAdapter; }
+});
+Object.defineProperty(exports, "isHostAllowed", {
+  enumerable: true,
+  get: function () { return agentToolExampleTools.isHostAllowed; }
+});
+Object.defineProperty(exports, "registerExampleTools", {
+  enumerable: true,
+  get: function () { return agentToolExampleTools.registerExampleTools; }
+});
+Object.defineProperty(exports, "yahooChartSpec", {
+  enumerable: true,
+  get: function () { return agentToolExampleTools.yahooChartSpec; }
+});
+Object.defineProperty(exports, "yahooQuoteSpec", {
+  enumerable: true,
+  get: function () { return agentToolExampleTools.yahooQuoteSpec; }
+});
+exports.BudgetManager = BudgetManager;
+exports.DirectoryScanner = DirectoryScanner;
+exports.EventLog = EventLog;
+exports.LangChainToolsHub = LangChainToolsHub;
+exports.MCPClientAdapter = MCPClientAdapter;
+exports.MCPProcessManager = MCPProcessManager;
+exports.Metrics = Metrics;
+exports.PTCRuntime = PTCRuntime;
+exports.PolicyDeniedError = PolicyDeniedError;
+exports.PolicyEngine = PolicyEngine;
+exports.SchemaValidationError = SchemaValidationError;
+exports.SchemaValidator = SchemaValidator;
+exports.ToolRegistry = ToolRegistry;
+exports.Tracing = Tracing;
+exports.buildEvidence = buildEvidence;
+exports.collectStreamSteps = collectStreamSteps;
+exports.connectMCP = connectMCP;
+exports.createAgentLLMAdapter = createAgentLLMAdapter;
+exports.createLogger = createLogger;
+exports.createTaggedError = createTaggedError;
+exports.formatStepProgress = formatStepProgress;
+exports.generateAgentReport = generateAgentReport;
+exports.isNpmToolDescriptor = isNpmToolDescriptor;
+exports.isRetryable = isRetryable;
+exports.loadAgentConfig = loadAgentConfig;
+exports.loadMCPTool = loadMCPTool;
+exports.mcpToolsToSpecs = mcpToolsToSpecs;
+exports.normalizeToolList = normalizeToolList;
+exports.parseNpmToolDescriptor = parseNpmToolDescriptor;
+exports.registerMCPToolsFromConfig = registerMCPToolsFromConfig;
+exports.resolveNpmToolDescriptor = resolveNpmToolDescriptor;
+exports.resolveToolDescriptor = resolveToolDescriptor;
+exports.runAgent = runAgent;
+exports.runAgentWithReport = runAgentWithReport;
+exports.sanitizeForLog = sanitizeForLog;
+exports.serializeStepOutput = serializeStepOutput;
+exports.summarizeForLog = summarizeForLog;
+exports.withRetry = withRetry;
+exports.writeReportFromStream = writeReportFromStream;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map