@easynet/agent-tool 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,2300 +1,19 @@
-import { DiscoveryError, loadN8nTool, loadSkillDefinition } from './chunk-BM4EVYI5.js';
-export { DiscoveryError, SkillManifestError, buildFunctionToTool, buildMcpPackage, initProject, loadSkillDefinition, parseSkillMd, runGeneratedMCP, runMcpServer, scanForTools, scanSkillResources, validateFrontmatter } from './chunk-BM4EVYI5.js';
-import { DEFAULT_OUTPUT_SCHEMA, DEFAULT_INPUT_SCHEMA } from './chunk-AXUNV4MK.js';
-export { DEFAULT_INPUT_SCHEMA, DEFAULT_OUTPUT_SCHEMA, createToolSpec } from './chunk-AXUNV4MK.js';
-import { ReActAgent } from './chunk-RPAMQCFH.js';
-export { ReActAgent as LangChainAgent, OpenAICompatibleClient, ReActAgent, createOpenAICompatibleClient } from './chunk-RPAMQCFH.js';
-import Ajv from 'ajv';
-import addFormats from 'ajv-formats';
-import { bulkhead, circuitBreaker, handleAll, ConsecutiveBreaker } from 'cockatiel';
-import { EventEmitter } from 'eventemitter3';
-import { v4 } from 'uuid';
-import pRetry from 'p-retry';
-import pTimeout from 'p-timeout';
-import { registerCoreTools } from '@easynet/agent-tool-builtin-tools';
-export { CoreAdapter, DEFAULT_CORE_TOOLS_CONFIG, deletePathSpec, downloadFileSpec, duckduckgoSearchSpec, fetchJsonSpec, fetchPageMainContentSpec, fetchTextSpec, hashTextSpec, headSpec, isIpInBlockedCidrs, jsonSelectSpec, listDirSpec, nowSpec, readTextSpec, registerCoreTools, resolveSandboxedPath, runCommandSpec, searchTextSpec, sha256Spec, templateRenderSpec, truncateSpec, validateUrl, writeTextSpec } from '@easynet/agent-tool-builtin-tools';
-import { registerExampleTools } from '@easynet/agent-tool-example-tools';
-export { ExampleAdapter, isHostAllowed, registerExampleTools, yahooChartSpec, yahooQuoteSpec } from '@easynet/agent-tool-example-tools';
-import { readFile, readdir, access, stat } from 'fs/promises';
-import { join, dirname, basename, resolve } from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { DynamicTool } from '@langchain/core/tools';
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import yaml from 'js-yaml';
-import { createLLMRegistry } from '@easynet/agent-llm';
+export { LangChainToolsHub, createAgentTools } from './chunk-7SGI5EGB.js';
+import { loadMCPTool } from './chunk-WOCVXQOW.js';
+export { DirectoryScanner, DiscoveryError, SkillManifestError, buildFunctionToTool, buildMcpPackage, initProject, loadMCPTool, loadSkillDefinition, parseSkillMd, runGeneratedMCP, runMcpServer, scan, scanForTools, scanSkillResources, validateFrontmatter } from './chunk-WOCVXQOW.js';
+import { MCP_KIND } from './chunk-YMCAX4O6.js';
+export { BudgetManager, EventLog, Metrics, PTCRuntime, PolicyDeniedError, PolicyEngine, SchemaValidationError, SchemaValidator, Tracing, buildEvidence, createLogger, expandToolDescriptorsToRegistryNames, isNpmToolDescriptor, loadToolConfig, normalizeToolList, parseNpmToolDescriptor, resolveNpmToolDescriptor, resolveToolDescriptor, sanitizeForLog, summarizeForLog } from './chunk-YMCAX4O6.js';
+import { DEFAULT_OUTPUT_SCHEMA, DEFAULT_INPUT_SCHEMA } from './chunk-5SWSNVMI.js';
+export { DEFAULT_INPUT_SCHEMA, DEFAULT_OUTPUT_SCHEMA, createToolSpec } from './chunk-5SWSNVMI.js';
+export { ToolRegistry, createTaggedError, isRetryable, withRetry } from './chunk-AE6FSNGY.js';
+import './chunk-FR2CXERF.js';
+import { join, dirname, basename } from 'path';
+import { execSync } from 'child_process';
+import { mkdirSync, readdirSync, existsSync, rmSync, renameSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { pathToFileURL } from 'url';
 
-// 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({
-      allErrors: true,
-      coerceTypes: true,
-      useDefaults: true,
-      removeAdditional: "failing",
-      strict: false
-    });
-    addFormats(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 = 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 = circuitBreaker(handleAll, {
-        breaker: new 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 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: v4(),
-      traceId: options.traceId ?? 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(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(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 = join(dirPath, manifest.entryPoint ?? "mcp.json");
-  let raw;
-  try {
-    raw = await readFile(mcpPath, "utf-8");
-  } catch (err) {
-    throw new DiscoveryError(
-      dirPath,
-      "load",
-      `Failed to read MCP config: ${mcpPath}`,
-      err
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    throw new DiscoveryError(
-      dirPath,
-      "load",
-      `Invalid JSON in ${mcpPath}`,
-      err
-    );
-  }
-  const baseName = manifest.name?.split("/").pop();
-  const config = extractMCPConfig(parsed, baseName);
-  if (!config.command && !config.url) {
-    throw new DiscoveryError(
-      dirPath,
-      "validate",
-      `mcp.json must have either "command" or "url" field`
-    );
-  }
-  return { manifest, dirPath, mcpConfig: config };
-}
-var DEFAULT_EXTENSIONS = [".js", ".mjs"];
-async function resolveEntryPoint(dirPath, baseName, extensions = DEFAULT_EXTENSIONS) {
-  if (extensions.some((ext) => baseName.endsWith(ext))) {
-    const fullPath = join(dirPath, baseName);
-    await stat(fullPath);
-    return fullPath;
-  }
-  for (const ext of extensions) {
-    const fullPath = join(dirPath, `${baseName}${ext}`);
-    try {
-      await stat(fullPath);
-      return fullPath;
-    } catch {
-    }
-  }
-  throw new Error(
-    `Could not find entry point in ${dirPath}. Tried: ${extensions.map((e) => baseName + e).join(", ")}`
-  );
-}
-
-// src/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 DiscoveryError(
-      dirPath,
-      "load",
-      `Cannot find LangChain entry point`,
-      err
-    );
-  }
-  let mod;
-  try {
-    mod = await import(pathToFileURL(entryFile).href);
-  } catch (err) {
-    throw new DiscoveryError(
-      dirPath,
-      "load",
-      `Failed to import ${entryFile}`,
-      err
-    );
-  }
-  const tool = mod.default ?? mod.tool ?? mod;
-  if (!tool || typeof tool.invoke !== "function") {
-    throw new DiscoveryError(
-      dirPath,
-      "validate",
-      `Entry point must export an object with invoke() method (LangChainToolLike)`
-    );
-  }
-  return { manifest, dirPath, impl: tool };
-}
-var DEFAULT_EXTENSIONS2 = [".js", ".mjs"];
-async function listSkillProgramFiles(dirPath, extensions = DEFAULT_EXTENSIONS2) {
-  let entries;
-  try {
-    const dirEntries = await readdir(dirPath, { withFileTypes: true });
-    entries = dirEntries.map((entry) => ({
-      name: entry.name,
-      isFile: entry.isFile()
-    }));
-  } catch {
-    return [];
-  }
-  return entries.filter((e) => e.isFile).map((e) => e.name).filter((name) => {
-    if (name.startsWith(".") || name.startsWith("_")) return false;
-    if (name.includes(".test.") || name.includes(".spec.")) return false;
-    return extensions.some((ext) => name.endsWith(ext));
-  }).sort((a, b) => {
-    if (a === "handler.js" || a === "index.js") return -1;
-    if (b === "handler.js" || b === "index.js") return 1;
-    return a.localeCompare(b);
-  });
-}
-function isLangChainLikeTool(val) {
-  return val != null && typeof val === "object" && "invoke" in val && typeof val.invoke === "function";
-}
-function isConstructable(val) {
-  return typeof val === "function" && typeof val.prototype === "object";
-}
-async function loadOneSkillProgram(dirPath, manifest, entryFile, skillDef, programKey, extensions) {
-  let impl;
-  try {
-    const fullPath = await resolveEntryPoint(dirPath, entryFile, extensions ?? [".js", ".mjs"]);
-    const mod = await import(pathToFileURL(fullPath).href);
-    const fn = mod.default ?? mod.handler ?? mod.Tool;
-    if (isLangChainLikeTool(fn)) {
-      impl = fn;
-    } else if (isConstructable(fn)) {
-      const instance = new fn();
-      if (isLangChainLikeTool(instance)) impl = instance;
-    } else if (typeof fn === "function") {
-      impl = fn;
-    }
-  } catch {
-  }
-  return {
-    manifest,
-    dirPath,
-    impl,
-    skillDefinition: skillDef,
-    programKey
-  };
-}
-async function loadSkillTools(dirPath, manifest, extensions) {
-  let skillDef;
-  try {
-    skillDef = await loadSkillDefinition(dirPath);
-  } catch (err) {
-    throw new DiscoveryError(
-      dirPath,
-      "load",
-      `Failed to parse SKILL.md: ${err.message}`,
-      err
-    );
-  }
-  const programs = manifest.programs;
-  if (programs && typeof programs === "object" && Object.keys(programs).length > 0) {
-    const result = [];
-    for (const [programKey, entryFile2] of Object.entries(programs)) {
-      const loaded2 = await loadOneSkillProgram(
-        dirPath,
-        manifest,
-        entryFile2,
-        skillDef,
-        programKey,
-        extensions
-      );
-      result.push(loaded2);
-    }
-    return result;
-  }
-  const exts = extensions ?? DEFAULT_EXTENSIONS2;
-  const files = await listSkillProgramFiles(dirPath, exts);
-  if (files.length >= 2) {
-    const result = [];
-    for (let i = 0; i < files.length; i++) {
-      const file = files[i];
-      const programKey = i === 0 ? "default" : file.replace(/\.[^.]+$/, "");
-      const loaded2 = await loadOneSkillProgram(
-        dirPath,
-        manifest,
-        file,
-        skillDef,
-        programKey,
-        extensions
-      );
-      result.push(loaded2);
-    }
-    return result;
-  }
-  const entryFile = manifest.entryPoint ?? files[0] ?? "handler";
-  const loaded = await loadOneSkillProgram(
-    dirPath,
-    manifest,
-    entryFile,
-    skillDef,
-    void 0,
-    extensions
-  );
-  return [loaded];
-}
-
-// 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 readdir(dirPath, { withFileTypes: true });
-      dirEntries = entries.map((entry) => ({
-        name: entry.name,
-        isDirectory: entry.isDirectory()
-      }));
-    } catch (error) {
-      this.onError?.(dirPath, error);
-      return specs;
-    }
-    const dirName = basename(dirPath);
-    try {
-      const loadedSpecs = await this.loadToolDir(dirPath, dirName, namespace);
-      if (loadedSpecs.length > 0) {
-        specs.push(...loadedSpecs);
-      }
-    } catch (error) {
-      this.onError?.(dirPath, error);
-    }
-    for (const entry of dirEntries) {
-      if (!entry.isDirectory) {
-        continue;
-      }
-      const childPath = join(dirPath, entry.name);
-      try {
-        const childSpecs = await this.scanRecursive(childPath, namespace);
-        specs.push(...childSpecs);
-      } catch (error) {
-        this.onError?.(childPath, error);
-      }
-    }
-    return specs;
-  }
-  async loadToolDir(dirPath, dirName, namespace) {
-    const manifestPath = join(dirPath, "tool.json");
-    let manifestRaw;
-    try {
-      manifestRaw = await readFile(manifestPath, "utf-8");
-    } catch {
-      const inferred = await this.inferManifest(dirPath, dirName);
-      if (!inferred) {
-        return [];
-      }
-      if (inferred.kind === "langchain") {
-        if (inferred.entryPoint) {
-          const loaded3 = await loadLangChainTool(dirPath, inferred, this.extensions);
-          return [this.toToolSpec(loaded3, dirName, dirPath, namespace)];
-        }
-        return 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 DiscoveryError(
-        dirPath,
-        "manifest",
-        "Invalid JSON in tool.json",
-        err
-      );
-    }
-    if (!manifest.kind) {
-      throw new DiscoveryError(
-        dirPath,
-        "manifest",
-        `tool.json must have a "kind" field`
-      );
-    }
-    if (manifest.enabled === false) {
-      return [];
-    }
-    if (manifest.kind === "langchain") {
-      if (manifest.entryPoint) {
-        const loaded2 = await loadLangChainTool(dirPath, manifest, this.extensions);
-        return [this.toToolSpec(loaded2, dirName, dirPath, namespace)];
-      }
-      return 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(join(dirPath, "SKILL.md"));
-    const hasN8n = await this.fileExists(join(dirPath, "workflow.json"));
-    const hasMcp = await this.fileExists(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 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 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 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 DiscoveryError(dirPath, "load", "No skill programs loaded", new Error("empty"));
-        }
-        return list[0];
-      }
-      case "n8n":
-        return loadN8nTool(dirPath, manifest);
-      default:
-        throw new 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 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 = 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 DiscoveryError && err.phase === "validate") {
-          if (strict) {
-            throw err;
-          }
-          continue;
-        }
-        this.onError?.(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 = basename(join(dirPath, ".."));
-    const isKindDir = kindDirNames.has(dirName);
-    const defaultDirName = isKindDir ? parentName : dirName;
-    const inferredName = isKindDir ? `${namespace}/${defaultDirName}-${dirName}` : `${namespace}/${defaultDirName}`;
-    const name = manifest.name ?? inferredName;
-    const spec = this.buildBaseSpec(manifest, name, dirName);
-    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
+// src/tools/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);
@@ -2307,7 +26,7 @@ var MCPClientAdapter = class {
   constructor(client) {
     this.client = client;
   }
-  kind = "mcp";
+  kind = MCP_KIND;
   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 });
@@ -2321,7 +40,7 @@ var MCPClientAdapter = class {
   }
 };
 
-// src/mcp/connectMCP.ts
+// src/tools/mcp/connectMCP.ts
 async function connectMCP(connectionInfo) {
   if (connectionInfo.type !== "stdio" || !connectionInfo.command) {
     throw new Error(
@@ -2348,19 +67,48 @@ function mcpToolsToSpecs(tools) {
   return tools.map((t) => ({
     name: t.name,
     version: "1.0.0",
-    kind: "mcp",
+    kind: MCP_KIND,
     description: t.description ?? `MCP tool: ${t.name}`,
     inputSchema: t.inputSchema ?? DEFAULT_INPUT_SCHEMA,
     outputSchema: DEFAULT_OUTPUT_SCHEMA,
     capabilities: []
   }));
 }
+
+// src/tools/mcp/MCPProcessManager.ts
+var MCPProcessManager = class {
+  connections = /* @__PURE__ */ new Map();
+  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(toolName) {
+    return this.connections.delete(toolName);
+  }
+  getToolNames() {
+    return [...this.connections.keys()];
+  }
+  dispose() {
+    this.connections.clear();
+  }
+};
+
+// src/tools/mcp/registerMCPTools.ts
 async function registerMCPToolsFromConfig(runtime, registry, options = {}) {
   const configPath = options.configPath ?? process.env.MCP_CONFIG_PATH ?? join(process.cwd(), "mcp.json");
   const dirPath = dirname(configPath);
   const entryPoint = basename(configPath);
-  const toolName = options.toolName ?? "mcp";
-  const loaded = await loadMCPTool(dirPath, { kind: "mcp", name: toolName, entryPoint });
+  const toolName = options.toolName ?? MCP_KIND;
+  const loaded = await loadMCPTool(dirPath, { kind: MCP_KIND, name: toolName, entryPoint });
   if (!loaded.mcpConfig) {
     throw new Error("mcp.json must have command or url");
   }
@@ -2373,406 +121,94 @@ async function registerMCPToolsFromConfig(runtime, registry, options = {}) {
   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 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 = resolve(configPath);
-  const raw = readFileSync(abs, "utf8");
-  const parsed = yaml.load(raw);
-  if (!parsed || typeof parsed !== "object") return {};
-  return parsed;
+var DEFAULT_CACHE_BASE = join(homedir(), ".agent", "cache");
+function packagePathSegments(name) {
+  const withoutScope = name.replace(/^@/, "");
+  return withoutScope.split("/").filter(Boolean);
 }
-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 = registerCoreTools(registry, coreConfig);
-  const exampleConfig = { sandboxRoot, allowedHosts };
-  const exampleAdapter = registerExampleTools(registry, exampleConfig);
-  const runtime = new PTCRuntime({ registry });
-  runtime.registerAdapter(coreAdapter);
-  runtime.registerAdapter(exampleAdapter);
-  return { runtime, coreAdapter, exampleAdapter };
+function resolveCacheDir(cacheBase, packageName, version) {
+  const segments = packagePathSegments(packageName);
+  return join(cacheBase, ...segments, version);
 }
-async function runAgent(configPath, task, options) {
-  const config = loadAgentConfig(configPath);
-  const llmSection = config.llm ?? null;
-  const registry = 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 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 dirname(fileURLToPath(import.meta.url));
-}
-var DEFAULT_REPORT_TEMPLATE_PATH = (() => {
-  const dir = getReportTemplateDir();
-  const nextToModule = join(dir, "agent-report-template.html");
-  if (existsSync(nextToModule)) return nextToModule;
-  return join(dir, "report", "agent-report-template.html");
-})();
-function generateAgentReport(data, options) {
-  const templatePath = options.templatePath ?? DEFAULT_REPORT_TEMPLATE_PATH;
-  const template = readFileSync(templatePath, "utf8");
-  let json = JSON.stringify(data);
-  json = json.replace(/<\/script/gi, "<\\/script");
-  const html = template.replace(PLACEHOLDER, json);
-  const outPath = resolve(options.outputPath);
-  writeFileSync(outPath, html, "utf8");
-  return outPath;
+function getVersionFromTarball(tgzName) {
+  const base = tgzName.replace(/\.tgz$/i, "");
+  const match = base.match(/-(\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?)$/);
+  return match ? match[1] : base;
 }
-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}`;
+function ensurePackageInCache(packageName, version = "latest", options = {}) {
+  const cacheBase = options.cacheBase ?? DEFAULT_CACHE_BASE;
+  const packDest = join(cacheBase, ".pack-tmp", packageName.replace(/@/g, "").replace(/\//g, "_"));
+  mkdirSync(packDest, { recursive: true });
+  try {
+    execSync(`npm pack ${packageName}@${version} --pack-destination "${packDest}"`, {
+      cwd: process.cwd(),
+      stdio: "pipe",
+      encoding: "utf-8"
     });
-    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;
+    const files = readdirSync(packDest);
+    const tgz = files.find((f) => f.endsWith(".tgz"));
+    if (!tgz) {
+      throw new Error(`npm pack did not produce a .tgz in ${packDest}`);
+    }
+    const resolvedVersion = getVersionFromTarball(tgz);
+    const cacheDir = resolveCacheDir(cacheBase, packageName, resolvedVersion);
+    const packageJsonPath = join(cacheDir, "package.json");
+    const nodeModulesPath = join(cacheDir, "node_modules");
+    if (existsSync(packageJsonPath) && existsSync(nodeModulesPath)) {
+      options.afterInstall?.(cacheDir, packageName);
+      rmSync(packDest, { recursive: true, force: true });
+      return cacheDir;
+    }
+    const extractDir = join(packDest, "extract");
+    mkdirSync(extractDir, { recursive: true });
+    execSync(`tar -xzf "${join(packDest, tgz)}" -C "${extractDir}"`, {
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    const extractedPackage = join(extractDir, "package");
+    if (!existsSync(extractedPackage)) {
+      throw new Error(`Extracted tarball did not contain "package" dir in ${extractDir}`);
+    }
+    mkdirSync(join(cacheDir, ".."), { recursive: true });
+    if (existsSync(cacheDir)) {
+      rmSync(cacheDir, { recursive: true, force: true });
+    }
+    renameSync(extractedPackage, cacheDir);
+    execSync("npm install", {
+      cwd: cacheDir,
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    options.afterInstall?.(cacheDir, packageName);
+    return cacheDir;
+  } finally {
+    if (existsSync(packDest)) {
+      rmSync(packDest, { recursive: true, force: true });
     }
   }
-  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 = resolve(options.reportPath);
-    if (existsSync(reportPath)) {
-      reportMarkdown = readFileSync(reportPath, "utf8");
-    }
+function getPackageEntryPath(packageRoot) {
+  const pkgPath = join(packageRoot, "package.json");
+  if (!existsSync(pkgPath)) {
+    throw new Error(`No package.json in ${packageRoot}`);
   }
-  let htmlPath;
-  if (options.htmlReportPath) {
-    htmlPath = generateAgentReport(
-      {
-        systemPrompt: options.systemPrompt,
-        userPrompt: options.userPrompt,
-        reportMarkdown,
-        steps
-      },
-      {
-        outputPath: options.htmlReportPath,
-        templatePath: options.templatePath
-      }
-    );
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const main = pkg.main ?? "dist/index.js";
+  const entry = join(packageRoot, main);
+  if (!existsSync(entry)) {
+    throw new Error(`Entry not found: ${entry}`);
   }
-  return { steps, reportMarkdown, htmlPath };
+  return entry;
 }
-async function writeReportFromStream(stream, options) {
-  const { steps, lastAiContent } = await collectStreamSteps(stream, { onStep: options.onStep });
-  let reportMarkdown = lastAiContent;
-  if (options.reportPath) {
-    const reportPath = resolve(options.reportPath);
-    if (existsSync(reportPath)) {
-      reportMarkdown = 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 importFromCache(packageRoot) {
+  const entryPath = getPackageEntryPath(packageRoot);
+  const fileUrl = pathToFileURL(entryPath).href;
+  return import(
+    /* @vite-ignore */
+    fileUrl
+  );
 }
 
-export { BudgetManager, DirectoryScanner, EventLog, LangChainToolsHub, MCPClientAdapter, MCPProcessManager, Metrics, PTCRuntime, PolicyDeniedError, PolicyEngine, SchemaValidationError, SchemaValidator, ToolRegistry, Tracing, buildEvidence, collectStreamSteps, connectMCP, createAgentLLMAdapter, createLogger, createTaggedError, formatStepProgress, generateAgentReport, isNpmToolDescriptor, isRetryable, loadAgentConfig, loadMCPTool, mcpToolsToSpecs, normalizeToolList, parseNpmToolDescriptor, registerMCPToolsFromConfig, resolveNpmToolDescriptor, resolveToolDescriptor, runAgent, runAgentWithReport, sanitizeForLog, serializeStepOutput, summarizeForLog, withRetry, writeReportFromStream };
+export { MCPClientAdapter, MCPProcessManager, connectMCP, ensurePackageInCache, getPackageEntryPath, importFromCache, mcpToolsToSpecs, registerMCPToolsFromConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map