@wrongstack/core 0.310.1 → 0.313.1

package/dist/registry/index.js

@@ -1,825 +1,12 @@
-// src/registry/provider-registry.ts
-var ProviderRegistry = class {
-  factories = /* @__PURE__ */ new Map();
-  /**
-   * Register a provider factory. If a factory with the same type already
-   * exists, it is replaced. Use this for both initial registration and
-   * runtime overrides (e.g. from plugins or CLI flags).
-   */
-  register(f) {
-    this.factories.set(f.type, f);
-  }
-  /**
-   * Bulk-register multiple provider factories at once.
-   */
-  registerAll(factories) {
-    for (const f of factories) this.register(f);
-  }
-  /**
-   * Override an existing factory. Throws if no factory is registered
-   * for the given type. Use this to safely replace a provider at runtime
-   * (e.g. in tests or when a plugin provides a custom implementation).
-   */
-  override(type, f) {
-    if (!this.factories.has(type)) {
-      throw new Error(`Provider type "${type}" not registered; cannot override`);
-    }
-    this.factories.set(type, f);
-  }
-  has(type) {
-    return this.factories.has(type);
-  }
-  /**
-   * Unregister a provider factory by type. Returns true if a factory was
-   * removed, false if none was registered for that type.
-   */
-  unregister(type) {
-    return this.factories.delete(type);
-  }
-  create(cfg, factoryType = cfg.type) {
-    const f = this.factories.get(factoryType);
-    if (!f) {
-      throw new Error(
-        `Provider type "${factoryType}" not registered. Available: ${Array.from(this.factories.keys()).join(", ")}`
-      );
-    }
-    return f.create(cfg);
-  }
-  list() {
-    return Array.from(this.factories.keys());
-  }
-};
-
-// src/utils/error.ts
-function toErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-
-// src/registry/slash-command-registry.ts
-var SlashCommandRegistry = class {
-  cmds = /* @__PURE__ */ new Map();
-  /**
-   * Register a command.
-   *
-   * Trust tiers, by `owner` and `opts.official`:
-   *
-   *  - **Built-ins** (`owner === 'core'`) and **official plugins**
-   *    (`opts.official === true`, set by the host only for first-party plugins
-   *    loaded from the built-in factory list) claim the **bare** command name
-   *    (`/prompts`). They may override one another — last write wins — so an
-   *    official plugin can replace a built-in. Official plugins are *also*
-   *    reachable under their `owner:name` namespace.
-   *  - **External plugins** (any other `owner`) are isolated under the
-   *    `owner:name` namespace: invocable only as `/owner:cmd`, never by bare
-   *    name, and unable to shadow or override a built-in or official command.
-   *
-   * Officiality is supplied by the host based on the plugin's load source, not
-   * self-declared by the plugin — an external plugin cannot name itself into
-   * the official tier.
-   */
-  register(cmd, owner = "core", opts) {
-    const isPlugin = owner !== "core";
-    const official = !isPlugin || opts?.official === true;
-    if (official) {
-      const existing = this.cmds.get(cmd.name);
-      if (existing) {
-        const existingIsOfficialPlugin = existing.official && existing.owner !== "core";
-        if (!isPlugin && existingIsOfficialPlugin) {
-          return;
-        }
-        if (!isPlugin && existing.owner === "core") return;
-      }
-      this.cmds.set(cmd.name, { cmd, owner, official });
-      for (const a of cmd.aliases ?? []) {
-        this.cmds.set(a, { cmd, owner, official });
-      }
-    }
-    if (isPlugin) {
-      this.cmds.set(`${owner}:${cmd.name}`, { cmd, owner, official });
-      for (const a of cmd.aliases ?? []) {
-        this.cmds.set(`${owner}:${a}`, { cmd, owner, official });
-      }
-    }
-  }
-  unregister(name) {
-    const entry = this.cmds.get(name);
-    if (!entry) return false;
-    for (const [key, e] of this.cmds.entries()) {
-      if (e.cmd === entry.cmd) this.cmds.delete(key);
-    }
-    return true;
-  }
-  /**
-   * Bulk-register multiple slash commands at once.
-   */
-  registerAll(cmds, owner = "core") {
-    for (const cmd of cmds) this.register(cmd, owner);
-  }
-  get(name) {
-    return this.cmds.get(name)?.cmd;
-  }
-  ownerOf(name) {
-    return this.cmds.get(name)?.owner;
-  }
-  list() {
-    const seen = /* @__PURE__ */ new Set();
-    const out = [];
-    for (const { cmd } of this.cmds.values()) {
-      if (!seen.has(cmd)) {
-        seen.add(cmd);
-        out.push(cmd);
-      }
-    }
-    return out;
-  }
-  listWithOwner() {
-    const seen = /* @__PURE__ */ new Set();
-    const out = [];
-    for (const [fullName, { cmd, owner }] of this.cmds.entries()) {
-      if (!seen.has(cmd)) {
-        seen.add(cmd);
-        out.push({ cmd, owner, fullName });
-      }
-    }
-    return out;
-  }
-  /**
-   * Parse a slash command line. Accepts both:
-   *   `/cmd args`          → builtin command (owner=core)
-   *   `/pluginName:cmd args` → plugin command
-   * The command name is split at the first `:` if the prefix matches a known owner.
-   */
-  async dispatch(line, ctx) {
-    if (!line.startsWith("/")) return null;
-    const trimmed = line.slice(1);
-    const spaceIdx = trimmed.indexOf(" ");
-    const firstColonIdx = trimmed.indexOf(":");
-    let name;
-    let args;
-    if (firstColonIdx !== -1 && (spaceIdx === -1 || firstColonIdx < spaceIdx)) {
-      const prefix = trimmed.slice(0, firstColonIdx);
-      name = trimmed.slice(0, spaceIdx === -1 ? void 0 : spaceIdx);
-      args = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1);
-      const entry2 = this.cmds.get(name);
-      if (!entry2 || entry2.owner !== prefix) {
-        name = trimmed.slice(0, spaceIdx === -1 ? void 0 : spaceIdx);
-        args = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1);
-      }
-    } else {
-      name = trimmed.slice(0, spaceIdx === -1 ? void 0 : spaceIdx);
-      args = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1);
-    }
-    const entry = this.cmds.get(name);
-    if (!entry) {
-      return { message: `Unknown command "/${name}". Type /help for a list.` };
-    }
-    try {
-      const res = await entry.cmd.run(args, ctx);
-      return res ?? {};
-    } catch (err) {
-      const msg = toErrorMessage(err);
-      return { message: `Command "/${name}" failed: ${msg}` };
-    }
-  }
-};
-
-// src/types/errors.ts
-var ERROR_CODES = {
-  // Provider
-  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
-  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
-  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
-  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
-  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
-  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
-  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
-  // Tool
-  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
-  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
-  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
-  TOOL_TIMEOUT: "TOOL_TIMEOUT",
-  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
-  // Config
-  CONFIG_INVALID: "CONFIG_INVALID",
-  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
-  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
-  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
-  // Plugin
-  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
-  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
-  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
-  // Agent
-  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
-  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
-  AGENT_ABORTED: "AGENT_ABORTED",
-  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
-  // Session
-  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
-  SESSION_CORRUPTED: "SESSION_CORRUPTED",
-  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
-  // Container / Registry
-  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
-  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
-  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
-  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
-  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
-  REGISTRY_INVALID: "REGISTRY_INVALID",
-  // File system
-  FS_READ_FAILED: "FS_READ_FAILED",
-  FS_WRITE_FAILED: "FS_WRITE_FAILED",
-  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
-  FS_DELETE_FAILED: "FS_DELETE_FAILED",
-  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
-  // SDD (Spec-Driven Development)
-  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
-  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
-  SDD_INVALID_STATE: "SDD_INVALID_STATE",
-  SDD_NOT_READY: "SDD_NOT_READY",
-  // General
-  VALIDATION_ERROR: "VALIDATION_ERROR",
-  PARSE_FAILED: "PARSE_FAILED",
-  UNKNOWN: "UNKNOWN"
-};
-var WrongStackError = class extends Error {
-  code;
-  subsystem;
-  severity;
-  recoverable;
-  context;
-  constructor(opts) {
-    super(opts.message, { cause: opts.cause });
-    this.name = "WrongStackError";
-    this.code = opts.code;
-    this.subsystem = opts.subsystem;
-    this.severity = opts.severity ?? "error";
-    this.recoverable = opts.recoverable ?? false;
-    this.context = opts.context;
-  }
-  /**
-   * Render a one-line user-facing description.
-   * Subclasses should override for domain-specific formatting.
-   */
-  describe() {
-    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
-    return `${this.code}: ${this.message}${ctx}`;
-  }
-};
-function formatContext(ctx) {
-  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
-  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
-}
-
-// src/utils/tool-wire-compact.ts
-var TOOL_DESCRIPTION_MAX_CHARS = 400;
-var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
-var compactCache = /* @__PURE__ */ new WeakMap();
-function compactToolDefinitionForWire(tool, opts = {}) {
-  const useDefaultOptions = opts.descriptionMaxChars === void 0 && opts.schemaDescriptionMaxChars === void 0;
-  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
-    const cached = compactCache.get(tool);
-    if (cached) return cached;
-  }
-  const compact = {
-    name: tool.name,
-    description: compactDescription(
-      tool.description ?? "",
-      opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
-    ),
-    inputSchema: normalizeTopLevelToolSchema(
-      compactSchemaDescriptions(
-        tool.inputSchema,
-        opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
-      )
-    )
-  };
-  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
-    compactCache.set(tool, compact);
-  }
-  return compact;
-}
-function normalizeTopLevelToolSchema(schema) {
-  const combinators = ["oneOf", "anyOf", "allOf"].map((keyword) => ({ keyword, branches: schema[keyword] })).filter(
-    (entry) => Array.isArray(entry.branches)
-  );
-  if (combinators.length === 0) return schema;
-  const out = { ...schema, type: "object" };
-  delete out["oneOf"];
-  delete out["anyOf"];
-  delete out["allOf"];
-  const properties = isRecord(schema["properties"]) ? { ...schema["properties"] } : {};
-  let required = stringSet(schema["required"]);
-  for (const { keyword, branches } of combinators) {
-    const objectBranches = branches.filter(isRecord);
-    for (const branch of objectBranches) {
-      if (isRecord(branch["properties"])) Object.assign(properties, branch["properties"]);
-    }
-    const branchRequired = objectBranches.map((branch) => stringSet(branch["required"]));
-    if (keyword === "allOf") {
-      for (const fields of branchRequired) for (const field of fields) required.add(field);
-    } else if (branchRequired.length > 0) {
-      const common = new Set(
-        [...branchRequired[0]].filter(
-          (field) => branchRequired.slice(1).every((fields) => fields.has(field))
-        )
-      );
-      required = /* @__PURE__ */ new Set([...required, ...common]);
-    }
-  }
-  out["properties"] = properties;
-  if (required.size > 0) out["required"] = [...required];
-  else delete out["required"];
-  return out;
-}
-function stringSet(value) {
-  return new Set(
-    Array.isArray(value) ? value.filter((item) => typeof item === "string") : []
-  );
-}
-function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
-  const compact = compactSchemaNode(schema, maxDescriptionChars);
-  return isRecord(compact) ? compact : { type: "object", properties: {} };
-}
-function compactSchemaNode(node, maxDescriptionChars) {
-  if (Array.isArray(node)) {
-    return node.map((item) => compactSchemaNode(item, maxDescriptionChars));
-  }
-  if (!isRecord(node)) return node;
-  const out = {};
-  for (const [key, value] of Object.entries(node)) {
-    if (key === "description" && typeof value === "string") {
-      out[key] = compactDescription(value, maxDescriptionChars);
-    } else {
-      out[key] = compactSchemaNode(value, maxDescriptionChars);
-    }
-  }
-  return out;
-}
-function compactDescription(text, maxChars) {
-  const normalized = text.replace(/\s+/g, " ").trim();
-  if (normalized.length <= maxChars) return normalized;
-  if (maxChars <= 20) return normalized.slice(0, maxChars);
-  const hardLimit = maxChars - 12;
-  const boundary = findSemanticBoundary(normalized, hardLimit);
-  const head = normalized.slice(0, boundary > 0 ? boundary : hardLimit).trimEnd();
-  return `${head} ...`;
-}
-function findSemanticBoundary(text, limit) {
-  const punctuation = Math.max(
-    text.lastIndexOf(". ", limit),
-    text.lastIndexOf("; ", limit),
-    text.lastIndexOf(": ", limit)
-  );
-  if (punctuation >= Math.floor(limit * 0.45)) return punctuation + 1;
-  const comma = text.lastIndexOf(", ", limit);
-  if (comma >= Math.floor(limit * 0.6)) return comma + 1;
-  const space = text.lastIndexOf(" ", limit);
-  return space >= Math.floor(limit * 0.6) ? space : limit;
-}
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-// src/utils/token-estimate.ts
-var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
-function estimateToolDefTokens(tool) {
-  const cached = tool._estDefTokens;
-  if (typeof cached === "number" && cached > 0) return cached;
-  const compact = compactToolDefinitionForWire(tool);
-  return RoughTokenEstimate(tool.name) + RoughTokenEstimate(compact.description) + RoughTokenEstimate(JSON.stringify(compact.inputSchema));
-}
-
-// src/utils/tool-description-mode.ts
-var ORIGINAL_TOOL_DESCRIPTION = /* @__PURE__ */ Symbol.for("wrongstack.tool.originalDescription");
-function normalizeToolDescriptionMode(value) {
-  if (typeof value !== "string") return void 0;
-  const raw = value.trim().toLowerCase();
-  if (raw === "extend" || raw === "extended" || raw === "full") return "extend";
-  if (raw === "simple" || raw === "short" || raw === "brief") return "simple";
-  return void 0;
-}
-function simplifyToolDescription(text, opts = {}) {
-  const maxSentences = Math.max(1, opts.maxSentences ?? 2);
-  const maxChars = Math.max(40, opts.maxChars ?? 180);
-  const normalized = text.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
-  if (normalized.length <= maxChars) return normalized;
-  const sentences = normalized.match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) ?? [normalized];
-  const selected = [];
-  for (const sentence of sentences) {
-    selected.push(sentence.trim());
-    const candidate = selected.join(" ");
-    if (selected.length >= maxSentences || candidate.length >= maxChars) break;
-  }
-  const summary = selected.join(" ").trim() || normalized;
-  if (summary.length <= maxChars) return summary;
-  const hardLimit = maxChars - 4;
-  const boundary = findWordBoundary(summary, hardLimit);
-  return `${summary.slice(0, boundary > 0 ? boundary : hardLimit).trimEnd()} ...`;
-}
-function applyToolDescriptionModeToTool(tool, mode) {
-  const existingOriginal = getOriginalDescription(tool);
-  if (mode === "extend" && !existingOriginal) return tool;
-  const original = existingOriginal ?? {
-    description: tool.description,
-    usageHint: tool.usageHint
-  };
-  const next = mode === "simple" ? withDescription(tool, {
-    description: simplifyToolDescription(original.description),
-    usageHint: original.usageHint === void 0 ? void 0 : simplifyToolDescription(original.usageHint)
-  }) : withDescription(tool, original);
-  return attachOriginalDescription(next, original);
-}
-function getOriginalDescription(tool) {
-  return tool[ORIGINAL_TOOL_DESCRIPTION];
-}
-function attachOriginalDescription(tool, original) {
-  Object.defineProperty(tool, ORIGINAL_TOOL_DESCRIPTION, {
-    configurable: true,
-    enumerable: false,
-    value: original,
-    writable: true
-  });
-  return tool;
-}
-function withDescription(tool, next) {
-  const copy = {
-    ...tool,
-    description: next.description,
-    usageHint: next.usageHint
-  };
-  if (next.usageHint === void 0) {
-    delete copy.usageHint;
-  }
-  return copy;
-}
-function findWordBoundary(text, limit) {
-  const semantic = Math.max(
-    text.lastIndexOf(". ", limit),
-    text.lastIndexOf("; ", limit),
-    text.lastIndexOf(", ", limit)
-  );
-  if (semantic > 40) return semantic + 1;
-  const space = text.lastIndexOf(" ", limit);
-  return space > 40 ? space : limit;
-}
-
-// src/registry/tool-registry.ts
-var ToolRegistry = class _ToolRegistry {
-  tools = /* @__PURE__ */ new Map();
-  descriptionModes = /* @__PURE__ */ new Map();
-  /**
-   * Set of tool names that are disabled (hidden from list(), get() and all
-   * other public accessors). The underlying tool data stays in `_tools` so
-   * re-enable is a constant-time operation.
-   */
-  _disabled = /* @__PURE__ */ new Set();
-  /** Monotonic version bumped on every registry mutation. */
-  _version = 0;
-  /** Cached `list()` result, frozen after build. Invalidated on _version change. */
-  _listSnapshot;
-  _listSnapshotVersion = -1;
-  /**
-   * Optional direct provider surface. `undefined` preserves the legacy
-   * behaviour (every enabled catalog tool is direct); when set, `list()` still
-   * exposes the complete executable catalog while `listForProvider()` returns
-   * only these names. This keeps lazy tools discoverable by tool_search/tool_use.
-   */
-  _providerToolNames;
-  _providerListSnapshot;
-  _providerListSnapshotVersion = -1;
-  /** Pre-compute tool definition token estimate once at registration time. */
-  _stampDefTokens(tool) {
-    if (tool._estDefTokens === void 0) {
-      tool._estDefTokens = estimateToolDefTokens(tool);
-    }
-  }
-  /** Apply the description mode transform and stamp token estimates. */
-  _prepareForStorage(tool) {
-    const mode = this.descriptionModes.get(tool.name) ?? "extend";
-    return applyToolDescriptionModeToTool(tool, mode);
-  }
-  register(tool, owner = "core") {
-    if (this.tools.has(tool.name)) {
-      throw new WrongStackError({
-        message: `Tool "${tool.name}" already registered`,
-        code: ERROR_CODES.REGISTRY_DUPLICATE,
-        subsystem: "container",
-        context: { tool: tool.name }
-      });
-    }
-    if (!tool.inputSchema || typeof tool.inputSchema !== "object") {
-      throw new WrongStackError({
-        message: `Tool "${tool.name}" has an invalid or missing inputSchema`,
-        code: ERROR_CODES.REGISTRY_INVALID,
-        subsystem: "container",
-        context: { tool: tool.name }
-      });
-    }
-    const stored = this._prepareForStorage(tool);
-    this._stampDefTokens(stored);
-    this.tools.set(tool.name, { tool: stored, owner });
-    this._version++;
-  }
-  /**
-   * Attempt to register a tool. Returns true if successful, false if a tool
-   * with the same name is already registered. Useful in multi-agent or plugin
-   * scenarios where duplicate registration may be intentional.
-   */
-  tryRegister(tool, owner = "core") {
-    if (this.tools.has(tool.name)) return false;
-    if (!tool.inputSchema || typeof tool.inputSchema !== "object") {
-      return false;
-    }
-    const stored = this._prepareForStorage(tool);
-    this._stampDefTokens(stored);
-    this.tools.set(tool.name, { tool: stored, owner });
-    this._version++;
-    return true;
-  }
-  /**
-   * Bulk-register multiple tools at once. Each tool that conflicts with an
-   * existing registration is silently skipped — use `registerAllOrThrow`
-   * if you want it to throw on conflicts.
-   */
-  registerAll(tools, owner = "core") {
-    for (const tool of tools) this.tryRegister(tool, owner);
-  }
-  /**
-   * Bulk-register and throw on the first conflict. Use when you need
-   * strict registration (e.g. at boot time).
-   */
-  registerAllOrThrow(tools, owner = "core") {
-    for (const tool of tools) this.register(tool, owner);
-  }
-  /**
-   * Register a tool as a default. If the tool name is already registered,
-   * this is a no-op — the existing registration (from core or another
-   * plugin) takes precedence. Use `override` to intentionally replace.
-   */
-  registerDefault(tool, owner = "core") {
-    if (this.tools.has(tool.name)) return;
-    const stored = this._prepareForStorage(tool);
-    this._stampDefTokens(stored);
-    this.tools.set(tool.name, { tool: stored, owner });
-    this._version++;
-  }
-  unregister(name) {
-    const deleted = this.tools.delete(name);
-    if (deleted) this._version++;
-    return deleted;
-  }
-  /**
-   * Override an existing tool. Throws if the tool is not already registered.
-   * Plugins use this to replace built-in tools with custom implementations.
-   */
-  override(name, tool, owner = "core") {
-    if (!this.tools.has(name)) {
-      throw new WrongStackError({
-        message: `Tool "${name}" not registered; cannot override`,
-        code: ERROR_CODES.REGISTRY_NOT_FOUND,
-        subsystem: "container",
-        context: { tool: name }
-      });
-    }
-    const stored = this._prepareForStorage(tool);
-    this._stampDefTokens(stored);
-    this.tools.set(name, { tool: stored, owner });
-    this._version++;
-  }
-  /**
-   * Wrap (decorate) an existing tool. The wrapper receives the current
-   * tool and must return a new tool — typically the same tool with a
-   * wrapped `execute` or `executeStream`. Throws if the tool is not
-   * registered.
-   *
-   * Multiple wraps stack: each wrapper gets the output of the previous.
-   *
-   * @example
-   * registry.wrap('bash', (t) => ({ ...t, permission: 'confirm' }));
-   */
-  wrap(name, wrapper, owner = "core") {
-    const entry = this.tools.get(name);
-    if (!entry) {
-      throw new WrongStackError({
-        message: `Tool "${name}" not registered; cannot wrap`,
-        code: ERROR_CODES.REGISTRY_NOT_FOUND,
-        subsystem: "container",
-        context: { tool: name }
-      });
-    }
-    const current = applyToolDescriptionModeToTool(entry.tool, "extend");
-    const wrapped = this._prepareForStorage(wrapper(current));
-    wrapped._estDefTokens = void 0;
-    this._stampDefTokens(wrapped);
-    this.tools.set(name, { tool: wrapped, owner: `${entry.owner}+${owner}` });
-    this._version++;
-  }
-  setDescriptionMode(name, mode) {
-    const normalized = normalizeToolDescriptionMode(mode);
-    if (!normalized) return false;
-    const entry = this.tools.get(name);
-    if (!entry) return false;
-    if (normalized === "extend") {
-      this.descriptionModes.delete(name);
-    } else {
-      this.descriptionModes.set(name, normalized);
-    }
-    const stored = applyToolDescriptionModeToTool(entry.tool, normalized);
-    stored._estDefTokens = void 0;
-    this._stampDefTokens(stored);
-    this.tools.set(name, { ...entry, tool: stored });
-    this._version++;
-    return true;
-  }
-  getDescriptionMode(name) {
-    return this.descriptionModes.get(name) ?? "extend";
-  }
-  applyDescriptionModes(modes = {}) {
-    const missing = [];
-    let applied = 0;
-    for (const [name, rawMode] of Object.entries(modes)) {
-      const mode = normalizeToolDescriptionMode(rawMode);
-      if (!mode) continue;
-      if (this.tools.has(name)) {
-        if (this.setDescriptionMode(name, mode)) applied++;
-      } else {
-        if (mode === "simple") this.descriptionModes.set(name, mode);
-        else this.descriptionModes.delete(name);
-        missing.push(name);
-      }
-    }
-    return { applied, missing };
-  }
-  get(name) {
-    if (this._disabled.has(name)) return void 0;
-    return this.tools.get(name)?.tool;
-  }
-  ownerOf(name) {
-    return this.tools.get(name)?.owner;
-  }
-  // ── Disable / enable ────────────────────────────────────────────
-  /**
-   * Disable a tool by name. The tool is removed from all public accessors
-   * (list(), get(), listByCategory(), listWithOwner()) so it does NOT
-   * appear in the system prompt or provider request. The underlying
-   * registration is preserved in memory — use `enable()` to restore it.
-   *
-   * @returns `true` if the tool was found and disabled; `false` if the
-   *          tool is not registered or is already disabled.
-   */
-  disable(name) {
-    if (!this.tools.has(name) || this._disabled.has(name)) return false;
-    this._disabled.add(name);
-    this._version++;
-    return true;
-  }
-  /**
-   * Re-enable a previously disabled tool. The tool reappears in all
-   * public accessors and will be included in the next system prompt /
-   * provider request.
-   *
-   * @returns `true` if the tool was disabled and is now re-enabled;
-   *          `false` if the tool was not disabled.
-   */
-  enable(name) {
-    if (!this._disabled.has(name)) return false;
-    this._disabled.delete(name);
-    this._version++;
-    return true;
-  }
-  /**
-   * Re-enable ALL currently disabled tools at once. Returns the number
-   * of tools that were re-enabled.
-   */
-  enableAll() {
-    const count = this._disabled.size;
-    if (count === 0) return 0;
-    this._disabled.clear();
-    this._version++;
-    return count;
-  }
-  /**
-   * Check whether a tool is currently disabled.
-   */
-  isDisabled(name) {
-    return this._disabled.has(name);
-  }
-  /**
-   * Apply a list of tool names to disable. Tools not in the registry
-   * are silently ignored so config can reference future tools without
-   * error. Returns the number of tools actually disabled.
-   */
-  applyDisabled(names) {
-    let count = 0;
-    for (const name of names) {
-      if (this.disable(name)) count++;
-    }
-    return count;
-  }
-  /**
-   * Return the list of all disabled tool entries (tool + owner). Useful
-   * for the /tools slash command to show disabled tools alongside
-   * enabled ones.
-   */
-  listDisabled() {
-    return Array.from(this._disabled).map((name) => {
-      const entry = this.tools.get(name);
-      return entry ? { tool: entry.tool, owner: entry.owner } : null;
-    }).filter((e) => e !== null);
-  }
-  list() {
-    if (this._listSnapshot && this._version === this._listSnapshotVersion) {
-      return this._listSnapshot;
-    }
-    const arr = Array.from(this.tools.entries()).filter(([name]) => !this._disabled.has(name)).map(([, entry]) => entry.tool);
-    this._listSnapshot = arr;
-    this._listSnapshotVersion = this._version;
-    return arr;
-  }
-  /** Replace the direct provider surface. Pass `undefined` to expose the catalog. */
-  setProviderToolNames(names) {
-    this._providerToolNames = names ? new Set(names) : void 0;
-    this._version++;
-  }
-  /** Add registered or future tool names to the direct provider surface. */
-  exposeToProvider(names) {
-    if (!this._providerToolNames) return;
-    for (const name of typeof names === "string" ? [names] : names) {
-      this._providerToolNames.add(name);
-    }
-    this._version++;
-  }
-  /** Tools serialized into provider requests and described by the system prompt. */
-  listForProvider() {
-    if (!this._providerToolNames) return this.list();
-    if (this._providerListSnapshot && this._version === this._providerListSnapshotVersion) {
-      return this._providerListSnapshot;
-    }
-    const arr = Array.from(this.tools.entries()).filter(([name]) => !this._disabled.has(name) && this._providerToolNames?.has(name) === true).map(([, entry]) => entry.tool);
-    this._providerListSnapshot = arr;
-    this._providerListSnapshotVersion = this._version;
-    return arr;
-  }
-  /**
-   * Whether an enabled catalog tool is part of the direct provider surface.
-   *
-   * This is intentionally different from `get()`/`list()`: a tool can remain
-   * executable through a lazy gateway while its schema is omitted from the
-   * next provider request. Disabled and unknown tools always return false.
-   */
-  isExposedToProvider(name) {
-    if (this._disabled.has(name) || !this.tools.has(name)) return false;
-    return this._providerToolNames?.has(name) ?? true;
-  }
-  /**
-   * Group tools by their `category` field. Tools without a category
-   * are placed under the key `""` (empty string). Returns a Map of
-   * category → tools, sorted by registration order within each category.
-   */
-  listByCategory() {
-    const map = /* @__PURE__ */ new Map();
-    for (const [name, { tool }] of this.tools) {
-      if (this._disabled.has(name)) continue;
-      const cat = tool.category ?? "";
-      let group = map.get(cat);
-      if (!group) {
-        group = [];
-        map.set(cat, group);
-      }
-      group.push(tool);
-    }
-    return map;
-  }
-  listWithOwner() {
-    return Array.from(this.tools.entries()).filter(([name]) => !this._disabled.has(name)).map(([, entry]) => entry);
-  }
-  clear() {
-    this.tools.clear();
-    this.descriptionModes.clear();
-    this._disabled.clear();
-    this._providerToolNames = void 0;
-    this._version++;
-  }
-  /**
-   * Return a new ToolRegistry with the same registered tools and owners.
-   * Useful for creating filtered copies in multi-agent scenarios.
-   */
-  clone() {
-    const copy = new _ToolRegistry();
-    copy.descriptionModes.clear();
-    for (const [name, mode] of this.descriptionModes) {
-      copy.descriptionModes.set(name, mode);
-    }
-    for (const [name, { tool, owner }] of this.tools) {
-      copy.tools.set(name, { tool, owner });
-    }
-    for (const name of this._disabled) {
-      copy._disabled.add(name);
-    }
-    copy._providerToolNames = this._providerToolNames ? new Set(this._providerToolNames) : void 0;
-    copy._version = this._version;
-    return copy;
-  }
-};
+import {
+  ProviderRegistry,
+  SlashCommandRegistry,
+  ToolRegistry
+} from "../chunk-KI4L2DUL.js";
+import "../chunk-WQTOVMGV.js";
+import "../chunk-FSWCWSTS.js";
+import "../chunk-WOEZV3Q4.js";
+import "../chunk-TBRL2RCC.js";
 export {
   ProviderRegistry,
   SlashCommandRegistry,