@nhtio/adk 0.1.0-master-f0aa531d

package/tool_registry-DqLOyGyG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool_registry-DqLOyGyG.mjs","names":["#value","#cache","#store","#tools"],"sources":["../src/lib/utils/guards.ts","../src/lib/classes/tokenizable.ts","../src/lib/classes/registry.ts","../src/lib/utils/canonical_json.ts","../src/lib/classes/tool_registry.ts"],"sourcesContent":["import { passesSchema } from './validation'\nimport { validator } from '@nhtio/validation'\n\n/**\n * Returns `true` if `value` is an instance of the class identified by `type` (and optionally `ctor`).\n *\n * @remarks\n * Performs three checks in order: `instanceof ctor`, `Symbol.hasInstance`, then constructor-name\n * comparison. The constructor-name fallback handles cross-realm cases where `instanceof` fails.\n *\n * @typeParam T - The expected instance type.\n * @param value - The value to test.\n * @param type - The constructor name to compare against when `instanceof` is unavailable.\n * @param ctor - Optional constructor to use for `instanceof` and `Symbol.hasInstance` checks.\n * @returns `true` when `value` is an instance of the class described by `type`/`ctor`.\n */\nexport const isInstanceOf = <T>(\n  value: unknown,\n  type: string,\n  ctor?: new (...args: any[]) => T\n): value is T => {\n  // eslint-disable-next-line adk/use-is-instance-of -- this IS the implementation of isInstanceOf\n  if ('undefined' !== typeof ctor && value instanceof ctor) return true\n  /* istanbul ignore next 4 */\n  if (\n    'undefined' !== typeof ctor &&\n    typeof ctor[Symbol.hasInstance] === 'function' &&\n    ctor[Symbol.hasInstance](value)\n  )\n    /* istanbul ignore next */\n    return true\n  // eslint-disable-next-line adk/prefer-is-object -- this guard is the building block isObject depends on (no circular usage)\n  if ('object' === typeof value && null !== value) {\n    const valueWithConstructor = value as { constructor?: Function }\n    const constructorName = valueWithConstructor.constructor?.name\n    return constructorName === type\n  }\n  return false\n}\n\nconst errorSchema = validator\n  .any()\n  .custom((value, helpers) => {\n    if (isInstanceOf(value, 'Error', Error)) {\n      return value\n    }\n    return helpers.error('any.invalid')\n  })\n  .required()\n\n/**\n * Returns `true` if `value` is an `Error` instance or satisfies the `Error` duck-type shape.\n *\n * @remarks\n * Returns `false` for `undefined` and `null` — the `Error` contract requires an actual instance.\n *\n * @param value - The value to test.\n * @returns `true` when `value` conforms to the `Error` shape.\n */\nexport const isError = (value: unknown): value is Error => {\n  return passesSchema(errorSchema, value)\n}\n\n/**\n * Type guard to check if a value is a plain object (not null, not array)\n * @param value - The value to check\n * @returns True if the value is a plain object, false otherwise\n */\nexport const isObject = (value: unknown): value is { [key: string]: unknown } => {\n  // eslint-disable-next-line adk/prefer-is-object -- this IS the implementation of isObject\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n","import { getEncoding } from 'js-tiktoken'\nimport { validator } from '@nhtio/validation'\nimport { isInstanceOf } from '../utils/guards'\nimport { LlamaTokenizer } from 'llama-tokenizer-js'\nimport { fromPreTrained as geminiFromPreTrained } from '@lenml/tokenizer-gemini'\nimport type { Tiktoken } from 'js-tiktoken'\n\n/**\n * The set of supported token encoding identifiers.\n *\n * @remarks\n * Each value maps to a specific estimation backend:\n * - `gpt2`, `r50k_base`, `p50k_base`, `p50k_edit`, `cl100k_base`, `o200k_base` — exact counts\n *   via `js-tiktoken` (OpenAI / tiktoken-compatible models).\n * - `gemini` — exact counts via `@lenml/tokenizer-gemini`, which embeds Gemini's actual\n *   SentencePiece vocabulary locally with no API call required.\n * - `llama2` — exact counts via `llama-tokenizer-js` (Llama 1 and 2). Llama 3+ uses a\n *   different vocabulary and should use the `llama3` identifier once a suitable sync backend\n *   is available.\n * - `claude` — heuristic approximation using Anthropic's published ~3.5 chars/token ratio.\n *   No local tokenizer is available for Claude 3+ models; the Anthropic SDK's\n *   `messages.countTokens()` API is the only exact path but requires a network call.\n *\n * When adding a new encoding, add a case to {@link Tokenizable.estimateTokens}.\n */\nexport const TokenEncoding = [\n  'gpt2',\n  'r50k_base',\n  'p50k_base',\n  'p50k_edit',\n  'cl100k_base',\n  'o200k_base',\n  'gemini',\n  'llama2',\n  'claude',\n] as const\n\n/**\n * Union of all recognised token encoding identifier strings.\n *\n * @remarks\n * Derived from {@link TokenEncoding} so the type and the runtime array stay in sync\n * automatically when new encodings are added.\n */\nexport type TokenEncoding = (typeof TokenEncoding)[number]\n\n/**\n * Backing schema for {@link Tokenizable.schema}.\n *\n * @remarks\n * Accepts a plain `string` or an existing {@link Tokenizable} instance. Strings pass through\n * unchanged; {@link Tokenizable} instances are accepted via {@link Tokenizable.isTokenizable}\n * to remain cross-realm safe.\n */\nconst stringOrTokenizableSchema = validator.alternatives(\n  validator.string(),\n  validator.custom((value, helpers) => {\n    if (Tokenizable.isTokenizable(value)) {\n      return value\n    }\n    return helpers.error('any.invalid')\n  })\n)\n\n// Lazily-initialised singletons — tokenizers are expensive to load so we defer\n// until first use and reuse across all Tokenizable instances thereafter.\nlet geminiTokenizerInstance: ReturnType<typeof geminiFromPreTrained> | undefined\nlet llamaTokenizerInstance: InstanceType<typeof LlamaTokenizer> | undefined\n\nconst getGeminiTokenizer = () => {\n  if (!geminiTokenizerInstance) {\n    geminiTokenizerInstance = geminiFromPreTrained()\n  }\n  return geminiTokenizerInstance\n}\n\nconst getLlamaTokenizer = () => {\n  if (!llamaTokenizerInstance) {\n    llamaTokenizerInstance = new LlamaTokenizer()\n  }\n  return llamaTokenizerInstance\n}\n\n/**\n * A mutable string with a built-in token counter.\n *\n * @remarks\n * The wrapped string can be read via the standard coercion protocol and updated at any time via\n * {@link Tokenizable.set}. Token counts are computed lazily on first access per encoding and\n * cached until the value changes, avoiding redundant encoder invocations when the same content\n * is measured multiple times across a pipeline.\n *\n * Estimation is dispatched by encoding identifier — see {@link TokenEncoding} for the full list\n * of supported backends and their accuracy characteristics. Unrecognised encodings fall back to\n * a `ceil(length / 4)` character heuristic.\n *\n * The class implements the standard JS value-coercion protocol (`toString`, `valueOf`,\n * `toJSON`, `toLocaleString`, `Symbol.for('nodejs.util.inspect.custom')`) so instances behave\n * transparently as strings in most contexts.\n */\nexport class Tokenizable {\n  public static TokenEncoding = TokenEncoding\n\n  /**\n   * Validator schema that accepts a plain `string` or a {@link Tokenizable} instance.\n   *\n   * @remarks\n   * Reusable fragment for any schema that wants to accept either form — for example,\n   * `systemPrompt` and each item in `standingInstructions` in `turnContextSchema`.\n   */\n  public static schema = stringOrTokenizableSchema\n\n  declare toJSON: () => string\n  declare toString: () => string\n  declare valueOf: () => string\n  declare toLocaleString: () => string\n  declare set: (value: string) => void\n  declare estimateTokens: (encoding: TokenEncoding) => number\n\n  #value: string\n  #cache: Map<TokenEncoding, number> = new Map()\n\n  /**\n   * @param value - The initial string value to wrap.\n   */\n  constructor(value: string) {\n    this.#value = value\n\n    const estimateTokensWithTiktoken = (encoding: TokenEncoding): number => {\n      try {\n        const enc: Tiktoken = getEncoding(encoding as any)\n        return enc.encode(this.#value, []).length\n      } catch {\n        return Number.POSITIVE_INFINITY\n      }\n    }\n\n    const estimateTokensWithGemini = (): number => {\n      try {\n        return getGeminiTokenizer().encode(this.#value).length\n      } catch {\n        return Number.POSITIVE_INFINITY\n      }\n    }\n\n    const estimateTokensWithLlama2 = (): number => {\n      try {\n        return getLlamaTokenizer().encode(this.#value, false).length\n      } catch {\n        return Number.POSITIVE_INFINITY\n      }\n    }\n\n    const estimateTokensWithClaudeHeuristic = (): number => {\n      try {\n        return Math.ceil(this.#value.length / 3.5)\n      } catch {\n        return Number.POSITIVE_INFINITY\n      }\n    }\n\n    Object.defineProperties(this, {\n      toJSON: {\n        value: () => this.#value,\n        enumerable: false,\n        configurable: false,\n        writable: false,\n      },\n      toString: {\n        value: () => this.#value,\n        enumerable: false,\n        configurable: false,\n        writable: false,\n      },\n      valueOf: {\n        value: () => this.#value,\n        enumerable: false,\n        configurable: false,\n        writable: false,\n      },\n      toLocaleString: {\n        value: () => this.#value,\n        enumerable: false,\n        configurable: false,\n        writable: false,\n      },\n      [Symbol.for('nodejs.util.inspect.custom')]: {\n        value: () => this.#value,\n        enumerable: false,\n        configurable: false,\n        writable: false,\n      },\n      set: {\n        value: (next: string) => {\n          this.#value = next\n          this.#cache.clear()\n        },\n        enumerable: false,\n        configurable: false,\n        writable: false,\n      },\n      estimateTokens: {\n        value: (encoding: TokenEncoding): number => {\n          if (this.#cache.has(encoding)) {\n            return this.#cache.get(encoding)!\n          }\n\n          let estimate: number\n          switch (encoding) {\n            case 'gpt2':\n            case 'r50k_base':\n            case 'p50k_base':\n            case 'p50k_edit':\n            case 'cl100k_base':\n            case 'o200k_base':\n              estimate = estimateTokensWithTiktoken(encoding)\n              break\n            case 'gemini':\n              estimate = estimateTokensWithGemini()\n              break\n            case 'llama2':\n              estimate = estimateTokensWithLlama2()\n              break\n            case 'claude':\n              estimate = estimateTokensWithClaudeHeuristic()\n              break\n          }\n          if (estimate === Number.POSITIVE_INFINITY) {\n            estimate = Math.ceil(this.#value.length / 4)\n          } else {\n            this.#cache.set(encoding, estimate)\n          }\n          return estimate\n        },\n        enumerable: false,\n        configurable: false,\n        writable: false,\n      },\n    })\n  }\n\n  /**\n   * Convenience overload for one-off token counting without managing a {@link Tokenizable} instance.\n   *\n   * @remarks\n   * Creates a temporary instance and immediately discards it — no caching benefit. Use the\n   * instance method when you need to count the same value under multiple encodings or when the\n   * value may change over time.\n   *\n   * @param value - The string to count tokens for.\n   * @param encoding - The encoding identifier to use for counting.\n   * @returns The estimated number of tokens.\n   */\n  public static estimateTokens(value: string, encoding: TokenEncoding): number {\n    const temp = new Tokenizable(value)\n    return temp.estimateTokens(encoding)\n  }\n\n  /**\n   * Returns `true` if `value` is a {@link Tokenizable} instance.\n   *\n   * @remarks\n   * Uses {@link @nhtio/adk!isInstanceOf} for cross-realm safety — `instanceof` would fail for instances\n   * created in a different module copy or VM context.\n   *\n   * @param value - The value to test.\n   * @returns `true` when `value` is a {@link Tokenizable} instance.\n   */\n  public static isTokenizable(value: unknown): value is Tokenizable {\n    return isInstanceOf(value, 'Tokenizable', Tokenizable)\n  }\n}\n\n/**\n * Returns `true` if `value` is a {@link Tokenizable} instance.\n *\n * @remarks\n * Module-level convenience alias for {@link Tokenizable.isTokenizable}. Prefer this form when\n * you need a standalone type guard without importing the full class.\n *\n * Uses {@link @nhtio/adk!isInstanceOf} for cross-realm safety — `instanceof` would fail for instances\n * created in a different module copy or VM context.\n *\n * @param value - The value to test.\n * @returns `true` when `value` is a {@link Tokenizable} instance.\n */\nexport const isTokenizable = (value: unknown): value is Tokenizable => {\n  return isInstanceOf(value, 'Tokenizable', Tokenizable)\n}\n","import { dset } from 'dset'\nimport { klona } from 'klona'\nimport { default as delve } from 'dlv'\nimport { isInstanceOf, isObject } from '../utils/guards'\nimport { E_INVALID_INITIAL_REGISTRY_VALUE } from '../exceptions/runtime'\n\n/**\n * A controlled-mutation key-value store with dot-path access and deep-clone isolation.\n *\n * @remarks\n * The registry enforces a safe read/write contract: callers never hold a live reference into\n * the internal store. Every value that enters (`set`) or leaves (`get`, `all`) is deep-cloned\n * via `klona`, so mutations to a retrieved value cannot affect stored state and vice versa.\n *\n * Keys are dot-delimited paths (e.g. `\"user.profile.name\"`), resolved via `dlv` for reads and\n * `dset` for writes; intermediate objects are created automatically on write.\n */\nexport class Registry {\n  #store: Record<string, unknown>\n\n  /**\n   * @param initial - Optional plain object to seed the registry. Deep-cloned on construction.\n   * @throws {@link @nhtio/adk!E_INVALID_INITIAL_REGISTRY_VALUE} when `initial` is defined but not a plain object.\n   */\n  constructor(initial?: Record<string, unknown>) {\n    if ('undefined' !== typeof initial && !isObject(initial)) {\n      throw new E_INVALID_INITIAL_REGISTRY_VALUE()\n    }\n    this.#store = initial ? klona(initial) : {}\n  }\n\n  /**\n   * Returns `true` if `value` is a {@link Registry} instance.\n   *\n   * @remarks\n   * Uses {@link @nhtio/adk!isInstanceOf} for cross-realm safety.\n   *\n   * @param value - The value to test.\n   * @returns `true` when `value` is a {@link Registry} instance.\n   */\n  public static isRegistry(value: unknown): value is Registry {\n    return isInstanceOf(value, 'Registry', Registry)\n  }\n\n  /**\n   * Retrieves the value at `key`, returning `defaultValue` if the path is absent.\n   *\n   * @remarks\n   * The returned value is a deep clone — mutating it will not affect the stored state.\n   *\n   * @typeParam T - Expected type of the value at `key`.\n   * @param key - Dot-delimited path into the store (e.g. `\"user.name\"`).\n   * @param defaultValue - Fallback returned when the path resolves to `undefined`.\n   * @returns A deep clone of the stored value cast to `T`, or `defaultValue` when the path is absent.\n   */\n  get<T = unknown>(key: string, defaultValue?: T): T {\n    const cloned = klona(this.#store)\n    const value = delve(cloned, key)\n    return 'undefined' === typeof value ? (defaultValue as T) : (value as T)\n  }\n\n  /**\n   * Sets the value at `key`, creating intermediate objects as needed.\n   *\n   * @remarks\n   * The stored value is isolated from the caller — mutating `value` after this call will not\n   * affect what is held in the registry.\n   *\n   * @param key - Dot-delimited path into the store (e.g. `\"user.name\"`).\n   * @param value - Value to store at the path.\n   */\n  set(key: string, value: unknown): void {\n    dset(this.#store, key, value)\n  }\n\n  /**\n   * Returns `true` if the registry has a value at `key`, `false` otherwise.\n   *\n   * @remarks\n   * A key resolving to `undefined` is treated as absent — same convention as {@link Registry.get}'s\n   * `defaultValue` fallback. No clone is performed; this is a pure existence check.\n   *\n   * @param key - Dot-delimited path into the store (e.g. `\"user.name\"`).\n   * @returns `true` when the path resolves to a value other than `undefined`.\n   */\n  has(key: string): boolean {\n    return 'undefined' !== typeof delve(this.#store, key)\n  }\n\n  /**\n   * Returns all leaf dot-paths present in the registry.\n   *\n   * @remarks\n   * The store is deep-cloned before traversal. Plain objects are walked recursively with path\n   * segments joined by dots; arrays, primitives, `null`, and class instances are treated as leaves.\n   *\n   * @returns A string array of dot-delimited paths to leaf values in the store.\n   */\n  keys(): string[] {\n    const store = klona(this.#store)\n    const keys: string[] = []\n\n    const isPlainRecord = (value: unknown): value is Record<string, unknown> => {\n      if (!isObject(value)) return false\n      const prototype = Object.getPrototypeOf(value)\n      return prototype === Object.prototype || prototype === null\n    }\n\n    const walk = (value: unknown, segments: string[]): void => {\n      if (!isPlainRecord(value)) {\n        if (segments.length > 0) keys.push(segments.join('.'))\n        return\n      }\n\n      for (const [segment, child] of Object.entries(value)) {\n        walk(child, [...segments, segment])\n      }\n    }\n\n    walk(store, [])\n    return keys\n  }\n\n  /**\n   * Returns a deep clone of the entire store contents.\n   *\n   * @returns A plain object snapshot of all stored key-value pairs.\n   */\n  all(): Record<string, unknown> {\n    return klona(this.#store)\n  }\n}\n","/**\n * Canonical `JSON.stringify` that sorts object keys recursively so that semantically-equal\n * objects produce identical strings.\n *\n * @remarks\n * Used wherever the ADK derives a stable identity from a structured value — for example,\n * `Tool.executor` computing the `callId` for `ToolExecutionStart`/`End` events, and the\n * `reportToolCall` executor helper computing the `checksum` field on `TurnToolCallContent`.\n * Both code paths hash `canonicalStringify({ tool, args })` so that argument key order does not\n * affect the resulting identifier.\n *\n * Arrays are serialised in their declared order (order is meaningful for an array). Object keys\n * are sorted with `Array.prototype.sort()`'s default lexicographic comparator.\n *\n * @param value - The value to serialise.\n * @returns A canonical JSON string representation of `value`.\n */\nexport function canonicalStringify(value: unknown): string {\n  if (value === null || typeof value !== 'object') return JSON.stringify(value)\n  if (Array.isArray(value)) return '[' + value.map((v) => canonicalStringify(v)).join(',') + ']'\n  const obj = value as Record<string, unknown>\n  const keys = Object.keys(obj).sort()\n  return '{' + keys.map((k) => JSON.stringify(k) + ':' + canonicalStringify(obj[k])).join(',') + '}'\n}\n","import { isInstanceOf } from '../utils/guards'\nimport { E_TOOL_ALREADY_REGISTERED } from '../exceptions/runtime'\nimport type { Tool } from './tool'\nimport type { DispatchContext } from '../contracts/dispatch_context'\n\n/**\n * Options accepted by {@link ToolRegistry.merge}.\n */\nexport interface MergeOptions {\n  /**\n   * What to do when two registries contain a tool with the same name AND neither tool's own\n   * `onCollision` resolves the collision.\n   *\n   * @remarks\n   * - `'throw'` (default): raise {@link @nhtio/adk!E_TOOL_ALREADY_REGISTERED} on the first unresolved\n   *   collision. Mirrors the default behaviour of {@link ToolRegistry.register} and surfaces\n   *   accidental name shadowing immediately.\n   * - `'replace'`: the later registry's tool wins.\n   * - `'keep'`: the earlier registry's tool wins; later occurrences are dropped.\n   *\n   * Per-tool {@link @nhtio/adk!Tool.onCollision} takes precedence: if the incoming tool declares\n   * `'replace'` or `'keep'`, that policy wins regardless of this option. Only when the incoming\n   * tool's policy is `'throw'` (the default) does this fallback apply.\n   *\n   * @defaultValue `'throw'`\n   */\n  onCollision?: 'throw' | 'replace' | 'keep'\n}\n\n/**\n * A mutable, turn-scoped collection of {@link @nhtio/adk!Tool} instances.\n *\n * @remarks\n * Each `TurnRunner.run()` call constructs a fresh `ToolRegistry` from the runner's configured\n * baseline tools, so middleware edits are isolated to the current turn and cannot bleed across\n * concurrent or subsequent turns.\n *\n * `Tool` instances are immutable, so `all()` returns a fresh array without deep-cloning.\n *\n * `register()` throws {@link @nhtio/adk!E_TOOL_ALREADY_REGISTERED} if a tool with the same name is already\n * present — pass `overwrite: true` to replace it explicitly.\n */\nexport class ToolRegistry {\n  #tools: Map<string, Tool>\n\n  /**\n   * Returns `true` if `value` is a {@link ToolRegistry} instance.\n   *\n   * @param value - The value to test.\n   * @returns `true` when `value` is a {@link ToolRegistry} instance.\n   */\n  public static isToolRegistry(value: unknown): value is ToolRegistry {\n    return isInstanceOf(value, 'ToolRegistry', ToolRegistry)\n  }\n\n  /**\n   * @param tools - Optional initial tools. Insertion order is preserved. Duplicate names throw\n   *   {@link @nhtio/adk!E_TOOL_ALREADY_REGISTERED} — ensure each tool has a unique name.\n   * @throws {@link @nhtio/adk!E_TOOL_ALREADY_REGISTERED} when two tools in `tools` share a name.\n   */\n  constructor(tools?: Tool[]) {\n    this.#tools = new Map()\n    for (const tool of tools ?? []) {\n      this.register(tool)\n    }\n  }\n\n  /**\n   * Adds a tool to the registry.\n   *\n   * @param tool - The tool to register.\n   * @param overwrite - When `true`, silently replaces an existing tool with the same name.\n   *   Defaults to `false`.\n   * @throws {@link @nhtio/adk!E_TOOL_ALREADY_REGISTERED} when a tool with the same name is already registered\n   *   and `overwrite` is not `true`.\n   */\n  register(tool: Tool, overwrite?: boolean): void {\n    if (this.#tools.has(tool.name) && !overwrite) {\n      throw new E_TOOL_ALREADY_REGISTERED()\n    }\n    this.#tools.set(tool.name, tool)\n  }\n\n  /**\n   * Removes the tool with the given name from the registry.\n   *\n   * @remarks\n   * No-ops if no tool with that name is registered.\n   *\n   * @param name - The name of the tool to remove.\n   */\n  unregister(name: string): void {\n    this.#tools.delete(name)\n  }\n\n  /**\n   * Returns the tool registered under `name`, or `undefined` if not present.\n   *\n   * @param name - The tool name to look up.\n   */\n  get(name: string): Tool | undefined {\n    return this.#tools.get(name)\n  }\n\n  /**\n   * Returns `true` if a tool with the given name is registered.\n   *\n   * @param name - The tool name to test.\n   */\n  has(name: string): boolean {\n    return this.#tools.has(name)\n  }\n\n  /**\n   * Returns a fresh array of all registered tools in insertion order.\n   *\n   * @remarks\n   * Since {@link @nhtio/adk!Tool} instances are immutable, no deep-cloning is needed.\n   */\n  all(): Tool[] {\n    return Array.from(this.#tools.values())\n  }\n\n  /**\n   * Removes every tool whose {@link @nhtio/adk!Tool.ephemeral} flag is `true`.\n   *\n   * @remarks\n   * Synchronous and idempotent — calling it twice in a row is a no-op the second time. The\n   * canonical caller is {@link ToolRegistry.bindContext}, which schedules this method to run\n   * at {@link @nhtio/adk!DispatchContext.ack}. Non-ephemeral tools are left untouched.\n   */\n  pruneEphemeral(): void {\n    for (const [name, tool] of this.#tools) {\n      if (tool.ephemeral) {\n        this.#tools.delete(name)\n      }\n    }\n  }\n\n  /**\n   * Binds this registry to a {@link @nhtio/adk!DispatchContext} so that {@link pruneEphemeral} runs\n   * automatically when the context is acked.\n   *\n   * @remarks\n   * The handler does NOT fire on {@link @nhtio/adk!DispatchContext.nack} — failed executor runs leave\n   * any forged tools in place so the consumer can inspect what was registered when debugging the\n   * failure. Subscriptions are short-lived and die with the context regardless.\n   *\n   * Forgetting this call after merging in `Subclass.forgeTools(ctx)` output means ephemeral tools\n   * accumulate across executor invocations, and subsequent `forgeTools(ctx)` calls in later\n   * iterations will see a stale `callId` enum that excludes new tool calls. The plan-documented\n   * pattern is:\n   *\n   * ```ts\n   * const executor: DispatchExecutorFn = async (ctx) => {\n   *   const forged = SpooledArtifact.forgeTools(ctx)\n   *   const merged = ToolRegistry.merge([main, forged])\n   *   main.bindContext(ctx)\n   *   const result = await llm.invoke({ tools: merged.all(), ... })\n   *   ctx.ack()\n   * }\n   * ```\n   *\n   * @param ctx - The execution context whose `ack` event should trigger pruning.\n   * @returns An unsubscribe function — calling it before `ctx.ack()` prevents pruning. Rarely\n   *   useful outside of tests.\n   *\n   * @see {@link @nhtio/adk!SpooledArtifact.forgeTools}\n   * @see {@link @nhtio/adk!DispatchContext.onAck}\n   */\n  bindContext(ctx: DispatchContext): () => void {\n    return ctx.onAck(() => this.pruneEphemeral())\n  }\n\n  /**\n   * Combines multiple {@link ToolRegistry} instances into a fresh registry without mutating any\n   * input.\n   *\n   * @remarks\n   * Iteration is left-to-right across `registries` and then in each registry's insertion order.\n   * Collisions are resolved by consulting the **incoming** tool's {@link @nhtio/adk!Tool.onCollision} first:\n   *\n   * - `'replace'` (per-tool): the incoming tool wins, replacing the existing entry.\n   * - `'keep'` (per-tool): the existing entry wins; the incoming tool is dropped.\n   * - `'throw'` (per-tool, the default): fall back to the merge-level `options.onCollision`.\n   *\n   * The merge-level `options.onCollision` defaults to `'throw'`, which mirrors {@link register}.\n   *\n   * The result is a brand-new registry; no input is mutated and no event subscription is\n   * propagated. Each `Tool`'s `ephemeral` flag carries through unchanged — the flag lives on the\n   * tool, not the registry, so `bindContext(ctx)` on the merged registry will prune the forged\n   * tools as expected.\n   *\n   * @param registries - Registries to merge, in priority order (left-to-right insertion).\n   * @param options - Merge-level collision policy. Defaults to `{ onCollision: 'throw' }`.\n   * @returns A fresh {@link ToolRegistry} containing the resolved union of all inputs.\n   * @throws {@link @nhtio/adk!E_TOOL_ALREADY_REGISTERED} when the resolved collision policy is `'throw'`\n   *   and a collision occurs.\n   */\n  static merge(registries: ToolRegistry[], options?: MergeOptions): ToolRegistry {\n    const policy = options?.onCollision ?? 'throw'\n    const merged = new ToolRegistry()\n    for (const registry of registries) {\n      for (const tool of registry.all()) {\n        const existing = merged.get(tool.name)\n        if (!existing) {\n          merged.register(tool)\n          continue\n        }\n        const incomingPolicy = tool.onCollision\n        if (incomingPolicy === 'replace') {\n          merged.register(tool, true)\n          continue\n        }\n        if (incomingPolicy === 'keep') {\n          continue\n        }\n        // Incoming policy is 'throw' — fall back to the merge-level option.\n        if (policy === 'replace') {\n          merged.register(tool, true)\n          continue\n        }\n        if (policy === 'keep') {\n          continue\n        }\n        throw new E_TOOL_ALREADY_REGISTERED()\n      }\n    }\n    return merged\n  }\n}\n"],"mappings":"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"}