@librechat/agents 3.4.6 → 3.5.0

package/dist/cjs/llm/streamLimits.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"streamLimits.cjs","names":["getStreamedToolCallSeal"],"sources":["../../../src/llm/streamLimits.ts"],"sourcesContent":["// src/llm/streamLimits.ts\nimport type { ToolCallChunk } from '@langchain/core/messages/tool';\nimport type * as t from '@/types';\nimport { getStreamedToolCallSeal } from '@/tools/streamedToolCallSeals';\n\n/**\n * Circuit breakers for pathological model streams.\n *\n * A malformed generation can stream a single tool call's arguments for many\n * minutes at the provider's full token rate while the arguments never become\n * executable (observed live: one 149,923-char SQL argument streamed for 26\n * minutes before the 64k output-token ceiling finally ended the run). These\n * guards fail fast instead: when a limit trips, the stream handler throws\n * `StreamLimitExceededError` out of the run's `streamEvents` loop, which\n * tears down the in-flight provider request where it stands (see the\n * mid-flight halt notes in `Run.processStream`: leaving the loop cancels the\n * reader and langgraph aborts the model call).\n */\n\n/** Default cap on a single streamed tool call's cumulative argument bytes (64 KiB). */\nexport const DEFAULT_MAX_TOOL_CALL_ARG_BYTES = 65_536;\n\n/** Limits normalized by {@link resolveStreamLimits}; `0` uniformly means disabled. */\nexport interface ResolvedStreamLimits {\n  maxToolCallArgBytes: number;\n  /** Per-tool overrides of the byte cap, keyed by model-facing tool name. */\n  maxToolCallArgBytesByTool?: Readonly<Record<string, number>>;\n  maxDeltaEventsPerTurn: number;\n  /** Precomputed once: whether ANY argument byte limit can fire. False when\n   * the global cap is disabled and every per-tool entry is a zero-valued\n   * disable — accounting must not allocate for guards that judge nothing. */\n  hasEnforceableToolCallArgLimit: boolean;\n}\n\n/** Cumulative streamed argument bytes for one in-flight tool call. */\nexport interface StreamedToolCallArgTally {\n  bytes: number;\n  name?: string;\n  /** The graph's breaker epoch when this tally was created. Entries from\n   * the epoch that is ending survive one `resetValues` sweep, so producer\n   * loops of straggling attempts — which are not behind the consumer-only\n   * epoch gate — stay on their original budgets instead of receiving a\n   * fresh allowance at every run start. */\n  epoch?: number;\n  /** Every tally-map key this tally is registered under: its primary key\n   * (which can migrate through identifier transitions), the batch-position\n   * fallback for id-bearing chunks, and the id for chunks carrying both\n   * identifiers. Release deletes all of them — a call sealed through one\n   * identity must not leave entries behind under another. */\n  keys?: string[];\n  /**\n   * True when the previous chunk ended on an unpaired UTF-16 high surrogate.\n   * Counting each half of a split surrogate pair alone yields 3 bytes per\n   * half (the replacement-character encoding) versus 4 for the pair, so the\n   * next chunk starting with the low surrogate reconciles by subtracting 2.\n   */\n  pendingHighSurrogate?: boolean;\n}\n\n/** Immutable snapshot of one run's breaker identity. Captured at\n * model/event/tool-batch entry and revalidated by REFERENCE after awaits —\n * one identity comparison proves no reset interleaved. */\nexport interface RunBreakerScope {\n  readonly epoch: number;\n  readonly controller: AbortController;\n}\n\n/** Streamed chunk events counted against one generation's event cap. */\nexport interface StreamDeltaEventTally {\n  count: number;\n  /** Creation-epoch tag, same grace semantics as\n   * {@link StreamedToolCallArgTally.epoch}. */\n  epoch?: number;\n}\n\n/**\n * The graph-owned state the guards read and write. Structural on purpose:\n * handler-level tests stub graphs with plain objects, and the guards lazily\n * create the tally maps so partial stubs need no extra setup.\n */\nexport interface StreamLimitState {\n  streamLimits?: ResolvedStreamLimits;\n  streamedToolCallArgTallies?: Map<string, StreamedToolCallArgTally>;\n  streamDeltaEventCounts?: Map<string, StreamDeltaEventTally>;\n  /** The graph's live breaker epoch; new accounting entries are tagged with\n   * it so `resetValues` can sweep by age instead of clearing outright. */\n  breakerEpoch?: number;\n  /** Generation keys of model attempts still in flight. Each attempt leases\n   * its generation at entry and releases it (with its accounting entries)\n   * from its `finally`, so retention follows ATTEMPT LIFETIME — a\n   * cancellation-ignoring straggler keeps its original budget no matter how\n   * many runs start and reset while it drains. */\n  activeStreamLimitGenerations?: Set<string>;\n  /** Per-chunk-object, per-generation charge balance: producer visits\n   * increment, consumer (handler echo) visits decrement, and a visit only\n   * charges when the other side has not pre-charged the same emission.\n   * Count-balancing rather than a lifetime set, because a streaming model\n   * may mutate and re-yield the same chunk object; scoped by generation so\n   * parallel generations sharing one reused object cannot cancel each\n   * other's charges. */\n  streamLimitChargeCredits?: WeakMap<object, Map<string, number>>;\n}\n\nfunction resolveLimit(value: number | undefined, fallback: number): number {\n  if (value == null || Number.isNaN(value)) {\n    return fallback;\n  }\n  if (!Number.isFinite(value)) {\n    return 0;\n  }\n  const whole = Math.floor(value);\n  return whole > 0 ? whole : 0;\n}\n\n/**\n * Normalizes host-supplied limits once at graph construction. `undefined`\n * applies the default for each guard (the tool-argument byte cap is ON by\n * default, the per-turn event cap is opt-in), `0` and negative values\n * disable a guard, `Infinity` means \"no limit\" and also disables, and `NaN`\n * falls back to the default.\n */\nexport function resolveStreamLimits(\n  limits?: t.StreamLimits\n): ResolvedStreamLimits {\n  const maxToolCallArgBytes = resolveLimit(\n    limits?.maxToolCallArgBytes,\n    DEFAULT_MAX_TOOL_CALL_ARG_BYTES\n  );\n  let maxToolCallArgBytesByTool: Record<string, number> | undefined;\n  if (limits?.maxToolCallArgBytesByTool != null) {\n    for (const [name, value] of Object.entries(\n      limits.maxToolCallArgBytesByTool\n    )) {\n      /** An unusable entry (NaN) falls back to the global cap by omission,\n       * matching how the global field treats NaN. */\n      if (name === '' || Number.isNaN(value)) {\n        continue;\n      }\n      /** Prototype-free: bracket-assigning a `__proto__` tool name into a\n       * plain object invokes the prototype setter instead of creating an own\n       * property, silently dropping that tool's configured override. */\n      maxToolCallArgBytesByTool ??= Object.create(null) as Record<\n        string,\n        number\n      >;\n      maxToolCallArgBytesByTool[name] = resolveLimit(\n        value,\n        maxToolCallArgBytes\n      );\n    }\n  }\n  const hasEnforceableToolCallArgLimit =\n    maxToolCallArgBytes > 0 ||\n    (maxToolCallArgBytesByTool != null &&\n      Object.values(maxToolCallArgBytesByTool).some((value) => value > 0));\n  return {\n    maxToolCallArgBytes,\n    ...(maxToolCallArgBytesByTool != null && { maxToolCallArgBytesByTool }),\n    maxDeltaEventsPerTurn: resolveLimit(limits?.maxDeltaEventsPerTurn, 0),\n    hasEnforceableToolCallArgLimit,\n  };\n}\n\nconst DEFAULT_RESOLVED_LIMITS: ResolvedStreamLimits = resolveStreamLimits();\n\nexport type StreamLimitKind = 'tool_call_args' | 'delta_events';\n\nfunction buildLimitMessage(\n  kind: StreamLimitKind,\n  limit: number,\n  toolName?: string\n): string {\n  if (kind === 'tool_call_args') {\n    const named =\n      toolName != null && toolName !== '' ? ` (tool call: ${toolName})` : '';\n    return (\n      `Streamed tool call arguments exceeded the ${limit}-byte safety limit${named}. ` +\n      'The generation was aborted mid-stream: arguments growing this large without completing ' +\n      'usually indicate a runaway or malformed tool call. Raise \\'maxToolCallArgBytes\\' (or the ' +\n      'tool\\'s \\'maxToolCallArgBytesByTool\\' entry) if your tools legitimately need larger arguments.'\n    );\n  }\n  return (\n    `Model stream exceeded the ${limit}-event safety limit for a single generation turn. ` +\n    'The generation was aborted mid-stream: this usually indicates a looping or duplicated ' +\n    'provider stream. Raise \\'maxDeltaEventsPerTurn\\' if legitimate generations need more stream events.'\n  );\n}\n\n/**\n * Raised when a {@link t.StreamLimits} guard trips. Thrown from inside the\n * run's `streamEvents` loop, so the in-flight provider request is torn down\n * and `processStream` rejects with this error.\n */\nexport class StreamLimitExceededError extends Error {\n  readonly kind: StreamLimitKind;\n  readonly limit: number;\n  readonly observed: number;\n  readonly toolName?: string;\n\n  constructor({\n    kind,\n    limit,\n    observed,\n    toolName,\n  }: {\n    kind: StreamLimitKind;\n    limit: number;\n    observed: number;\n    toolName?: string;\n  }) {\n    super(buildLimitMessage(kind, limit, toolName));\n    this.name = 'StreamLimitExceededError';\n    this.kind = kind;\n    this.limit = limit;\n    this.observed = observed;\n    this.toolName = toolName;\n  }\n}\n\n/**\n * Identity of one model generation, derived from langgraph's node-execution\n * metadata. Deliberately NOT `Graph.getStepKey()`: the step key forks within\n * a single generation on reasoning transitions (`'reasoning'` /\n * `post-reasoning-<n>` suffixes in `getKeyList`) and on mid-turn server-tool\n * results (`invokedToolIds` count), which would hand a fresh budget to each\n * segment. One agent-node execution is one superstep, so\n * `checkpoint_ns + node + step` stays stable for the whole generation and\n * distinguishes parallel agents in the same superstep.\n *\n * The attempt stamp scopes attempts within one node execution:\n * `attemptInvoke` is the single funnel for primary, fallback, and\n * summarization model calls and stamps {@link STREAM_LIMIT_ATTEMPT_KEY}\n * with a unique sequence number into each attempt's callback metadata. A\n * fallback's chunks therefore key separately from the failed primary's,\n * even for two fallbacks configured with the same provider and model name,\n * and even when the decoupled `streamEvents` reader drains a failed\n * attempt's buffered chunks late. Those late chunks land in their own\n * attempt's bucket instead of polluting the next one's.\n */\nexport function resolveGenerationKey(\n  metadata: Record<string, unknown> | undefined\n): string {\n  if (metadata == null) {\n    return '';\n  }\n  const checkpointNs = metadata.langgraph_checkpoint_ns ?? '';\n  const node = metadata.langgraph_node ?? '';\n  const step = metadata.langgraph_step ?? '';\n  const attempt = metadata[STREAM_LIMIT_ATTEMPT_KEY] ?? '';\n  return `${checkpointNs}|${node}|${step}|${attempt}`;\n}\n\n/**\n * Metadata key carrying the unique per-model-attempt sequence number that\n * `attemptInvoke` stamps into every attempt's callback metadata. Part of\n * the generation key so budgets never alias across attempts.\n */\nexport const STREAM_LIMIT_ATTEMPT_KEY = 'lc_stream_limit_attempt';\n\n/**\n * Event-metadata marker for a chunk the SDK re-dispatches inline after\n * transforming it (`attemptInvoke`'s OpenRouter final-reasoning replay). The\n * original wire chunk still reaches the handler through `streamEvents` and\n * is counted there, so the re-dispatch must not consume a second\n * event-budget slot.\n */\nexport const STREAM_LIMIT_REDISPATCH_KEY = 'lc_stream_limit_redispatch';\n\n/**\n * Metadata key carrying the graph's breaker epoch at the time a model\n * attempt started. The stream handler trips the shared breaker only when\n * the event's epoch matches the live controller's — a straggling chunk from\n * a failed run that outlived `resetValues()` must fail its own (dead) run,\n * not abort the controller now serving the next one. A primitive rather\n * than the controller itself so attempt metadata stays serialization-safe\n * for tracing.\n */\nexport const STREAM_LIMIT_EPOCH_KEY = 'lc_stream_limit_epoch';\n\n/**\n * Configurable key carrying the tool batch's entry-captured\n * {@link RunBreakerScope} to tools that spawn their own runs (subagents).\n * Captured BEFORE PreToolUse hooks, so a reset during a hook cannot rebind\n * the spawned child to the new run's controller. Stripped from host-facing\n * batch requests and from child-graph configurables.\n */\nexport const RUN_BREAKER_SCOPE_CONFIG_KEY = 'lc_run_breaker_scope';\n\n/**\n * True when the event's `single` seal marks this chunk's own call as\n * complete. On the OpenAI Responses adapter the sealing chunk RESTATES the\n * full argument string (`response.function_call_arguments.done`), so summing\n * it would double-count every legitimate call; on Bedrock Converse the\n * sealing chunk carries empty args. Either way the call is finished: its\n * tally is replaced by the sealing chunk's own bytes, checked, and released.\n */\nfunction sealsChunk(\n  seal: ReturnType<typeof getStreamedToolCallSeal>,\n  chunk: ToolCallChunk\n): boolean {\n  if (seal == null || seal.kind !== 'single') {\n    return false;\n  }\n  /** Either supplied identifier agreeing is sufficient (matching the\n   * eager-call seal handling in stream.ts): a mismatch on one identifier\n   * must not veto a match on the other, or an OpenAI-style full-argument\n   * restatement gets ADDED to the tally instead of replacing it, and an\n   * empty seal leaves the tally unreleased. */\n  if (\n    seal.index != null &&\n    chunk.index != null &&\n    seal.index === chunk.index\n  ) {\n    return true;\n  }\n  const sealId = seal.id != null && seal.id !== '' ? seal.id : undefined;\n  return sealId != null && sealId === chunkCallId(chunk);\n}\n\nfunction chunkToolName(chunk: ToolCallChunk): string | undefined {\n  return chunk.name != null && chunk.name !== '' ? chunk.name : undefined;\n}\n\n/** The chunk's id with empty-string placeholders treated as absent —\n * OpenAI-compatible adapters emit `id: ''` on continuation deltas, and a\n * shared placeholder must not merge independent calls onto one identity\n * (mirrors `getEagerToolChunkKey`). */\nfunction chunkCallId(chunk: ToolCallChunk): string | undefined {\n  return chunk.id != null && chunk.id !== '' ? chunk.id : undefined;\n}\n\nfunction isHighSurrogate(code: number): boolean {\n  return code >= 0xd800 && code <= 0xdbff;\n}\n\nfunction isLowSurrogate(code: number): boolean {\n  return code >= 0xdc00 && code <= 0xdfff;\n}\n\n/**\n * Accumulates the UTF-8 byte size of streamed tool-call argument chunks per\n * in-flight tool call and throws once a single call's cumulative bytes\n * exceed `maxToolCallArgBytes`. Runs once per streamed chunk event, before\n * complete tool calls are dispatched or eagerly executed and before chunks\n * are recorded, so a tripped limit stops the run without dispatching the\n * offending call.\n *\n * Calls are keyed by generation and chunk `index`, falling back to the\n * chunk `id` and then to the chunk's position within the event's batch when\n * a provider identifies chunks by neither (Google emits complete parallel\n * calls with optional ids and no index). A `kind: 'all'` arrival seal marks\n * every chunk in the event as its own complete call, so those are checked\n * standalone and never share a budget; a matching `kind: 'single'` seal\n * replaces the call's tally with the sealing chunk's own bytes (the OpenAI\n * Responses done-chunk restates the full argument string) and releases it.\n */\nexport function enforceStreamedToolCallArgLimit({\n  graph,\n  metadata,\n  toolCallChunks,\n  responseMetadata,\n  parsedToolCalls,\n}: {\n  graph: StreamLimitState;\n  metadata: Record<string, unknown> | undefined;\n  toolCallChunks: ToolCallChunk[];\n  responseMetadata?: Record<string, unknown>;\n  /** Complete parsed calls from the same event, used to name anonymous raw\n   * chunks so per-tool overrides are honored before the global cap trips. */\n  parsedToolCalls?: CompleteToolCallLike[];\n}): void {\n  const resolved = graph.streamLimits ?? DEFAULT_RESOLVED_LIMITS;\n  const globalLimit = resolved.maxToolCallArgBytes;\n  const byTool = resolved.maxToolCallArgBytesByTool;\n  if (!resolved.hasEnforceableToolCallArgLimit) {\n    return;\n  }\n  /** An inline re-dispatch of a transformed chunk (OpenRouter final-reasoning\n   * replay) duplicates tool-call chunks the original `streamEvents` event\n   * already charged — the original always survives the content-specific\n   * skips when it carries tool calls, so counting the marked copy would\n   * double every legitimate argument byte. */\n  if (metadata?.[STREAM_LIMIT_REDISPATCH_KEY] === true) {\n    return;\n  }\n  const tallies: Map<string, StreamedToolCallArgTally> =\n    (graph.streamedToolCallArgTallies ??= new Map<\n      string,\n      StreamedToolCallArgTally\n    >());\n  const generationKey = resolveGenerationKey(metadata);\n  const seal = getStreamedToolCallSeal(responseMetadata);\n  /** The complete call in this event sharing the chunk's id — the strongest\n   * name evidence: adapters may stream raw names in FRAGMENTS, and an\n   * id-correlated complete call states the full name outright. */\n  const correlateParsedNameById = (id: string): string | undefined => {\n    if (parsedToolCalls == null) {\n      return undefined;\n    }\n    for (const parsed of parsedToolCalls) {\n      if (parsed.id === id && parsed.name != null && parsed.name !== '') {\n        return parsed.name;\n      }\n    }\n    return undefined;\n  };\n  const generationPrefix = `${generationKey}:`;\n  const getLiveGenerationTallies = (): StreamedToolCallArgTally[] => {\n    const live = new Set<StreamedToolCallArgTally>();\n    for (const [tallyKey, tally] of tallies) {\n      if (tallyKey.startsWith(generationPrefix)) {\n        live.add(tally);\n      }\n    }\n    return [...live];\n  };\n  const resolveChunkName = (chunk: ToolCallChunk): string | undefined => {\n    const chunkId = chunkCallId(chunk);\n    const correlated =\n      chunkId != null ? correlateParsedNameById(chunkId) : undefined;\n    if (correlated != null) {\n      return correlated;\n    }\n    const name = chunkToolName(chunk);\n    if (name != null || parsedToolCalls == null || chunkId != null) {\n      return name;\n    }\n    /** No id to correlate on; positional association is unambiguous only\n     * when the event carries exactly one raw chunk AND one parsed call —\n     * with several id-less raw chunks in flight, handing one parsed call's\n     * name (and its override) to all of them would let an unrelated\n     * still-partial call bypass the global cap. */\n    if (parsedToolCalls.length === 1 && toolCallChunks.length === 1) {\n      const only = parsedToolCalls[0];\n      if (only.name != null && only.name !== '') {\n        return only.name;\n      }\n    }\n    return undefined;\n  };\n  const enforceTallyLimit = (target: StreamedToolCallArgTally): void => {\n    const tallyLimit =\n      byTool != null &&\n      target.name != null &&\n      Object.hasOwn(byTool, target.name)\n        ? byTool[target.name]\n        : globalLimit;\n    if (tallyLimit > 0 && target.bytes > tallyLimit) {\n      throw new StreamLimitExceededError({\n        kind: 'tool_call_args',\n        limit: tallyLimit,\n        observed: target.bytes,\n        toolName: target.name,\n      });\n    }\n  };\n  for (let i = 0; i < toolCallChunks.length; i++) {\n    const chunk = toolCallChunks[i];\n    const args = chunk.args;\n    const hasArgs = typeof args === 'string' && args !== '';\n    if (seal?.kind === 'all') {\n      if (!hasArgs) {\n        continue;\n      }\n      const bytes = Buffer.byteLength(args, 'utf8');\n      const sealedName = resolveChunkName(chunk);\n      const limit =\n        byTool != null && sealedName != null && Object.hasOwn(byTool, sealedName)\n          ? byTool[sealedName]\n          : globalLimit;\n      if (limit > 0 && bytes > limit) {\n        throw new StreamLimitExceededError({\n          kind: 'tool_call_args',\n          limit,\n          observed: bytes,\n          toolName: sealedName,\n        });\n      }\n      continue;\n    }\n    /** Keys are namespaced by identity kind (`i:` index, `c:` id, `#`\n     * batch position) so an index and a string id with the same textual\n     * value — index 0 and id \"0\" — cannot alias distinct calls onto one\n     * tally. Empty-string ids are placeholders, not identities. */\n    const chunkId = chunkCallId(chunk);\n    const sealed = sealsChunk(seal, chunk);\n    /** Applies this chunk's name contribution and reports whether the\n     * effective name changed. Adapters may stream the name in FRAGMENTS\n     * (\"create_\" then \"file\"), so unsealed fragments append — matching\n     * langchain's own tool-call-chunk merge — while a sealing chunk's name\n     * is a full restatement and replaces, mirroring how sealed args replace\n     * the tally bytes. An id-correlated complete call in the same event\n     * outranks both; positional parsed-call correlation fills in only when\n     * the chunk carries no fragment. */\n    const applyChunkName = (target: StreamedToolCallArgTally): boolean => {\n      const correlated =\n        chunkId != null ? correlateParsedNameById(chunkId) : undefined;\n      const fragment = chunkToolName(chunk);\n      let next = target.name;\n      if (correlated != null) {\n        /** An id-correlated complete call wins over fragment accumulation:\n         * a raw name like \"create_\" must not hide the \"create_file\"\n         * override behind the global cap. */\n        next = correlated;\n      } else if (fragment != null) {\n        if (sealed || target.name == null) {\n          next = fragment;\n        } else if (fragment !== target.name) {\n          /** A fragment identical to the accumulated name is a repeated\n           * full-name delta (a common provider shape) and is a no-op; a\n           * differing fragment is a continuation and appends. */\n          next = target.name + fragment;\n        }\n      } else if (target.name == null) {\n        next = resolveChunkName(chunk);\n      }\n      if (next === target.name) {\n        return false;\n      }\n      target.name = next;\n      return true;\n    };\n    /** A single identifier-less event while calls are live is a sparse\n     * parallel continuation: its position is relative to this event, not to\n     * the original batch, so `#0` cannot identify which call it belongs to.\n     * With exactly one live call the association is unambiguous — charge\n     * that tally, keeping its budget continuous (a fresh `#0` tally here\n     * would RESET the sole remaining call's byte budget). With several,\n     * charge every live candidate. Each tally is judged under its OWN\n     * name-specific limit: comparing only against the global cap would let\n     * a call with a lower per-tool override stream past it indefinitely\n     * while its chunks stay anonymous. */\n    if (\n      chunk.index == null &&\n      chunkId == null &&\n      toolCallChunks.length === 1\n    ) {\n      const liveTallies = getLiveGenerationTallies();\n      if (liveTallies.length > 0) {\n        if (liveTallies.length === 1 && applyChunkName(liveTallies[0])) {\n          /** A late name can select a lower override than the limit under\n           * which prior bytes were accepted, so re-judge before charging\n           * this continuation. */\n          enforceTallyLimit(liveTallies[0]);\n        }\n        if (hasArgs) {\n          const argBytes = Buffer.byteLength(args, 'utf8');\n          for (const liveTally of liveTallies) {\n            const reconcilesSplitPair =\n              liveTally.pendingHighSurrogate === true &&\n              isLowSurrogate(args.charCodeAt(0));\n            liveTally.bytes += reconcilesSplitPair ? argBytes - 2 : argBytes;\n            liveTally.pendingHighSurrogate = isHighSurrogate(\n              args.charCodeAt(args.length - 1)\n            );\n            enforceTallyLimit(liveTally);\n          }\n        }\n        continue;\n      }\n    }\n    let key: string;\n    if (chunk.index != null) {\n      key = `${generationKey}:i:${chunk.index}`;\n    } else if (chunkId != null) {\n      key = `${generationKey}:c:${chunkId}`;\n    } else {\n      key = `${generationKey}:#${i}`;\n    }\n    /** Batch position is a stable identity only when the event carries a\n     * single chunk: sparse parallel events reuse position 0 for whichever\n     * call happens to continue, and a position alias would hand one call's\n     * tally — and its per-tool override — to another live call's deltas. */\n    const positionAliasSafe = toolCallChunks.length === 1;\n    /** Secondary keys this call is also reachable under, so a later delta\n     * that drops one or both identifiers still lands on the same tally:\n     * id-bearing chunks register the batch-position fallback (single-chunk\n     * events only), and chunks carrying both identifiers additionally\n     * register the id. */\n    const aliasCandidates: string[] = [];\n    if (chunkId != null) {\n      if (positionAliasSafe) {\n        aliasCandidates.push(`${generationKey}:#${i}`);\n      }\n      if (chunk.index != null) {\n        aliasCandidates.push(`${generationKey}:c:${chunkId}`);\n      }\n    }\n    let tally = tallies.get(key);\n    /** A later delta can also ADD an identifier, changing the primary key;\n     * adopt the call's existing tally through a stronger prior identity\n     * before allocating. An index maps to that call's original batch\n     * position, never this sparse event's position. A newly arrived id can\n     * adopt a position only when one anonymous tally is live; with several,\n     * positional association is ambiguous. The old identity is recorded as\n     * an alias and released together with the rest. */\n    if (tally == null) {\n      const adoptionCandidates: string[] = [];\n      if (chunkId != null) {\n        adoptionCandidates.push(`${generationKey}:c:${chunkId}`);\n      }\n      if (chunk.index != null) {\n        /** An index is stable across sparse events; the loop position is\n         * merely this event's position and may be 0 for call index 1. */\n        const indexedPositionKey = `${generationKey}:#${chunk.index}`;\n        adoptionCandidates.push(indexedPositionKey);\n        /** A single anonymous call may first appear alone at event position\n         * #0 and reveal a nonzero provider index only later. Exact indexed\n         * position wins above; when it does not exist, one anonymous tally\n         * is still an unambiguous fallback. */\n        const liveTallies = getLiveGenerationTallies();\n        const soleTally = liveTallies.length === 1 ? liveTallies[0] : undefined;\n        if (\n          soleTally?.keys?.[0]?.startsWith(`${generationPrefix}#`) === true\n        ) {\n          const anonymousKey = soleTally.keys[0];\n          if (anonymousKey !== indexedPositionKey) {\n            adoptionCandidates.push(anonymousKey);\n          }\n        }\n      } else if (chunkId != null) {\n        const anonymousTallies = getLiveGenerationTallies().filter(\n          (liveTally: StreamedToolCallArgTally) =>\n            liveTally.keys?.[0]?.startsWith(`${generationPrefix}#`) === true\n        );\n        if (anonymousTallies.length === 1) {\n          const anonymousKey = anonymousTallies[0].keys?.[0];\n          if (anonymousKey != null) {\n            adoptionCandidates.push(anonymousKey);\n          }\n        }\n      }\n      for (const adoptionKey of adoptionCandidates) {\n        if (adoptionKey === key) {\n          continue;\n        }\n        const existing = tallies.get(adoptionKey);\n        if (existing == null) {\n          continue;\n        }\n        /** A position entry may only be adopted when the tally was CREATED\n         * anonymous (its first key is the position): id-bearing calls also\n         * alias their position, and adopting a live parallel call's alias\n         * would merge distinct budgets. */\n        if (\n          adoptionKey.includes(':#') &&\n          existing.keys?.[0] !== adoptionKey\n        ) {\n          continue;\n        }\n        tally = existing;\n        tallies.set(key, existing);\n        if (existing.keys?.includes(adoptionKey) !== true) {\n          (existing.keys ??= []).push(adoptionKey);\n        }\n        if (!existing.keys.includes(key)) {\n          existing.keys.push(key);\n        }\n        break;\n      }\n    }\n    const registerAliasKeys = (\n      target: StreamedToolCallArgTally,\n      candidates: string[]\n    ): void => {\n      for (const aliasKey of candidates) {\n        const currentOwner = tallies.get(aliasKey);\n        if (currentOwner === target) {\n          continue;\n        }\n        /** Parallel calls can contend for one batch position, so the newest\n         * live call takes the alias over and the previous owner is disowned\n         * — its seal must not delete a key it no longer holds. */\n        if (currentOwner?.keys != null) {\n          const remaining = currentOwner.keys.filter(\n            (ownedKey: string) => ownedKey !== aliasKey\n          );\n          currentOwner.keys = remaining.length > 0 ? remaining : undefined;\n        }\n        tallies.set(aliasKey, target);\n        (target.keys ??= []).push(aliasKey);\n      }\n    };\n    const registerAliases = (target: StreamedToolCallArgTally): void => {\n      registerAliasKeys(target, aliasCandidates);\n    };\n    /** Index-only calls register their batch position ONCE, at creation:\n     * later deltas that drop the index then land on the same tally, while\n     * the per-delta hot path (indexed id-less deltas) stays free of alias\n     * work. */\n    const registerCreationPositionAlias = (\n      target: StreamedToolCallArgTally\n    ): void => {\n      if (chunkId != null || chunk.index == null || sealed) {\n        return;\n      }\n      if (!positionAliasSafe) {\n        return;\n      }\n      registerAliasKeys(target, [`${generationKey}:#${i}`]);\n    };\n    const releaseTally = (target: StreamedToolCallArgTally): void => {\n      tallies.delete(key);\n      if (target.keys == null) {\n        return;\n      }\n      for (const aliasKey of target.keys) {\n        if (tallies.get(aliasKey) === target) {\n          tallies.delete(aliasKey);\n        }\n      }\n    };\n    if (!hasArgs) {\n      if (tally == null) {\n        if (!sealed) {\n          tally = {\n            bytes: 0,\n            name: resolveChunkName(chunk),\n            keys: [key],\n            epoch: graph.breakerEpoch,\n          };\n          tallies.set(key, tally);\n          registerAliases(tally);\n          registerCreationPositionAlias(tally);\n        }\n        continue;\n      }\n      /** A sealing chunk is about to release this tally; taking the position\n       * alias here would steal it from a still-live parallel call. */\n      if (!sealed) {\n        registerAliases(tally);\n      }\n      if (applyChunkName(tally)) {\n        /** Bytes tallied under the previous (or absent) name were held\n         * against that name's limit; a changed name — late arrival or a\n         * completed fragment — must re-judge them, including on a sealing\n         * chunk about to release the tally. */\n        enforceTallyLimit(tally);\n      }\n      if (sealed) {\n        releaseTally(tally);\n      }\n      continue;\n    }\n    if (tally == null) {\n      tally = { bytes: 0, keys: [key], epoch: graph.breakerEpoch };\n      tallies.set(key, tally);\n      registerCreationPositionAlias(tally);\n    }\n    if (!sealed) {\n      registerAliases(tally);\n    }\n    applyChunkName(tally);\n    const argBytes = Buffer.byteLength(args, 'utf8');\n    if (sealed) {\n      tally.bytes = argBytes;\n    } else {\n      const reconcilesSplitPair =\n        tally.pendingHighSurrogate === true &&\n        isLowSurrogate(args.charCodeAt(0));\n      tally.bytes += reconcilesSplitPair ? argBytes - 2 : argBytes;\n    }\n    tally.pendingHighSurrogate =\n      !sealed && isHighSurrogate(args.charCodeAt(args.length - 1));\n    const toolName = tally.name ?? resolveChunkName(chunk);\n    const limit =\n      byTool != null && toolName != null && Object.hasOwn(byTool, toolName)\n        ? byTool[toolName]\n        : globalLimit;\n    if (limit > 0 && tally.bytes > limit) {\n      throw new StreamLimitExceededError({\n        kind: 'tool_call_args',\n        limit,\n        observed: tally.bytes,\n        toolName,\n      });\n    }\n    if (sealed) {\n      releaseTally(tally);\n    }\n  }\n}\n\n/** Structural subset of a complete parsed tool call. */\ninterface CompleteToolCallLike {\n  id?: string;\n  name?: string;\n  args?: unknown;\n}\n\n/**\n * Standalone byte check for complete parsed tool calls that arrive without a\n * raw chunk representation: a streaming custom or OpenAI-compatible\n * `ChatModel` can yield fully parsed `tool_calls` with empty\n * `tool_call_chunks`, which would otherwise dispatch without consuming any\n * byte budget. Complete calls are self-contained, so each is judged\n * standalone without tallying.\n */\nexport function enforceCompleteToolCallArgLimit({\n  graph,\n  metadata,\n  toolCalls,\n}: {\n  graph: StreamLimitState;\n  metadata: Record<string, unknown> | undefined;\n  toolCalls: CompleteToolCallLike[];\n}): void {\n  const resolved = graph.streamLimits ?? DEFAULT_RESOLVED_LIMITS;\n  const globalLimit = resolved.maxToolCallArgBytes;\n  const byTool = resolved.maxToolCallArgBytesByTool;\n  if (!resolved.hasEnforceableToolCallArgLimit) {\n    return;\n  }\n  if (metadata?.[STREAM_LIMIT_REDISPATCH_KEY] === true) {\n    return;\n  }\n  for (const toolCall of toolCalls) {\n    const name =\n      toolCall.name != null && toolCall.name !== '' ? toolCall.name : undefined;\n    const limit =\n      byTool != null && name != null && Object.hasOwn(byTool, name)\n        ? byTool[name]\n        : globalLimit;\n    if (limit <= 0) {\n      continue;\n    }\n    const args = toolCall.args;\n    let serialized: string;\n    if (typeof args === 'string') {\n      serialized = args;\n    } else if (args == null) {\n      serialized = '';\n    } else {\n      serialized = JSON.stringify(args);\n    }\n    const bytes = Buffer.byteLength(serialized, 'utf8');\n    if (bytes > limit) {\n      throw new StreamLimitExceededError({\n        kind: 'tool_call_args',\n        limit,\n        observed: bytes,\n        toolName: name,\n      });\n    }\n  }\n}\n\n/**\n * Whether a chunk needs charge accounting at all. With the event cap off\n * (the default) and no tool payload on the chunk, there is nothing a claim\n * could ever gate — skipping restores the documented zero-cost-disabled\n * behavior by avoiding a WeakMap entry and nested Map per ordinary text\n * delta. Both the producer and consumer paths use this same predicate on\n * the same chunk, so claim pairing is unaffected.\n */\nexport function requiresStreamLimitAccounting(\n  graph: StreamLimitState,\n  chunk: {\n    tool_call_chunks?: unknown[];\n    tool_calls?: unknown[];\n    invalid_tool_calls?: unknown[];\n  }\n): boolean {\n  const resolved = graph.streamLimits ?? DEFAULT_RESOLVED_LIMITS;\n  if (resolved.maxDeltaEventsPerTurn > 0) {\n    return true;\n  }\n  /** With no argument limit able to fire (byte cap disabled and every\n   * per-tool entry a zero-valued disable), neither enforcement function can\n   * trip — hosts that explicitly disable the guards for legitimate large\n   * arguments must not pay per-chunk claim allocations (generation keys,\n   * WeakMap entries, nested Maps) for bookkeeping that judges nothing. */\n  if (!resolved.hasEnforceableToolCallArgLimit) {\n    return false;\n  }\n  return (\n    (chunk.tool_call_chunks?.length ?? 0) > 0 ||\n    (chunk.tool_calls?.length ?? 0) > 0 ||\n    (chunk.invalid_tool_calls?.length ?? 0) > 0\n  );\n}\n\n/** True when any stream-limit guard can fire for this graph. The attempt\n * lease and per-chunk claims are both gated on it — fully disabled guards\n * must allocate no bookkeeping at all, per-attempt included. */\nexport function streamLimitAccountingEnabled(\n  graph: StreamLimitState\n): boolean {\n  const resolved = graph.streamLimits ?? DEFAULT_RESOLVED_LIMITS;\n  return (\n    resolved.hasEnforceableToolCallArgLimit ||\n    resolved.maxDeltaEventsPerTurn > 0\n  );\n}\n\n/** Leases a model attempt's generation: entries under it are exempt from\n * the reset sweep until {@link releaseStreamLimitGeneration} runs from the\n * attempt's `finally`. */\nexport function registerActiveStreamLimitGeneration(\n  graph: StreamLimitState,\n  generationKey: string\n): void {\n  (graph.activeStreamLimitGenerations ??= new Set()).add(generationKey);\n}\n\n/** Ends an attempt's lease and deletes its accounting entries — the\n * authoritative retirement point for attempt-scoped state. */\nexport function releaseStreamLimitGeneration(\n  graph: StreamLimitState,\n  generationKey: string\n): void {\n  graph.activeStreamLimitGenerations?.delete(generationKey);\n  deleteGenerationEntries(graph.streamedToolCallArgTallies, generationKey);\n  deleteGenerationEntries(graph.streamDeltaEventCounts, generationKey);\n}\n\nfunction deleteGenerationEntries(\n  entries: Map<string, unknown> | undefined,\n  generationKey: string\n): void {\n  if (entries == null) {\n    return;\n  }\n  const prefix = `${generationKey}:`;\n  for (const key of entries.keys()) {\n    if (key === generationKey || key.startsWith(prefix)) {\n      entries.delete(key);\n    }\n  }\n}\n\nfunction isOwnedByActiveGeneration(\n  key: string,\n  activeGenerations: ReadonlySet<string>\n): boolean {\n  for (const generationKey of activeGenerations) {\n    if (key === generationKey || key.startsWith(`${generationKey}:`)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Deletes accounting entries older than the epoch that is ending, EXCEPT\n * entries leased by a still-active attempt. Called by `resetValues` instead\n * of clearing: producer loops of straggling attempts use the graph's maps\n * directly and are not behind the consumer-only epoch gate, so a clear\n * would hand a cancellation-ignoring provider a fresh allowance at every\n * run start. Leased entries live until their attempt's `finally` releases\n * them; unleased entries (direct callers with no attempt stamp) get one\n * grace reset via their epoch tag.\n */\nexport function sweepStaleStreamLimitEntries(\n  entries: Map<string, { epoch?: number }>,\n  endingEpoch: number,\n  activeGenerations?: ReadonlySet<string>\n): void {\n  const hasActive = activeGenerations != null && activeGenerations.size > 0;\n  for (const [key, value] of entries) {\n    if (value.epoch === endingEpoch) {\n      continue;\n    }\n    if (hasActive && isOwnedByActiveGeneration(key, activeGenerations)) {\n      continue;\n    }\n    entries.delete(key);\n  }\n}\n\n/** Links a secondary representation of a wire chunk (e.g. a provider\n * adapter's callback copy) to its canonical emission object, so claim\n * accounting treats both as one emission even though their identities\n * differ. Non-enumerable, so the link stays out of serialization and chunk\n * merges. */\nconst STREAM_LIMIT_CANONICAL: unique symbol = Symbol('streamLimitCanonical');\n\nexport function linkStreamLimitCanonical(\n  copy: object,\n  canonical: object\n): void {\n  Object.defineProperty(copy, STREAM_LIMIT_CANONICAL, {\n    value: canonical,\n    enumerable: false,\n    configurable: true,\n  });\n}\n\nfunction canonicalChunk(chunk: object): object {\n  const linked = (chunk as Record<PropertyKey, unknown>)[\n    STREAM_LIMIT_CANONICAL\n  ];\n  return typeof linked === 'object' && linked != null ? linked : chunk;\n}\n\n/**\n * Claims accounting ownership of one EMISSION of a wire chunk. LangChain can\n * hand the same chunk object to the decoupled `streamEvents` handler\n * (`consumer`) and to the dispatch loop (`producer`) in either order, and a\n * streaming model may mutate and re-yield the same object across emissions —\n * so dedup is a signed credit balance per object rather than a lifetime set.\n * Each producer visit adds a credit, each consumer visit removes one, and a\n * visit charges only when the other side has not already charged that\n * emission (positive balance = producer ahead, negative = consumer ahead).\n * Paths where only one side ever observes the chunk (summarization, local\n * replay-skip) charge every visit, since their balance never crosses zero\n * the other way. Balances are scoped by generation identity so parallel\n * generations sharing one reused chunk object cannot cancel each other's\n * charges. Non-object chunks cannot be identity-tracked and are always\n * claimable.\n */\nexport function claimStreamLimitCharge(\n  graph: StreamLimitState,\n  chunk: unknown,\n  side: 'producer' | 'consumer',\n  metadata: Record<string, unknown> | undefined\n): boolean {\n  if (typeof chunk !== 'object' || chunk == null) {\n    return true;\n  }\n  const emission = canonicalChunk(chunk);\n  const credits = (graph.streamLimitChargeCredits ??= new WeakMap());\n  let byGeneration = credits.get(emission);\n  if (byGeneration == null) {\n    byGeneration = new Map();\n    credits.set(emission, byGeneration);\n  }\n  const generationKey = resolveGenerationKey(metadata);\n  const balance = byGeneration.get(generationKey) ?? 0;\n  if (side === 'producer') {\n    byGeneration.set(generationKey, balance + 1);\n    return balance >= 0;\n  }\n  byGeneration.set(generationKey, balance - 1);\n  return balance <= 0;\n}\n\n/**\n * Synchronous producer-side accounting for wire chunks that would otherwise\n * be judged only when the decoupled `streamEvents` reader catches up — or,\n * on replay-skipped and summarization chunks, not at all. A lagging reader\n * would let an oversized complete call return to LangGraph and reach\n * `ToolNode` before the queued handler throws; charging in the producer\n * loop keeps the breaker ahead of graph progression. Claim-based, so\n * whichever of this path and the handler echo sees the chunk object first\n * charges it and the other skips.\n */\nexport function enforceStreamLimitsForWireChunk({\n  graph,\n  metadata,\n  chunk,\n  side = 'producer',\n}: {\n  graph: StreamLimitState;\n  metadata: Record<string, unknown> | undefined;\n  chunk: {\n    tool_call_chunks?: ToolCallChunk[];\n    tool_calls?: CompleteToolCallLike[];\n    invalid_tool_calls?: CompleteToolCallLike[];\n    response_metadata?: Record<string, unknown>;\n  };\n  /** Claim side for the credit balance. The local dispatch branch charges\n   * as `consumer` because its handler-handled and replay-skipped emissions\n   * of one reused object ALTERNATE — mixed sides would pair them as\n   * producer/echo and swallow a charge. */\n  side?: 'producer' | 'consumer';\n}): void {\n  if (!requiresStreamLimitAccounting(graph, chunk)) {\n    return;\n  }\n  if (!claimStreamLimitCharge(graph, chunk, side, metadata)) {\n    return;\n  }\n  enforceStreamDeltaEventLimit({ graph, metadata });\n  /** Combined view computed first so the raw-chunk guard can correlate\n   * names from BOTH parsed and invalid calls in the same event; an unnamed\n   * raw chunk twinned with a named invalid call must select that tool's\n   * override, not the global cap. */\n  const completeCalls = combineCompleteToolCalls(chunk);\n  if (chunk.tool_call_chunks != null && chunk.tool_call_chunks.length > 0) {\n    enforceStreamedToolCallArgLimit({\n      graph,\n      metadata,\n      toolCallChunks: chunk.tool_call_chunks,\n      responseMetadata: chunk.response_metadata,\n      parsedToolCalls: completeCalls,\n    });\n  }\n  /** Judged whenever parsed calls are present, not only when raw chunks are\n   * absent: an adapter can pair an empty or partial raw chunk with a\n   * complete parsed call, and the standalone check is stateless so the\n   * common both-present case is not double-tallied. `invalid_tool_calls`\n   * are included — ToolNode processes and promotes them, and a malformed\n   * call streaming oversized arguments is the exact pathology this breaker\n   * exists to stop. */\n  if (completeCalls != null) {\n    enforceCompleteToolCallArgLimit({ graph, metadata, toolCalls: completeCalls });\n  }\n}\n\n/** Combined view of a chunk's parsed and invalid complete calls, avoiding\n * allocation on the common paths where one or both are absent. */\nexport function combineCompleteToolCalls(chunk: {\n  tool_calls?: CompleteToolCallLike[];\n  invalid_tool_calls?: CompleteToolCallLike[];\n}): CompleteToolCallLike[] | undefined {\n  const parsed = chunk.tool_calls;\n  const invalid = chunk.invalid_tool_calls;\n  const hasParsed = parsed != null && parsed.length > 0;\n  const hasInvalid = invalid != null && invalid.length > 0;\n  if (hasParsed && hasInvalid) {\n    return [...parsed, ...invalid];\n  }\n  if (hasParsed) {\n    return parsed;\n  }\n  return hasInvalid ? invalid : undefined;\n}\n\n/**\n * Counts streamed chunk events per model generation and throws once a single\n * generation exceeds `maxDeltaEventsPerTurn`. Opt-in defense in depth for\n * pathologies a byte cap cannot see, such as a provider stream looping on\n * empty chunks. Zero cost while disabled.\n */\nexport function enforceStreamDeltaEventLimit({\n  graph,\n  metadata,\n}: {\n  graph: StreamLimitState;\n  metadata: Record<string, unknown> | undefined;\n}): void {\n  const limit = (graph.streamLimits ?? DEFAULT_RESOLVED_LIMITS)\n    .maxDeltaEventsPerTurn;\n  if (limit <= 0) {\n    return;\n  }\n  if (metadata?.[STREAM_LIMIT_REDISPATCH_KEY] === true) {\n    return;\n  }\n  const counts = (graph.streamDeltaEventCounts ??= new Map());\n  const key = resolveGenerationKey(metadata);\n  const existing = counts.get(key);\n  const next = (existing?.count ?? 0) + 1;\n  if (next > limit) {\n    throw new StreamLimitExceededError({\n      kind: 'delta_events',\n      limit,\n      observed: next,\n    });\n  }\n  if (existing != null) {\n    existing.count = next;\n  } else {\n    counts.set(key, { count: next, epoch: graph.breakerEpoch });\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"streamLimits.cjs","names":["getStreamedToolCallSeal"],"sources":["../../../src/llm/streamLimits.ts"],"mappings":"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"}

package/dist/cjs/llm/truncation.cjs

@@ -1,12 +1,6 @@
 require("../common/enum.cjs");
 require("../common/index.cjs");
 //#region src/llm/truncation.ts
-/**
-* Providers whose adapters deliver tool calls as complete, atomic objects
-* rather than streamed argument deltas. Google/Vertex (GenAI) emit each
-* `functionCall` whole and seal it on arrival, so a `MAX_TOKENS` finish does
-* NOT imply the arguments were cut off — the truncation guard must skip them.
-*/
 const ATOMIC_TOOL_CALL_ARG_PROVIDERS = new Set(["google", "vertexai"]);
 const MAX_TOKEN_VALUES = new Set([
 	"max_tokens",
@@ -22,20 +16,6 @@ function normalizeStopValue(value) {
 	if (LENGTH_VALUES.has(normalized)) return "length";
 	return null;
 }
-/**
-* Reads the truncation stop reason off a message, covering every provider
-* shape we stream:
-* - `response_metadata.stopReason` (Bedrock Converse, non-streaming)
-* - `response_metadata.messageStop.stopReason` (Bedrock Converse streaming)
-* - `response_metadata.stop_reason` (Anthropic, non-streaming)
-* - `additional_kwargs.stop_reason` (Anthropic streaming `message_delta`)
-* - `response_metadata.finish_reason` (OpenAI chat-completions / compatible)
-* - `response_metadata.incomplete_details.reason` (OpenAI Responses API)
-* - `response_metadata.finishReason` (Google)
-*
-* Returns the normalized reason when the model stopped because it hit the
-* output token ceiling, otherwise `null`.
-*/
 function getTruncationStopReason(message) {
 	const meta = message?.response_metadata;
 	const additionalKwargs = message?.additional_kwargs;
@@ -61,12 +41,6 @@ function hasOpenToolCall(message) {
 	const m = message;
 	return (m.tool_calls?.length ?? 0) > 0 || (m.tool_call_chunks?.length ?? 0) > 0 || (m.invalid_tool_calls?.length ?? 0) > 0;
 }
-/**
-* Error raised when a model turn is cut off by the output token limit while it
-* was still emitting a tool call. The arguments are necessarily incomplete, so
-* executing or re-prompting the call would loop on a malformed request. Failing
-* fast with this surfaces an actionable message to the caller instead.
-*/
 var OutputTruncationError = class extends Error {
 	stopReason;
 	toolCallNames;
@@ -87,16 +61,6 @@ function collectToolCallNames(message) {
 	].map((tc) => tc.name).filter((name) => typeof name === "string" && name !== "");
 	return [...new Set(names)];
 }
-/**
-* Throws {@link OutputTruncationError} when `message` was truncated by the
-* output token limit AND still carries a tool call. For providers that stream
-* tool arguments incrementally (Anthropic, Bedrock, OpenAI), a tool call
-* emitted under truncation has incomplete arguments — the tool-use block is the
-* last thing the model streams — so letting it through makes the agent loop on a
-* malformed call. No-ops for normal completions, truncated plain-text turns, and
-* providers that deliver complete tool calls atomically (Google/Vertex), where
-* `MAX_TOKENS` does not imply the arguments were cut off.
-*/
 function assertNotTruncatedToolCall(message, provider) {
 	if (message == null) return;
 	if (provider != null && ATOMIC_TOOL_CALL_ARG_PROVIDERS.has(provider)) return;

package/dist/cjs/llm/truncation.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"truncation.cjs","names":[],"sources":["../../../src/llm/truncation.ts"],"sourcesContent":["import type { AIMessageChunk, BaseMessage } from '@langchain/core/messages';\nimport { Providers } from '@/common';\n\n/**\n * Providers whose adapters deliver tool calls as complete, atomic objects\n * rather than streamed argument deltas. Google/Vertex (GenAI) emit each\n * `functionCall` whole and seal it on arrival, so a `MAX_TOKENS` finish does\n * NOT imply the arguments were cut off — the truncation guard must skip them.\n */\nconst ATOMIC_TOOL_CALL_ARG_PROVIDERS = new Set<Providers>([\n  Providers.GOOGLE,\n  Providers.VERTEXAI,\n]);\n\n/**\n * Normalized truncation reasons across providers. Providers disagree on the\n * key and the value: Anthropic/Bedrock use `max_tokens`, OpenAI uses `length`,\n * Google uses `MAX_TOKENS`.\n */\nexport type TruncationStopReason = 'max_tokens' | 'length';\n\nconst MAX_TOKEN_VALUES = new Set([\n  'max_tokens',\n  'max_token',\n  'maxtokens',\n  'max_output_tokens',\n]);\nconst LENGTH_VALUES = new Set(['length']);\n\nfunction normalizeStopValue(value: unknown): TruncationStopReason | null {\n  if (typeof value !== 'string') {\n    return null;\n  }\n  const normalized = value.trim().toLowerCase();\n  if (MAX_TOKEN_VALUES.has(normalized)) {\n    return 'max_tokens';\n  }\n  if (LENGTH_VALUES.has(normalized)) {\n    return 'length';\n  }\n  return null;\n}\n\n/**\n * Reads the truncation stop reason off a message, covering every provider\n * shape we stream:\n * - `response_metadata.stopReason` (Bedrock Converse, non-streaming)\n * - `response_metadata.messageStop.stopReason` (Bedrock Converse streaming)\n * - `response_metadata.stop_reason` (Anthropic, non-streaming)\n * - `additional_kwargs.stop_reason` (Anthropic streaming `message_delta`)\n * - `response_metadata.finish_reason` (OpenAI chat-completions / compatible)\n * - `response_metadata.incomplete_details.reason` (OpenAI Responses API)\n * - `response_metadata.finishReason` (Google)\n *\n * Returns the normalized reason when the model stopped because it hit the\n * output token ceiling, otherwise `null`.\n */\nexport function getTruncationStopReason(\n  message:\n    | Pick<BaseMessage, 'response_metadata' | 'additional_kwargs'>\n    | undefined\n    | null\n): TruncationStopReason | null {\n  const meta = message?.response_metadata as\n    | Record<string, unknown>\n    | undefined;\n  const additionalKwargs = message?.additional_kwargs as\n    | Record<string, unknown>\n    | undefined;\n  if (meta == null && additionalKwargs == null) {\n    return null;\n  }\n\n  const messageStop = meta?.messageStop as { stopReason?: unknown } | undefined;\n  const incompleteDetails = meta?.incomplete_details as\n    | { reason?: unknown }\n    | undefined;\n  const candidates: unknown[] = [\n    meta?.stopReason,\n    meta?.stop_reason,\n    meta?.finish_reason,\n    meta?.finishReason,\n    messageStop?.stopReason,\n    incompleteDetails?.reason,\n    additionalKwargs?.stop_reason,\n  ];\n\n  for (const candidate of candidates) {\n    const normalized = normalizeStopValue(candidate);\n    if (normalized != null) {\n      return normalized;\n    }\n  }\n  return null;\n}\n\nfunction hasOpenToolCall(message: AIMessageChunk | BaseMessage): boolean {\n  const m = message as AIMessageChunk & {\n    tool_calls?: unknown[];\n    tool_call_chunks?: unknown[];\n    invalid_tool_calls?: unknown[];\n  };\n  return (\n    (m.tool_calls?.length ?? 0) > 0 ||\n    (m.tool_call_chunks?.length ?? 0) > 0 ||\n    (m.invalid_tool_calls?.length ?? 0) > 0\n  );\n}\n\n/**\n * Error raised when a model turn is cut off by the output token limit while it\n * was still emitting a tool call. The arguments are necessarily incomplete, so\n * executing or re-prompting the call would loop on a malformed request. Failing\n * fast with this surfaces an actionable message to the caller instead.\n */\nexport class OutputTruncationError extends Error {\n  readonly stopReason: TruncationStopReason;\n  readonly toolCallNames: string[];\n\n  constructor(stopReason: TruncationStopReason, toolCallNames: string[]) {\n    const named =\n      toolCallNames.length > 0\n        ? ` (tool call: ${toolCallNames.join(', ')})`\n        : '';\n    super(\n      'The model response was truncated at the maximum output token limit before ' +\n        `the tool call arguments were complete${named}. Increase the model's max ` +\n        'output tokens, or have the model produce smaller arguments — for large ' +\n        'files, write a lean main file and move bulky content into separate files.'\n    );\n    this.name = 'OutputTruncationError';\n    this.stopReason = stopReason;\n    this.toolCallNames = toolCallNames;\n  }\n}\n\nfunction collectToolCallNames(message: AIMessageChunk | BaseMessage): string[] {\n  const m = message as AIMessageChunk & {\n    tool_calls?: Array<{ name?: string }>;\n    tool_call_chunks?: Array<{ name?: string }>;\n    invalid_tool_calls?: Array<{ name?: string }>;\n  };\n  const names = [\n    ...(m.tool_calls ?? []),\n    ...(m.tool_call_chunks ?? []),\n    ...(m.invalid_tool_calls ?? []),\n  ]\n    .map((tc) => tc.name)\n    .filter((name): name is string => typeof name === 'string' && name !== '');\n  return [...new Set(names)];\n}\n\n/**\n * Throws {@link OutputTruncationError} when `message` was truncated by the\n * output token limit AND still carries a tool call. For providers that stream\n * tool arguments incrementally (Anthropic, Bedrock, OpenAI), a tool call\n * emitted under truncation has incomplete arguments — the tool-use block is the\n * last thing the model streams — so letting it through makes the agent loop on a\n * malformed call. No-ops for normal completions, truncated plain-text turns, and\n * providers that deliver complete tool calls atomically (Google/Vertex), where\n * `MAX_TOKENS` does not imply the arguments were cut off.\n */\nexport function assertNotTruncatedToolCall(\n  message: AIMessageChunk | BaseMessage | undefined | null,\n  provider?: Providers\n): void {\n  if (message == null) {\n    return;\n  }\n  if (provider != null && ATOMIC_TOOL_CALL_ARG_PROVIDERS.has(provider)) {\n    return;\n  }\n  const stopReason = getTruncationStopReason(message);\n  if (stopReason == null || !hasOpenToolCall(message)) {\n    return;\n  }\n  throw new OutputTruncationError(stopReason, collectToolCallNames(message));\n}\n"],"mappings":";;;;;;;;;AASA,MAAM,iCAAiC,IAAI,IAAe,CAAA,UAAA,UAG1D,CAAC;AASD,MAAM,mBAAmB,IAAI,IAAI;CAC/B;CACA;CACA;CACA;AACF,CAAC;AACD,MAAM,gBAAgB,IAAI,IAAI,CAAC,QAAQ,CAAC;AAExC,SAAS,mBAAmB,OAA6C;CACvE,IAAI,OAAO,UAAU,UACnB,OAAO;CAET,MAAM,aAAa,MAAM,KAAK,CAAC,CAAC,YAAY;CAC5C,IAAI,iBAAiB,IAAI,UAAU,GACjC,OAAO;CAET,IAAI,cAAc,IAAI,UAAU,GAC9B,OAAO;CAET,OAAO;AACT;;;;;;;;;;;;;;;AAgBA,SAAgB,wBACd,SAI6B;CAC7B,MAAM,OAAO,SAAS;CAGtB,MAAM,mBAAmB,SAAS;CAGlC,IAAI,QAAQ,QAAQ,oBAAoB,MACtC,OAAO;CAGT,MAAM,cAAc,MAAM;CAC1B,MAAM,oBAAoB,MAAM;CAGhC,MAAM,aAAwB;EAC5B,MAAM;EACN,MAAM;EACN,MAAM;EACN,MAAM;EACN,aAAa;EACb,mBAAmB;EACnB,kBAAkB;CACpB;CAEA,KAAK,MAAM,aAAa,YAAY;EAClC,MAAM,aAAa,mBAAmB,SAAS;EAC/C,IAAI,cAAc,MAChB,OAAO;CAEX;CACA,OAAO;AACT;AAEA,SAAS,gBAAgB,SAAgD;CACvE,MAAM,IAAI;CAKV,QACG,EAAE,YAAY,UAAU,KAAK,MAC7B,EAAE,kBAAkB,UAAU,KAAK,MACnC,EAAE,oBAAoB,UAAU,KAAK;AAE1C;;;;;;;AAQA,IAAa,wBAAb,cAA2C,MAAM;CAC/C;CACA;CAEA,YAAY,YAAkC,eAAyB;EACrE,MAAM,QACJ,cAAc,SAAS,IACnB,gBAAgB,cAAc,KAAK,IAAI,EAAE,KACzC;EACN,MACE,kHAC0C,MAAM,4KAGlD;EACA,KAAK,OAAO;EACZ,KAAK,aAAa;EAClB,KAAK,gBAAgB;CACvB;AACF;AAEA,SAAS,qBAAqB,SAAiD;CAC7E,MAAM,IAAI;CAKV,MAAM,QAAQ;EACZ,GAAI,EAAE,cAAc,CAAC;EACrB,GAAI,EAAE,oBAAoB,CAAC;EAC3B,GAAI,EAAE,sBAAsB,CAAC;CAC/B,CAAC,CACE,KAAK,OAAO,GAAG,IAAI,CAAC,CACpB,QAAQ,SAAyB,OAAO,SAAS,YAAY,SAAS,EAAE;CAC3E,OAAO,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC;AAC3B;;;;;;;;;;;AAYA,SAAgB,2BACd,SACA,UACM;CACN,IAAI,WAAW,MACb;CAEF,IAAI,YAAY,QAAQ,+BAA+B,IAAI,QAAQ,GACjE;CAEF,MAAM,aAAa,wBAAwB,OAAO;CAClD,IAAI,cAAc,QAAQ,CAAC,gBAAgB,OAAO,GAChD;CAEF,MAAM,IAAI,sBAAsB,YAAY,qBAAqB,OAAO,CAAC;AAC3E"}
+{"version":3,"file":"truncation.cjs","names":[],"sources":["../../../src/llm/truncation.ts"],"mappings":";;;AASA,MAAM,iCAAiC,IAAI,IAAe,CAAA,UAAA,UAG1D,CAAC;AASD,MAAM,mBAAmB,IAAI,IAAI;CAC/B;CACA;CACA;CACA;AACF,CAAC;AACD,MAAM,gBAAgB,IAAI,IAAI,CAAC,QAAQ,CAAC;AAExC,SAAS,mBAAmB,OAA6C;CACvE,IAAI,OAAO,UAAU,UACnB,OAAO;CAET,MAAM,aAAa,MAAM,KAAK,CAAC,CAAC,YAAY;CAC5C,IAAI,iBAAiB,IAAI,UAAU,GACjC,OAAO;CAET,IAAI,cAAc,IAAI,UAAU,GAC9B,OAAO;CAET,OAAO;AACT;AAgBA,SAAgB,wBACd,SAI6B;CAC7B,MAAM,OAAO,SAAS;CAGtB,MAAM,mBAAmB,SAAS;CAGlC,IAAI,QAAQ,QAAQ,oBAAoB,MACtC,OAAO;CAGT,MAAM,cAAc,MAAM;CAC1B,MAAM,oBAAoB,MAAM;CAGhC,MAAM,aAAwB;EAC5B,MAAM;EACN,MAAM;EACN,MAAM;EACN,MAAM;EACN,aAAa;EACb,mBAAmB;EACnB,kBAAkB;CACpB;CAEA,KAAK,MAAM,aAAa,YAAY;EAClC,MAAM,aAAa,mBAAmB,SAAS;EAC/C,IAAI,cAAc,MAChB,OAAO;CAEX;CACA,OAAO;AACT;AAEA,SAAS,gBAAgB,SAAgD;CACvE,MAAM,IAAI;CAKV,QACG,EAAE,YAAY,UAAU,KAAK,MAC7B,EAAE,kBAAkB,UAAU,KAAK,MACnC,EAAE,oBAAoB,UAAU,KAAK;AAE1C;AAQA,IAAa,wBAAb,cAA2C,MAAM;CAC/C;CACA;CAEA,YAAY,YAAkC,eAAyB;EACrE,MAAM,QACJ,cAAc,SAAS,IACnB,gBAAgB,cAAc,KAAK,IAAI,EAAE,KACzC;EACN,MACE,kHAC0C,MAAM,4KAGlD;EACA,KAAK,OAAO;EACZ,KAAK,aAAa;EAClB,KAAK,gBAAgB;CACvB;AACF;AAEA,SAAS,qBAAqB,SAAiD;CAC7E,MAAM,IAAI;CAKV,MAAM,QAAQ;EACZ,GAAI,EAAE,cAAc,CAAC;EACrB,GAAI,EAAE,oBAAoB,CAAC;EAC3B,GAAI,EAAE,sBAAsB,CAAC;CAC/B,CAAC,CACE,KAAK,OAAO,GAAG,IAAI,CAAC,CACpB,QAAQ,SAAyB,OAAO,SAAS,YAAY,SAAS,EAAE;CAC3E,OAAO,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC;AAC3B;AAYA,SAAgB,2BACd,SACA,UACM;CACN,IAAI,WAAW,MACb;CAEF,IAAI,YAAY,QAAQ,+BAA+B,IAAI,QAAQ,GACjE;CAEF,MAAM,aAAa,wBAAwB,OAAO;CAClD,IAAI,cAAc,QAAQ,CAAC,gBAAgB,OAAO,GAChD;CAEF,MAAM,IAAI,sBAAsB,YAAY,qBAAqB,OAAO,CAAC;AAC3E"}

package/dist/cjs/llm/vertexai/index.cjs

@@ -5,30 +5,6 @@ let _langchain_core_messages = require("@langchain/core/messages");
 let _langchain_google_gauth = require("@langchain/google-gauth");
 let _langchain_google_common = require("@langchain/google-common");
 //#region src/llm/vertexai/index.ts
-/**
-* `@langchain/google-common`'s `_streamResponseChunks` emits usage on TWO
-* different paths within the same stream:
-*
-*   - Streaming chunks set `chunk.generationInfo.usage_metadata` via
-*     `responseToUsageMetadata`, which correctly sums
-*     `candidatesTokenCount + thoughtsTokenCount` and includes
-*     `output_token_details.reasoning`.
-*   - The trailing fallback chunk (emitted after the API stream exhausts)
-*     attaches its own `chunk.message.usage_metadata` built inline as
-*     `output_tokens = candidatesTokenCount` only — dropping
-*     `thoughtsTokenCount` and `output_token_details` entirely.
-*
-* After `AIMessageChunk.concat`, only `message.usage_metadata` survives —
-* which is the buggy fallback value. This breaks the documented
-* `total_tokens === input_tokens + output_tokens` invariant and silently
-* undercharges thinking models for reasoning tokens.
-*
-* The repair: track the last `generationInfo.usage_metadata` we see, and
-* when the fallback chunk arrives with its buggy `message.usage_metadata`,
-* replace it with the tracked good value. `CustomChatGoogleGenerativeAI`
-* solves the same problem for the Google API path differently — by
-* overriding `_convertToUsageMetadata`.
-*/
 function repairStreamUsageMetadata(current, generationInfoUsage) {
 	if (!current) return current;
 	if (!generationInfoUsage) return current;
@@ -36,14 +12,6 @@ function repairStreamUsageMetadata(current, generationInfoUsage) {
 	if (generationInfoUsage.output_tokens <= current.output_tokens) return current;
 	return generationInfoUsage;
 }
-/**
-* The Gemini API delivers function calls as complete objects — never as
-* partial arg deltas. `@langchain/google-common` pre-parses each streamed
-* functionCall part into `tool_calls` (invalid args land in
-* `invalid_tool_calls` instead), so a chunk whose tool-call chunks all parsed
-* cleanly is sealed on arrival for eager tool execution. Anything that fails
-* the parse check is left unstamped and falls back to the lazy path.
-*/
 function sealCompleteStreamedToolCalls(message) {
 	const chunkCount = message.tool_call_chunks?.length ?? 0;
 	if (chunkCount === 0 || (message.invalid_tool_calls?.length ?? 0) > 0 || (message.tool_calls?.length ?? 0) !== chunkCount) return;
@@ -53,22 +21,6 @@ function sealCompleteStreamedToolCalls(message) {
 		[require_streamedToolCallSeals.STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: "all" }
 	};
 }
-/**
-* Fixes thought signatures on functionCall parts in the formatted Gemini request.
-*
-* `@langchain/google-common` stores signatures as a flat array in
-* `additional_kwargs.signatures` (one per response part) and re-attaches them
-* by index only when `signatures.length === parts.length`. This fails when:
-* - The API omits a signature (length mismatch)
-* - Streaming chunks merge with different part counts
-* - The signature for a functionCall part is an empty string
-*
-* This function correlates each "model" content block in the formatted request
-* back to its originating AI message by *position*, then re-attaches non-empty
-* signatures that the library failed to apply. AI messages without signatures
-* still consume their slot — filtering them out shifted later messages onto
-* the wrong content block and dropped real signatures on the floor.
-*/
 function fixThoughtSignatures(contents, input) {
 	const aiMessages = input.filter(_langchain_core_messages.isAIMessage);
 	const modelContents = contents.filter((c) => c.role === "model");
@@ -110,288 +62,6 @@ var CustomChatConnection = class extends _langchain_google_common.ChatConnection
 		return formattedData;
 	}
 };
-/**
-* Integration with Google Vertex AI chat models.
-*
-* Setup:
-* Install `@langchain/google-vertexai` and set your stringified
-* Vertex AI credentials as an environment variable named `GOOGLE_APPLICATION_CREDENTIALS`.
-*
-* ```bash
-* npm install @langchain/google-vertexai
-* export GOOGLE_APPLICATION_CREDENTIALS="path/to/credentials"
-* ```
-*
-* ## [Constructor args](https://api.js.langchain.com/classes/_langchain_google_vertexai.index.ChatVertexAI.html#constructor.new_ChatVertexAI)
-*
-* ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_google_common_types.GoogleAIBaseLanguageModelCallOptions.html)
-*
-* Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.
-* They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:
-*
-* ```typescript
-* // When calling `.withConfig`, call options should be passed via the first argument
-* const llmWithArgsBound = llm.withConfig({
-*   stop: ["\n"],
-*   tools: [...],
-* });
-*
-* // When calling `.bindTools`, call options should be passed via the second argument
-* const llmWithTools = llm.bindTools(
-*   [...],
-*   {
-*     tool_choice: "auto",
-*   }
-* );
-* ```
-*
-* ## Examples
-*
-* <details open>
-* <summary><strong>Instantiate</strong></summary>
-*
-* ```typescript
-* import { ChatVertexAI } from '@langchain/google-vertexai';
-*
-* const llm = new ChatVertexAI({
-*   model: "gemini-1.5-pro",
-*   temperature: 0,
-*   // other params...
-* });
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Invoking</strong></summary>
-*
-* ```typescript
-* const input = `Translate "I love programming" into French.`;
-*
-* // Models also accept a list of chat messages or a formatted prompt
-* const result = await llm.invoke(input);
-* console.log(result);
-* ```
-*
-* ```txt
-* AIMessageChunk {
-*   "content": "\"J'adore programmer\" \n\nHere's why this is the best translation:\n\n* **J'adore** means \"I love\" and conveys a strong passion.\n* **Programmer** is the French verb for \"to program.\"\n\nThis translation is natural and idiomatic in French. \n",
-*   "additional_kwargs": {},
-*   "response_metadata": {},
-*   "tool_calls": [],
-*   "tool_call_chunks": [],
-*   "invalid_tool_calls": [],
-*   "usage_metadata": {
-*     "input_tokens": 9,
-*     "output_tokens": 63,
-*     "total_tokens": 72
-*   }
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Streaming Chunks</strong></summary>
-*
-* ```typescript
-* for await (const chunk of await llm.stream(input)) {
-*   console.log(chunk);
-* }
-* ```
-*
-* ```txt
-* AIMessageChunk {
-*   "content": "\"",
-*   "additional_kwargs": {},
-*   "response_metadata": {},
-*   "tool_calls": [],
-*   "tool_call_chunks": [],
-*   "invalid_tool_calls": []
-* }
-* AIMessageChunk {
-*   "content": "J'adore programmer\" \n",
-*   "additional_kwargs": {},
-*   "response_metadata": {},
-*   "tool_calls": [],
-*   "tool_call_chunks": [],
-*   "invalid_tool_calls": []
-* }
-* AIMessageChunk {
-*   "content": "",
-*   "additional_kwargs": {},
-*   "response_metadata": {},
-*   "tool_calls": [],
-*   "tool_call_chunks": [],
-*   "invalid_tool_calls": []
-* }
-* AIMessageChunk {
-*   "content": "",
-*   "additional_kwargs": {},
-*   "response_metadata": {
-*     "finishReason": "stop"
-*   },
-*   "tool_calls": [],
-*   "tool_call_chunks": [],
-*   "invalid_tool_calls": [],
-*   "usage_metadata": {
-*     "input_tokens": 9,
-*     "output_tokens": 8,
-*     "total_tokens": 17
-*   }
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Aggregate Streamed Chunks</strong></summary>
-*
-* ```typescript
-* import { AIMessageChunk } from '@langchain/core/messages';
-* import { concat } from '@langchain/core/utils/stream';
-*
-* const stream = await llm.stream(input);
-* let full: AIMessageChunk | undefined;
-* for await (const chunk of stream) {
-*   full = !full ? chunk : concat(full, chunk);
-* }
-* console.log(full);
-* ```
-*
-* ```txt
-* AIMessageChunk {
-*   "content": "\"J'adore programmer\" \n",
-*   "additional_kwargs": {},
-*   "response_metadata": {
-*     "finishReason": "stop"
-*   },
-*   "tool_calls": [],
-*   "tool_call_chunks": [],
-*   "invalid_tool_calls": [],
-*   "usage_metadata": {
-*     "input_tokens": 9,
-*     "output_tokens": 8,
-*     "total_tokens": 17
-*   }
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Bind tools</strong></summary>
-*
-* ```typescript
-* import { z } from 'zod';
-*
-* const GetWeather = {
-*   name: "GetWeather",
-*   description: "Get the current weather in a given location",
-*   schema: z.object({
-*     location: z.string().describe("The city and state, e.g. San Francisco, CA")
-*   }),
-* }
-*
-* const GetPopulation = {
-*   name: "GetPopulation",
-*   description: "Get the current population in a given location",
-*   schema: z.object({
-*     location: z.string().describe("The city and state, e.g. San Francisco, CA")
-*   }),
-* }
-*
-* const llmWithTools = llm.bindTools([GetWeather, GetPopulation]);
-* const aiMsg = await llmWithTools.invoke(
-*   "Which city is hotter today and which is bigger: LA or NY?"
-* );
-* console.log(aiMsg.tool_calls);
-* ```
-*
-* ```txt
-* [
-*   {
-*     name: 'GetPopulation',
-*     args: { location: 'New York City, NY' },
-*     id: '33c1c1f47e2f492799c77d2800a43912',
-*     type: 'tool_call'
-*   }
-* ]
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Structured Output</strong></summary>
-*
-* ```typescript
-* import { z } from 'zod';
-*
-* const Joke = z.object({
-*   setup: z.string().describe("The setup of the joke"),
-*   punchline: z.string().describe("The punchline to the joke"),
-*   rating: z.number().optional().describe("How funny the joke is, from 1 to 10")
-* }).describe('Joke to tell user.');
-*
-* const structuredLlm = llm.withStructuredOutput(Joke, { name: "Joke" });
-* const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
-* console.log(jokeResult);
-* ```
-*
-* ```txt
-* {
-*   setup: 'What do you call a cat that loves to bowl?',
-*   punchline: 'An alley cat!'
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Usage Metadata</strong></summary>
-*
-* ```typescript
-* const aiMsgForMetadata = await llm.invoke(input);
-* console.log(aiMsgForMetadata.usage_metadata);
-* ```
-*
-* ```txt
-* { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Stream Usage Metadata</strong></summary>
-*
-* ```typescript
-* const streamForMetadata = await llm.stream(
-*   input,
-*   {
-*     streamUsage: true
-*   }
-* );
-* let fullForMetadata: AIMessageChunk | undefined;
-* for await (const chunk of streamForMetadata) {
-*   fullForMetadata = !fullForMetadata ? chunk : concat(fullForMetadata, chunk);
-* }
-* console.log(fullForMetadata?.usage_metadata);
-* ```
-*
-* ```txt
-* { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
-* ```
-* </details>
-*
-* <br />
-*/
 var ChatVertexAI = class extends _langchain_google_gauth.ChatGoogle {
 	lc_namespace = [
 		"langchain",