@librechat/agents 3.4.7 → 3.5.1

package/dist/cjs/tools/toolOutputReferences.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"toolOutputReferences.cjs","names":["HARD_MAX_TOOL_RESULT_CHARS","HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE","calculateMaxTotalToolOutputSize","isComputerCallOutputMessage","ToolMessage"],"sources":["../../../src/tools/toolOutputReferences.ts"],"sourcesContent":["/**\n * Tool output reference registry.\n *\n * When enabled via `RunConfig.toolOutputReferences.enabled`, ToolNode\n * stores each successful tool output under a stable key\n * (`tool<idx>turn<turn>`) where `idx` is the tool's position within a\n * ToolNode batch and `turn` is the batch index within the run\n * (incremented once per ToolNode invocation).\n *\n * Subsequent tool calls can pipe a previous output into their args by\n * embedding `{{tool<idx>turn<turn>}}` inside any string argument;\n * {@link ToolOutputReferenceRegistry.resolve} walks the args and\n * substitutes the placeholders immediately before invocation.\n *\n * The registry stores the *raw, untruncated* tool output so a later\n * `{{…}}` substitution pipes the full payload into the next tool —\n * even when the LLM only saw a head+tail-truncated preview in\n * `ToolMessage.content`. Outputs are stored without any annotation\n * (the `_ref` key or the `[ref: ...]` prefix seen by the LLM is\n * strictly a UX signal attached to `ToolMessage.content`). Keeping the\n * registry pristine means downstream bash/jq piping receives the\n * complete, verbatim output with no injected fields.\n */\n\nimport { ToolMessage } from '@langchain/core/messages';\nimport type { BaseMessage } from '@langchain/core/messages';\nimport {\n  calculateMaxTotalToolOutputSize,\n  HARD_MAX_TOOL_RESULT_CHARS,\n  HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE,\n} from '@/utils/truncation';\nimport { isComputerCallOutputMessage } from '@/utils/toolContent';\nimport { INTENT_ARG } from '@/tools/intentArg';\n\n/** Parses a stringified JSON object arg; undefined for anything else. */\nfunction parseStringifiedArgsObject(\n  value: string\n): Record<string, unknown> | undefined {\n  if (!value.trim().startsWith('{')) {\n    return undefined;\n  }\n  try {\n    const parsed = JSON.parse(value) as unknown;\n    if (\n      parsed != null &&\n      typeof parsed === 'object' &&\n      !Array.isArray(parsed)\n    ) {\n      return parsed as Record<string, unknown>;\n    }\n  } catch {\n    return undefined;\n  }\n  return undefined;\n}\n\n/**\n * Non-global matcher for a single `{{tool<i>turn<n>}}` placeholder.\n * Exported for consumers that want to detect references (e.g., syntax\n * highlighting, docs). The stateful `g` variant lives inside the\n * registry so nobody trips on `lastIndex`.\n */\nexport const TOOL_OUTPUT_REF_PATTERN = /\\{\\{(tool\\d+turn\\d+)\\}\\}/;\n\n/** Object key used when a parsed-object output has `_ref` injected. */\nexport const TOOL_OUTPUT_REF_KEY = '_ref';\n\n/**\n * Object key used to carry unresolved reference warnings on a parsed-\n * object output. Using a dedicated field instead of a trailing text\n * line keeps the annotated `ToolMessage.content` parseable as JSON for\n * downstream consumers that rely on the object shape.\n */\nexport const TOOL_OUTPUT_UNRESOLVED_KEY = '_unresolved_refs';\n\n/** Single-line prefix prepended to non-object tool outputs so the LLM sees the reference key. */\nexport function buildReferencePrefix(key: string): string {\n  return `[ref: ${key}]`;\n}\n\n/** Stable registry key for a tool output. */\nexport function buildReferenceKey(toolIndex: number, turn: number): string {\n  return `tool${toolIndex}turn${turn}`;\n}\n\nexport type ToolOutputReferenceRegistryOptions = {\n  /** Maximum characters stored per registered output. */\n  maxOutputSize?: number;\n  /** Maximum total characters retained across all registered outputs. */\n  maxTotalSize?: number;\n  /**\n   * Upper bound on the number of concurrently-tracked runs. When\n   * exceeded, the oldest run bucket is evicted (FIFO). Defaults to 32.\n   */\n  maxActiveRuns?: number;\n};\n\nexport interface ToolOutputReferenceState {\n  entries: Array<{ key: string; value: string }>;\n  turnCounter: number;\n  warnedNonStringTools: string[];\n}\n\n/**\n * Result of resolving placeholders in tool args.\n */\nexport type ResolveResult<T> = {\n  /** Arguments with placeholders replaced. Same shape as the input. */\n  resolved: T;\n  /** Reference keys that were referenced but had no stored value. */\n  unresolved: string[];\n};\n\n/**\n * Read-only view over a frozen registry snapshot. Returned by\n * {@link ToolOutputReferenceRegistry.snapshot} for callers that need\n * to resolve placeholders against the registry state at a specific\n * point in time, ignoring any subsequent registrations.\n */\nexport interface ToolOutputResolveView {\n  resolve<T>(args: T, options?: ResolveOptions): ResolveResult<T>;\n}\n\n/**\n * Per-call resolution options. `substituteIntentKey` opts the top-level\n * `intent` key back INTO placeholder substitution: the exemption protects\n * the injected display label, but a tool whose own schema declares a\n * business parameter named `intent` (the injectors skip such tools) still\n * needs references piped into it like any other argument.\n */\nexport type ResolveOptions = {\n  substituteIntentKey?: boolean;\n};\n\n/**\n * Pre-resolved arg map keyed by `toolCallId`. Used by the mixed\n * direct+event dispatch path to feed event calls' resolved args\n * (captured pre-batch) into the dispatcher without re-resolving\n * against the now-stale live registry.\n */\nexport type PreResolvedArgsMap = Map<\n  string,\n  { resolved: Record<string, unknown>; unresolved: string[] }\n>;\n\n/**\n * Per-call sink for resolved args, keyed by `toolCallId`. Threaded\n * as a per-batch local map so concurrent `ToolNode.run()` calls do\n * not race on shared sink state.\n */\nexport type ResolvedArgsByCallId = Map<string, Record<string, unknown>>;\n\nconst EMPTY_ENTRIES: ReadonlyMap<string, string> = new Map<string, string>();\n\n/**\n * Per-run state bucket held inside the registry. Each distinct\n * `run_id` gets its own bucket so overlapping concurrent runs on a\n * shared registry cannot leak outputs, turn counters, or warn-memos\n * into one another.\n */\nclass RunStateBucket {\n  entries: Map<string, string> = new Map();\n  totalSize: number = 0;\n  turnCounter: number = 0;\n  warnedNonStringTools: Set<string> = new Set();\n}\n\n/**\n * Anonymous (`run_id` absent) bucket key. Anonymous batches are\n * treated as fresh runs on every invocation — see `nextTurn`.\n */\nconst ANON_RUN_KEY = '\\0anon';\n\n/**\n * Default upper bound on the number of concurrently-tracked runs per\n * registry. When exceeded, the oldest run's bucket (by insertion\n * order) is evicted. Keeps memory bounded when a ToolNode is reused\n * across many runs without explicit `releaseRun` calls.\n */\nconst DEFAULT_MAX_ACTIVE_RUNS = 32;\n\n/**\n * Ordered map of reference-key → stored output, partitioned by run so\n * concurrent / interleaved runs sharing one registry cannot leak\n * outputs between each other.\n *\n * Each public method takes a `runId` which selects the run's bucket.\n * Hosts typically get one registry per run via `Graph`, in which\n * case only a single bucket is ever populated; the partitioning\n * exists so the registry also behaves correctly when a single\n * instance is reused directly.\n */\nexport class ToolOutputReferenceRegistry {\n  private runStates: Map<string, RunStateBucket> = new Map();\n  private readonly maxOutputSize: number;\n  private readonly maxTotalSize: number;\n  private readonly maxActiveRuns: number;\n  /**\n   * Local stateful matcher used only by `replaceInString`. Kept\n   * off-module so callers of the exported `TOOL_OUTPUT_REF_PATTERN`\n   * never see a stale `lastIndex`.\n   */\n  private static readonly PLACEHOLDER_MATCHER = /\\{\\{(tool\\d+turn\\d+)\\}\\}/g;\n\n  constructor(options: ToolOutputReferenceRegistryOptions = {}) {\n    /**\n     * Per-output default is the same ~400 KB budget as the standard\n     * tool-result truncation (`HARD_MAX_TOOL_RESULT_CHARS`). This\n     * keeps a single `{{…}}` substitution at a size that is safe to\n     * pass through typical shell `ARG_MAX` limits and matches what\n     * the LLM would otherwise have seen. Hosts that want larger per-\n     * output payloads (API consumers, long JSON streams) can raise\n     * the cap explicitly up to the 5 MB total budget.\n     */\n    const perOutput =\n      options.maxOutputSize != null && options.maxOutputSize > 0\n        ? options.maxOutputSize\n        : HARD_MAX_TOOL_RESULT_CHARS;\n    /**\n     * Clamp a caller-supplied `maxTotalSize` to\n     * `HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE` (5 MB) so the documented\n     * absolute cap is enforced regardless of host config —\n     * `calculateMaxTotalToolOutputSize` already applies the same\n     * upper bound on its computed default, but the user-provided\n     * branch was bypassing it.\n     */\n    const totalRaw =\n      options.maxTotalSize != null && options.maxTotalSize > 0\n        ? Math.min(options.maxTotalSize, HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE)\n        : calculateMaxTotalToolOutputSize(perOutput);\n    this.maxTotalSize = totalRaw;\n    /**\n     * The per-output cap can never exceed the per-run aggregate cap:\n     * if a single entry were allowed to be larger than `maxTotalSize`,\n     * the eviction loop would either blow the cap (to keep the entry)\n     * or self-evict a just-stored value. Clamping here turns\n     * `maxTotalSize` into a hard upper bound on *any* state the\n     * registry retains per run.\n     */\n    this.maxOutputSize = Math.min(perOutput, totalRaw);\n    this.maxActiveRuns =\n      options.maxActiveRuns != null && options.maxActiveRuns > 0\n        ? options.maxActiveRuns\n        : DEFAULT_MAX_ACTIVE_RUNS;\n  }\n\n  private keyFor(runId: string | undefined): string {\n    return runId ?? ANON_RUN_KEY;\n  }\n\n  private getOrCreate(runId: string | undefined): RunStateBucket {\n    const key = this.keyFor(runId);\n    let state = this.runStates.get(key);\n    if (state == null) {\n      state = new RunStateBucket();\n      this.runStates.set(key, state);\n      if (this.runStates.size > this.maxActiveRuns) {\n        const oldest = this.runStates.keys().next().value;\n        if (oldest != null && oldest !== key) {\n          this.runStates.delete(oldest);\n        }\n      }\n    }\n    return state;\n  }\n\n  /** Registers (or replaces) the output stored under `key` for `runId`. */\n  set(runId: string | undefined, key: string, value: string): void {\n    const bucket = this.getOrCreate(runId);\n    const clipped =\n      value.length > this.maxOutputSize\n        ? value.slice(0, this.maxOutputSize)\n        : value;\n    const existing = bucket.entries.get(key);\n    if (existing != null) {\n      bucket.totalSize -= existing.length;\n      bucket.entries.delete(key);\n    }\n    bucket.entries.set(key, clipped);\n    bucket.totalSize += clipped.length;\n    this.evictWithinBucket(bucket);\n  }\n\n  /** Returns the stored value for `key` in `runId`'s bucket, or `undefined`. */\n  get(runId: string | undefined, key: string): string | undefined {\n    return this.runStates.get(this.keyFor(runId))?.entries.get(key);\n  }\n\n  /**\n   * Returns `true` when `key` is currently stored in `runId`'s bucket.\n   * Used by {@link annotateMessagesForLLM} to gate transient annotation\n   * on whether the registry still owns the referenced output (a stale\n   * `_refKey` from a prior run silently no-ops here).\n   */\n  has(runId: string | undefined, key: string): boolean {\n    return this.runStates.get(this.keyFor(runId))?.entries.has(key) ?? false;\n  }\n\n  /** Total number of registered outputs across every run bucket. */\n  get size(): number {\n    let n = 0;\n    for (const bucket of this.runStates.values()) {\n      n += bucket.entries.size;\n    }\n    return n;\n  }\n\n  /** Maximum characters retained per output (post-clip). */\n  get perOutputLimit(): number {\n    return this.maxOutputSize;\n  }\n\n  /** Maximum total characters retained *per run*. */\n  get totalLimit(): number {\n    return this.maxTotalSize;\n  }\n\n  /** Drops every run's state. */\n  clear(): void {\n    this.runStates.clear();\n  }\n\n  /**\n   * Explicitly release `runId`'s state. Safe to call when a run has\n   * finished. Hosts sharing one registry across runs should call this\n   * to reclaim memory deterministically; otherwise LRU eviction kicks\n   * in when `maxActiveRuns` runs accumulate.\n   */\n  releaseRun(runId: string | undefined): void {\n    this.runStates.delete(this.keyFor(runId));\n  }\n\n  /**\n   * Claims the next batch turn synchronously from `runId`'s bucket.\n   *\n   * Must be called once at the start of each ToolNode batch before\n   * any `await`, so concurrent invocations within the same run see\n   * distinct turn values (reads are effectively atomic by JS's\n   * single-threaded execution of the sync prefix).\n   *\n   * If `runId` is missing the anonymous bucket is dropped and a\n   * fresh one created so each anonymous call behaves as its own run.\n   */\n  nextTurn(runId: string | undefined): number {\n    if (runId == null) {\n      this.runStates.delete(ANON_RUN_KEY);\n    }\n    const bucket = this.getOrCreate(runId);\n    return bucket.turnCounter++;\n  }\n\n  /**\n   * Records that `toolName` has been warned about in `runId` (returns\n   * `true` on the first call per run, `false` after). Used by\n   * ToolNode to emit one log line per offending tool per run when a\n   * `ToolMessage.content` isn't a string.\n   */\n  claimWarnOnce(runId: string | undefined, toolName: string): boolean {\n    const bucket = this.getOrCreate(runId);\n    if (bucket.warnedNonStringTools.has(toolName)) {\n      return false;\n    }\n    bucket.warnedNonStringTools.add(toolName);\n    return true;\n  }\n\n  /**\n   * Walks `args` and replaces every `{{tool<i>turn<n>}}` placeholder in\n   * string values with the stored output *from `runId`'s bucket*. Non-\n   * string values and object keys are left untouched. Unresolved\n   * references are left in-place and reported so the caller can\n   * surface them to the LLM. When no placeholder appears anywhere in\n   * the serialized args, the original input is returned without\n   * walking the tree.\n   */\n  resolve<T>(\n    runId: string | undefined,\n    args: T,\n    options?: ResolveOptions\n  ): ResolveResult<T> {\n    if (!hasAnyPlaceholder(args)) {\n      return { resolved: args, unresolved: [] };\n    }\n    const bucket = this.runStates.get(this.keyFor(runId));\n    return this.resolveAgainst(bucket?.entries ?? EMPTY_ENTRIES, args, options);\n  }\n\n  /**\n   * Captures a frozen snapshot of `runId`'s current entries and\n   * returns a view that resolves placeholders against *only* that\n   * snapshot. The snapshot is decoupled from the live registry, so\n   * subsequent `set()` calls (for example, same-turn direct outputs\n   * registering while an event branch is still in flight) are\n   * invisible to the snapshot's `resolve`. Used by the mixed\n   * direct+event dispatch path to preserve same-turn isolation when\n   * a `PreToolUse` hook rewrites event args after directs have\n   * completed.\n   */\n  snapshot(runId: string | undefined): ToolOutputResolveView {\n    const bucket = this.runStates.get(this.keyFor(runId));\n    const entries: ReadonlyMap<string, string> = bucket\n      ? new Map(bucket.entries)\n      : EMPTY_ENTRIES;\n    return {\n      resolve: <T>(args: T, options?: ResolveOptions): ResolveResult<T> =>\n        this.resolveAgainst(entries, args, options),\n    };\n  }\n\n  /** Captures the checkpoint-safe state needed to resume one run bucket. */\n  snapshotState(runId: string | undefined): ToolOutputReferenceState {\n    const bucket = this.runStates.get(this.keyFor(runId));\n    return {\n      entries: [...(bucket?.entries ?? EMPTY_ENTRIES)].map(([key, value]) => ({\n        key,\n        value,\n      })),\n      turnCounter: bucket?.turnCounter ?? 0,\n      warnedNonStringTools: [...(bucket?.warnedNonStringTools ?? [])],\n    };\n  }\n\n  /** Restores a checkpointed run bucket under the current resume scope. */\n  restoreState(\n    runId: string | undefined,\n    state: ToolOutputReferenceState\n  ): void {\n    this.releaseRun(runId);\n    const bucket = this.getOrCreate(runId);\n    for (const { key, value } of state.entries) {\n      this.set(runId, key, value);\n    }\n    bucket.turnCounter = state.turnCounter;\n    for (const toolName of state.warnedNonStringTools) {\n      bucket.warnedNonStringTools.add(toolName);\n    }\n  }\n\n  private resolveAgainst<T>(\n    entries: ReadonlyMap<string, string>,\n    args: T,\n    options?: ResolveOptions\n  ): ResolveResult<T> {\n    if (!hasAnyPlaceholder(args)) {\n      return { resolved: args, unresolved: [] };\n    }\n    const exemptIntentKey = options?.substituteIntentKey !== true;\n    const unresolved = new Set<string>();\n    /**\n     * Providers may deliver the args OBJECT as a JSON string. A plain\n     * string-root transform would expand placeholders inside the `intent`\n     * label too, bypassing the top-level exclusion below — parse, transform\n     * key-aware, and re-serialize so the label stays verbatim while every\n     * other field still substitutes. Only taken when an `intent` key is\n     * actually present; other strings keep the fast raw-string path.\n     */\n    if (exemptIntentKey && typeof args === 'string') {\n      const parsedRoot = parseStringifiedArgsObject(args);\n      if (parsedRoot != null && INTENT_ARG in parsedRoot) {\n        const resolved = JSON.stringify(\n          this.transform(entries, parsedRoot, unresolved, true)\n        ) as T;\n        return { resolved, unresolved: Array.from(unresolved) };\n      }\n    }\n    const resolved = this.transform(\n      entries,\n      args,\n      unresolved,\n      exemptIntentKey\n    ) as T;\n    return { resolved, unresolved: Array.from(unresolved) };\n  }\n\n  private transform(\n    entries: ReadonlyMap<string, string>,\n    value: unknown,\n    unresolved: Set<string>,\n    exemptRootIntent = false\n  ): unknown {\n    if (typeof value === 'string') {\n      return this.replaceInString(entries, value, unresolved);\n    }\n    if (Array.isArray(value)) {\n      return value.map((item) => this.transform(entries, item, unresolved));\n    }\n    if (value !== null && typeof value === 'object') {\n      const source = value as Record<string, unknown>;\n      const next: Record<string, unknown> = {};\n      for (const [key, item] of Object.entries(source)) {\n        /**\n         * The top-level `intent` arg is a display label, never a data\n         * channel: expanding a `{{tool<i>turn<n>}}` placeholder there would\n         * dump a stored output (up to the registry cap) into a single-line\n         * UI label and persist it with the message. Left verbatim instead.\n         */\n        next[key] =\n          exemptRootIntent && key === INTENT_ARG\n            ? item\n            : this.transform(entries, item, unresolved);\n      }\n      return next;\n    }\n    return value;\n  }\n\n  private replaceInString(\n    entries: ReadonlyMap<string, string>,\n    input: string,\n    unresolved: Set<string>\n  ): string {\n    if (input.indexOf('{{tool') === -1) {\n      return input;\n    }\n    return input.replace(\n      ToolOutputReferenceRegistry.PLACEHOLDER_MATCHER,\n      (match, key: string) => {\n        const stored = entries.get(key);\n        if (stored == null) {\n          unresolved.add(key);\n          return match;\n        }\n        return stored;\n      }\n    );\n  }\n\n  private evictWithinBucket(bucket: RunStateBucket): void {\n    if (bucket.totalSize <= this.maxTotalSize) {\n      return;\n    }\n    for (const key of bucket.entries.keys()) {\n      if (bucket.totalSize <= this.maxTotalSize) {\n        return;\n      }\n      const entry = bucket.entries.get(key);\n      if (entry == null) {\n        continue;\n      }\n      bucket.totalSize -= entry.length;\n      bucket.entries.delete(key);\n    }\n  }\n}\n\n/**\n * Cheap pre-check: returns true if any string value in `args` contains\n * the `{{tool` substring. Lets `resolve()` skip the deep tree walk (and\n * its object allocations) for the common case of plain args.\n */\nfunction hasAnyPlaceholder(value: unknown): boolean {\n  if (typeof value === 'string') {\n    return value.indexOf('{{tool') !== -1;\n  }\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      if (hasAnyPlaceholder(item)) {\n        return true;\n      }\n    }\n    return false;\n  }\n  if (value !== null && typeof value === 'object') {\n    for (const item of Object.values(value as Record<string, unknown>)) {\n      if (hasAnyPlaceholder(item)) {\n        return true;\n      }\n    }\n    return false;\n  }\n  return false;\n}\n\n/**\n * Annotates `content` with a reference key and/or unresolved-ref\n * warnings so the LLM sees both alongside the tool output.\n *\n * Behavior:\n *  - If `content` parses as a plain (non-array, non-null) JSON object\n *    and the object does not already have a conflicting `_ref` key,\n *    the reference key and (when present) `_unresolved_refs` array\n *    are injected as object fields, preserving JSON validity for\n *    downstream consumers that parse the output.\n *  - Otherwise (string output, JSON array/primitive, parse failure,\n *    or `_ref` collision), a `[ref: <key>]\\n` prefix line is\n *    prepended and unresolved refs are appended as a trailing\n *    `[unresolved refs: …]` line.\n *\n * The annotated string is what the LLM sees as `ToolMessage.content`.\n * The *original* (un-annotated) value is what gets stored in the\n * registry, so downstream piping remains pristine.\n *\n * @param content     Raw (post-truncation) tool output.\n * @param key         Reference key for this output, or undefined when\n *                    there is nothing to register (errors etc.).\n * @param unresolved  Reference keys that failed to resolve during\n *                    argument substitution. Surfaced so the LLM can\n *                    self-correct its next tool call.\n */\nexport function annotateToolOutputWithReference(\n  content: string,\n  key: string | undefined,\n  unresolved: string[] = []\n): string {\n  const hasRefKey = key != null;\n  const hasUnresolved = unresolved.length > 0;\n  if (!hasRefKey && !hasUnresolved) {\n    return content;\n  }\n  const trimmed = content.trimStart();\n  if (trimmed.startsWith('{')) {\n    const annotated = tryInjectRefIntoJsonObject(content, key, unresolved);\n    if (annotated != null) {\n      return annotated;\n    }\n  }\n  const prefix = hasRefKey ? `${buildReferencePrefix(key!)}\\n` : '';\n  const trailer = hasUnresolved\n    ? `\\n[unresolved refs: ${unresolved.join(', ')}]`\n    : '';\n  return `${prefix}${content}${trailer}`;\n}\n\nfunction tryInjectRefIntoJsonObject(\n  content: string,\n  key: string | undefined,\n  unresolved: string[]\n): string | null {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(content);\n  } catch {\n    return null;\n  }\n\n  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {\n    return null;\n  }\n\n  const obj = parsed as Record<string, unknown>;\n  const injectingRef = key != null;\n  const injectingUnresolved = unresolved.length > 0;\n\n  /**\n   * Reject the JSON-injection path (fall back to prefix form) when\n   * either of our keys collides with real payload data:\n   *  - `_ref` collision: existing value is non-null and differs from\n   *    the key we're about to inject.\n   *  - `_unresolved_refs` collision: existing value is non-null and\n   *    is not a deep-equal match for the array we'd inject.\n   * This keeps us from silently overwriting legitimate tool output.\n   */\n  if (\n    injectingRef &&\n    TOOL_OUTPUT_REF_KEY in obj &&\n    obj[TOOL_OUTPUT_REF_KEY] !== key &&\n    obj[TOOL_OUTPUT_REF_KEY] != null\n  ) {\n    return null;\n  }\n  if (\n    injectingUnresolved &&\n    TOOL_OUTPUT_UNRESOLVED_KEY in obj &&\n    obj[TOOL_OUTPUT_UNRESOLVED_KEY] != null &&\n    !arraysShallowEqual(obj[TOOL_OUTPUT_UNRESOLVED_KEY], unresolved)\n  ) {\n    return null;\n  }\n\n  /**\n   * Only strip the framework-owned key we're actually injecting —\n   * leave everything else (including a pre-existing `_ref` on the\n   * unresolved-only path, or a pre-existing `_unresolved_refs` on a\n   * plain-annotation path) untouched so we annotate rather than\n   * mutate downstream payload data. Our injected keys land first in\n   * the serialized JSON so the LLM sees them before the body.\n   */\n  const omitKeys = new Set<string>();\n  if (injectingRef) omitKeys.add(TOOL_OUTPUT_REF_KEY);\n  if (injectingUnresolved) omitKeys.add(TOOL_OUTPUT_UNRESOLVED_KEY);\n  const rest: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(obj)) {\n    if (!omitKeys.has(k)) {\n      rest[k] = v;\n    }\n  }\n  const injected: Record<string, unknown> = {};\n  if (injectingRef) {\n    injected[TOOL_OUTPUT_REF_KEY] = key;\n  }\n  if (injectingUnresolved) {\n    injected[TOOL_OUTPUT_UNRESOLVED_KEY] = unresolved;\n  }\n  Object.assign(injected, rest);\n\n  const pretty = /^\\{\\s*\\n/.test(content);\n  return pretty ? JSON.stringify(injected, null, 2) : JSON.stringify(injected);\n}\n\nfunction arraysShallowEqual(a: unknown, b: readonly string[]): boolean {\n  if (!Array.isArray(a) || a.length !== b.length) {\n    return false;\n  }\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Lazy projection that, given a registry and a runId, returns a new\n * `messages` array where each `ToolMessage` carrying ref metadata is\n * projected into a transient copy with annotated content (when the ref\n * is live in the registry) and with the framework-owned `additional_\n * kwargs` keys (`_refKey`, `_refScope`, `_unresolvedRefs`) stripped\n * regardless of whether annotation applied. The original input array\n * and its messages are never mutated.\n *\n * Annotation is gated on registry presence: a stale `_refKey` from a\n * prior run (e.g. one that survived in persisted history) silently\n * no-ops on the *content* side. The strip-metadata side still runs so\n * stale framework keys never leak onto the wire under any custom or\n * future provider serializer that might transmit `additional_kwargs`.\n * `_unresolvedRefs` is always meaningful and is not gated.\n *\n * **Feature-disabled fast path:** when the host hasn't enabled the\n * tool-output-reference feature, the registry is `undefined` and this\n * function returns the input array reference-equal *without iterating\n * a single message*. The loop is exclusive to the feature-enabled\n * code path.\n */\nexport function annotateMessagesForLLM(\n  messages: BaseMessage[],\n  registry: ToolOutputReferenceRegistry | undefined,\n  runId: string | undefined\n): BaseMessage[] {\n  if (registry == null) return messages;\n\n  /**\n   * Lazy-allocate the output array so the common case (no ToolMessage\n   * carries framework metadata) returns the input reference-equal with\n   * zero allocations beyond the per-message predicate checks.\n   */\n  let out: BaseMessage[] | undefined;\n  for (let i = 0; i < messages.length; i++) {\n    const m = messages[i];\n    if (m._getType() !== 'tool') continue;\n    /**\n     * `additional_kwargs` is untyped at the LangChain layer\n     * (`Record<string, unknown>`), so persisted or client-supplied\n     * ToolMessages can carry arbitrary shapes — including primitives\n     * (a malformed serializer might write a string, or `null`).\n     * Guard with a runtime object check before the `in` probes\n     * because the `in` operator throws `TypeError` on primitives.\n     * A single malformed message must never crash the provider call\n     * path; skip its annotation/strip and continue.\n     */\n    const rawMeta = m.additional_kwargs as unknown;\n    if (rawMeta == null || typeof rawMeta !== 'object') continue;\n    const meta = rawMeta as Record<string, unknown>;\n    const hasRefKey = '_refKey' in meta;\n    const hasRefScope = '_refScope' in meta;\n    const hasUnresolvedField = '_unresolvedRefs' in meta;\n    if (!hasRefKey && !hasRefScope && !hasUnresolvedField) continue;\n    if (isComputerCallOutputMessage(m)) {\n      out ??= messages.slice();\n      out[i] = cloneToolMessageWithContent(m as ToolMessage, m.content);\n      continue;\n    }\n\n    const refKey = readRefKey(meta);\n    const unresolved = readUnresolvedRefs(meta);\n\n    /**\n     * Prefer the message-stamped `_refScope` for the registry lookup.\n     * For named runs it equals the current `runId`; for anonymous\n     * invocations it carries the per-batch synthetic scope minted by\n     * ToolNode (`\\0anon-<n>`), which `runId` from config cannot\n     * recover. Falling back to `runId` keeps backward compatibility\n     * with messages stamped before this field existed.\n     */\n    const lookupScope = readRefScope(meta) ?? runId;\n    const liveRef =\n      refKey != null && registry.has(lookupScope, refKey) ? refKey : undefined;\n    const annotates = liveRef != null || unresolved.length > 0;\n\n    const tm = m as ToolMessage;\n    let nextContent: ToolMessage['content'] = tm.content;\n\n    if (annotates && typeof tm.content === 'string') {\n      nextContent = annotateToolOutputWithReference(\n        tm.content,\n        liveRef,\n        unresolved\n      );\n    } else if (annotates && Array.isArray(tm.content)) {\n      /**\n       * Array tool content. The string annotator can't run — this notably\n       * includes a tail tool result that prompt caching rewrote from a string\n       * into a text-block array to host its `cache_control` / `cachePoint`\n       * marker (the `_refKey` survives on `additional_kwargs`). Project the\n       * same markers the string path would, as leading text blocks: the live\n       * `[ref: …]` prefix and/or the unresolved-refs warning. Without this the\n       * common tool-result tail loses its reference marker once cached.\n       *\n       * `as unknown as ToolMessage['content']` is unavoidable: LangChain's\n       * content union does not accept a freshly built mixed array literal even\n       * though the structural shape is valid at runtime. The double-cast is\n       * structurally safe — every original block is preserved and only\n       * `{ type: 'text', text }` blocks (which all providers accept) are\n       * prepended.\n       */\n      const prefixBlocks: Array<{ type: 'text'; text: string }> = [];\n      if (liveRef != null) {\n        prefixBlocks.push({\n          type: 'text',\n          text: buildReferencePrefix(liveRef),\n        });\n      }\n      if (unresolved.length > 0) {\n        prefixBlocks.push({\n          type: 'text',\n          text: `[unresolved refs: ${unresolved.join(', ')}]`,\n        });\n      }\n      if (prefixBlocks.length > 0) {\n        nextContent = [\n          ...prefixBlocks,\n          ...tm.content,\n        ] as unknown as ToolMessage['content'];\n      }\n    }\n\n    /**\n     * Project unconditionally: even when no annotation applies (stale\n     * `_refKey` or non-annotatable content), `cloneToolMessageWithContent`\n     * runs `stripFrameworkRefMetadata` on `additional_kwargs` so the\n     * framework-owned keys never reach the wire.\n     */\n    out ??= messages.slice();\n    out[i] = cloneToolMessageWithContent(tm, nextContent);\n  }\n\n  return out ?? messages;\n}\n\n/**\n * Reads `_refKey` defensively from untyped `additional_kwargs`. Returns\n * undefined for non-string values so a malformed field cannot poison\n * the registry lookup or downstream string operations.\n */\nfunction readRefKey(\n  meta: Record<string, unknown> | undefined\n): string | undefined {\n  const v = meta?._refKey;\n  return typeof v === 'string' ? v : undefined;\n}\n\n/**\n * Reads `_refScope` defensively from untyped `additional_kwargs`.\n * Mirrors {@link readRefKey} — non-string scopes are dropped (the\n * caller falls back to the run-derived scope) rather than passed into\n * the registry as a malformed key.\n */\nfunction readRefScope(\n  meta: Record<string, unknown> | undefined\n): string | undefined {\n  const v = meta?._refScope;\n  return typeof v === 'string' ? v : undefined;\n}\n\n/**\n * Reads `_unresolvedRefs` defensively from untyped `additional_kwargs`.\n * Returns an empty array for any non-array value, and filters out\n * non-string entries from a real array. Without this guard, a hydrated\n * ToolMessage carrying e.g. `_unresolvedRefs: 'tool0turn0'` would crash\n * `attemptInvoke` on the eventual `.length` / `.join(...)` call.\n */\nfunction readUnresolvedRefs(\n  meta: Record<string, unknown> | undefined\n): string[] {\n  const v = meta?._unresolvedRefs;\n  if (!Array.isArray(v)) return [];\n  const out: string[] = [];\n  for (const item of v) {\n    if (typeof item === 'string') out.push(item);\n  }\n  return out;\n}\n\n/**\n * Builds a fresh `ToolMessage` that mirrors `tm`'s identity fields with\n * the supplied `content`. Every `ToolMessage` field but `content` is\n * carried over so the projection is structurally identical to the\n * original from a LangChain serializer's perspective.\n *\n * `additional_kwargs` is rebuilt with the framework-owned ref keys\n * stripped. Defensive: LangChain's standard provider serializers do not\n * transmit `additional_kwargs` to provider HTTP APIs, but a custom\n * adapter or future LangChain change could. Stripping keeps the\n * implementation correct under any serializer behavior at the cost of a\n * shallow object spread per annotated message.\n */\nfunction cloneToolMessageWithContent(\n  tm: ToolMessage,\n  content: ToolMessage['content']\n): ToolMessage {\n  return new ToolMessage({\n    id: tm.id,\n    name: tm.name,\n    status: tm.status,\n    artifact: tm.artifact,\n    tool_call_id: tm.tool_call_id,\n    response_metadata: tm.response_metadata,\n    additional_kwargs: stripFrameworkRefMetadata(tm.additional_kwargs),\n    content,\n  });\n}\n\n/**\n * Returns a copy of `kwargs` with `_refKey`, `_refScope`, and\n * `_unresolvedRefs` removed. Returns the input reference-equal when\n * none of those keys are present so the no-strip path stays cheap;\n * returns `undefined` when stripping leaves the object empty so the\n * caller can drop the field entirely.\n */\nfunction stripFrameworkRefMetadata(\n  kwargs: Record<string, unknown> | undefined\n): Record<string, unknown> | undefined {\n  if (kwargs == null) return undefined;\n  if (\n    !('_refKey' in kwargs) &&\n    !('_refScope' in kwargs) &&\n    !('_unresolvedRefs' in kwargs)\n  ) {\n    return kwargs;\n  }\n  const { _refKey, _refScope, _unresolvedRefs, ...rest } = kwargs as Record<\n    string,\n    unknown\n  > & {\n    _refKey?: unknown;\n    _refScope?: unknown;\n    _unresolvedRefs?: unknown;\n  };\n  void _refKey;\n  void _refScope;\n  void _unresolvedRefs;\n  return Object.keys(rest).length === 0 ? undefined : rest;\n}\n"],"mappings":"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"}
+{"version":3,"file":"toolOutputReferences.cjs","names":["HARD_MAX_TOOL_RESULT_CHARS","HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE","calculateMaxTotalToolOutputSize","isComputerCallOutputMessage","ToolMessage"],"sources":["../../../src/tools/toolOutputReferences.ts"],"mappings":"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"}

package/dist/cjs/types/hitl.cjs

@@ -1,9 +1,4 @@
 //#region src/types/hitl.ts
-/**
-* Type guard narrowing an arbitrary value to an
-* `AskUserQuestionInterruptPayload`. Same `unknown`-tolerant contract
-* as `isToolApprovalInterrupt`.
-*/
 function isAskUserQuestionInterrupt(payload) {
 	return typeof payload === "object" && payload !== null && payload.type === "ask_user_question";
 }

package/dist/cjs/types/hitl.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hitl.cjs","names":[],"sources":["../../../src/types/hitl.ts"],"sourcesContent":["/**\n * First-class human-in-the-loop (HITL) types for `@librechat/agents`.\n * Surfaces the interrupt payload that `ToolNode` raises when a `PreToolUse`\n * hook returns `decision: 'ask'` and HITL is enabled on the run, plus the\n * resume-decision shape the host returns to continue or reject the tool.\n *\n * Mirrors the LangChain HITL middleware shape (action_requests /\n * review_configs) so hosts and clients can share rendering/UI semantics\n * across the langchain ecosystem.\n */\n\n/** Per-tool approval request emitted inside an interrupt payload. */\nexport interface ToolApprovalRequest {\n  /** Stable id of the tool call (matches LangGraph `ToolCall.id`). */\n  tool_call_id: string;\n  /** Tool name being invoked. */\n  name: string;\n  /**\n   * Arguments the tool is about to be invoked with — already resolved by\n   * any `{{tool<i>turn<n>}}` references and any `updatedInput` returned\n   * by the firing PreToolUse hook.\n   */\n  arguments: Record<string, unknown>;\n  /**\n   * Optional reason the hook supplied for asking (e.g., \"destructive\n   * filesystem write\"). Hosts can render this verbatim.\n   */\n  description?: string;\n}\n\n/** Allowed host-side decisions for a `tool_approval` interrupt. */\nexport type ToolApprovalDecisionType =\n  | 'approve'\n  | 'reject'\n  | 'edit'\n  | 'respond';\n\n/** Per-action review configuration paired with each action_request. */\nexport interface ToolApprovalReviewConfig {\n  /** Tool name (matches the `name` field on the corresponding action_request). */\n  action_name: string;\n  /**\n   * Stable id of the tool call this review_config applies to (matches\n   * the `tool_call_id` of the corresponding action_request). Lets a UI\n   * map review_configs → action_requests directly when a batch\n   * contains the same tool called more than once — by-position\n   * mapping breaks down with duplicates.\n   */\n  tool_call_id: string;\n  /** Decisions the host UI is allowed to surface for this action. */\n  allowed_decisions: ToolApprovalDecisionType[];\n}\n\n/**\n * Resume value the host returns through `Run.resume(decisions)` after a\n * `tool_approval` interrupt. One entry per action_request, in the same\n * order. Hosts may also return a record keyed by `tool_call_id`; the SDK\n * handles either shape.\n *\n * Variants:\n *   - `approve`: run the tool with its original (or hook-rewritten) args.\n *   - `reject`: skip the tool, emit a blocked error `ToolMessage` with\n *     `reason` surfaced to the model.\n *   - `edit`: replace the tool's args with `updatedInput` (re-resolves\n *     any `{{tool<i>turn<n>}}` placeholders) and run the tool.\n *   - `respond`: skip the tool entirely and emit `responseText` as a\n *     successful `ToolMessage`. Mirrors LangChain HITL middleware's\n *     `respond` semantic — the human supplies the result the model sees,\n *     bypassing tool execution. Useful when the user wants to short-circuit\n *     a tool call with a hand-written answer (e.g., \"don't actually run\n *     the search, just tell the model 'no relevant results'\").\n *\n * Note on hook semantics: `respond` does NOT fire the per-tool\n * `PostToolUse` hook (no real tool execution happened, so the\n * \"post-tool\" semantic doesn't apply). It DOES appear in the\n * `PostToolBatch` entry array with `status: 'success'` and the\n * user-supplied text as `toolOutput`, so batch-level audit /\n * convention hooks see the full set of outcomes.\n */\nexport type ToolApprovalDecision =\n  | { type: 'approve' }\n  | { type: 'reject'; reason?: string }\n  | { type: 'edit'; updatedInput: Record<string, unknown> }\n  | { type: 'respond'; responseText: string };\n\n/** Map form of resume decisions, keyed by tool call id. */\nexport type ToolApprovalDecisionMap = Record<string, ToolApprovalDecision>;\n\n/**\n * Categories of human-in-the-loop interrupts the SDK can raise. Hosts\n * narrow on `HumanInterruptPayload.type` to determine which payload\n * shape they're handling and which resume value to send back through\n * `Run.resume()`.\n *\n * Exported as a discrete type so downstream consumers (notably\n * LibreChat's wire types in `librechat-data-provider`) can mirror\n * the discriminator alongside their own host-side `PendingAction`\n * record without re-declaring the union themselves. Internal SDK\n * code narrows directly on the literal strings via the type guards\n * below; this type alias is primarily an integration-layer contract.\n */\nexport type HumanInterruptType = 'tool_approval' | 'ask_user_question';\n\n/** Identifies an interrupt that originated inside a checkpointed subagent. */\nexport interface SubagentInterruptScope {\n  /** Child execution run id used by subagent update and usage events. */\n  run_id: string;\n  /** Child agent id that owns the interrupted tool call. */\n  agent_id: string;\n  /** Configured subagent type selected by the parent tool call. */\n  subagent_type: string;\n  /** Parent `subagent` tool call that launched this child. */\n  parent_tool_call_id?: string;\n}\n\n/**\n * Structured payload the SDK passes to `interrupt()` when one or more\n * pending tool calls require host approval. All `ask`-decision tool calls\n * from a single ToolNode batch are bundled into one interrupt so the host\n * can render and resolve them together.\n *\n * Resume value: `ToolApprovalDecision[]` (in `action_requests` order) or\n * `ToolApprovalDecisionMap` (keyed by `tool_call_id`).\n */\nexport interface ToolApprovalInterruptPayload {\n  type: 'tool_approval';\n  action_requests: ToolApprovalRequest[];\n  review_configs: ToolApprovalReviewConfig[];\n  /** Hook-registry session whose policy raised this interrupt. */\n  hook_session_id?: string;\n  /** Present when the approval request was bridged from a child graph. */\n  subagent?: SubagentInterruptScope;\n}\n\n/**\n * Pre-defined option the user can pick when answering an\n * `ask_user_question` interrupt. The selected option's `value` becomes\n * the resume value's `answer` field.\n */\nexport interface AskUserQuestionOption {\n  /** Human-readable label rendered in the host UI. */\n  label: string;\n  /** Value returned via `AskUserQuestionResolution.answer` if picked. */\n  value: string;\n}\n\n/** Question request emitted inside an `ask_user_question` interrupt. */\nexport interface AskUserQuestionRequest {\n  /** The question to ask the human. */\n  question: string;\n  /** Optional context / description rendered alongside the question. */\n  description?: string;\n  /**\n   * Optional pre-defined response options. When present, hosts can render\n   * a picker; the user may still type a free-form answer when the host\n   * UI allows it. Omit to require a free-form answer.\n   */\n  options?: AskUserQuestionOption[];\n  /**\n   * When `true`, the host UI may let the user pick several options; the\n   * resulting `AskUserQuestionResolution.answer` is the selected option\n   * values joined by `\", \"`. When omitted or `false`, hosts render a\n   * single-select picker. Only meaningful alongside `options`.\n   */\n  multiSelect?: boolean;\n}\n\n/** One independently answerable question in a batched question request. */\nexport interface AskUserQuestionBatchItem extends AskUserQuestionRequest {\n  /** Batch-unique identifier (`[A-Za-z][A-Za-z0-9_-]{0,63}`). */\n  id: string;\n  /** Optional short heading rendered above the question. */\n  header?: string;\n}\n\n/** Input shape for one tool call that asks one to four questions together. */\nexport interface AskUserQuestionsRequest {\n  questions: AskUserQuestionBatchItem[];\n}\n\n/**\n * Structured payload the SDK passes to `interrupt()` when an agent (or\n * a custom node) needs to ask the user a clarifying question. Mirrors\n * Claude Code's `AskUserQuestion` semantic. Resume value is\n * `AskUserQuestionResolution` for a single question, or\n * `AskUserQuestionsResolution` when `questions` is present.\n */\nexport interface AskUserQuestionInterruptPayload {\n  type: 'ask_user_question';\n  /**\n   * Single-question request, or the first question as a compatibility\n   * fallback when `questions` contains a batch. This lets existing hosts show\n   * a useful preview during a staged rollout, but they must support `questions`\n   * and `AskUserQuestionsResolution` before enabling a batched tool schema.\n   */\n  question: AskUserQuestionRequest;\n  /** One to four questions collected by one `ask_user_question` tool call. */\n  questions?: AskUserQuestionsRequest['questions'];\n  /**\n   * The `tool_call_id` of the ask-tool call that raised this interrupt,\n   * when the tool body supplied it (see `askUserQuestion`'s `options`).\n   * Lets hosts attribute the question — and later the answer — to the\n   * exact tool-call content part instead of guessing by position, which\n   * mislabels cards when a model emits several ask calls in one turn.\n   */\n  tool_call_id?: string;\n}\n\n/** Batch-specialized ask payload for hosts that render several questions. */\nexport interface AskUserQuestionsInterruptPayload\n  extends AskUserQuestionInterruptPayload {\n  questions: AskUserQuestionsRequest['questions'];\n}\n\n/**\n * Discriminated union of every interrupt payload the SDK raises. New\n * variants can be added without breaking existing handlers as long as\n * those handlers check `payload.type` before reading variant-specific\n * fields. Use the `isToolApprovalInterrupt` / `isAskUserQuestionInterrupt`\n * type guards for ergonomic narrowing.\n */\nexport type HumanInterruptPayload =\n  | ToolApprovalInterruptPayload\n  | AskUserQuestionInterruptPayload;\n\n/** Resume value the host returns for an `ask_user_question` interrupt. */\nexport interface AskUserQuestionResolution {\n  /**\n   * The human's answer. Free-form text, or — when `options` were\n   * provided — one of the option `value`s (or, when the request set\n   * `multiSelect`, several option `value`s joined by `\", \"`). Hosts may\n   * also send any structured object their custom UI defines; see the\n   * host docs for what your downstream consumer expects.\n   */\n  answer: string;\n}\n\n/** Resume value for a batched `ask_user_question` interrupt. */\nexport interface AskUserQuestionsResolution {\n  /** Human answers keyed by each `AskUserQuestionBatchItem.id`. */\n  answers: Record<string, string>;\n}\n\n/**\n * Type guard narrowing an arbitrary value to a `ToolApprovalInterruptPayload`.\n * Accepts `unknown` (not just `HumanInterruptPayload`) because hosts can\n * raise custom interrupt payloads from custom nodes — `getInterrupt()`\n * surfaces them as-is, and downstream code must validate the shape at\n * runtime before reading variant-specific fields.\n */\nexport function isToolApprovalInterrupt(\n  payload: unknown\n): payload is ToolApprovalInterruptPayload {\n  return (\n    typeof payload === 'object' &&\n    payload !== null &&\n    (payload as { type?: unknown }).type === 'tool_approval'\n  );\n}\n\n/**\n * Type guard narrowing an arbitrary value to an\n * `AskUserQuestionInterruptPayload`. Same `unknown`-tolerant contract\n * as `isToolApprovalInterrupt`.\n */\nexport function isAskUserQuestionInterrupt(\n  payload: unknown\n): payload is AskUserQuestionInterruptPayload {\n  return (\n    typeof payload === 'object' &&\n    payload !== null &&\n    (payload as { type?: unknown }).type === 'ask_user_question'\n  );\n}\n\n/**\n * Run-level configuration controlling HITL semantics. **HITL is OFF by\n * default** for now — the SDK ships the interrupt machinery, but the\n * default stays opt-in until host UIs (notably LibreChat) ship the\n * approval-rendering affordances needed to surface interrupts to end\n * users. Without that UI, an interrupt with no resolver looks like a\n * hung tool-call card. Hosts opt in explicitly with\n * `{ enabled: true }`. The intent is to flip this default to ON in a\n * future minor once the consumer ecosystem is ready to render\n * interrupts end-to-end.\n *\n * When enabled (`{ enabled: true }`):\n *\n *   - `PreToolUse` hooks returning `decision: 'ask'` raise a real\n *     LangGraph `interrupt()` instead of being treated as a synchronous\n *     deny.\n *   - `Run.create` installs a `MemorySaver` checkpointer fallback on the\n *     run's compile options if the host did not provide one, since\n *     LangGraph requires a checkpointer to suspend and resume.\n *\n * When disabled (the default — omitted, or `{ enabled: false }`):\n * `ask` decisions are fail-closed (blocked with an error\n * `ToolMessage`) and no checkpointer is implicitly attached. This\n * matches the pre-HITL behavior so existing hosts upgrading the SDK\n * see no change until they're ready to wire the resume UI.\n *\n * ## Scope: every tool the ToolNode runs\n *\n * The interrupt path is wired into both `dispatchToolEvents` (the\n * event-driven path) and `runDirectToolWithLifecycleHooks` (the\n * direct path used by `directToolNames` entries — graph-managed\n * handoff/subagent tools and every in-process `graphTool` instance).\n * `PreToolUse` hooks fire for every tool the ToolNode invokes, and\n * HITL approval gates every tool whose hook returns `'ask'` —\n * regardless of whether the tool is dispatched as an event or\n * invoked in-process. This convergence happened in two follow-up\n * commits to the original HITL surface (see `Graph.ts` —\n * `hookRegistry`/`humanInTheLoop` are passed in both\n * event-driven and legacy branches; and `ToolNode.runDirectToolWithLifecycleHooks`\n * — direct-path tools build their own single-tool `tool_approval`\n * payload and raise `interrupt()` the same way the event path does).\n *\n * Practical implications:\n *   - Every host gets the full HITL surface across every tool the\n *     model calls — event-dispatched, direct, mixed.\n *   - `createToolPolicyHook` and `createWorkspacePolicyHook` apply\n *     uniformly. A hook can be registered without knowing or caring\n *     which path the tool will take.\n *   - Direct tools that the host opted into via `directToolNames` no\n *     longer bypass policy. If you need a tool to skip the hook\n *     surface entirely, omit it from any registered matcher.\n *\n * ## Resume re-execution: every tool in the interrupted batch\n *\n * LangGraph rolls back to the start of the interrupted node on\n * resume. That means **every tool in the same batch as the one that\n * interrupted re-runs from the top on the resume pass**, not just\n * the interrupting tool, and not just the direct half (this used to\n * be framed as a direct-tool-specific concern; it is not — it\n * applies to event-dispatched siblings too). Practical contract:\n *\n *   - The body of the interrupting tool itself runs **once** total\n *     (the first pass interrupted *before* the body, the resume pass\n *     ran the body after the host's decision was applied).\n *   - The body of any sibling tool that already executed in the\n *     same batch before the interrupting tool runs **twice** — once\n *     on the first pass, once on the resume pass.\n *   - `PreToolUse` hooks fire **once per pass per tool**. A hook\n *     that always returns `'ask'` will loop forever on resume; real\n *     hooks should be deterministic w.r.t. inputs and use the\n *     `'ask' → host approves → resume → hook returns 'allow'`\n *     pattern, where the second-pass `allow` reflects the host\n *     having recorded the approval (e.g., a session-scoped approved-\n *     paths set keyed by `runId`).\n *\n * Consequence: any tool with side effects MUST be idempotent if\n * there's any chance another tool in the same batch could trigger\n * an interrupt. This applies equally to direct tools (handoffs,\n * subagents) and to event tools.\n *\n * ### Guarding non-idempotent siblings via `interruptingToolNames`\n *\n * The \"must be idempotent\" rule above is unavoidable in the general\n * case, but the SDK can protect siblings against the one interrupt\n * shape it can predict: a tool whose *body* raises `interrupt()`\n * mid-execution — the `ask_user_question` shape, where the tool\n * suspends the run to collect a human answer. Declare such tools in\n * `RunConfig.interruptingToolNames`\n * ({@link ToolNodeOptions.interruptingToolNames}) and the ToolNode\n * schedules them, within each batch, **ahead of** their\n * non-interrupting direct siblings. When one interrupts, the batch\n * unwinds before any declared-safe sibling has run, so the sibling\n * executes exactly once (on resume) instead of twice. Empirically:\n *\n *   - A **direct** sibling sharing the interrupter's in-process\n *     `Promise.all` is the only shape that double-executes; declaring\n *     the interrupter closes it.\n *   - An **event-dispatched** sibling is already safe without any\n *     config: the ToolNode awaits the whole direct group (where the\n *     body interrupt unwinds) before it dispatches event tools, so a\n *     dispatched sibling never runs on the first pass.\n *\n * This is a *scheduling* guard, not full resume idempotency: it only\n * covers tools that interrupt from their own body and only protects\n * siblings scheduled after them. It does not retroactively make a\n * `PreToolUse` `'ask'` gate on tool B stop tool A (already executed)\n * from re-running — unless B is itself declared interrupting, so it\n * runs first. Tools with side effects should still be written\n * idempotent as defense in depth.\n *\n * The guard only REORDERS the direct group — declaring a name does not\n * force it onto the direct path. The interrupting tool must already be a\n * real in-process graphTool (the only kind whose body can reach\n * `interrupt()`). A name that resolves to a schema-only event stub (an\n * inherited `toolDefinition` with no executable instance, e.g. in a\n * self-spawned child that scrubs `graphTools`) stays event-dispatched\n * and the ordering is a no-op for it.\n *\n * ## Note on idempotency\n *\n * Same root cause as the resume re-execution above: LangGraph\n * re-runs the interrupted node from the start on resume, which\n * fires `PreToolUse` hooks again. Hooks that produce side effects\n * (logging, external calls) will see at least two invocations per\n * paused turn — exactly two for the interrupting tool, possibly\n * more across siblings.\n */\nexport interface HumanInTheLoopConfig {\n  /**\n   * Master switch. Defaults to `false` — omit the field (or pass\n   * `false`) to keep HITL off, or set `true` to opt in once the host\n   * UI is ready to render and resolve `tool_approval` interrupts.\n   */\n  enabled?: boolean;\n}\n\n/**\n * Snapshot of an in-flight interrupt surfaced from `Run.processStream`\n * via `run.getInterrupt()`. Hosts persist this alongside their job\n * record so they can later call `Run.resume(decisions)` against a Run\n * compiled with the same `thread_id` / checkpointer.\n *\n * The `payload` type defaults to `HumanInterruptPayload` (the SDK's\n * built-in `tool_approval` / `ask_user_question` discriminated union)\n * for ergonomic narrowing in the common case. Hosts that raise custom\n * interrupt payloads from custom graph nodes can pass the type\n * parameter (`run.getInterrupt<MyCustom>()` or\n * `RunInterruptResult<MyCustom>`) — the SDK does not validate the\n * runtime shape, it just transports whatever the node passed to\n * `interrupt()`. Use the `isToolApprovalInterrupt` /\n * `isAskUserQuestionInterrupt` guards (which accept `unknown`) when\n * the source of the interrupt isn't statically known.\n */\nexport interface RunInterruptResult<TPayload = HumanInterruptPayload> {\n  /** Stable id of the LangGraph interrupt (from `Interrupt.id`). */\n  interruptId: string;\n  /** `thread_id` the run was bound to — required to resume. */\n  threadId?: string;\n  /** LangGraph checkpoint id that contains the paused interrupt task. */\n  checkpointId?: string;\n  /** LangGraph checkpoint namespace for the paused interrupt task. */\n  checkpointNs?: string;\n  /** Structured payload describing what needs human input. */\n  payload: TPayload;\n}\n"],"mappings":";;;;;;AAyQA,SAAgB,2BACd,SAC4C;CAC5C,OACE,OAAO,YAAY,YACnB,YAAY,QACX,QAA+B,SAAS;AAE7C"}
+{"version":3,"file":"hitl.cjs","names":[],"sources":["../../../src/types/hitl.ts"],"mappings":";AAyQA,SAAgB,2BACd,SAC4C;CAC5C,OACE,OAAO,YAAY,YACnB,YAAY,QACX,QAA+B,SAAS;AAE7C"}

package/dist/cjs/utils/callbacks.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"callbacks.cjs","names":["ensureHandler"],"sources":["../../../src/utils/callbacks.ts"],"sourcesContent":["import { ensureHandler } from '@langchain/core/callbacks/manager';\nimport type {\n  BaseCallbackHandler,\n  CallbackHandlerMethods,\n} from '@langchain/core/callbacks/base';\nimport type { Callbacks } from '@langchain/core/callbacks/manager';\n\nexport type CallbackEntry = BaseCallbackHandler | CallbackHandlerMethods;\n\nexport function appendCallbacks(\n  callbacks: Callbacks | undefined,\n  additions: readonly CallbackEntry[]\n): Callbacks {\n  if (additions.length === 0) {\n    return callbacks ?? [];\n  }\n\n  if (callbacks == null) {\n    return [...additions];\n  }\n\n  if (Array.isArray(callbacks)) {\n    return callbacks.concat(additions);\n  }\n\n  return callbacks.copy(additions.map(ensureHandler));\n}\n\nexport function findCallback(\n  callbacks: Callbacks | undefined,\n  predicate: (callback: CallbackEntry) => boolean\n): CallbackEntry | undefined {\n  if (callbacks == null) {\n    return undefined;\n  }\n\n  const handlers = Array.isArray(callbacks) ? callbacks : callbacks.handlers;\n  return handlers.find(predicate);\n}\n\nexport function filterCallbacks(\n  callbacks: Callbacks | undefined,\n  predicate: (callback: CallbackEntry) => boolean\n): Callbacks {\n  if (callbacks == null) {\n    return [];\n  }\n\n  if (Array.isArray(callbacks)) {\n    return callbacks.filter(predicate);\n  }\n\n  const filtered = callbacks.copy();\n  for (const handler of [...filtered.handlers]) {\n    if (!predicate(handler)) {\n      filtered.removeHandler(handler);\n    }\n  }\n  return filtered;\n}\n"],"mappings":";;AASA,SAAgB,gBACd,WACA,WACW;CACX,IAAI,UAAU,WAAW,GACvB,OAAO,aAAa,CAAC;CAGvB,IAAI,aAAa,MACf,OAAO,CAAC,GAAG,SAAS;CAGtB,IAAI,MAAM,QAAQ,SAAS,GACzB,OAAO,UAAU,OAAO,SAAS;CAGnC,OAAO,UAAU,KAAK,UAAU,IAAIA,kCAAAA,aAAa,CAAC;AACpD;AAEA,SAAgB,aACd,WACA,WAC2B;CAC3B,IAAI,aAAa,MACf;CAIF,QADiB,MAAM,QAAQ,SAAS,IAAI,YAAY,UAAU,SAAA,CAClD,KAAK,SAAS;AAChC;AAEA,SAAgB,gBACd,WACA,WACW;CACX,IAAI,aAAa,MACf,OAAO,CAAC;CAGV,IAAI,MAAM,QAAQ,SAAS,GACzB,OAAO,UAAU,OAAO,SAAS;CAGnC,MAAM,WAAW,UAAU,KAAK;CAChC,KAAK,MAAM,WAAW,CAAC,GAAG,SAAS,QAAQ,GACzC,IAAI,CAAC,UAAU,OAAO,GACpB,SAAS,cAAc,OAAO;CAGlC,OAAO;AACT"}
+{"version":3,"file":"callbacks.cjs","names":["ensureHandler"],"sources":["../../../src/utils/callbacks.ts"],"mappings":";;AASA,SAAgB,gBACd,WACA,WACW;CACX,IAAI,UAAU,WAAW,GACvB,OAAO,aAAa,CAAC;CAGvB,IAAI,aAAa,MACf,OAAO,CAAC,GAAG,SAAS;CAGtB,IAAI,MAAM,QAAQ,SAAS,GACzB,OAAO,UAAU,OAAO,SAAS;CAGnC,OAAO,UAAU,KAAK,UAAU,IAAIA,kCAAAA,aAAa,CAAC;AACpD;AAEA,SAAgB,aACd,WACA,WAC2B;CAC3B,IAAI,aAAa,MACf;CAIF,QADiB,MAAM,QAAQ,SAAS,IAAI,YAAY,UAAU,SAAA,CAClD,KAAK,SAAS;AAChC;AAEA,SAAgB,gBACd,WACA,WACW;CACX,IAAI,aAAa,MACf,OAAO,CAAC;CAGV,IAAI,MAAM,QAAQ,SAAS,GACzB,OAAO,UAAU,OAAO,SAAS;CAGnC,MAAM,WAAW,UAAU,KAAK;CAChC,KAAK,MAAM,WAAW,CAAC,GAAG,SAAS,QAAQ,GACzC,IAAI,CAAC,UAAU,OAAO,GACpB,SAAS,cAAc,OAAO;CAGlC,OAAO;AACT"}

package/dist/cjs/utils/errors.cjs

@@ -1,184 +1,86 @@
 let _langchain_core_errors = require("@langchain/core/errors");
 //#region src/utils/errors.ts
-/**
-* Context overflow error detection.
-*
-* Providers disagree on how they report "your input is bigger than I can
-* take" — the class thrown, the HTTP status, whether numbers are reported,
-* and even whether it arrives as an HTTP error at all. Every pattern below
-* was captured from a live over-limit request (see
-* `src/scripts/context-overflow-probe.ts` and
-* `docs/context-overflow-signatures.md`); nothing here is guessed.
-*
-* Consumed by the graph's overflow recovery loop, which converts a detection
-* into a forced summarization pass instead of surfacing the error.
-*/
-/**
-* Fraction of the believed budget the prompt must reach before an ambiguous
-* provider error is read as overflow. Well above normal traffic, low enough to
-* catch the case the budget itself was miscalibrated.
-*/
 const CONTEXT_PRESSURE_RATIO = .8;
-/**
-* Ordered most-specific first; the first match wins. Patterns that capture
-* both numbers come before the bare-phrase fallbacks for the same provider so
-* a recoverable error still yields the numbers when the provider reported
-* them.
-*/
 const OVERFLOW_PATTERNS = [
-	(
-	/** Anthropic, and Bedrock's passthrough of the same upstream. */
 	{
 		kind: "context_window",
 		re: /prompt is too long:\s*(\d+)\s*tokens\s*>\s*(\d+)\s*maximum/i,
 		requestedGroup: 1,
 		limitGroup: 2,
 		requestedIsPromptOnly: true
-	}),
-	(
-	/**
-	* OpenAI's own wording, which measures the messages and nothing else.
-	* Ordered ahead of the shared sentence below so the prompt-only reading is
-	* preferred when OpenAI is the one answering.
-	*/
+	},
 	{
 		kind: "context_window",
 		re: /maximum context length is\s*(\d+)\s*tokens\.\s*however,\s*your messages resulted in\s*(\d+)/i,
 		limitGroup: 1,
 		requestedGroup: 2,
 		requestedIsPromptOnly: true
-	}),
-	(
-	/**
-	* OpenRouter (`you requested about`) and DeepSeek (`you requested`). Their
-	* total folds in the completion allowance — both then break it down in
-	* parentheses, which `PROMPT_ONLY_BREAKDOWN_RE` recovers.
-	*/
+	},
 	{
 		kind: "context_window",
 		re: /maximum context length is\s*(\d+)\s*tokens\.\s*however,\s*you requested(?:\s*about)?\s*(\d+)/i,
 		limitGroup: 1,
 		requestedGroup: 2
-	}),
-	(
-	/**
-	* xAI. Says "prompt length" rather than "context length", and does not say
-	* whether the count it quotes includes the completion allowance — so it is
-	* not trusted as a prompt measurement.
-	*/
+	},
 	{
 		kind: "context_window",
 		re: /maximum prompt length is\s*(\d+)\s*(?:tokens\s*)?but the request contains\s*(\d+)\s*tokens/i,
 		limitGroup: 1,
 		requestedGroup: 2
-	}),
-	(
-	/** Mistral. */
+	},
 	{
 		kind: "context_window",
 		re: /prompt contains\s*(\d+)\s*tokens[^.]*?too large for model with\s*(\d+)\s*maximum context length/i,
 		requestedGroup: 1,
 		limitGroup: 2,
 		requestedIsPromptOnly: true
-	}),
-	(
-	/** Google Gemini / Vertex. Reports the ceiling only. */
+	},
 	{
 		kind: "context_window",
 		re: /input token count exceeds the maximum number of tokens allowed\s*\((\d+)\)/i,
 		limitGroup: 1
-	}),
-	(
-	/**
-	* OpenAI's token-bucket rejection. Numbers are validated by the caller:
-	* `Requested >= Limit` means no retry can ever succeed.
-	*/
+	},
 	{
 		kind: "request_too_large",
 		re: /request too large[\s\S]*?limit\s*(\d+),\s*requested\s*(\d+)/i,
 		limitGroup: 1,
 		requestedGroup: 2
-	}),
-	(
-	/** Bedrock (Llama upstream) and any provider naming the ceiling alone. */
+	},
 	{
 		kind: "context_window",
 		re: /(?:maximum context length|maximum prompt length) is\s*(\d+)\s*tokens/i,
 		limitGroup: 1
-	}),
-	(
-	/** Bedrock (Nova upstream). */
+	},
 	{
 		kind: "context_window",
 		re: /number of input tokens exceeds maximum length|input tokens exceeded/i
-	}),
-	(
-	/** Bedrock (Claude Sonnet upstream). */
+	},
 	{
 		kind: "context_window",
 		re: /\binput (?:is )?too long(?: for requested model)?\b/i
-	}),
-	(
-	/** OpenAI-compatible error code, and the phrases LangChain itself keys on. */
+	},
 	{
 		kind: "context_window",
 		re: /context[_ ]length[_ ]exceeded|input tokens exceed the configured limit|exceeds the context window|exceeds model context window/i
-	}),
-	(
-	/** Generic long-tail phrasings observed across OpenAI-compatible gateways. */
+	},
 	{
 		kind: "context_window",
 		re: /prompt is too long|too large for model|reduce the length of (?:the |your )?(?:messages|prompt)/i
-	}),
-	(
-	/**
-	* Vertex AI. Its gaxios path discards the API error document, so an
-	* over-limit prompt arrives as a bare status line with no reason —
-	* identical to every other 400 from the same endpoint. Only a corroborated
-	* near-budget prompt makes this readable as overflow.
-	*/
+	},
 	{
 		kind: "context_window",
 		re: /google request failed with status code 400(?!\s*:)/i,
 		requiresContextPressure: true
-	})
+	}
 ];
-/**
-* Errors that mention size or limits but are NOT recoverable by compaction.
-* Checked before the positive patterns.
-*
-* Note the deliberate precision: OpenAI's *recoverable* "Request too large"
-* body links to `platform.openai.com/account/rate-limits`, so a loose
-* /rate.?limit/ test would discard the very case this module exists to catch.
-* URLs are stripped from the haystack before matching, and genuine throttling
-* is matched on its own distinct phrasing.
-*/
 const NON_RECOVERABLE_RE = /rate limit reached|requests per (?:min|day)|\brpm\b|too many requests|insufficient[_ ]quota|quota exceeded|billing|payment required|invalid[_ ]api[_ ]key|authentication|unauthorized|permission denied|forbidden/i;
-/**
-* Output-cap complaints. `max_tokens` appears in both families, so these are
-* matched on the surrounding grammar rather than the bare parameter name.
-*/
 const OUTPUT_LIMIT_RE = /max_?(?:completion_?)?tokens\s*(?:must be|is too|cannot|exceeds|too large|greater than)|maximum number of output tokens|max_tokens.*less than or equal/i;
-/**
-* Recovers the input-only figure from providers that quote a combined total
-* and then break it down — OpenRouter's "(56811 of text input, 16 in the
-* output)" and DeepSeek's "(1179652 in the messages, 16 in the completion)".
-*/
 const PROMPT_ONLY_BREAKDOWN_RE = /\(\s*(\d+)\s*(?:of\s+text\s+input|in\s+the\s+messages|of\s+input|input\s+tokens)\b/i;
-/** Broader hints for the deliberately fuzzy `isLikelyContextOverflowError`. */
 const CONTEXT_OVERFLOW_HINT_RE = /413|payload too large|content_too_large|request entity too large|too many tokens|token count.*exceed|exceed.*token count/i;
 const MAX_CAUSE_DEPTH = 4;
 function asRecord(value) {
 	return typeof value === "object" && value !== null ? value : void 0;
 }
-/**
-* Flattens an error into a single searchable string.
-*
-* Necessary because providers bury the useful sentence at different depths:
-* Anthropic puts a JSON document in `message`, Mistral puts one in `body`,
-* LangChain's `ContextOverflowError` keeps the original API error under
-* `cause`, and the OpenAI SDK nests the body under `error`.
-*/
 function collectErrorText(error, depth = 0) {
 	if (error == null || depth > MAX_CAUSE_DEPTH) return "";
 	if (typeof error === "string") return error;
@@ -203,14 +105,12 @@ function collectErrorText(error, depth = 0) {
 		parts.push(typeof nested === "string" ? nested : collectErrorText(nested, depth + 1));
 	}
 	if (parts.length === 0) try {
-		/** Non-objects returned above, so this always yields a string. */
 		return JSON.stringify(error);
 	} catch {
 		return String(error);
 	}
 	return parts.join(" ");
 }
-/** Strips URLs so their path segments cannot trip the negative matchers. */
 function stripUrls(text) {
 	return text.replace(/https?:\/\/\S+/gi, " ");
 }
@@ -219,13 +119,6 @@ function readNumber(match, group) {
 	const parsed = Number(match[group]);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
 }
-/**
-* The provider's count of the prompt alone: its own breakdown when it gave
-* one, otherwise the quoted total but only for providers that quote the
-* prompt rather than the whole request. Returns undefined when the number on
-* offer includes the completion allowance, since treating that as a prompt
-* measurement would overstate how much the prompt has to shrink.
-*/
 function resolvePromptTokens(haystack, pattern, requestedTokens) {
 	const breakdown = haystack.match(PROMPT_ONLY_BREAKDOWN_RE);
 	if (breakdown != null) {
@@ -234,11 +127,6 @@ function resolvePromptTokens(haystack, pattern, requestedTokens) {
 	}
 	return pattern.requestedIsPromptOnly === true ? requestedTokens : void 0;
 }
-/**
-* True when the caller's own accounting says the failed prompt was close
-* enough to the budget that an otherwise ambiguous provider error is best
-* explained by overflow.
-*/
 function hasContextPressure(context) {
 	const estimated = context?.estimatedPromptTokens;
 	const budget = context?.maxContextTokens;
@@ -247,21 +135,15 @@ function hasContextPressure(context) {
 }
 function isLangChainOverflowError(error) {
 	if (_langchain_core_errors.ContextOverflowError.isInstance(error)) return true;
-	/** Duplicate `@langchain/core` copies break branding; the name survives. */
 	const record = asRecord(error);
 	return record?.name === "ContextOverflowError" || record?.lc_error_code === "CONTEXT_OVERFLOW";
 }
-/**
-* Extracts a human-readable error message from an unknown error value.
-*/
 function extractErrorMessage(error) {
 	if (error == null) return "";
 	if (typeof error === "string") return error;
 	if (error instanceof Error) return error.message;
 	const record = asRecord(error);
-	if (record == null)
- /** Functions and symbols serialize to nothing; describe them instead. */
-	return String(error);
+	if (record == null) return String(error);
 	if (typeof record.message === "string") return record.message;
 	if (typeof record.error === "string") return record.error;
 	const nested = asRecord(record.error);
@@ -272,18 +154,6 @@ function extractErrorMessage(error) {
 		return String(error);
 	}
 }
-/**
-* Classifies a provider error as a recoverable context overflow, returning
-* whatever the provider disclosed about the limit and the request size.
-*
-* Returns `null` for anything that compaction cannot fix — genuine
-* throttling, auth, quota, and output-token-cap errors all mention limits
-* and must not be mistaken for overflow.
-*
-* The reported numbers are the point of the return value: they let the
-* caller retarget the token budget to the provider's real ceiling instead of
-* retrying blindly against a configured value that was evidently wrong.
-*/
 function getContextOverflowInfo(error, context) {
 	const provider = context?.provider;
 	const haystack = stripUrls(collectErrorText(error));
@@ -298,13 +168,6 @@ function getContextOverflowInfo(error, context) {
 		if (pattern.requiresContextPressure === true && !underContextPressure) continue;
 		const limitTokens = readNumber(match, pattern.limitGroup);
 		const requestedTokens = readNumber(match, pattern.requestedGroup);
-		/**
-		* A token-bucket rejection is only unrecoverable-by-waiting when the
-		* request alone overruns the bucket. When it merely fills it, the account
-		* was busy and the request will fit once the window drains — so equality
-		* belongs on the retry side, not the compaction side. Losing conversation
-		* history to a temporarily busy account is the worse error.
-		*/
 		if (pattern.kind === "request_too_large" && limitTokens != null && requestedTokens != null && requestedTokens <= limitTokens) return null;
 		return {
 			kind: pattern.kind,
@@ -322,23 +185,9 @@ function getContextOverflowInfo(error, context) {
 	};
 	return null;
 }
-/**
-* Returns true if the error definitively indicates a context overflow.
-*
-* Accepts either a raw error or a pre-extracted message; passing the error
-* itself is preferred, since several providers report the decisive detail in
-* a nested body rather than in `message`.
-*/
 function isContextOverflowError(error, context) {
 	return getContextOverflowInfo(error, context) != null;
 }
-/**
-* Returns true if the error likely indicates a context overflow, adding
-* body-size and token-count heuristics on top of the definitive patterns.
-*
-* May produce false positives on unusual messages. Use when the cost of
-* being wrong is one extra compaction pass.
-*/
 function isLikelyContextOverflowError(error, context) {
 	if (isContextOverflowError(error, context)) return true;
 	const haystack = stripUrls(collectErrorText(error));

package/dist/cjs/utils/errors.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.cjs","names":["ContextOverflowError"],"sources":["../../../src/utils/errors.ts"],"sourcesContent":["/**\n * Context overflow error detection.\n *\n * Providers disagree on how they report \"your input is bigger than I can\n * take\" — the class thrown, the HTTP status, whether numbers are reported,\n * and even whether it arrives as an HTTP error at all. Every pattern below\n * was captured from a live over-limit request (see\n * `src/scripts/context-overflow-probe.ts` and\n * `docs/context-overflow-signatures.md`); nothing here is guessed.\n *\n * Consumed by the graph's overflow recovery loop, which converts a detection\n * into a forced summarization pass instead of surfacing the error.\n */\nimport { ContextOverflowError } from '@langchain/core/errors';\nimport type { Providers } from '@/common';\n\n/**\n * Why the request was rejected. Both kinds are fixed by shrinking the\n * prompt, which is what makes them recoverable; they are distinguished\n * because only `context_window` tells us the model's true window.\n */\nexport type ContextOverflowKind =\n  /** Input exceeded the model's context window. */\n  | 'context_window'\n  /**\n   * A single request exceeded a per-minute token allowance. Waiting cannot\n   * help — the request can never fit the bucket — so this is a payload\n   * problem wearing a 429, not throttling.\n   */\n  | 'request_too_large';\n\nexport interface ContextOverflowInfo {\n  kind: ContextOverflowKind;\n  /** Ceiling the provider reported, when it named one. */\n  limitTokens?: number;\n  /**\n   * Token count the provider attributed to the whole request. Several\n   * providers fold the requested completion allowance into this number, so it\n   * is not interchangeable with the prompt size.\n   */\n  requestedTokens?: number;\n  /**\n   * The prompt alone, counted by the provider — set only when the provider\n   * distinguished input from output, either by reporting an input-only figure\n   * or by breaking the total down. Callers comparing provider counts against\n   * their own prompt estimate must use this and not `requestedTokens`, whose\n   * completion component would inflate the comparison.\n   */\n  promptTokens?: number;\n  /** Which layer produced the verdict. Surfaced in logs and asserted in tests. */\n  source: 'langchain' | 'pattern';\n  provider?: Providers;\n}\n\ninterface OverflowPattern {\n  readonly kind: ContextOverflowKind;\n  readonly re: RegExp;\n  readonly limitGroup?: number;\n  readonly requestedGroup?: number;\n  /**\n   * Whether `requestedGroup` counts the prompt alone. Providers that report a\n   * combined input+completion total leave this false, and their number is\n   * never used as a prompt measurement.\n   */\n  readonly requestedIsPromptOnly?: boolean;\n  /**\n   * Marks a signature that is consistent with overflow but not exclusive to\n   * it, so it only counts when the caller can corroborate that the prompt was\n   * actually near the budget. Without corroboration the error propagates\n   * untouched rather than triggering a needless compaction.\n   */\n  readonly requiresContextPressure?: boolean;\n}\n\n/**\n * Fraction of the believed budget the prompt must reach before an ambiguous\n * provider error is read as overflow. Well above normal traffic, low enough to\n * catch the case the budget itself was miscalibrated.\n */\nconst CONTEXT_PRESSURE_RATIO = 0.8;\n\nexport interface ContextOverflowContext {\n  provider?: Providers;\n  /** Our own estimate of the prompt size for the call that failed. */\n  estimatedPromptTokens?: number;\n  /** The budget we believed applied when we built that prompt. */\n  maxContextTokens?: number;\n}\n\n/**\n * Ordered most-specific first; the first match wins. Patterns that capture\n * both numbers come before the bare-phrase fallbacks for the same provider so\n * a recoverable error still yields the numbers when the provider reported\n * them.\n */\nconst OVERFLOW_PATTERNS: readonly OverflowPattern[] = [\n  /** Anthropic, and Bedrock's passthrough of the same upstream. */\n  {\n    kind: 'context_window',\n    re: /prompt is too long:\\s*(\\d+)\\s*tokens\\s*>\\s*(\\d+)\\s*maximum/i,\n    requestedGroup: 1,\n    limitGroup: 2,\n    requestedIsPromptOnly: true,\n  },\n  /**\n   * OpenAI's own wording, which measures the messages and nothing else.\n   * Ordered ahead of the shared sentence below so the prompt-only reading is\n   * preferred when OpenAI is the one answering.\n   */\n  {\n    kind: 'context_window',\n    re: /maximum context length is\\s*(\\d+)\\s*tokens\\.\\s*however,\\s*your messages resulted in\\s*(\\d+)/i,\n    limitGroup: 1,\n    requestedGroup: 2,\n    requestedIsPromptOnly: true,\n  },\n  /**\n   * OpenRouter (`you requested about`) and DeepSeek (`you requested`). Their\n   * total folds in the completion allowance — both then break it down in\n   * parentheses, which `PROMPT_ONLY_BREAKDOWN_RE` recovers.\n   */\n  {\n    kind: 'context_window',\n    re: /maximum context length is\\s*(\\d+)\\s*tokens\\.\\s*however,\\s*you requested(?:\\s*about)?\\s*(\\d+)/i,\n    limitGroup: 1,\n    requestedGroup: 2,\n  },\n  /**\n   * xAI. Says \"prompt length\" rather than \"context length\", and does not say\n   * whether the count it quotes includes the completion allowance — so it is\n   * not trusted as a prompt measurement.\n   */\n  {\n    kind: 'context_window',\n    re: /maximum prompt length is\\s*(\\d+)\\s*(?:tokens\\s*)?but the request contains\\s*(\\d+)\\s*tokens/i,\n    limitGroup: 1,\n    requestedGroup: 2,\n  },\n  /** Mistral. */\n  {\n    kind: 'context_window',\n    re: /prompt contains\\s*(\\d+)\\s*tokens[^.]*?too large for model with\\s*(\\d+)\\s*maximum context length/i,\n    requestedGroup: 1,\n    limitGroup: 2,\n    requestedIsPromptOnly: true,\n  },\n  /** Google Gemini / Vertex. Reports the ceiling only. */\n  {\n    kind: 'context_window',\n    re: /input token count exceeds the maximum number of tokens allowed\\s*\\((\\d+)\\)/i,\n    limitGroup: 1,\n  },\n  /**\n   * OpenAI's token-bucket rejection. Numbers are validated by the caller:\n   * `Requested >= Limit` means no retry can ever succeed.\n   */\n  {\n    kind: 'request_too_large',\n    re: /request too large[\\s\\S]*?limit\\s*(\\d+),\\s*requested\\s*(\\d+)/i,\n    limitGroup: 1,\n    requestedGroup: 2,\n  },\n  /** Bedrock (Llama upstream) and any provider naming the ceiling alone. */\n  {\n    kind: 'context_window',\n    re: /(?:maximum context length|maximum prompt length) is\\s*(\\d+)\\s*tokens/i,\n    limitGroup: 1,\n  },\n  /** Bedrock (Nova upstream). */\n  {\n    kind: 'context_window',\n    re: /number of input tokens exceeds maximum length|input tokens exceeded/i,\n  },\n  /** Bedrock (Claude Sonnet upstream). */\n  {\n    kind: 'context_window',\n    re: /\\binput (?:is )?too long(?: for requested model)?\\b/i,\n  },\n  /** OpenAI-compatible error code, and the phrases LangChain itself keys on. */\n  {\n    kind: 'context_window',\n    re: /context[_ ]length[_ ]exceeded|input tokens exceed the configured limit|exceeds the context window|exceeds model context window/i,\n  },\n  /** Generic long-tail phrasings observed across OpenAI-compatible gateways. */\n  {\n    kind: 'context_window',\n    re: /prompt is too long|too large for model|reduce the length of (?:the |your )?(?:messages|prompt)/i,\n  },\n  /**\n   * Vertex AI. Its gaxios path discards the API error document, so an\n   * over-limit prompt arrives as a bare status line with no reason —\n   * identical to every other 400 from the same endpoint. Only a corroborated\n   * near-budget prompt makes this readable as overflow.\n   */\n  {\n    kind: 'context_window',\n    re: /google request failed with status code 400(?!\\s*:)/i,\n    requiresContextPressure: true,\n  },\n] as const;\n\n/**\n * Errors that mention size or limits but are NOT recoverable by compaction.\n * Checked before the positive patterns.\n *\n * Note the deliberate precision: OpenAI's *recoverable* \"Request too large\"\n * body links to `platform.openai.com/account/rate-limits`, so a loose\n * /rate.?limit/ test would discard the very case this module exists to catch.\n * URLs are stripped from the haystack before matching, and genuine throttling\n * is matched on its own distinct phrasing.\n */\nconst NON_RECOVERABLE_RE =\n  /rate limit reached|requests per (?:min|day)|\\brpm\\b|too many requests|insufficient[_ ]quota|quota exceeded|billing|payment required|invalid[_ ]api[_ ]key|authentication|unauthorized|permission denied|forbidden/i;\n\n/**\n * Output-cap complaints. `max_tokens` appears in both families, so these are\n * matched on the surrounding grammar rather than the bare parameter name.\n */\nconst OUTPUT_LIMIT_RE =\n  /max_?(?:completion_?)?tokens\\s*(?:must be|is too|cannot|exceeds|too large|greater than)|maximum number of output tokens|max_tokens.*less than or equal/i;\n\n/**\n * Recovers the input-only figure from providers that quote a combined total\n * and then break it down — OpenRouter's \"(56811 of text input, 16 in the\n * output)\" and DeepSeek's \"(1179652 in the messages, 16 in the completion)\".\n */\nconst PROMPT_ONLY_BREAKDOWN_RE =\n  /\\(\\s*(\\d+)\\s*(?:of\\s+text\\s+input|in\\s+the\\s+messages|of\\s+input|input\\s+tokens)\\b/i;\n\n/** Broader hints for the deliberately fuzzy `isLikelyContextOverflowError`. */\nconst CONTEXT_OVERFLOW_HINT_RE =\n  /413|payload too large|content_too_large|request entity too large|too many tokens|token count.*exceed|exceed.*token count/i;\n\nconst MAX_CAUSE_DEPTH = 4;\n\ninterface NestedErrorShape {\n  message?: unknown;\n  code?: unknown;\n  type?: unknown;\n  status?: unknown;\n  reason?: unknown;\n  error?: unknown;\n  cause?: unknown;\n  body?: unknown;\n  response?: unknown;\n  /** gaxios-style clients (Vertex AI) put the API error document here. */\n  data?: unknown;\n}\n\nfunction asRecord(value: unknown): NestedErrorShape | undefined {\n  return typeof value === 'object' && value !== null\n    ? (value as NestedErrorShape)\n    : undefined;\n}\n\n/**\n * Flattens an error into a single searchable string.\n *\n * Necessary because providers bury the useful sentence at different depths:\n * Anthropic puts a JSON document in `message`, Mistral puts one in `body`,\n * LangChain's `ContextOverflowError` keeps the original API error under\n * `cause`, and the OpenAI SDK nests the body under `error`.\n */\nfunction collectErrorText(error: unknown, depth = 0): string {\n  if (error == null || depth > MAX_CAUSE_DEPTH) {\n    return '';\n  }\n  if (typeof error === 'string') {\n    return error;\n  }\n  const record = asRecord(error);\n  if (record == null) {\n    return String(error);\n  }\n\n  const parts: string[] = [];\n  if (typeof record.message === 'string') {\n    parts.push(record.message);\n  }\n  for (const reason of [\n    record.code,\n    record.type,\n    record.status,\n    record.reason,\n  ]) {\n    if (typeof reason === 'string') {\n      parts.push(reason);\n    }\n  }\n  for (const nested of [\n    record.error,\n    record.cause,\n    record.body,\n    record.data,\n    record.response,\n  ]) {\n    if (nested == null) {\n      continue;\n    }\n    parts.push(\n      typeof nested === 'string' ? nested : collectErrorText(nested, depth + 1)\n    );\n  }\n  if (parts.length === 0) {\n    try {\n      /** Non-objects returned above, so this always yields a string. */\n      return JSON.stringify(error);\n    } catch {\n      return String(error);\n    }\n  }\n  return parts.join(' ');\n}\n\n/** Strips URLs so their path segments cannot trip the negative matchers. */\nfunction stripUrls(text: string): string {\n  return text.replace(/https?:\\/\\/\\S+/gi, ' ');\n}\n\nfunction readNumber(\n  match: RegExpMatchArray,\n  group?: number\n): number | undefined {\n  if (group == null) {\n    return undefined;\n  }\n  const parsed = Number(match[group]);\n  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;\n}\n\n/**\n * The provider's count of the prompt alone: its own breakdown when it gave\n * one, otherwise the quoted total but only for providers that quote the\n * prompt rather than the whole request. Returns undefined when the number on\n * offer includes the completion allowance, since treating that as a prompt\n * measurement would overstate how much the prompt has to shrink.\n */\nfunction resolvePromptTokens(\n  haystack: string,\n  pattern: OverflowPattern,\n  requestedTokens: number | undefined\n): number | undefined {\n  const breakdown = haystack.match(PROMPT_ONLY_BREAKDOWN_RE);\n  if (breakdown != null) {\n    const parsed = Number(breakdown[1]);\n    if (Number.isFinite(parsed) && parsed > 0) {\n      return parsed;\n    }\n  }\n  return pattern.requestedIsPromptOnly === true ? requestedTokens : undefined;\n}\n\n/**\n * True when the caller's own accounting says the failed prompt was close\n * enough to the budget that an otherwise ambiguous provider error is best\n * explained by overflow.\n */\nfunction hasContextPressure(context?: ContextOverflowContext): boolean {\n  const estimated = context?.estimatedPromptTokens;\n  const budget = context?.maxContextTokens;\n  if (\n    estimated == null ||\n    budget == null ||\n    !Number.isFinite(estimated) ||\n    !Number.isFinite(budget) ||\n    budget <= 0\n  ) {\n    return false;\n  }\n  return estimated / budget >= CONTEXT_PRESSURE_RATIO;\n}\n\nfunction isLangChainOverflowError(error: unknown): boolean {\n  if (ContextOverflowError.isInstance(error)) {\n    return true;\n  }\n  /** Duplicate `@langchain/core` copies break branding; the name survives. */\n  const record = asRecord(error) as\n    | { name?: unknown; lc_error_code?: unknown }\n    | undefined;\n  return (\n    record?.name === 'ContextOverflowError' ||\n    record?.lc_error_code === 'CONTEXT_OVERFLOW'\n  );\n}\n\n/**\n * Extracts a human-readable error message from an unknown error value.\n */\nexport function extractErrorMessage(error: unknown): string {\n  if (error == null) {\n    return '';\n  }\n  if (typeof error === 'string') {\n    return error;\n  }\n  if (error instanceof Error) {\n    return error.message;\n  }\n  const record = asRecord(error);\n  if (record == null) {\n    /** Functions and symbols serialize to nothing; describe them instead. */\n    return String(error);\n  }\n  if (typeof record.message === 'string') {\n    return record.message;\n  }\n  if (typeof record.error === 'string') {\n    return record.error;\n  }\n  const nested = asRecord(record.error);\n  if (typeof nested?.message === 'string') {\n    return nested.message;\n  }\n  try {\n    return JSON.stringify(error);\n  } catch {\n    return String(error);\n  }\n}\n\n/**\n * Classifies a provider error as a recoverable context overflow, returning\n * whatever the provider disclosed about the limit and the request size.\n *\n * Returns `null` for anything that compaction cannot fix — genuine\n * throttling, auth, quota, and output-token-cap errors all mention limits\n * and must not be mistaken for overflow.\n *\n * The reported numbers are the point of the return value: they let the\n * caller retarget the token budget to the provider's real ceiling instead of\n * retrying blindly against a configured value that was evidently wrong.\n */\nexport function getContextOverflowInfo(\n  error: unknown,\n  context?: ContextOverflowContext\n): ContextOverflowInfo | null {\n  const provider = context?.provider;\n  const haystack = stripUrls(collectErrorText(error));\n  if (haystack === '') {\n    return null;\n  }\n\n  if (OUTPUT_LIMIT_RE.test(haystack)) {\n    return null;\n  }\n\n  const langChainFlagged = isLangChainOverflowError(error);\n  if (!langChainFlagged && NON_RECOVERABLE_RE.test(haystack)) {\n    return null;\n  }\n\n  const underContextPressure = hasContextPressure(context);\n\n  for (const pattern of OVERFLOW_PATTERNS) {\n    const match = haystack.match(pattern.re);\n    if (match == null) {\n      continue;\n    }\n    if (pattern.requiresContextPressure === true && !underContextPressure) {\n      continue;\n    }\n    const limitTokens = readNumber(match, pattern.limitGroup);\n    const requestedTokens = readNumber(match, pattern.requestedGroup);\n\n    /**\n     * A token-bucket rejection is only unrecoverable-by-waiting when the\n     * request alone overruns the bucket. When it merely fills it, the account\n     * was busy and the request will fit once the window drains — so equality\n     * belongs on the retry side, not the compaction side. Losing conversation\n     * history to a temporarily busy account is the worse error.\n     */\n    if (\n      pattern.kind === 'request_too_large' &&\n      limitTokens != null &&\n      requestedTokens != null &&\n      requestedTokens <= limitTokens\n    ) {\n      return null;\n    }\n\n    return {\n      kind: pattern.kind,\n      limitTokens,\n      requestedTokens,\n      promptTokens: resolvePromptTokens(haystack, pattern, requestedTokens),\n      source: 'pattern',\n      provider,\n    };\n  }\n\n  if (langChainFlagged) {\n    return { kind: 'context_window', source: 'langchain', provider };\n  }\n\n  return null;\n}\n\n/**\n * Returns true if the error definitively indicates a context overflow.\n *\n * Accepts either a raw error or a pre-extracted message; passing the error\n * itself is preferred, since several providers report the decisive detail in\n * a nested body rather than in `message`.\n */\nexport function isContextOverflowError(\n  error?: unknown,\n  context?: ContextOverflowContext\n): boolean {\n  return getContextOverflowInfo(error, context) != null;\n}\n\n/**\n * Returns true if the error likely indicates a context overflow, adding\n * body-size and token-count heuristics on top of the definitive patterns.\n *\n * May produce false positives on unusual messages. Use when the cost of\n * being wrong is one extra compaction pass.\n */\nexport function isLikelyContextOverflowError(\n  error?: unknown,\n  context?: ContextOverflowContext\n): boolean {\n  if (isContextOverflowError(error, context)) {\n    return true;\n  }\n  const haystack = stripUrls(collectErrorText(error));\n  if (haystack === '' || OUTPUT_LIMIT_RE.test(haystack)) {\n    return false;\n  }\n  if (NON_RECOVERABLE_RE.test(haystack)) {\n    return false;\n  }\n  return CONTEXT_OVERFLOW_HINT_RE.test(haystack);\n}\n"],"mappings":"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"}
+{"version":3,"file":"errors.cjs","names":["ContextOverflowError"],"sources":["../../../src/utils/errors.ts"],"mappings":"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"}

package/dist/cjs/utils/events.cjs

@@ -2,10 +2,6 @@ require("../common/enum.cjs");
 require("../common/index.cjs");
 let _langchain_core_callbacks_dispatch = require("@langchain/core/callbacks/dispatch");
 //#region src/utils/events.ts
-/**
-* Safely dispatches a custom event and properly awaits it to avoid
-* race conditions where events are dispatched after run cleanup.
-*/
 async function safeDispatchCustomEvent(event, payload, config) {
 	try {
 		await (0, _langchain_core_callbacks_dispatch.dispatchCustomEvent)(event, payload, config);
@@ -16,12 +12,6 @@ async function safeDispatchCustomEvent(event, payload, config) {
 		return false;
 	}
 }
-/**
-* Fire-and-forget diagnostic log event.
-* Debug-level logs are gated behind AGENT_DEBUG_LOGGING=true to avoid
-* overhead in production. Info/warn/error always flow through.
-* Pass `force: true` to bypass the env-var gate (e.g. invoke timing).
-*/
 function emitAgentLog(config, level, scope, message, data, meta, options) {
 	if (!config) return;
 	if (level === "debug" && !(options?.force ?? false) && process.env.AGENT_DEBUG_LOGGING !== "true") return;

package/dist/cjs/utils/events.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"events.cjs","names":[],"sources":["../../../src/utils/events.ts"],"sourcesContent":["/* eslint-disable no-console */\n// src/utils/events.ts\nimport { dispatchCustomEvent } from '@langchain/core/callbacks/dispatch';\nimport type { RunnableConfig } from '@langchain/core/runnables';\nimport type { AgentLogEvent } from '@/types/graph';\nimport { GraphEvents } from '@/common';\n\n/**\n * Safely dispatches a custom event and properly awaits it to avoid\n * race conditions where events are dispatched after run cleanup.\n */\nexport async function safeDispatchCustomEvent(\n  event: string,\n  payload: unknown,\n  config?: RunnableConfig\n): Promise<boolean | void> {\n  try {\n    await dispatchCustomEvent(event, payload, config);\n    return true;\n  } catch (e) {\n    // Check if this is the known EventStreamCallbackHandler error\n    if (\n      e instanceof Error &&\n      e.message.includes('handleCustomEvent: Run ID') &&\n      e.message.includes('not found in run map')\n    ) {\n      // Suppress this specific error - it's expected during parallel execution\n      // when EventStreamCallbackHandler loses track of run IDs\n      // console.debug('Suppressed error dispatching custom event:', e);\n      return false;\n    }\n    // Log other errors\n    console.error('Error dispatching custom event:', e);\n    return false;\n  }\n}\n\n/**\n * Fire-and-forget diagnostic log event.\n * Debug-level logs are gated behind AGENT_DEBUG_LOGGING=true to avoid\n * overhead in production. Info/warn/error always flow through.\n * Pass `force: true` to bypass the env-var gate (e.g. invoke timing).\n */\nexport function emitAgentLog(\n  config: RunnableConfig | undefined,\n  level: AgentLogEvent['level'],\n  scope: AgentLogEvent['scope'],\n  message: string,\n  data?: Record<string, unknown>,\n  meta?: { runId?: string; agentId?: string },\n  options?: { force?: boolean }\n): void {\n  if (!config) return;\n  if (\n    level === 'debug' &&\n    !(options?.force ?? false) &&\n    process.env.AGENT_DEBUG_LOGGING !== 'true'\n  )\n    return;\n  void safeDispatchCustomEvent(\n    GraphEvents.ON_AGENT_LOG,\n    { level, scope, message, data, ...meta } satisfies AgentLogEvent,\n    config\n  );\n}\n"],"mappings":";;;;;;;;AAWA,eAAsB,wBACpB,OACA,SACA,QACyB;CACzB,IAAI;EACF,OAAA,GAAA,mCAAA,oBAAA,CAA0B,OAAO,SAAS,MAAM;EAChD,OAAO;CACT,SAAS,GAAG;EAEV,IACE,aAAa,SACb,EAAE,QAAQ,SAAS,2BAA2B,KAC9C,EAAE,QAAQ,SAAS,sBAAsB,GAKzC,OAAO;EAGT,QAAQ,MAAM,mCAAmC,CAAC;EAClD,OAAO;CACT;AACF;;;;;;;AAQA,SAAgB,aACd,QACA,OACA,OACA,SACA,MACA,MACA,SACM;CACN,IAAI,CAAC,QAAQ;CACb,IACE,UAAU,WACV,EAAE,SAAS,SAAS,UACpB,QAAQ,IAAI,wBAAwB,QAEpC;CACF,wBAAK,gBAEH;EAAE;EAAO;EAAO;EAAS;EAAM,GAAG;CAAK,GACvC,MACF;AACF"}
+{"version":3,"file":"events.cjs","names":[],"sources":["../../../src/utils/events.ts"],"mappings":";;;;AAWA,eAAsB,wBACpB,OACA,SACA,QACyB;CACzB,IAAI;EACF,OAAA,GAAA,mCAAA,oBAAA,CAA0B,OAAO,SAAS,MAAM;EAChD,OAAO;CACT,SAAS,GAAG;EAEV,IACE,aAAa,SACb,EAAE,QAAQ,SAAS,2BAA2B,KAC9C,EAAE,QAAQ,SAAS,sBAAsB,GAKzC,OAAO;EAGT,QAAQ,MAAM,mCAAmC,CAAC;EAClD,OAAO;CACT;AACF;AAQA,SAAgB,aACd,QACA,OACA,OACA,SACA,MACA,MACA,SACM;CACN,IAAI,CAAC,QAAQ;CACb,IACE,UAAU,WACV,EAAE,SAAS,SAAS,UACpB,QAAQ,IAAI,wBAAwB,QAEpC;CACF,wBAAK,gBAEH;EAAE;EAAO;EAAO;EAAS;EAAM,GAAG;CAAK,GACvC,MACF;AACF"}

package/dist/cjs/utils/graph.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"graph.cjs","names":[],"sources":["../../../src/utils/graph.ts"],"sourcesContent":["export const resetIfNotEmpty = <T>(value: T, resetValue: T): T => {\n  if (Array.isArray(value)) {\n    return value.length > 0 ? resetValue : value;\n  }\n  if (value instanceof Set || value instanceof Map) {\n    return value.size > 0 ? resetValue : value;\n  }\n  return value !== undefined ? resetValue : value;\n};\n\nexport const joinKeys = (args: (string | number | undefined)[]): string => args.join('_');"],"mappings":";AAAA,MAAa,mBAAsB,OAAU,eAAqB;CAChE,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,SAAS,IAAI,aAAa;CAEzC,IAAI,iBAAiB,OAAO,iBAAiB,KAC3C,OAAO,MAAM,OAAO,IAAI,aAAa;CAEvC,OAAO,UAAU,KAAA,IAAY,aAAa;AAC5C;AAEA,MAAa,YAAY,SAAkD,KAAK,KAAK,GAAG"}
+{"version":3,"file":"graph.cjs","names":[],"sources":["../../../src/utils/graph.ts"],"mappings":";AAAA,MAAa,mBAAsB,OAAU,eAAqB;CAChE,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,SAAS,IAAI,aAAa;CAEzC,IAAI,iBAAiB,OAAO,iBAAiB,KAC3C,OAAO,MAAM,OAAO,IAAI,aAAa;CAEvC,OAAO,UAAU,KAAA,IAAY,aAAa;AAC5C;AAEA,MAAa,YAAY,SAAkD,KAAK,KAAK,GAAG"}

package/dist/cjs/utils/handlers.cjs

@@ -3,9 +3,6 @@ require("../common/index.cjs");
 const require_stream = require("../stream.cjs");
 const require_events = require("../events.cjs");
 //#region src/utils/handlers.ts
-/**
-* Creates handlers with content aggregation for multi-agent scripts
-*/
 function createHandlers(callbacks) {
 	const { contentParts, aggregateContent } = require_stream.createContentAggregator();
 	return {