@easynet/agent-tool 1.0.0 → 1.0.2

package/dist/chunk-Q7KPGWC6.js

@@ -0,0 +1,1584 @@
+import { ToolRegistry, createTaggedError, withRetry } from './chunk-AE6FSNGY.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 pTimeout from 'p-timeout';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import yaml from 'js-yaml';
+import { registerCoreTools } from '@easynet/agent-tool-builtin-tools';
+import { registerExampleTools } from '@easynet/agent-tool-example-tools';
+
+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/core/runtime/PolicyEngine.ts
+var PolicyEngine = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      requireExplicitDangerPermission: true,
+      deniedSqlPatterns: ["DROP\\s", "TRUNCATE\\s", "DELETE\\s+FROM\\s+\\w+\\s*$"],
+      ...config
+    };
+  }
+  /**
+   * Enforce all policy checks. Throws PolicyDeniedError if denied.
+   */
+  enforce(spec, args, ctx) {
+    const result = this.check(spec, args, ctx);
+    if (!result.allowed) {
+      throw new PolicyDeniedError(
+        result.reason ?? "Policy denied",
+        result.missingCapabilities
+      );
+    }
+  }
+  /**
+   * Check all policies without throwing.
+   */
+  check(spec, args, ctx) {
+    const capResult = this.checkCapabilities(spec, ctx);
+    if (!capResult.allowed) return capResult;
+    const paramResult = this.checkParameters(spec, args);
+    if (!paramResult.allowed) return paramResult;
+    return { allowed: true };
+  }
+  /**
+   * Check that context permissions cover tool capabilities.
+   */
+  checkCapabilities(spec, ctx) {
+    const missing = [];
+    for (const cap of spec.capabilities) {
+      if (cap === "danger:destructive") {
+        if (this.config.requireExplicitDangerPermission && !ctx.permissions.includes("danger:destructive")) {
+          missing.push(cap);
+        }
+      } else if (!ctx.permissions.includes(cap)) {
+        missing.push(cap);
+      }
+    }
+    if (missing.length > 0) {
+      return {
+        allowed: false,
+        reason: `Missing capabilities: ${missing.join(", ")}`,
+        missingCapabilities: missing
+      };
+    }
+    return { allowed: true };
+  }
+  /**
+   * Check parameter-level security constraints.
+   */
+  checkParameters(spec, args) {
+    if (!args || typeof args !== "object") return { allowed: true };
+    const argsObj = args;
+    if (spec.capabilities.includes("write:fs") && this.config.sandboxPaths) {
+      const pathResult = this.checkFilePaths(argsObj);
+      if (!pathResult.allowed) return pathResult;
+    }
+    if (spec.capabilities.includes("network") || spec.capabilities.includes("read:web")) {
+      const urlResult = this.checkUrls(argsObj);
+      if (!urlResult.allowed) return urlResult;
+    }
+    if (spec.capabilities.includes("write:db") || spec.capabilities.includes("read:db")) {
+      const sqlResult = this.checkSql(argsObj);
+      if (!sqlResult.allowed) return sqlResult;
+    }
+    if (spec.capabilities.includes("network") && this.config.allowedDomains) {
+      const domainResult = this.checkDomains(argsObj);
+      if (!domainResult.allowed) return domainResult;
+    }
+    return { allowed: true };
+  }
+  checkFilePaths(args) {
+    const paths = this.extractStringValues(args, ["path", "file", "filepath", "filename", "dir", "directory"]);
+    for (const p of paths) {
+      const normalized = p.replace(/\.\./g, "");
+      if (p.includes("..")) {
+        return {
+          allowed: false,
+          reason: `Path traversal detected: ${p}`
+        };
+      }
+      if (this.config.sandboxPaths && this.config.sandboxPaths.length > 0) {
+        const inSandbox = this.config.sandboxPaths.some(
+          (sp) => normalized.startsWith(sp)
+        );
+        if (!inSandbox) {
+          return {
+            allowed: false,
+            reason: `Path outside sandbox: ${p}. Allowed: ${this.config.sandboxPaths.join(", ")}`
+          };
+        }
+      }
+    }
+    return { allowed: true };
+  }
+  checkUrls(args) {
+    const urls = this.extractStringValues(args, ["url", "endpoint", "href", "uri"]);
+    for (const url of urls) {
+      if (this.config.urlDenylist) {
+        for (const pattern of this.config.urlDenylist) {
+          if (new RegExp(pattern, "i").test(url)) {
+            return {
+              allowed: false,
+              reason: `URL denied by policy: ${url}`
+            };
+          }
+        }
+      }
+      if (this.config.urlAllowlist && this.config.urlAllowlist.length > 0) {
+        const allowed = this.config.urlAllowlist.some(
+          (pattern) => new RegExp(pattern, "i").test(url)
+        );
+        if (!allowed) {
+          return {
+            allowed: false,
+            reason: `URL not in allowlist: ${url}`
+          };
+        }
+      }
+    }
+    return { allowed: true };
+  }
+  checkSql(args) {
+    const sqls = this.extractStringValues(args, ["sql", "query", "statement"]);
+    for (const sql of sqls) {
+      if (this.config.deniedSqlPatterns) {
+        for (const pattern of this.config.deniedSqlPatterns) {
+          if (new RegExp(pattern, "i").test(sql)) {
+            return {
+              allowed: false,
+              reason: `SQL pattern denied: ${sql.slice(0, 50)}...`
+            };
+          }
+        }
+      }
+    }
+    return { allowed: true };
+  }
+  checkDomains(args) {
+    const urls = this.extractStringValues(args, ["url", "endpoint", "href", "host", "domain"]);
+    for (const url of urls) {
+      try {
+        const hostname = url.includes("://") ? new URL(url).hostname : url;
+        if (this.config.allowedDomains && !this.config.allowedDomains.some(
+          (d) => hostname === d || hostname.endsWith(`.${d}`)
+        )) {
+          return {
+            allowed: false,
+            reason: `Domain not allowed: ${hostname}`
+          };
+        }
+      } catch {
+      }
+    }
+    return { allowed: true };
+  }
+  /**
+   * Extract string values from args matching given key patterns.
+   */
+  extractStringValues(args, keyPatterns) {
+    const results = [];
+    const walk = (obj) => {
+      for (const [key, val] of Object.entries(obj)) {
+        const lowerKey = key.toLowerCase();
+        if (typeof val === "string" && keyPatterns.some((p) => lowerKey.includes(p))) {
+          results.push(val);
+        } else if (val && typeof val === "object" && !Array.isArray(val)) {
+          walk(val);
+        }
+      }
+    };
+    walk(args);
+    return results;
+  }
+};
+var PolicyDeniedError = class extends Error {
+  constructor(message, missingCapabilities) {
+    super(message);
+    this.missingCapabilities = missingCapabilities;
+    this.name = "PolicyDeniedError";
+  }
+  kind = "POLICY_DENIED";
+};
+var RateLimiter = class {
+  constructor(maxCalls, windowMs) {
+    this.maxCalls = maxCalls;
+    this.windowMs = windowMs;
+  }
+  timestamps = [];
+  tryAcquire() {
+    const now = Date.now();
+    while (this.timestamps.length > 0 && this.timestamps[0] <= now - this.windowMs) {
+      this.timestamps.shift();
+    }
+    if (this.timestamps.length >= this.maxCalls) {
+      return false;
+    }
+    this.timestamps.push(now);
+    return true;
+  }
+  get remaining() {
+    const now = Date.now();
+    const active = this.timestamps.filter((t) => t > now - this.windowMs);
+    return Math.max(0, this.maxCalls - active.length);
+  }
+};
+var BudgetManager = class {
+  defaultTimeoutMs;
+  bulkheads = /* @__PURE__ */ new Map();
+  circuitBreakers = /* @__PURE__ */ new Map();
+  rateLimiters = /* @__PURE__ */ new Map();
+  options;
+  constructor(options = {}) {
+    this.options = options;
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? 3e4;
+  }
+  /**
+   * Get effective timeout for a tool invocation.
+   */
+  getTimeout(_toolName, contextTimeoutMs) {
+    return contextTimeoutMs ?? this.defaultTimeoutMs;
+  }
+  /**
+   * Check rate limit for a tool. Returns true if allowed.
+   */
+  checkRateLimit(toolName) {
+    if (!this.options.rateLimit) return true;
+    let limiter = this.rateLimiters.get(toolName);
+    if (!limiter) {
+      limiter = new RateLimiter(
+        this.options.rateLimit.maxCalls,
+        this.options.rateLimit.windowMs
+      );
+      this.rateLimiters.set(toolName, limiter);
+    }
+    return limiter.tryAcquire();
+  }
+  /**
+   * Get or create a bulkhead (concurrency limiter) for a tool.
+   */
+  getBulkhead(toolName) {
+    if (!this.options.maxConcurrency) return void 0;
+    let bh = this.bulkheads.get(toolName);
+    if (!bh) {
+      bh = 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/core/runtime/Evidence.ts
+function buildEvidence(options) {
+  const { spec, args, result, ctx, durationMs } = options;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const evidence = [];
+  evidence.push({
+    type: "tool",
+    ref: `${spec.name}@${spec.version}`,
+    summary: summarizeToolCall(spec, args, result, durationMs),
+    createdAt: now
+  });
+  if (result && typeof result === "object") {
+    const urls = extractUrls(result);
+    for (const url of urls) {
+      evidence.push({
+        type: "url",
+        ref: url,
+        summary: `Output URL from ${spec.name}`,
+        createdAt: now
+      });
+    }
+    const files = extractFilePaths(result);
+    for (const file of files) {
+      evidence.push({
+        type: "file",
+        ref: file,
+        summary: `Output file from ${spec.name}`,
+        createdAt: now
+      });
+    }
+  }
+  if (durationMs !== void 0 && durationMs > 0) {
+    evidence.push({
+      type: "metric",
+      ref: `latency:${spec.name}`,
+      summary: `Completed in ${durationMs}ms (request: ${ctx.requestId})`,
+      createdAt: now
+    });
+  }
+  return evidence;
+}
+function summarizeToolCall(spec, args, result, durationMs) {
+  const argKeys = args && typeof args === "object" ? Object.keys(args).join(", ") : "none";
+  const duration = durationMs ? ` in ${durationMs}ms` : "";
+  const resultPreview = summarizeValue(result, 100);
+  return `${spec.kind}:${spec.name} called with [${argKeys}]${duration} \u2192 ${resultPreview}`;
+}
+function summarizeValue(value, maxLen) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "string") {
+    return value.length > maxLen ? value.slice(0, maxLen) + "..." : value;
+  }
+  const str = JSON.stringify(value);
+  return str.length > maxLen ? str.slice(0, maxLen) + "..." : str;
+}
+function extractUrls(obj) {
+  const urls = [];
+  const walk = (val) => {
+    if (typeof val === "string" && /^https?:\/\//i.test(val)) {
+      urls.push(val);
+    } else if (val && typeof val === "object") {
+      for (const v of Object.values(val)) {
+        walk(v);
+      }
+    }
+  };
+  walk(obj);
+  return urls.slice(0, 10);
+}
+function extractFilePaths(obj) {
+  const paths = [];
+  const walk = (val) => {
+    if (typeof val === "string" && (val.startsWith("/") || val.startsWith("./")) && val.includes(".")) {
+      paths.push(val);
+    } else if (val && typeof val === "object") {
+      for (const v of Object.values(val)) {
+        walk(v);
+      }
+    }
+  };
+  walk(obj);
+  return paths.slice(0, 10);
+}
+var EventLog = class {
+  entries = [];
+  seq = 0;
+  maxEntries;
+  emitter = new 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();
+  }
+};
+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/core/runtime/PTCRuntimeObservability.ts
+function emitToolCalled(intent, ctx, deps) {
+  const event = {
+    type: "TOOL_CALLED",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: ctx.requestId,
+    taskId: ctx.taskId,
+    toolName: intent.tool,
+    traceId: ctx.traceId,
+    userId: ctx.userId,
+    argsSummary: sanitizeArgs(intent.args),
+    purpose: intent.purpose,
+    idempotencyKey: intent.idempotencyKey
+  };
+  deps.eventLog.append(event);
+}
+function recordSuccess(spec, durationMs, _evidence, spanId, deps) {
+  deps.metrics.recordInvocation(spec.name, true, durationMs);
+  deps.tracing.setAttributes(spanId, {
+    "tool.duration_ms": durationMs,
+    "tool.ok": true
+  });
+  deps.tracing.endSpan(spanId, "ok");
+}
+function handleError(error, intent, ctx, durationMs, spanId, deps) {
+  const kind = error?.kind ?? "UPSTREAM_ERROR";
+  const message = error instanceof Error ? error.message : String(error);
+  const details = error?.details;
+  deps.metrics.recordInvocation(intent.tool, false, durationMs);
+  deps.tracing.setAttributes(spanId, {
+    "tool.duration_ms": durationMs,
+    "tool.ok": false,
+    "tool.error_kind": kind
+  });
+  deps.tracing.endSpan(spanId, "error");
+  const event = {
+    type: "TOOL_RESULT",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: ctx.requestId,
+    taskId: ctx.taskId,
+    toolName: intent.tool,
+    traceId: ctx.traceId,
+    userId: ctx.userId,
+    ok: false,
+    durationMs,
+    resultSummary: message,
+    evidence: [],
+    error: { kind, message, details }
+  };
+  deps.eventLog.append(event);
+  deps.logger.warn("invoke.error", {
+    tool: intent.tool,
+    requestId: ctx.requestId,
+    taskId: ctx.taskId,
+    traceId: ctx.traceId,
+    kind,
+    message,
+    durationMs,
+    details: deps.logger.options.includeResults ? summarizeForLog(details) : void 0
+  });
+  return {
+    ok: false,
+    evidence: [],
+    error: { kind, message, details }
+  };
+}
+function sanitizeArgs(args) {
+  if (!args) return "{}";
+  return sanitizeForLog(args);
+}
+
+// src/core/runtime/PTCRuntime.ts
+var PTCRuntime = class {
+  registry;
+  adapters = /* @__PURE__ */ new Map();
+  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/tools/util/toolDescriptor.ts
+var TOOL_PATH_REGEX = /^([a-z][a-z0-9-]*):([^/]+)\/([^#]+)(#(.+))?$/;
+function isToolPath(descriptor) {
+  return TOOL_PATH_REGEX.test(descriptor.trim());
+}
+function parseToolPath(descriptor) {
+  const s = descriptor.trim();
+  const m = s.match(TOOL_PATH_REGEX);
+  if (!m || m[1] === void 0 || m[2] === void 0 || m[3] === void 0) return null;
+  return {
+    protocol: m[1],
+    scope: m[2],
+    packageWithVersion: m[3],
+    toolName: m[5] ?? ""
+  };
+}
+function parsePackageVersion(packageWithVersion) {
+  const at = packageWithVersion.lastIndexOf("@");
+  if (at <= 0) return { package: packageWithVersion };
+  const pkg = packageWithVersion.slice(0, at);
+  const version = packageWithVersion.slice(at + 1);
+  if (!version || /^\d/.test(version)) return { package: pkg, version };
+  return { package: packageWithVersion };
+}
+function isNpmToolDescriptor(descriptor) {
+  return isToolPath(descriptor) && parseToolPath(descriptor)?.protocol === "npm";
+}
+function parseNpmToolDescriptor(descriptor) {
+  const parsed = parseToolPath(descriptor);
+  if (!parsed || parsed.protocol !== "npm") return null;
+  return {
+    fullPackage: `${parsed.scope}/${parsed.packageWithVersion}`,
+    toolPath: parsed.toolName
+  };
+}
+var BUILTIN_NPM_PACKAGE = "@easynet/agent-tool-builtin";
+var BUILTIN_REGISTRY_PREFIX = "core/";
+var BUILTIN_DISPLAY_SCOPE_PREFIX = "npm:@easynet/agent-tool-builtin";
+function getDisplayScope(registryName, kind, toolVersion) {
+  if (kind === "core" || registryName.startsWith(BUILTIN_REGISTRY_PREFIX)) {
+    return toolVersion ? `${BUILTIN_DISPLAY_SCOPE_PREFIX}@${toolVersion}` : BUILTIN_DISPLAY_SCOPE_PREFIX;
+  }
+  const i = registryName.indexOf("/");
+  return i < 0 ? registryName : registryName.slice(0, i);
+}
+function resolveNpmToolDescriptor(descriptor) {
+  const parsed = parseToolPath(descriptor);
+  if (!parsed || parsed.protocol !== "npm") return null;
+  const pv = parsePackageVersion(parsed.packageWithVersion);
+  const pkgId = `${parsed.scope}/${pv.package}`;
+  if (pkgId !== BUILTIN_NPM_PACKAGE) return null;
+  if (!parsed.toolName) return null;
+  if (parsed.toolName.includes("*")) return null;
+  return BUILTIN_REGISTRY_PREFIX + parsed.toolName;
+}
+function expandToolDescriptorsToRegistryNames(descriptors, registryNames) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  function add(name) {
+    if (registryNames.includes(name) && !seen.has(name)) {
+      seen.add(name);
+      out.push(name);
+    }
+  }
+  function globMatch(pattern, name) {
+    const re = new RegExp("^" + pattern.replace(/\*/g, "[^.]*").replace(/\./g, "\\.") + "$");
+    return re.test(name);
+  }
+  for (const d of descriptors) {
+    const s = d.trim();
+    if (!s) continue;
+    const parsed = parseToolPath(s);
+    if (parsed && parsed.protocol === "npm") {
+      const pv = parsePackageVersion(parsed.packageWithVersion);
+      const pkgId = `${parsed.scope}/${pv.package}`;
+      if (pkgId === BUILTIN_NPM_PACKAGE) {
+        if (!parsed.toolName) {
+          registryNames.filter((n) => n.startsWith(BUILTIN_REGISTRY_PREFIX)).forEach(add);
+          continue;
+        }
+        if (parsed.toolName.includes("*")) {
+          registryNames.filter((n) => n.startsWith(BUILTIN_REGISTRY_PREFIX) && globMatch(parsed.toolName, n.slice(BUILTIN_REGISTRY_PREFIX.length))).forEach(add);
+          continue;
+        }
+        add(BUILTIN_REGISTRY_PREFIX + parsed.toolName);
+        continue;
+      }
+    }
+    add(s);
+  }
+  return out;
+}
+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 loadToolConfig(toolYamlPath) {
+  const abs = resolve(toolYamlPath);
+  const raw = readFileSync(abs, "utf8");
+  const parsed = yaml.load(raw);
+  if (!parsed || typeof parsed !== "object") return {};
+  return parsed;
+}
+function resolveSandboxedPath(toolYamlPath, sandboxedPath) {
+  const configDir = dirname(resolve(toolYamlPath));
+  return resolve(configDir, sandboxedPath);
+}
+function findAndLoadToolConfig(dir) {
+  const candidates = [join(dir, "tool.yaml"), join(dir, ".tool.yaml")];
+  for (const p of candidates) {
+    if (existsSync(p)) {
+      const config = loadToolConfig(p);
+      return { ...config, configPath: p };
+    }
+  }
+  return {};
+}
+function createRuntimeFromConfigSync(options = {}) {
+  const registry = new ToolRegistry();
+  if (options.coreTools !== void 0) {
+    const coreAdapter = registerCoreTools(registry, options.coreTools);
+    const runtime2 = new PTCRuntime({ registry });
+    runtime2.registerAdapter(coreAdapter);
+    if (options.exampleTools !== void 0) {
+      const exampleAdapter = registerExampleTools(registry, options.exampleTools);
+      runtime2.registerAdapter(exampleAdapter);
+    }
+    return { runtime: runtime2, registry };
+  }
+  if (options.exampleTools !== void 0) {
+    const exampleAdapter = registerExampleTools(registry, options.exampleTools);
+    const runtime2 = new PTCRuntime({ registry });
+    runtime2.registerAdapter(exampleAdapter);
+    return { runtime: runtime2, registry };
+  }
+  const runtime = new PTCRuntime({ registry });
+  return { runtime, registry };
+}
+async function createRuntimeFromConfig(options = {}) {
+  return createRuntimeFromConfigSync(options);
+}
+
+// src/tools/mcp/types.ts
+var MCP_KIND = "mcp";
+
+// src/tools/langchain/types.ts
+var LANGCHAIN_KIND = "langchain";
+var LANGCHAIN_DIR_NAME = "langchain";
+
+export { BudgetManager, EventLog, LANGCHAIN_DIR_NAME, LANGCHAIN_KIND, MCP_KIND, Metrics, PTCRuntime, PolicyDeniedError, PolicyEngine, SchemaValidationError, SchemaValidator, Tracing, buildEvidence, createLogger, createRuntimeFromConfig, createRuntimeFromConfigSync, expandToolDescriptorsToRegistryNames, findAndLoadToolConfig, getDisplayScope, isNpmToolDescriptor, loadToolConfig, normalizeToolList, parseNpmToolDescriptor, resolveNpmToolDescriptor, resolveSandboxedPath, resolveToolDescriptor, sanitizeForLog, summarizeForLog };
+//# sourceMappingURL=chunk-Q7KPGWC6.js.map
+//# sourceMappingURL=chunk-Q7KPGWC6.js.map