@librechat/agents 3.4.7 → 3.5.0

package/dist/esm/hooks/matchers.mjs

@@ -1,44 +1,7 @@
 //#region src/hooks/matchers.ts
-/**
-* Upper bound on hook-matcher pattern length. Patterns longer than this
-* are rejected outright — the goal is a cheap cap on pathological inputs
-* (repeated quantifiers, huge alternation groups) without pulling in a
-* safe-regex dependency.
-*
-* Legitimate matchers are almost always under 50 characters (tool names,
-* short alternations, simple prefix anchors); 512 leaves generous
-* headroom while preventing 10KB regexes.
-*/
 const MAX_PATTERN_LENGTH = 512;
-/**
-* Upper bound on the compilation cache. Chosen to comfortably hold every
-* distinct pattern a single multi-tenant run is likely to see (tools,
-* agent types, basename filters) without growing without bound.
-*
-* Under hosts that register unique patterns per tenant, LRU eviction
-* keeps the working set bounded — cold patterns are re-compiled on next
-* use, which is the correct cost trade-off for long-running processes
-* that must not leak memory.
-*/
 const MAX_CACHE_SIZE = 256;
-/**
-* Module-level LRU cache keyed by pattern string. Map iteration order is
-* insertion order in ECMAScript, so refreshing an entry's position means
-* "delete then re-set". On overflow we evict the first key (least
-* recently used).
-*
-* Failed compiles are cached as `{ regex: null }` so a malformed pattern
-* does not re-enter the compiler — and so a tenant spamming bad patterns
-* doesn't burn CPU on every call.
-*/
 const patternCache = /* @__PURE__ */ new Map();
-/**
-* Threshold above which `touchCacheEntry` actually performs the LRU
-* refresh. Below this watermark the cache has zero eviction pressure, so
-* the delete+set on every hit would be pure overhead. Above it we refresh
-* properly so hot patterns survive evictions. 75% of capacity is the
-* standard sweet spot.
-*/
 const LRU_REFRESH_THRESHOLD = Math.floor(256 * 3 / 4);
 function touchCacheEntry(pattern, entry) {
 	if (patternCache.size < LRU_REFRESH_THRESHOLD) return;
@@ -65,38 +28,6 @@ function skipGroupSyntaxPrefix(pattern, start) {
 	if (i < pattern.length) i++;
 	return i;
 }
-/**
-* Cheap syntactic detector for the most common catastrophic-backtracking
-* shape: a quantified group that contains another quantifier (e.g.
-* `(a+)+`, `(.*)*`, `(\w+)+$`, `(?:(a+))+`). This is the "nested
-* quantifier" class of ReDoS — runs in polynomial-or-worse time on
-* adversarial inputs.
-*
-* The scan walks the pattern linearly using an explicit stack of group
-* frames. For each group it tracks whether the group's contents include
-* "backtrack risk" — meaning a direct quantifier OR a nested group that
-* carries risk up. When a group closes with a trailing quantifier AND its
-* frame carries backtrack risk, the pattern is flagged. Risk propagates
-* to the enclosing frame when a child group closes (whether the child
-* itself was quantified or not), so `(?:(a+))+` — equivalent to `(a+)+`
-* — is flagged correctly even though the outer non-capturing wrapper is
-* one level removed from the inner quantifier.
-*
-* ## Group-syntax prefixes
-*
-* Non-capturing groups (`(?:`), lookaheads (`(?=`, `(?!`), lookbehinds
-* (`(?<=`, `(?<!`), and named groups (`(?<name>`) are skipped over at
-* the `(` so their `?` is not misread as a quantifier. Without this,
-* `(?:pre_)?tool_name` would be incorrectly rejected because the scanner
-* would see the group-syntax `?` as a quantifier at depth 1.
-*
-* ## Heuristic, not a proof
-*
-* This catches the common forms but not all. Ambiguous-alternation ReDoS
-* like `(a|a)+` is not detected. Pathologically long patterns are also
-* caught by {@link MAX_PATTERN_LENGTH}. Hosts that accept user-supplied
-* patterns must still validate upstream.
-*/
 function hasNestedQuantifier(pattern) {
 	const stack = [];
 	let i = 0;
@@ -171,41 +102,6 @@ function compile(pattern) {
 		return null;
 	}
 }
-/**
-* Tests whether a hook matcher pattern matches the given query string.
-*
-* ## Semantics
-*
-* - `undefined` or empty `pattern` matches any query (wildcard). This is
-*   the intended shape for events that do not supply a query string at
-*   all (`RunStart`, `Stop`, etc.) — register such matchers without a
-*   pattern.
-* - `undefined` or empty `query` with a non-empty `pattern` never matches.
-*   Setting a pattern on a query-less event is therefore inert: the
-*   matcher will simply never fire. This is intentional — it keeps
-*   query-based filtering out of event types where "query" has no meaning,
-*   and is documented on `HookMatcher.pattern`.
-* - Otherwise, the pattern is compiled once (via a bounded LRU cache) and
-*   tested against the query.
-* - Invalid regex patterns never throw — a failed compile is cached as
-*   "never matches" so a single malformed pattern cannot take out a whole
-*   `executeHooks` batch.
-*
-* ## ReDoS mitigations
-*
-* Patterns compile through three cheap gates before reaching `new RegExp`:
-*
-* 1. {@link MAX_PATTERN_LENGTH} length cap rejects oversized inputs.
-* 2. {@link hasNestedQuantifier} rejects the most common catastrophic-
-*    backtracking shape (quantified group containing a quantifier).
-* 3. Successful compiles are cached in a bounded LRU so repeated calls
-*    never re-enter the regex compiler.
-*
-* These are a floor, not a ceiling. Hosts that accept user-supplied
-* patterns should still validate upstream. The design report §3.8 routes
-* persistable hooks through a host-side compiler before they reach this
-* module.
-*/
 function matchesQuery(pattern, query) {
 	if (pattern === void 0 || pattern === "") return true;
 	if (query === void 0 || query === "") return false;

package/dist/esm/hooks/matchers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"matchers.mjs","names":[],"sources":["../../../src/hooks/matchers.ts"],"sourcesContent":["// src/hooks/matchers.ts\n\n/**\n * Upper bound on hook-matcher pattern length. Patterns longer than this\n * are rejected outright — the goal is a cheap cap on pathological inputs\n * (repeated quantifiers, huge alternation groups) without pulling in a\n * safe-regex dependency.\n *\n * Legitimate matchers are almost always under 50 characters (tool names,\n * short alternations, simple prefix anchors); 512 leaves generous\n * headroom while preventing 10KB regexes.\n */\nexport const MAX_PATTERN_LENGTH = 512;\n\n/**\n * Upper bound on the compilation cache. Chosen to comfortably hold every\n * distinct pattern a single multi-tenant run is likely to see (tools,\n * agent types, basename filters) without growing without bound.\n *\n * Under hosts that register unique patterns per tenant, LRU eviction\n * keeps the working set bounded — cold patterns are re-compiled on next\n * use, which is the correct cost trade-off for long-running processes\n * that must not leak memory.\n */\nexport const MAX_CACHE_SIZE = 256;\n\ninterface CacheEntry {\n  regex: RegExp | null;\n}\n\n/**\n * Module-level LRU cache keyed by pattern string. Map iteration order is\n * insertion order in ECMAScript, so refreshing an entry's position means\n * \"delete then re-set\". On overflow we evict the first key (least\n * recently used).\n *\n * Failed compiles are cached as `{ regex: null }` so a malformed pattern\n * does not re-enter the compiler — and so a tenant spamming bad patterns\n * doesn't burn CPU on every call.\n */\nconst patternCache: Map<string, CacheEntry> = new Map();\n\n/**\n * Threshold above which `touchCacheEntry` actually performs the LRU\n * refresh. Below this watermark the cache has zero eviction pressure, so\n * the delete+set on every hit would be pure overhead. Above it we refresh\n * properly so hot patterns survive evictions. 75% of capacity is the\n * standard sweet spot.\n */\nconst LRU_REFRESH_THRESHOLD = Math.floor((MAX_CACHE_SIZE * 3) / 4);\n\nfunction touchCacheEntry(pattern: string, entry: CacheEntry): void {\n  if (patternCache.size < LRU_REFRESH_THRESHOLD) {\n    return;\n  }\n  patternCache.delete(pattern);\n  patternCache.set(pattern, entry);\n}\n\nfunction setCacheEntry(pattern: string, entry: CacheEntry): void {\n  if (patternCache.size >= MAX_CACHE_SIZE) {\n    const oldestKey = patternCache.keys().next().value;\n    if (oldestKey !== undefined) {\n      patternCache.delete(oldestKey);\n    }\n  }\n  patternCache.set(pattern, entry);\n}\n\ninterface QuantifierFrame {\n  hasBacktrackRisk: boolean;\n}\n\nfunction skipGroupSyntaxPrefix(pattern: string, start: number): number {\n  if (start >= pattern.length || pattern[start] !== '?') {\n    return start;\n  }\n  let i = start + 1;\n  if (i >= pattern.length) {\n    return i;\n  }\n  const modifier = pattern[i];\n  if (modifier === ':' || modifier === '=' || modifier === '!') {\n    return i + 1;\n  }\n  if (modifier !== '<') {\n    return i;\n  }\n  i++;\n  if (i < pattern.length && (pattern[i] === '=' || pattern[i] === '!')) {\n    return i + 1;\n  }\n  while (i < pattern.length && pattern[i] !== '>') {\n    i++;\n  }\n  if (i < pattern.length) {\n    i++;\n  }\n  return i;\n}\n\n/**\n * Cheap syntactic detector for the most common catastrophic-backtracking\n * shape: a quantified group that contains another quantifier (e.g.\n * `(a+)+`, `(.*)*`, `(\\w+)+$`, `(?:(a+))+`). This is the \"nested\n * quantifier\" class of ReDoS — runs in polynomial-or-worse time on\n * adversarial inputs.\n *\n * The scan walks the pattern linearly using an explicit stack of group\n * frames. For each group it tracks whether the group's contents include\n * \"backtrack risk\" — meaning a direct quantifier OR a nested group that\n * carries risk up. When a group closes with a trailing quantifier AND its\n * frame carries backtrack risk, the pattern is flagged. Risk propagates\n * to the enclosing frame when a child group closes (whether the child\n * itself was quantified or not), so `(?:(a+))+` — equivalent to `(a+)+`\n * — is flagged correctly even though the outer non-capturing wrapper is\n * one level removed from the inner quantifier.\n *\n * ## Group-syntax prefixes\n *\n * Non-capturing groups (`(?:`), lookaheads (`(?=`, `(?!`), lookbehinds\n * (`(?<=`, `(?<!`), and named groups (`(?<name>`) are skipped over at\n * the `(` so their `?` is not misread as a quantifier. Without this,\n * `(?:pre_)?tool_name` would be incorrectly rejected because the scanner\n * would see the group-syntax `?` as a quantifier at depth 1.\n *\n * ## Heuristic, not a proof\n *\n * This catches the common forms but not all. Ambiguous-alternation ReDoS\n * like `(a|a)+` is not detected. Pathologically long patterns are also\n * caught by {@link MAX_PATTERN_LENGTH}. Hosts that accept user-supplied\n * patterns must still validate upstream.\n */\nexport function hasNestedQuantifier(pattern: string): boolean {\n  const stack: QuantifierFrame[] = [];\n  let i = 0;\n  while (i < pattern.length) {\n    const ch = pattern[i];\n    if (ch === '\\\\') {\n      i += 2;\n      continue;\n    }\n    if (ch === '[') {\n      i = findCharClassEnd(pattern, i) + 1;\n      continue;\n    }\n    if (ch === '(') {\n      stack.push({ hasBacktrackRisk: false });\n      i = skipGroupSyntaxPrefix(pattern, i + 1);\n      continue;\n    }\n    if (ch === ')') {\n      const frame = stack.pop();\n      if (frame === undefined) {\n        i++;\n        continue;\n      }\n      const next = pattern[i + 1];\n      const isQuantifier =\n        next === '*' || next === '+' || next === '?' || next === '{';\n      if (isQuantifier && frame.hasBacktrackRisk) {\n        return true;\n      }\n      if (stack.length > 0 && (frame.hasBacktrackRisk || isQuantifier)) {\n        stack[stack.length - 1].hasBacktrackRisk = true;\n      }\n      i++;\n      continue;\n    }\n    if (ch === '*' || ch === '+' || ch === '?' || ch === '{') {\n      if (stack.length > 0) {\n        stack[stack.length - 1].hasBacktrackRisk = true;\n      }\n    }\n    i++;\n  }\n  return false;\n}\n\nfunction findCharClassEnd(pattern: string, start: number): number {\n  let i = start + 1;\n  while (i < pattern.length) {\n    const ch = pattern[i];\n    if (ch === '\\\\') {\n      i += 2;\n      continue;\n    }\n    if (ch === ']') {\n      return i;\n    }\n    i++;\n  }\n  return pattern.length - 1;\n}\n\nfunction compile(pattern: string): RegExp | null {\n  const cached = patternCache.get(pattern);\n  if (cached !== undefined) {\n    touchCacheEntry(pattern, cached);\n    return cached.regex;\n  }\n  if (pattern.length > MAX_PATTERN_LENGTH) {\n    setCacheEntry(pattern, { regex: null });\n    return null;\n  }\n  if (hasNestedQuantifier(pattern)) {\n    setCacheEntry(pattern, { regex: null });\n    return null;\n  }\n  try {\n    const regex = new RegExp(pattern);\n    setCacheEntry(pattern, { regex });\n    return regex;\n  } catch {\n    setCacheEntry(pattern, { regex: null });\n    return null;\n  }\n}\n\n/**\n * Tests whether a hook matcher pattern matches the given query string.\n *\n * ## Semantics\n *\n * - `undefined` or empty `pattern` matches any query (wildcard). This is\n *   the intended shape for events that do not supply a query string at\n *   all (`RunStart`, `Stop`, etc.) — register such matchers without a\n *   pattern.\n * - `undefined` or empty `query` with a non-empty `pattern` never matches.\n *   Setting a pattern on a query-less event is therefore inert: the\n *   matcher will simply never fire. This is intentional — it keeps\n *   query-based filtering out of event types where \"query\" has no meaning,\n *   and is documented on `HookMatcher.pattern`.\n * - Otherwise, the pattern is compiled once (via a bounded LRU cache) and\n *   tested against the query.\n * - Invalid regex patterns never throw — a failed compile is cached as\n *   \"never matches\" so a single malformed pattern cannot take out a whole\n *   `executeHooks` batch.\n *\n * ## ReDoS mitigations\n *\n * Patterns compile through three cheap gates before reaching `new RegExp`:\n *\n * 1. {@link MAX_PATTERN_LENGTH} length cap rejects oversized inputs.\n * 2. {@link hasNestedQuantifier} rejects the most common catastrophic-\n *    backtracking shape (quantified group containing a quantifier).\n * 3. Successful compiles are cached in a bounded LRU so repeated calls\n *    never re-enter the regex compiler.\n *\n * These are a floor, not a ceiling. Hosts that accept user-supplied\n * patterns should still validate upstream. The design report §3.8 routes\n * persistable hooks through a host-side compiler before they reach this\n * module.\n */\nexport function matchesQuery(\n  pattern: string | undefined,\n  query: string | undefined\n): boolean {\n  if (pattern === undefined || pattern === '') {\n    return true;\n  }\n  if (query === undefined || query === '') {\n    return false;\n  }\n  const regex = compile(pattern);\n  if (regex === null) {\n    return false;\n  }\n  return regex.test(query);\n}\n\n/** Clears the regex compilation cache. Intended for test isolation. */\nexport function clearMatcherCache(): void {\n  patternCache.clear();\n}\n\n/** Returns the current size of the compilation cache. Intended for tests. */\nexport function getMatcherCacheSize(): number {\n  return patternCache.size;\n}\n"],"mappings":"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"}
+{"version":3,"file":"matchers.mjs","names":[],"sources":["../../../src/hooks/matchers.ts"],"mappings":"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"}

package/dist/esm/hooks/types.mjs

@@ -1,12 +1,4 @@
 //#region src/hooks/types.ts
-/**
-* Closed set of hook lifecycle events supported by the hooks system.
-*
-* These mirror the subset of Claude Code's event surface that makes sense
-* for a library context (no filesystem/CLI-specific events). See
-* `docs/hooks-design-report.md` §3.2 for the mapping to existing
-* `@librechat/agents` emission points.
-*/
 const HOOK_EVENTS = [
 	"RunStart",
 	"UserPromptSubmit",

package/dist/esm/hooks/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","names":[],"sources":["../../../src/hooks/types.ts"],"sourcesContent":["// src/hooks/types.ts\nimport type { BaseMessage } from '@langchain/core/messages';\nimport type { InjectedMessage } from '@/types/tools';\n\n/**\n * Closed set of hook lifecycle events supported by the hooks system.\n *\n * These mirror the subset of Claude Code's event surface that makes sense\n * for a library context (no filesystem/CLI-specific events). See\n * `docs/hooks-design-report.md` §3.2 for the mapping to existing\n * `@librechat/agents` emission points.\n */\nexport const HOOK_EVENTS = [\n  'RunStart',\n  'UserPromptSubmit',\n  'PreToolUse',\n  'PostToolUse',\n  'PostToolUseFailure',\n  'PostToolBatch',\n  'PreemptBoundary',\n  'PermissionDenied',\n  'SubagentStart',\n  'SubagentStop',\n  'Stop',\n  'StopFailure',\n  'PreCompact',\n  'PostCompact',\n] as const;\n\nexport const TOOL_APPROVAL_EXECUTION_SCOPE_CONFIG_KEY =\n  '__librechat_tool_approval_execution_scope';\n\nexport type HookEvent = (typeof HOOK_EVENTS)[number];\n\n/** Tool-gating decision; executeHooks folds with `deny > ask > allow` precedence. */\nexport type ToolDecision = 'allow' | 'deny' | 'ask';\n\n/** Stop-loop decision; `block` means \"do not stop, run another turn\". Any `block` wins. */\nexport type StopDecision = 'continue' | 'block';\n\n/**\n * Fields shared by every `HookInput`. Discriminated by `hook_event_name`.\n *\n * - `runId` identifies the current agent run and is always present.\n * - `threadId` identifies the conversation thread when the host has one.\n * - `agentId` is only set when the hook fires inside a subagent scope.\n * - `executingAgentId` identifies the agent that owns the node emitting the hook,\n *   whenever the graph knows it — including top-level agents in a multi-agent\n *   graph (where `agentId` is intentionally undefined). Use this to attribute a\n *   hook to a specific agent regardless of subagent scope.\n */\nexport interface BaseHookInput {\n  runId: string;\n  threadId?: string;\n  agentId?: string;\n  executingAgentId?: string;\n}\n\nexport interface RunStartHookInput extends BaseHookInput {\n  hook_event_name: 'RunStart';\n  messages: BaseMessage[];\n}\n\nexport interface UserPromptSubmitHookInput extends BaseHookInput {\n  hook_event_name: 'UserPromptSubmit';\n  prompt: string;\n  attachments?: BaseMessage[];\n}\n\n/**\n * Fires before a tool is invoked. Hook may return `deny`/`ask`/`allow` and/or\n * an `updatedInput` that replaces the tool arguments before invocation.\n *\n * `toolInput` is intentionally typed as `Record<string, unknown>` because the\n * SDK is tool-agnostic — concrete tool argument shapes are only known at the\n * call site and are narrowed by the host. This is the one escape hatch in\n * the hook type system.\n */\nexport interface PreToolUseHookInput extends BaseHookInput {\n  hook_event_name: 'PreToolUse';\n  toolName: string;\n  toolInput: Record<string, unknown>;\n  toolUseId: string;\n  stepId?: string;\n  /**\n   * Number of times this tool has been invoked in prior batches within the\n   * current run. Within a single batch of parallel calls, all calls to the\n   * same tool share the same turn value — per-call discrimination within a\n   * batch is not supported in v1.\n   */\n  turn?: number;\n}\n\nexport interface PostToolUseHookInput extends BaseHookInput {\n  hook_event_name: 'PostToolUse';\n  toolName: string;\n  toolInput: Record<string, unknown>;\n  toolOutput: unknown;\n  toolUseId: string;\n  stepId?: string;\n  turn?: number;\n}\n\nexport interface PostToolUseFailureHookInput extends BaseHookInput {\n  hook_event_name: 'PostToolUseFailure';\n  toolName: string;\n  toolInput: Record<string, unknown>;\n  toolUseId: string;\n  error: string;\n  stepId?: string;\n  turn?: number;\n}\n\n/**\n * Per-tool result snapshot included in a `PostToolBatch` event. Mirrors\n * the data PostToolUse / PostToolUseFailure get individually, but the\n * batch view lets a single hook see the whole set so it can inject one\n * consolidated convention/audit message rather than N per-tool ones.\n */\nexport interface PostToolBatchEntry {\n  toolName: string;\n  toolInput: Record<string, unknown>;\n  toolUseId: string;\n  stepId?: string;\n  turn?: number;\n  /** Successful tool output, present only when `status === 'success'`. */\n  toolOutput?: unknown;\n  /** Error message, present only when `status === 'error'`. */\n  error?: string;\n  status: 'success' | 'error';\n}\n\n/**\n * Fires once after every tool call in a single batch finishes (including\n * any that were rejected via HITL). Lets a hook react to the batch as a\n * whole — useful for \"inject conventions once for the whole batch\", batch\n * audit logging, or coordinating cleanup that depends on knowing the full\n * result set rather than streaming each tool's result independently.\n *\n * Order: fires AFTER all per-tool PostToolUse / PostToolUseFailure hooks\n * for the same batch have completed, BEFORE the next model call. Pass an\n * `additionalContext` to inject context for that next model turn, or\n * `injectedMessages` to inject standalone per-message user speech (e.g.\n * mid-run steering) that must not be consolidated with hook context.\n */\nexport interface PostToolBatchHookInput extends BaseHookInput {\n  hook_event_name: 'PostToolBatch';\n  /** All tool calls (and their outcomes) from this batch, in batch order. */\n  entries: PostToolBatchEntry[];\n}\n\n/**\n * Fires when a cooperative preemption seals the model stream mid-generation\n * — the second injection boundary, and the only one that exists during a\n * long text answer with no tool calls in it.\n *\n * Order: fires after the model stream is sealed and BEFORE the next model\n * call. The `injectedMessages` a hook returns here are appended verbatim and\n * the agent node self-loops. Returning nothing is a valid outcome (the host's\n * queue was cancelled or already drained): the run stops honestly rather than\n * self-looping into an empty turn.\n *\n * The sealed turn is NOT yet observable from graph state when this fires.\n * Dispatch happens inside the agent node, and only the outer graph's reducer\n * writes `StandardGraph.messages` — which cannot run until the node returns.\n * A hook calling `Run.getRunMessages()` here sees the state as of the last\n * completed superstep, so the sealed text is absent. `PostToolBatch` behaves\n * the same way: a tool-boundary hook cannot see the assistant turn that\n * requested the tool. This is a property of the single-node outer graph, not\n * of preemption, and committing first would mean returning from the node and\n * re-entering — precisely what the self-loop exists to avoid.\n *\n * A hook that needs the sealed text should therefore not go looking for it in\n * graph state. Decide from the host's own queue, or read it after the run.\n *\n * Requires `RunConfig.preemption`. This event is deliberately NOT\n * result-altering, so registering it never disables eager tool execution.\n */\nexport interface PreemptBoundaryHookInput extends BaseHookInput {\n  hook_event_name: 'PreemptBoundary';\n  /** 1-based index of this seal within the run. */\n  sealCount: number;\n}\n\nexport interface PermissionDeniedHookInput extends BaseHookInput {\n  hook_event_name: 'PermissionDenied';\n  toolName: string;\n  toolInput: Record<string, unknown>;\n  toolUseId: string;\n  reason: string;\n}\n\nexport interface SubagentStartHookInput extends BaseHookInput {\n  hook_event_name: 'SubagentStart';\n  parentAgentId?: string;\n  agentId: string;\n  agentType: string;\n  inputs: BaseMessage[];\n}\n\nexport interface SubagentStopHookInput extends BaseHookInput {\n  hook_event_name: 'SubagentStop';\n  agentId: string;\n  agentType: string;\n  messages: BaseMessage[];\n}\n\nexport interface StopHookInput extends BaseHookInput {\n  hook_event_name: 'Stop';\n  messages: BaseMessage[];\n  stopReason?: string;\n  stopHookActive: boolean;\n}\n\nexport interface StopFailureHookInput extends BaseHookInput {\n  hook_event_name: 'StopFailure';\n  error: string;\n  lastAssistantMessage?: BaseMessage;\n}\n\nexport interface PreCompactHookInput extends BaseHookInput {\n  hook_event_name: 'PreCompact';\n  messagesBeforeCount: number;\n  /**\n   * What triggered compaction. Matches `SummarizationTrigger.type` from the\n   * agent's summarization config. `'default'` means no trigger was\n   * configured and compaction fired because messages were pruned.\n   */\n  trigger:\n    | 'token_ratio'\n    | 'remaining_tokens'\n    | 'messages_to_refine'\n    | 'default'\n    | (string & {});\n}\n\nexport interface PostCompactHookInput extends BaseHookInput {\n  hook_event_name: 'PostCompact';\n  summary: string;\n  /**\n   * Number of messages remaining after compaction. The summarize node\n   * returns a `removeAll` signal that clears all messages from state;\n   * the summary itself is injected into the system prompt, not as a\n   * message. This is `0` at the point of hook dispatch.\n   */\n  messagesAfterCount: number;\n}\n\n/** Discriminated union of every hook input shape. */\nexport type HookInput =\n  | RunStartHookInput\n  | UserPromptSubmitHookInput\n  | PreToolUseHookInput\n  | PostToolUseHookInput\n  | PostToolUseFailureHookInput\n  | PostToolBatchHookInput\n  | PreemptBoundaryHookInput\n  | PermissionDeniedHookInput\n  | SubagentStartHookInput\n  | SubagentStopHookInput\n  | StopHookInput\n  | StopFailureHookInput\n  | PreCompactHookInput\n  | PostCompactHookInput;\n\n/** Compile-time map from event name to its input shape. */\nexport type HookInputByEvent = {\n  RunStart: RunStartHookInput;\n  UserPromptSubmit: UserPromptSubmitHookInput;\n  PreToolUse: PreToolUseHookInput;\n  PostToolUse: PostToolUseHookInput;\n  PostToolUseFailure: PostToolUseFailureHookInput;\n  PostToolBatch: PostToolBatchHookInput;\n  PreemptBoundary: PreemptBoundaryHookInput;\n  PermissionDenied: PermissionDeniedHookInput;\n  SubagentStart: SubagentStartHookInput;\n  SubagentStop: SubagentStopHookInput;\n  Stop: StopHookInput;\n  StopFailure: StopFailureHookInput;\n  PreCompact: PreCompactHookInput;\n  PostCompact: PostCompactHookInput;\n};\n\n/**\n * Fields common to every hook output. Hooks that have nothing to say simply\n * return `{}` (or omit the fields below).\n */\nexport interface BaseHookOutput {\n  /** Context string to inject into the conversation. Accumulated across hooks. */\n  additionalContext?: string;\n  /**\n   * Messages to inject into graph state, one `HumanMessage` per entry\n   * (converted via `convertInjectedMessages`, which preserves\n   * `role`/`source`/`isMeta` in `additional_kwargs`). Unlike\n   * `additionalContext` — which is consolidated across hooks into a single\n   * system-flavored message — each entry keeps its own identity and role,\n   * making this the channel for injecting verbatim user speech (e.g. a\n   * mid-run steering message). Accumulated across hooks in registration\n   * order.\n   *\n   * Consumed at exactly two dispatch sites, both of which run the same\n   * converter so the emitted shapes cannot drift: `PostToolBatch` (the tool\n   * boundary) and `PreemptBoundary` (a cooperative mid-generation seal).\n   * Every other event ignores the field.\n   */\n  injectedMessages?: InjectedMessage[];\n  /** True to prevent the next model turn. Any hook can set this. */\n  preventContinuation?: boolean;\n  /** Reason reported alongside `preventContinuation`. */\n  stopReason?: string;\n  /**\n   * Marks this hook output as fire-and-forget for INFLUENCE only.\n   * When `true`, the SDK skips every other field on this output —\n   * `decision`, `additionalContext`, `updatedInput`,\n   * `preventContinuation`, `allowedDecisions`, `updatedOutput` are\n   * all ignored. The hook's return value cannot block, modify, or\n   * inject context, so it's safe to use for pure side effects\n   * (logging, metrics, webhooks).\n   *\n   * Important caveat: the hook's CALLBACK promise is still awaited\n   * by `executeHooks` (subject to the matcher's timeout and the\n   * default `DEFAULT_HOOK_TIMEOUT_MS`). The SDK does not\n   * speculatively detach hooks based on output shape, because the\n   * shape is only known after the promise resolves. For TRUE\n   * fire-and-forget where the agent doesn't wait at all, the hook\n   * body should detach its side effect itself and return\n   * immediately:\n   *\n   * @example\n   * ```ts\n   * async (input) => {\n   *   // Detach the slow work — the SDK awaits this hook's\n   *   // returned promise, which resolves immediately because we\n   *   // don't `await` the side effect.\n   *   void sendToLoggingService(input).catch(console.error);\n   *   return { async: true };\n   * };\n   * ```\n   *\n   * @example WRONG — the agent will block on the webhook\n   * ```ts\n   * async (input) => {\n   *   await sendToLoggingService(input);  // ← awaited, blocks\n   *   return { async: true };  // returning async:true doesn't undo the await\n   * };\n   * ```\n   *\n   * Mirrors Claude Code Agent SDK's `async` output, with the same\n   * \"detach inside the hook body\" pattern.\n   */\n  async?: boolean;\n  /**\n   * Optional advisory timeout in milliseconds for the background work\n   * a host has detached inside an `async: true` hook body. The SDK\n   * does not enforce this (the hook's own AbortSignal handling does)\n   * but the field is preserved on the wire so downstream\n   * observability can surface long-running side effects. Ignored\n   * unless `async` is true.\n   */\n  asyncTimeout?: number;\n}\n\nexport type RunStartHookOutput = BaseHookOutput;\n\nexport interface UserPromptSubmitHookOutput extends BaseHookOutput {\n  decision?: ToolDecision;\n  reason?: string;\n}\n\nexport interface PreToolUseHookOutput extends BaseHookOutput {\n  decision?: ToolDecision;\n  reason?: string;\n  /**\n   * Replacement tool input. Merged into the pending tool call by the host.\n   *\n   * When multiple hooks set `updatedInput` within a single `executeHooks`\n   * call, the last writer in registration order wins (outer loop: matcher\n   * registration order; inner loop: hook position within the matcher). The\n   * winner is deterministic — `Promise.all` preserves input-array order.\n   * Consumers that need a single authoritative rewrite should still scope\n   * `updatedInput` to one hook per matcher to avoid confusing precedence.\n   */\n  updatedInput?: Record<string, unknown>;\n  /**\n   * Restricts which decisions the host UI is allowed to surface for this\n   * tool call when the hook returns `decision: 'ask'`. Pass to lock a\n   * tool down to a subset of `'approve' | 'reject' | 'edit' | 'respond'`\n   * — for example, `['approve', 'reject']` to forbid the user from\n   * editing the tool's args or substituting a custom response.\n   *\n   * The values flow into the resulting interrupt's\n   * `review_configs[i].allowed_decisions`. Omitting the field keeps the\n   * SDK default (all four decisions advertised). Last-writer-wins in\n   * registration order, same precedence rules as `updatedInput`.\n   */\n  allowedDecisions?: ReadonlyArray<'approve' | 'reject' | 'edit' | 'respond'>;\n}\n\n/** Stable identity for replaying a consumed one-shot tool approval. */\nexport interface ToolApprovalReplayKey {\n  executionScope: string;\n  agentId: string;\n  toolUseId: string;\n}\n\n/** Checkpoint-safe copy of a consumed one-shot approval contribution. */\nexport interface ToolApprovalReplaySnapshot {\n  key: ToolApprovalReplayKey;\n  result: AggregatedHookResult;\n}\n\nexport interface PostToolUseHookOutput extends BaseHookOutput {\n  /**\n   * Replacement tool output. Flows through the aggregated result so the\n   * host can substitute it before appending the tool result message.\n   * Ordering semantics match `PreToolUseHookOutput.updatedInput`:\n   * last-writer-wins in registration order.\n   */\n  updatedOutput?: unknown;\n}\n\nexport type PostToolUseFailureHookOutput = BaseHookOutput;\n\nexport type PostToolBatchHookOutput = BaseHookOutput;\n\nexport type PreemptBoundaryHookOutput = BaseHookOutput;\n\nexport type PermissionDeniedHookOutput = BaseHookOutput;\n\nexport interface SubagentStartHookOutput extends BaseHookOutput {\n  decision?: ToolDecision;\n  reason?: string;\n}\n\nexport type SubagentStopHookOutput = BaseHookOutput;\n\nexport interface StopHookOutput extends BaseHookOutput {\n  decision?: StopDecision;\n  reason?: string;\n}\n\nexport type StopFailureHookOutput = BaseHookOutput;\n\nexport type PreCompactHookOutput = BaseHookOutput;\n\nexport type PostCompactHookOutput = BaseHookOutput;\n\n/** Compile-time map from event name to its output shape. */\nexport type HookOutputByEvent = {\n  RunStart: RunStartHookOutput;\n  UserPromptSubmit: UserPromptSubmitHookOutput;\n  PreToolUse: PreToolUseHookOutput;\n  PostToolUse: PostToolUseHookOutput;\n  PostToolUseFailure: PostToolUseFailureHookOutput;\n  PostToolBatch: PostToolBatchHookOutput;\n  PreemptBoundary: PreemptBoundaryHookOutput;\n  PermissionDenied: PermissionDeniedHookOutput;\n  SubagentStart: SubagentStartHookOutput;\n  SubagentStop: SubagentStopHookOutput;\n  Stop: StopHookOutput;\n  StopFailure: StopFailureHookOutput;\n  PreCompact: PreCompactHookOutput;\n  PostCompact: PostCompactHookOutput;\n};\n\n/** Superset output shape used by the executor's fold loop. */\nexport type HookOutput =\n  | RunStartHookOutput\n  | UserPromptSubmitHookOutput\n  | PreToolUseHookOutput\n  | PostToolUseHookOutput\n  | PostToolUseFailureHookOutput\n  | PostToolBatchHookOutput\n  | PreemptBoundaryHookOutput\n  | PermissionDeniedHookOutput\n  | SubagentStartHookOutput\n  | SubagentStopHookOutput\n  | StopHookOutput\n  | StopFailureHookOutput\n  | PreCompactHookOutput\n  | PostCompactHookOutput;\n\n/**\n * A hook callback is a plain async function registered against a specific\n * event. The `signal` is always supplied by `executeHooks` and combines the\n * batch's parent signal with the per-hook timeout — callbacks that perform\n * long-running work should observe it.\n */\nexport type HookCallback<E extends HookEvent = HookEvent> = (\n  input: HookInputByEvent[E],\n  signal: AbortSignal\n) => HookOutputByEvent[E] | Promise<HookOutputByEvent[E]>;\n\n/**\n * A matcher groups one or more callbacks under a shared regex filter and\n * shared timeout/once/internal flags. The generic `E` ties the callback\n * types to the event the matcher is registered against.\n */\nexport interface HookMatcher<E extends HookEvent = HookEvent> {\n  /**\n   * Regex pattern matched against the event's primary query string (e.g.\n   * the tool name for `PreToolUse`, the agent type for `SubagentStart`).\n   *\n   * Omitted or empty means \"always match\". For events that do not supply a\n   * query string (`RunStart`, `Stop`, etc.), only wildcard matchers fire —\n   * a non-empty pattern on such events will never match.\n   *\n   * Patterns are treated as trusted input: `executeHooks` compiles them\n   * with `new RegExp(pattern)` without any sandbox, and a pathological\n   * pattern can block the event loop. Host registration code is expected\n   * to validate or length-bound patterns that originate from user input.\n   */\n  pattern?: string;\n  /** Callbacks that fire when the matcher hits. Executed in parallel. */\n  hooks: HookCallback<E>[];\n  /** Per-matcher timeout in ms. Defaults to the executor's batch timeout. */\n  timeout?: number;\n  /**\n   * Atomically remove the matcher before its first dispatch.\n   *\n   * `executeHooks` claims `once: true` matchers synchronously — between\n   * `getMatchers` and its first `await` — so two concurrent calls cannot\n   * both dispatch the same matcher. Whichever call runs its sync prefix\n   * first wins the matcher; the other sees an empty bucket.\n   *\n   * Semantics are \"at most one dispatch, ever\" — if every hook in the\n   * matcher throws, the matcher is still gone. Use `once` for\n   * fire-and-forget bootstrapping (registration, telemetry, setup). Hosts\n   * that need retry semantics should register a normal matcher and\n   * self-unregister via the callback returned from `registry.register`.\n   */\n  once?: boolean;\n  /** Internal hooks are excluded from telemetry and non-fatal error logging. */\n  internal?: boolean;\n}\n\n/**\n * Storage shape for matchers keyed by event. Each event's matcher list is\n * a generic array parameterized by that event type, so lookup via\n * `HooksByEvent[E]` preserves type-safe callback signatures.\n */\nexport type HooksByEvent = {\n  [E in HookEvent]?: HookMatcher<E>[];\n};\n\n/**\n * Aggregated result of a single `executeHooks` call. Fields are populated\n * according to the fold rules in `executeHooks.ts`.\n */\nexport interface AggregatedHookResult {\n  /** Folded tool-gating decision; `deny > ask > allow`. */\n  decision?: ToolDecision;\n  /** Folded stop decision; any `block` wins. */\n  stopDecision?: StopDecision;\n  /** Reason from the hook that set the winning decision. */\n  reason?: string;\n  /**\n   * Replacement tool input from a `PreToolUse` hook.\n   *\n   * Last-writer-wins in **registration order**: `executeHooks` uses\n   * `Promise.all`, which preserves input-array order, so the fold iterates\n   * outcomes in the same order they were pushed — outer loop over matchers\n   * as they sit in the registry, inner loop over each matcher's `hooks`\n   * array. The winner is therefore deterministic but may not match the\n   * order in which hooks actually completed. Consumers that want a single\n   * authoritative rewrite should still register one `updatedInput`-setting\n   * hook per matcher to avoid subtle precedence bugs.\n   */\n  updatedInput?: Record<string, unknown>;\n  /**\n   * Restricted decision set from a `PreToolUse` hook. Same last-writer-wins\n   * semantics as `updatedInput`. Surfaces to the interrupt payload's\n   * `review_configs[i].allowed_decisions`.\n   */\n  allowedDecisions?: ReadonlyArray<'approve' | 'reject' | 'edit' | 'respond'>;\n  /**\n   * Replacement tool output from a `PostToolUse` hook.\n   *\n   * Same last-writer-wins-in-registration-order semantics as\n   * `updatedInput`. Present only when at least one hook set it; `undefined`\n   * means \"use the original tool output\".\n   */\n  updatedOutput?: unknown;\n  /** Accumulated `additionalContext` strings from every hook, in order. */\n  additionalContexts: string[];\n  /** Accumulated `injectedMessages` from every hook, in registration order. */\n  injectedMessages: InjectedMessage[];\n  /** True if any hook returned `preventContinuation`. */\n  preventContinuation?: boolean;\n  /**\n   * Reason recorded alongside `preventContinuation`. First winner wins:\n   * once a hook sets both flags, later hooks that also set\n   * `preventContinuation` do not overwrite the reason.\n   */\n  stopReason?: string;\n  /** Error messages from hooks that threw; always present (possibly empty). */\n  errors: string[];\n}\n"],"mappings":";;;;;;;;;AAYA,MAAa,cAAc;CACzB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,MAAa,2CACX"}
+{"version":3,"file":"types.mjs","names":[],"sources":["../../../src/hooks/types.ts"],"mappings":";AAYA,MAAa,cAAc;CACzB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,MAAa,2CACX"}

package/dist/esm/instrumentation.mjs

@@ -10,17 +10,6 @@ import { randomBytes } from "node:crypto";
 import { BasicTracerProvider } from "@opentelemetry/sdk-trace-base";
 import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
 //#region src/instrumentation.ts
-/**
-* Per-run seed for deterministic Langfuse trace ids. When a run opts in
-* (`LangfuseConfig.deterministicTraceId`), it executes its stream inside
-* `runWithTraceIdSeed(runId, ...)` from `./langfuseRuntimeContext`, and the
-* IdGenerator below derives the root trace id from that seed instead of a
-* random one. This lets external systems (e.g. a host app recording user
-* feedback after the fact) attach scores or observations to the trace by
-* regenerating the same id from the run/message id; no trace lookup required.
-* With no active seed it falls back to random ids, so default behavior is
-* unchanged.
-*/
 var SeededTraceIdGenerator = class {
 	generateTraceId() {
 		const seed = resolveTraceIdSeedForSpan(context.active());
@@ -42,9 +31,6 @@ function ensureOpenTelemetryContextManager() {
 	contextManager.enable();
 	if (!context.setGlobalContextManager(contextManager)) contextManager.disable();
 }
-/** Cache key for processor instances: the destination plus processor-level
-*  policy (`toolOutputTracing` is baked into each processor's redaction
-*  behavior), unlike the pure destination identity used for span parenting. */
 function getLangfuseProcessorCacheKey(destinationKey, langfuse) {
 	return JSON.stringify({
 		destinationKey,

package/dist/esm/instrumentation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.mjs","names":[],"sources":["../../src/instrumentation.ts"],"sourcesContent":["import { randomBytes } from 'node:crypto';\nimport { setLangfuseTracerProvider } from '@langfuse/tracing';\nimport { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';\nimport { context, ROOT_CONTEXT, createContextKey } from '@opentelemetry/api';\nimport { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';\nimport type {\n  IdGenerator,\n  ReadableSpan,\n  Span,\n  SpanProcessor,\n} from '@opentelemetry/sdk-trace-base';\nimport type { LangfuseSpanProcessorParams } from '@langfuse/otel';\nimport type { Context } from '@opentelemetry/api';\nimport type * as t from '@/types';\nimport {\n  getLangfuseDestinationKey,\n  getLangfuseSpanProcessorParams,\n  registerLangfuseManagedSpan,\n} from '@/langfuseSpanRegistry';\nimport {\n  resolveLangfuseConfigForSpan,\n  resolveTraceIdSeedForSpan,\n} from '@/langfuseRuntimeScope';\nimport { createLangfuseSpanProcessor } from '@/langfuseToolOutputTracing';\nimport { createLibreChatTraceAttributes } from '@/langfuse';\nimport { traceIdFromSeed } from '@/langfuseRuntimeContext';\nimport { isPresent } from '@/utils/misc';\n\n/**\n * Per-run seed for deterministic Langfuse trace ids. When a run opts in\n * (`LangfuseConfig.deterministicTraceId`), it executes its stream inside\n * `runWithTraceIdSeed(runId, ...)` from `./langfuseRuntimeContext`, and the\n * IdGenerator below derives the root trace id from that seed instead of a\n * random one. This lets external systems (e.g. a host app recording user\n * feedback after the fact) attach scores or observations to the trace by\n * regenerating the same id from the run/message id; no trace lookup required.\n * With no active seed it falls back to random ids, so default behavior is\n * unchanged.\n */\nclass SeededTraceIdGenerator implements IdGenerator {\n  generateTraceId(): string {\n    const seed = resolveTraceIdSeedForSpan(context.active());\n    return isPresent(seed)\n      ? traceIdFromSeed(seed)\n      : randomBytes(16).toString('hex');\n  }\n\n  generateSpanId(): string {\n    return randomBytes(8).toString('hex');\n  }\n}\n\nlet langfuseTracerProvider: BasicTracerProvider | undefined;\nlet langfuseRoutingSpanProcessor: RoutingLangfuseSpanProcessor | undefined;\nconst contextManagerProbeKey = createContextKey(\n  'langfuse-context-manager-probe'\n);\n\nfunction hasActiveContextManager(): boolean {\n  return context.with(\n    ROOT_CONTEXT.setValue(contextManagerProbeKey, true),\n    () => context.active().getValue(contextManagerProbeKey) === true\n  );\n}\n\nexport function ensureOpenTelemetryContextManager(): void {\n  if (hasActiveContextManager()) {\n    return;\n  }\n\n  const contextManager = new AsyncLocalStorageContextManager();\n  contextManager.enable();\n  if (!context.setGlobalContextManager(contextManager)) {\n    contextManager.disable();\n  }\n}\n\n/** Cache key for processor instances: the destination plus processor-level\n *  policy (`toolOutputTracing` is baked into each processor's redaction\n *  behavior), unlike the pure destination identity used for span parenting. */\nfunction getLangfuseProcessorCacheKey(\n  destinationKey: string,\n  langfuse?: t.LangfuseConfig\n): string {\n  return JSON.stringify({\n    destinationKey,\n    mediaUploadEnabled: langfuse?.mediaUploadEnabled,\n    toolOutputTracing: langfuse?.toolOutputTracing,\n  });\n}\n\nclass RoutingLangfuseSpanProcessor implements SpanProcessor {\n  // Processors live for the process lifetime. LibreChat tenant Langfuse\n  // destinations are expected to be a bounded admin-managed set, and shutdown\n  // drains every cached processor when the provider is disposed.\n  private readonly processors = new Map<string, SpanProcessor>();\n  private readonly spanProcessors = new WeakMap<object, SpanProcessor>();\n\n  ensureProcessor(langfuse?: t.LangfuseConfig): SpanProcessor | undefined {\n    const params = getLangfuseSpanProcessorParams(langfuse);\n    if (params == null) {\n      return undefined;\n    }\n    return this.ensureProcessorForKey(\n      getLangfuseProcessorCacheKey(getLangfuseDestinationKey(params), langfuse),\n      params,\n      langfuse\n    );\n  }\n\n  private ensureProcessorForKey(\n    processorCacheKey: string,\n    params: LangfuseSpanProcessorParams,\n    langfuse?: t.LangfuseConfig\n  ): SpanProcessor {\n    const existing = this.processors.get(processorCacheKey);\n    if (existing != null) {\n      return existing;\n    }\n\n    const processor = createLangfuseSpanProcessor(params, langfuse);\n    this.processors.set(processorCacheKey, processor);\n    return processor;\n  }\n\n  onStart(span: Span, parentContext: Context): void {\n    const langfuse = resolveLangfuseConfigForSpan(parentContext);\n    const params = getLangfuseSpanProcessorParams(langfuse);\n    if (params == null) {\n      return;\n    }\n\n    const destinationKey = getLangfuseDestinationKey(params);\n    const processor = this.ensureProcessorForKey(\n      getLangfuseProcessorCacheKey(destinationKey, langfuse),\n      params,\n      langfuse\n    );\n    registerLangfuseManagedSpan(span, destinationKey);\n\n    const librechatTraceAttributes = createLibreChatTraceAttributes(\n      langfuse?.librechatTraceAttributes ?? {}\n    );\n    if (Object.keys(librechatTraceAttributes).length > 0) {\n      span.setAttributes(librechatTraceAttributes);\n    }\n\n    this.spanProcessors.set(span, processor);\n    processor.onStart(span, parentContext);\n  }\n\n  onEnd(span: ReadableSpan): void {\n    this.spanProcessors.get(span)?.onEnd(span);\n  }\n\n  async forceFlush(): Promise<void> {\n    await Promise.all(\n      Array.from(this.processors.values(), (processor) =>\n        processor.forceFlush()\n      )\n    );\n  }\n\n  async shutdown(): Promise<void> {\n    await Promise.all(\n      Array.from(this.processors.values(), (processor) => processor.shutdown())\n    );\n  }\n}\n\nexport function initializeLangfuseTracing(\n  langfuse?: t.LangfuseConfig\n): BasicTracerProvider | undefined {\n  const params = getLangfuseSpanProcessorParams(langfuse);\n  if (params == null) {\n    return undefined;\n  }\n\n  if (langfuseTracerProvider != null) {\n    langfuseRoutingSpanProcessor?.ensureProcessor(langfuse);\n    return langfuseTracerProvider;\n  }\n\n  ensureOpenTelemetryContextManager();\n  langfuseRoutingSpanProcessor = new RoutingLangfuseSpanProcessor();\n  langfuseRoutingSpanProcessor.ensureProcessor(langfuse);\n  langfuseTracerProvider = new BasicTracerProvider({\n    spanProcessors: [langfuseRoutingSpanProcessor],\n    idGenerator: new SeededTraceIdGenerator(),\n  });\n\n  setLangfuseTracerProvider(langfuseTracerProvider);\n  return langfuseTracerProvider;\n}\n\nexport function initializeLangfuseTracingFromEnv():\n  | BasicTracerProvider\n  | undefined {\n  return initializeLangfuseTracing();\n}\n\ninitializeLangfuseTracingFromEnv();\n"],"mappings":"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"}
+{"version":3,"file":"instrumentation.mjs","names":[],"sources":["../../src/instrumentation.ts"],"mappings":"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"}

package/dist/esm/langfuse.mjs

@@ -71,50 +71,21 @@ function normalizeBedrockUsageForLangfuse(output) {
 	};
 }
 const LANGGRAPH_NODE_METADATA_KEY = "langgraph_node";
-/** Explicit agent identity in invoke metadata. Every identity-stamping
-*  component (graph model path, ToolNode, summarization node) overwrites the
-*  canonical `agentId` at its own invoke, so spread order guarantees the
-*  closest stamper wins — key priority alone could not (an inherited key of
-*  either casing can name the wrong agent). `agent_id` remains a fallback
-*  for third-party graphs that only stamp the snake-case form. */
 const AGENT_ID_METADATA_KEYS = ["agentId", "agent_id"];
 const LANGGRAPH_NODE_AGENT_PREFIXES = [
 	"agent=",
 	"tools=",
 	"summarize="
 ];
-/** The LangGraph node a callback executes under, from its inherited
-*  `langgraph_node` run metadata. `undefined` when the callback carries no
-*  node identity. */
 function getCallbackNode(metadata) {
 	const node = metadata?.[LANGGRAPH_NODE_METADATA_KEY];
 	return typeof node === "string" && node !== "" ? node : void 0;
 }
-/** Whether a callback's node identifies the given agent. The outer workflow
-*  node carries the agent id VERBATIM — including ids that themselves begin
-*  with an internal prefix (an agent literally named `agent=research`) — so
-*  an exact match is checked before decoding the inner subgraph prefixes
-*  (`agent=` / `tools=` / `summarize=`). */
 function callbackNodeMatchesAgent(node, agentId) {
 	if (node === agentId) return true;
 	for (const prefix of LANGGRAPH_NODE_AGENT_PREFIXES) if (node.startsWith(prefix) && node.slice(prefix.length) === agentId) return true;
 	return false;
 }
-/**
-* Hosts often execute agent code inside their own OpenTelemetry spans (HTTP
-* server auto-instrumentation on the global provider). Root observations must
-* not inherit that ambient identity: the foreign parent is never exported to
-* Langfuse, which orphans the trace root (root/trace input-output shaping is
-* skipped because the span no longer looks like a root), collapses concurrent
-* runs inside one request context — an agent run and the previous turn's
-* title run — into a single merged trace with racing names and unioned tags,
-* and bypasses the seeded deterministic trace id generator. Only a
-* Langfuse-managed span bound to the same export destination as the starting
-* run is a safe parent — that is the sanctioned way for hosts to group runs
-* under their own Langfuse observations; a managed span from a different
-* destination (another tenant's project) would leave this run's trace
-* dangling in its own destination while inheriting the other trace's id.
-*/
 function detachForeignAmbientSpan(activeContext, destinationKey) {
 	const activeSpan = trace.getSpan(activeContext);
 	if (activeSpan == null) return activeContext;
@@ -147,27 +118,11 @@ var ScopedLangfuseCallbackHandler = class extends CallbackHandler {
 	getDeterministicTraceSeed() {
 		return this.langfuse?.deterministicTraceId === true ? this.traceIdSeed : void 0;
 	}
-	/**
-	* Mirrors the base handler's `runMap`: a start callback whose `parentRunId`
-	* this handler never observed gets no explicit parent span and falls back
-	* to the ambient OTEL context (`startAndRegisterOtelSpan`), so it needs the
-	* same foreign-span detachment as a true root. This happens whenever a
-	* handler is attached mid-graph — e.g. the per-agent handler created for a
-	* detached subagent's model invocations, whose surrounding graph runs were
-	* never traced.
-	*/
 	startsDetachedRun(runId, parentRunId) {
 		const detached = parentRunId == null || !this.trackedRunIds.has(parentRunId);
 		this.trackedRunIds.add(runId);
 		return detached;
 	}
-	/**
-	* Whether the ambient runtime scope belongs to a different run — or, for
-	* per-agent overlay scopes, to a different concurrently executing agent of
-	* the same run than the one this callback reports via its inherited
-	* `langgraph_node` metadata. Unstamped scopes on unstamped handlers are
-	* never foreign (host-managed handler semantics).
-	*/
 	isForeignScope(scopeRunId, scopeAgentId, callbackMetadata) {
 		if (this.runId == null || scopeRunId == null) return false;
 		if (scopeRunId !== this.runId) return true;
@@ -179,26 +134,6 @@ var ScopedLangfuseCallbackHandler = class extends CallbackHandler {
 		const callbackNode = getCallbackNode(callbackMetadata);
 		return callbackNode != null && !callbackNodeMatchesAgent(callbackNode, scopeAgentId);
 	}
-	/**
-	* LangChain executes non-awaited callbacks on a process-wide background
-	* queue (`consumeCallback`), so this callback may be running inside a
-	* DIFFERENT concurrent run's async context. The ambient runtime scope is
-	* therefore only adopted when it belongs to this handler's run (and, for
-	* agent sub-scopes, to this callback's agent): scopes are stamped at their
-	* call sites, and a foreign stamp means the scope's config would route
-	* spans to the wrong destination, its seed would collapse this run's spans
-	* into the foreign trace, and its tool-output policy could leak output the
-	* foreign run permits but this run redacts — so config, seed, AND redaction
-	* policy all fall back to this handler's own run. Unstamped scopes on
-	* unstamped handlers keep scope-first semantics (agent overlays and
-	* per-path seeds like the title/label scopes, host-managed handlers).
-	*
-	* Detached runs (roots, or starts whose parent this handler never tracked)
-	* take their span parent from the ambient OTEL context, so drop any
-	* foreign ambient span first — a run launched from a host's instrumented
-	* request context must start its own trace, not join an unexported
-	* foreign one.
-	*/
 	withRuntimeContext(action, isDetachedRun = false, callbackMetadata) {
 		const currentContext = context.active();
 		const scopeRunId = resolveLangfuseScopeRunId(currentContext);
@@ -213,16 +148,6 @@ var ScopedLangfuseCallbackHandler = class extends CallbackHandler {
 		}, action);
 		return activeContext === currentContext ? scoped() : context.with(activeContext, scoped);
 	}
-	/**
-	* A foreign concurrent run's context must be replaced wholesale, not
-	* merged: this library's scope keys (config, seed, tool-output policy,
-	* identity stamps) via the replace-mode runtime scope, `@langfuse/tracing`'s
-	* propagated trace attributes (userId, sessionId, tags, metadata, …) by
-	* deleting their context keys and re-propagating this handler's own
-	* identity, and the foreign active span — removed both so detached runs
-	* root their own trace and so `propagateAttributes` cannot stamp this
-	* run's identity onto the foreign run's still-recording span.
-	*/
 	withForeignScopeRejected(action) {
 		let cleanContext = trace.deleteSpan(context.active());
 		for (const key of Object.values(LangfuseOtelContextKeys)) cleanContext = cleanContext.deleteValue(key);

package/dist/esm/langfuse.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"langfuse.mjs","names":["otelTrace","otelContext"],"sources":["../../src/langfuse.ts"],"sourcesContent":["import { CallbackHandler } from '@langfuse/langchain';\nimport { LangfuseOtelContextKeys } from '@langfuse/core';\nimport { AIMessage, AIMessageChunk } from '@langchain/core/messages';\nimport { isGraphInterrupt, isParentCommand } from '@langchain/langgraph';\nimport { context as otelContext, trace as otelTrace } from '@opentelemetry/api';\nimport {\n  getLangfuseTracerProvider,\n  propagateAttributes,\n} from '@langfuse/tracing';\nimport type {\n  AIMessageChunkFields,\n  AIMessageFields,\n  UsageMetadata,\n} from '@langchain/core/messages';\nimport type {\n  ChatGeneration,\n  Generation,\n  LLMResult,\n} from '@langchain/core/outputs';\nimport type { PropagateAttributesParams } from '@langfuse/tracing';\nimport type { Context } from '@opentelemetry/api';\nimport type { ResolvedLangfuseToolOutputTracingConfig } from '@/langfuseRuntimeContext';\nimport type * as t from '@/types';\nimport {\n  resolveLangfuseConfigForSpan,\n  resolveLangfuseScopeAgentId,\n  resolveLangfuseScopeRunId,\n  resolveTraceIdSeedForSpan,\n  withLangfuseRuntimeScope,\n} from '@/langfuseRuntimeScope';\nimport {\n  hasLangfuseConfigCredentials,\n  hasLangfuseEnvCredentials,\n  resolveToolOutputTracingConfig,\n  hasLangfuseEnvConfig,\n} from '@/langfuseConfig';\nimport {\n  getLangfuseManagedSpanDestination,\n  resolveLangfuseDestinationKey,\n} from '@/langfuseSpanRegistry';\nimport { isPresent, parseBooleanEnv } from '@/utils/misc';\n\nexport {\n  hasLangfuseConfigCredentials,\n  hasLangfuseEnvCredentials,\n  hasLangfuseEnvConfig,\n};\n\nconst TRACE_METADATA_MAX_LENGTH = 200;\nconst LANGFUSE_FORCE_FLUSH_ON_DISPOSE = 'LANGFUSE_FORCE_FLUSH_ON_DISPOSE';\nconst GRAPH_INTERRUPT_CONTROL_FLOW = { controlFlow: 'GraphInterrupt' } as const;\nconst GRAPH_INTERRUPT_TOOL_OUTPUT = JSON.stringify(\n  GRAPH_INTERRUPT_CONTROL_FLOW\n);\n\nexport type LangfuseTraceMetadata = Record<string, string>;\nexport type LangfuseTraceAttributes = Record<string, string | number | boolean>;\ntype LangfuseMetadata = NonNullable<t.LangfuseConfig['metadata']>;\ntype LangfuseConfigTraceAttributes = NonNullable<\n  t.LangfuseConfig['librechatTraceAttributes']\n>;\n\ntype LangfuseHandlerParams = {\n  userId?: string;\n  sessionId?: string;\n  traceMetadata?: LangfuseTraceMetadata;\n  tags?: string[];\n  traceIdSeed?: string;\n  /** Identity of the run this handler traces; ambient runtime scopes are\n   *  only adopted when stamped with the same run (see\n   *  `LangfuseRuntimeContext.runId`). */\n  runId?: string;\n  /** The run's resolved tool-output policy — for multi-agent streams the\n   *  conservative aggregate across agents, which `this.langfuse` (the\n   *  primary agent's config) cannot reproduce. Applied when a foreign\n   *  scope's policy is rejected. */\n  toolOutputTracing?: ResolvedLangfuseToolOutputTracingConfig;\n  /** The run's propagated trace name, re-propagated when a foreign scope's\n   *  attributes are cleared. */\n  traceName?: string;\n};\n\ntype AgentLangfuseHandlerParams = LangfuseHandlerParams & {\n  langfuse?: t.LangfuseConfig;\n};\n\ntype HandlerIdentity = {\n  userId?: string;\n  sessionId?: string;\n  tags?: string[];\n  metadata?: LangfuseTraceMetadata;\n  traceName?: string;\n};\n\ntype LangfuseAttributeParams = AgentLangfuseHandlerParams & {\n  traceName?: string;\n};\n\ntype FlushableTracerProvider = {\n  forceFlush?: () => Promise<void> | void;\n};\n\ntype BedrockResponseUsage = {\n  inputTokens?: number;\n  cacheReadInputTokens?: number;\n  cacheWriteInputTokens?: number;\n};\n\ntype BedrockResponseMetadata = {\n  metadata?: {\n    usage?: BedrockResponseUsage;\n  };\n};\n\nfunction getLangfuseBedrockUsage(\n  message: AIMessage | AIMessageChunk\n): UsageMetadata | undefined {\n  const usageMetadata = message.usage_metadata;\n  const bedrockUsage = (message.response_metadata as BedrockResponseMetadata)\n    .metadata?.usage;\n  if (\n    usageMetadata == null ||\n    bedrockUsage == null ||\n    usageMetadata.input_tokens !== bedrockUsage.inputTokens\n  ) {\n    return usageMetadata;\n  }\n\n  const cacheRead = bedrockUsage.cacheReadInputTokens ?? 0;\n  const cacheCreation = bedrockUsage.cacheWriteInputTokens ?? 0;\n  if (cacheRead === 0 && cacheCreation === 0) {\n    return usageMetadata;\n  }\n\n  return {\n    ...usageMetadata,\n    input_tokens: usageMetadata.input_tokens + cacheRead + cacheCreation,\n  };\n}\n\nfunction cloneMessageWithUsage(\n  message: AIMessage | AIMessageChunk,\n  usageMetadata: UsageMetadata\n): AIMessage | AIMessageChunk {\n  const fields: AIMessageFields = {\n    content: message.content,\n    additional_kwargs: message.additional_kwargs,\n    response_metadata: message.response_metadata,\n    id: message.id,\n    name: message.name,\n    tool_calls: message.tool_calls,\n    invalid_tool_calls: message.invalid_tool_calls,\n    usage_metadata: usageMetadata,\n  };\n\n  if (message instanceof AIMessageChunk) {\n    const chunkFields: AIMessageChunkFields = {\n      ...fields,\n      tool_call_chunks: message.tool_call_chunks,\n    };\n    return new AIMessageChunk(chunkFields);\n  }\n\n  return new AIMessage(fields);\n}\n\nfunction normalizeGenerationForLangfuse(generation: Generation): Generation {\n  if (!('message' in generation)) {\n    return generation;\n  }\n\n  const message = (generation as ChatGeneration).message;\n  if (!(message instanceof AIMessage || message instanceof AIMessageChunk)) {\n    return generation;\n  }\n\n  const usageMetadata = getLangfuseBedrockUsage(message);\n  if (usageMetadata == null || usageMetadata === message.usage_metadata) {\n    return generation;\n  }\n\n  const chatGeneration: ChatGeneration = {\n    ...(generation as ChatGeneration),\n    message: cloneMessageWithUsage(message, usageMetadata),\n  };\n  return chatGeneration;\n}\n\nfunction normalizeBedrockUsageForLangfuse(output: LLMResult): LLMResult {\n  if (output.generations.length === 0) {\n    return output;\n  }\n\n  const listIndex = output.generations.length - 1;\n  const generationList = output.generations[listIndex];\n  if (generationList.length === 0) {\n    return output;\n  }\n\n  const generationIndex = generationList.length - 1;\n  const generation = generationList[generationIndex];\n  const normalized = normalizeGenerationForLangfuse(generation);\n  if (normalized === generation) {\n    return output;\n  }\n\n  const generations = [...output.generations];\n  generations[listIndex] = [...generationList];\n  generations[listIndex][generationIndex] = normalized;\n  return { ...output, generations };\n}\n\nconst LANGGRAPH_NODE_METADATA_KEY = 'langgraph_node';\n/** Explicit agent identity in invoke metadata. Every identity-stamping\n *  component (graph model path, ToolNode, summarization node) overwrites the\n *  canonical `agentId` at its own invoke, so spread order guarantees the\n *  closest stamper wins — key priority alone could not (an inherited key of\n *  either casing can name the wrong agent). `agent_id` remains a fallback\n *  for third-party graphs that only stamp the snake-case form. */\nconst AGENT_ID_METADATA_KEYS = ['agentId', 'agent_id'];\nconst LANGGRAPH_NODE_AGENT_PREFIXES = ['agent=', 'tools=', 'summarize='];\n\n/** The LangGraph node a callback executes under, from its inherited\n *  `langgraph_node` run metadata. `undefined` when the callback carries no\n *  node identity. */\nfunction getCallbackNode(\n  metadata?: Record<string, unknown>\n): string | undefined {\n  const node = metadata?.[LANGGRAPH_NODE_METADATA_KEY];\n  return typeof node === 'string' && node !== '' ? node : undefined;\n}\n\n/** Whether a callback's node identifies the given agent. The outer workflow\n *  node carries the agent id VERBATIM — including ids that themselves begin\n *  with an internal prefix (an agent literally named `agent=research`) — so\n *  an exact match is checked before decoding the inner subgraph prefixes\n *  (`agent=` / `tools=` / `summarize=`). */\nfunction callbackNodeMatchesAgent(node: string, agentId: string): boolean {\n  if (node === agentId) {\n    return true;\n  }\n  for (const prefix of LANGGRAPH_NODE_AGENT_PREFIXES) {\n    if (node.startsWith(prefix) && node.slice(prefix.length) === agentId) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Hosts often execute agent code inside their own OpenTelemetry spans (HTTP\n * server auto-instrumentation on the global provider). Root observations must\n * not inherit that ambient identity: the foreign parent is never exported to\n * Langfuse, which orphans the trace root (root/trace input-output shaping is\n * skipped because the span no longer looks like a root), collapses concurrent\n * runs inside one request context — an agent run and the previous turn's\n * title run — into a single merged trace with racing names and unioned tags,\n * and bypasses the seeded deterministic trace id generator. Only a\n * Langfuse-managed span bound to the same export destination as the starting\n * run is a safe parent — that is the sanctioned way for hosts to group runs\n * under their own Langfuse observations; a managed span from a different\n * destination (another tenant's project) would leave this run's trace\n * dangling in its own destination while inheriting the other trace's id.\n */\nfunction detachForeignAmbientSpan(\n  activeContext: Context,\n  destinationKey?: string\n): Context {\n  const activeSpan = otelTrace.getSpan(activeContext);\n  if (activeSpan == null) {\n    return activeContext;\n  }\n  const parentDestination = getLangfuseManagedSpanDestination(activeSpan);\n  if (parentDestination != null && parentDestination === destinationKey) {\n    return activeContext;\n  }\n  return otelTrace.deleteSpan(activeContext);\n}\n\nclass ScopedLangfuseCallbackHandler extends CallbackHandler {\n  private readonly langfuse?: t.LangfuseConfig;\n  private readonly traceIdSeed?: string;\n  private readonly runId?: string;\n  private readonly identity: HandlerIdentity;\n  private readonly toolOutputTracing?: ResolvedLangfuseToolOutputTracingConfig;\n  private readonly trackedRunIds = new Set<string>();\n\n  constructor(params?: AgentLangfuseHandlerParams) {\n    const {\n      langfuse,\n      traceIdSeed,\n      runId,\n      toolOutputTracing,\n      traceName,\n      ...handlerParams\n    } = params ?? {};\n    super(handlerParams);\n    this.langfuse = langfuse;\n    this.traceIdSeed = traceIdSeed;\n    this.runId = runId;\n    this.toolOutputTracing = toolOutputTracing;\n    this.identity = {\n      userId: handlerParams.userId,\n      sessionId: handlerParams.sessionId,\n      tags: handlerParams.tags,\n      metadata: handlerParams.traceMetadata,\n      traceName,\n    };\n  }\n\n  private getDeterministicTraceSeed(): string | undefined {\n    return this.langfuse?.deterministicTraceId === true\n      ? this.traceIdSeed\n      : undefined;\n  }\n\n  /**\n   * Mirrors the base handler's `runMap`: a start callback whose `parentRunId`\n   * this handler never observed gets no explicit parent span and falls back\n   * to the ambient OTEL context (`startAndRegisterOtelSpan`), so it needs the\n   * same foreign-span detachment as a true root. This happens whenever a\n   * handler is attached mid-graph — e.g. the per-agent handler created for a\n   * detached subagent's model invocations, whose surrounding graph runs were\n   * never traced.\n   */\n  private startsDetachedRun(runId: string, parentRunId?: string): boolean {\n    const detached =\n      parentRunId == null || !this.trackedRunIds.has(parentRunId);\n    this.trackedRunIds.add(runId);\n    return detached;\n  }\n\n  /**\n   * Whether the ambient runtime scope belongs to a different run — or, for\n   * per-agent overlay scopes, to a different concurrently executing agent of\n   * the same run than the one this callback reports via its inherited\n   * `langgraph_node` metadata. Unstamped scopes on unstamped handlers are\n   * never foreign (host-managed handler semantics).\n   */\n  private isForeignScope(\n    scopeRunId: string | undefined,\n    scopeAgentId: string | undefined,\n    callbackMetadata?: Record<string, unknown>\n  ): boolean {\n    if (this.runId == null || scopeRunId == null) {\n      return false;\n    }\n    if (scopeRunId !== this.runId) {\n      return true;\n    }\n    if (scopeAgentId == null) {\n      return false;\n    }\n    // Explicit agent identity (stamped into invoke metadata by the graph's\n    // model path and ToolNode) is unambiguous; node names are a fallback —\n    // an agent literally named `agent=research` makes its outer node\n    // indistinguishable from agent `research`'s inner model node.\n    for (const key of AGENT_ID_METADATA_KEYS) {\n      const explicitAgentId = callbackMetadata?.[key];\n      if (typeof explicitAgentId === 'string' && explicitAgentId !== '') {\n        return explicitAgentId !== scopeAgentId;\n      }\n    }\n    const callbackNode = getCallbackNode(callbackMetadata);\n    return (\n      callbackNode != null &&\n      !callbackNodeMatchesAgent(callbackNode, scopeAgentId)\n    );\n  }\n\n  /**\n   * LangChain executes non-awaited callbacks on a process-wide background\n   * queue (`consumeCallback`), so this callback may be running inside a\n   * DIFFERENT concurrent run's async context. The ambient runtime scope is\n   * therefore only adopted when it belongs to this handler's run (and, for\n   * agent sub-scopes, to this callback's agent): scopes are stamped at their\n   * call sites, and a foreign stamp means the scope's config would route\n   * spans to the wrong destination, its seed would collapse this run's spans\n   * into the foreign trace, and its tool-output policy could leak output the\n   * foreign run permits but this run redacts — so config, seed, AND redaction\n   * policy all fall back to this handler's own run. Unstamped scopes on\n   * unstamped handlers keep scope-first semantics (agent overlays and\n   * per-path seeds like the title/label scopes, host-managed handlers).\n   *\n   * Detached runs (roots, or starts whose parent this handler never tracked)\n   * take their span parent from the ambient OTEL context, so drop any\n   * foreign ambient span first — a run launched from a host's instrumented\n   * request context must start its own trace, not join an unexported\n   * foreign one.\n   */\n  private withRuntimeContext<T>(\n    action: () => T,\n    isDetachedRun = false,\n    callbackMetadata?: Record<string, unknown>\n  ): T {\n    const currentContext = otelContext.active();\n    const scopeRunId = resolveLangfuseScopeRunId(currentContext);\n    const scopeAgentId = resolveLangfuseScopeAgentId(currentContext);\n    if (this.isForeignScope(scopeRunId, scopeAgentId, callbackMetadata)) {\n      return this.withForeignScopeRejected(action);\n    }\n    const langfuse =\n      resolveLangfuseConfigForSpan(currentContext) ?? this.langfuse;\n    const activeContext = isDetachedRun\n      ? detachForeignAmbientSpan(\n        currentContext,\n        resolveLangfuseDestinationKey(langfuse)\n      )\n      : currentContext;\n    const scoped = (): T =>\n      withLangfuseRuntimeScope(\n        {\n          langfuse,\n          traceIdSeed:\n            resolveTraceIdSeedForSpan(activeContext) ??\n            this.getDeterministicTraceSeed(),\n          runId: scopeRunId ?? this.runId,\n        },\n        action\n      );\n    return activeContext === currentContext\n      ? scoped()\n      : otelContext.with(activeContext, scoped);\n  }\n\n  /**\n   * A foreign concurrent run's context must be replaced wholesale, not\n   * merged: this library's scope keys (config, seed, tool-output policy,\n   * identity stamps) via the replace-mode runtime scope, `@langfuse/tracing`'s\n   * propagated trace attributes (userId, sessionId, tags, metadata, …) by\n   * deleting their context keys and re-propagating this handler's own\n   * identity, and the foreign active span — removed both so detached runs\n   * root their own trace and so `propagateAttributes` cannot stamp this\n   * run's identity onto the foreign run's still-recording span.\n   */\n  private withForeignScopeRejected<T>(action: () => T): T {\n    let cleanContext = otelTrace.deleteSpan(otelContext.active());\n    for (const key of Object.values(LangfuseOtelContextKeys)) {\n      cleanContext = cleanContext.deleteValue(key);\n    }\n    const scoped = (): T =>\n      withLangfuseRuntimeScope(\n        {\n          langfuse: this.langfuse,\n          traceIdSeed: this.getDeterministicTraceSeed(),\n          runId: this.runId,\n          toolOutputTracing:\n            this.toolOutputTracing ??\n            resolveToolOutputTracingConfig(this.langfuse),\n        },\n        action,\n        { replace: true }\n      );\n    const { userId, sessionId, tags, metadata, traceName } = this.identity;\n    const hasIdentity =\n      userId != null ||\n      sessionId != null ||\n      metadata != null ||\n      traceName != null ||\n      (tags?.length ?? 0) > 0;\n    return otelContext.with(cleanContext, () =>\n      hasIdentity\n        ? propagateAttributes(\n          { userId, sessionId, tags, metadata, traceName },\n          scoped\n        )\n        : scoped()\n    );\n  }\n\n  // LangChain may invoke callback handlers outside the caller's OTEL context.\n  // Re-enter tenant scope only for callbacks that start Langfuse observations;\n  // end/error/token callbacks use spans already bound to a processor at start.\n  override handleChainStart(\n    ...args: Parameters<CallbackHandler['handleChainStart']>\n  ): ReturnType<CallbackHandler['handleChainStart']> {\n    return this.withRuntimeContext(\n      () => super.handleChainStart(...args),\n      this.startsDetachedRun(args[2], args[3]),\n      args[5]\n    );\n  }\n\n  override handleChainError(\n    ...args: Parameters<CallbackHandler['handleChainError']>\n  ): ReturnType<CallbackHandler['handleChainError']> {\n    const [error, runId, parentRunId] = args;\n    if (error != null && parentRunId != null && isGraphInterrupt(error)) {\n      return super.handleChainEnd(\n        GRAPH_INTERRUPT_CONTROL_FLOW,\n        runId,\n        parentRunId\n      );\n    }\n    if (error != null && parentRunId != null && isParentCommand(error)) {\n      return super.handleChainEnd(\n        { controlFlow: 'ParentCommand' },\n        runId,\n        parentRunId\n      );\n    }\n    return super.handleChainError(...args);\n  }\n\n  override handleAgentAction(\n    ...args: Parameters<CallbackHandler['handleAgentAction']>\n  ): ReturnType<CallbackHandler['handleAgentAction']> {\n    return this.withRuntimeContext(\n      () => super.handleAgentAction(...args),\n      this.startsDetachedRun(args[1], args[2])\n    );\n  }\n\n  override handleGenerationStart(\n    ...args: Parameters<CallbackHandler['handleGenerationStart']>\n  ): ReturnType<CallbackHandler['handleGenerationStart']> {\n    return this.withRuntimeContext(\n      () => super.handleGenerationStart(...args),\n      this.startsDetachedRun(args[2], args[3]),\n      args[6]\n    );\n  }\n\n  override handleChatModelStart(\n    ...args: Parameters<CallbackHandler['handleChatModelStart']>\n  ): ReturnType<CallbackHandler['handleChatModelStart']> {\n    return this.withRuntimeContext(\n      () => super.handleChatModelStart(...args),\n      this.startsDetachedRun(args[2], args[3]),\n      args[6]\n    );\n  }\n\n  override handleLLMStart(\n    ...args: Parameters<CallbackHandler['handleLLMStart']>\n  ): ReturnType<CallbackHandler['handleLLMStart']> {\n    return this.withRuntimeContext(\n      () => super.handleLLMStart(...args),\n      this.startsDetachedRun(args[2], args[3]),\n      args[6]\n    );\n  }\n\n  override handleLLMEnd(\n    output: LLMResult,\n    runId: string,\n    parentRunId?: string\n  ): Promise<void> {\n    return super.handleLLMEnd(\n      normalizeBedrockUsageForLangfuse(output),\n      runId,\n      parentRunId\n    );\n  }\n\n  override handleToolStart(\n    ...args: Parameters<CallbackHandler['handleToolStart']>\n  ): ReturnType<CallbackHandler['handleToolStart']> {\n    return this.withRuntimeContext(\n      () => super.handleToolStart(...args),\n      this.startsDetachedRun(args[2], args[3]),\n      args[5]\n    );\n  }\n\n  override handleToolError(\n    ...args: Parameters<CallbackHandler['handleToolError']>\n  ): ReturnType<CallbackHandler['handleToolError']> {\n    const [error, runId, parentRunId] = args;\n    if (error != null && parentRunId != null && isGraphInterrupt(error)) {\n      return super.handleToolEnd(\n        GRAPH_INTERRUPT_TOOL_OUTPUT,\n        runId,\n        parentRunId\n      );\n    }\n    return super.handleToolError(...args);\n  }\n\n  override handleRetrieverStart(\n    ...args: Parameters<CallbackHandler['handleRetrieverStart']>\n  ): ReturnType<CallbackHandler['handleRetrieverStart']> {\n    return this.withRuntimeContext(\n      () => super.handleRetrieverStart(...args),\n      this.startsDetachedRun(args[2], args[3]),\n      args[5]\n    );\n  }\n}\n\nfunction hasLangfuseTracingConfig(langfuse?: t.LangfuseConfig): boolean {\n  return (\n    langfuse?.toolNodeTracing != null || langfuse?.toolOutputTracing != null\n  );\n}\n\nfunction hasLangfuseTraceAttributes(langfuse?: t.LangfuseConfig): boolean {\n  return (\n    Object.keys(createTraceMetadata(langfuse?.metadata ?? {})).length > 0 ||\n    Object.keys(\n      createLibreChatTraceAttributes(langfuse?.librechatTraceAttributes ?? {})\n    ).length > 0 ||\n    (mergeLangfuseTags(undefined, langfuse?.tags)?.length ?? 0) > 0\n  );\n}\n\nfunction hasLangfuseConfigBaseUrl(langfuse?: t.LangfuseConfig): boolean {\n  return isPresent(langfuse?.baseUrl);\n}\n\nexport function isExplicitLangfuseConfig(langfuse?: t.LangfuseConfig): boolean {\n  return (\n    langfuse?.enabled != null ||\n    isPresent(langfuse?.publicKey) ||\n    isPresent(langfuse?.secretKey) ||\n    isPresent(langfuse?.baseUrl) ||\n    hasLangfuseTraceAttributes(langfuse) ||\n    hasLangfuseTracingConfig(langfuse)\n  );\n}\n\nfunction createTraceMetadata(\n  metadata: Record<string, unknown>\n): LangfuseTraceMetadata {\n  const traceMetadata: LangfuseTraceMetadata = {};\n  for (const [key, value] of Object.entries(metadata)) {\n    if (value == null) {\n      continue;\n    }\n    const stringValue = typeof value === 'string' ? value : String(value);\n    if (\n      stringValue.trim() === '' ||\n      stringValue.length > TRACE_METADATA_MAX_LENGTH\n    ) {\n      continue;\n    }\n    traceMetadata[key] = stringValue;\n  }\n  return traceMetadata;\n}\n\nexport function createLibreChatTraceAttributes(\n  attributes: LangfuseConfigTraceAttributes\n): LangfuseTraceAttributes {\n  const librechatTraceAttributes: LangfuseTraceAttributes = {};\n  for (const [key, value] of Object.entries(attributes)) {\n    if (value == null || key.trim() === '') {\n      continue;\n    }\n    if (typeof value === 'string') {\n      if (value.trim() === '' || value.length > TRACE_METADATA_MAX_LENGTH) {\n        continue;\n      }\n      librechatTraceAttributes[key] = value;\n      continue;\n    }\n    librechatTraceAttributes[key] = value;\n  }\n  return librechatTraceAttributes;\n}\n\nexport function createLangfuseTraceMetadata({\n  messageId,\n  parentMessageId,\n  agentId,\n  agentName,\n}: {\n  messageId?: unknown;\n  parentMessageId?: unknown;\n  agentId?: unknown;\n  agentName?: unknown;\n}): LangfuseTraceMetadata {\n  return createTraceMetadata({\n    messageId,\n    parentMessageId,\n    agentId,\n    agentName,\n  });\n}\n\nfunction mergeLangfuseTraceMetadata(\n  traceMetadata?: LangfuseTraceMetadata,\n  metadata?: LangfuseMetadata\n): LangfuseTraceMetadata | undefined {\n  const merged = createTraceMetadata({\n    ...(metadata ?? {}),\n    ...(traceMetadata ?? {}),\n  });\n  return Object.keys(merged).length > 0 ? merged : undefined;\n}\n\nfunction mergeLangfuseTags(\n  tags?: string[],\n  configTags?: string[]\n): string[] | undefined {\n  const merged = [...(tags ?? []), ...(configTags ?? [])].filter(\n    (tag) => tag.trim() !== ''\n  );\n  return merged.length > 0 ? [...new Set(merged)] : undefined;\n}\n\nexport function getLangfuseTraceName(\n  traceMetadata?: LangfuseTraceMetadata,\n  fallback: string = 'LibreChat Agent'\n): string {\n  const agentName = traceMetadata?.agentName;\n  return isPresent(agentName) ? `${fallback}: ${agentName}` : fallback;\n}\n\nexport function shouldCreateLangfuseHandler(\n  langfuse?: t.LangfuseConfig\n): boolean {\n  if (langfuse?.enabled === false) {\n    return false;\n  }\n  return (\n    hasLangfuseEnvConfig() ||\n    hasLangfuseConfigCredentials(langfuse) ||\n    (hasLangfuseConfigBaseUrl(langfuse) && hasLangfuseEnvCredentials())\n  );\n}\n\nexport function createLegacyLangfuseHandler(\n  params: LangfuseHandlerParams\n): CallbackHandler {\n  return new ScopedLangfuseCallbackHandler(params);\n}\n\nexport function createLangfuseHandler({\n  langfuse,\n  userId,\n  sessionId,\n  traceMetadata,\n  tags,\n  traceIdSeed,\n  runId,\n  toolOutputTracing,\n  traceName,\n}: AgentLangfuseHandlerParams): CallbackHandler | undefined {\n  if (!shouldCreateLangfuseHandler(langfuse)) {\n    return undefined;\n  }\n  return new ScopedLangfuseCallbackHandler({\n    userId,\n    sessionId,\n    traceMetadata: mergeLangfuseTraceMetadata(\n      traceMetadata,\n      langfuse?.metadata\n    ),\n    tags: mergeLangfuseTags(tags, langfuse?.tags),\n    langfuse,\n    traceIdSeed,\n    runId,\n    toolOutputTracing,\n    traceName,\n  });\n}\n\nfunction createPropagateAttributeParams({\n  langfuse,\n  userId,\n  sessionId,\n  traceMetadata,\n  traceName,\n  tags,\n}: LangfuseAttributeParams): PropagateAttributesParams {\n  return {\n    userId,\n    sessionId,\n    traceName,\n    tags: mergeLangfuseTags(tags, langfuse?.tags),\n    metadata: mergeLangfuseTraceMetadata(traceMetadata, langfuse?.metadata),\n  };\n}\n\nexport function withLangfuseAttributes<T>(\n  params: LangfuseAttributeParams,\n  action: () => T\n): T {\n  if (!shouldCreateLangfuseHandler(params.langfuse)) {\n    return action();\n  }\n  return propagateAttributes(createPropagateAttributeParams(params), action);\n}\n\nexport function hasExplicitLangfuseConfig(\n  contexts: Iterable<{ langfuse?: t.LangfuseConfig }>\n): boolean {\n  for (const context of contexts) {\n    if (isExplicitLangfuseConfig(context.langfuse)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function isLangfuseCallbackHandler(value: unknown): boolean {\n  return value instanceof CallbackHandler;\n}\n\nexport async function disposeLangfuseHandler(value: unknown): Promise<void> {\n  if (\n    value == null ||\n    parseBooleanEnv(process.env[LANGFUSE_FORCE_FLUSH_ON_DISPOSE]) !== true\n  ) {\n    return;\n  }\n  const provider = getLangfuseTracerProvider() as FlushableTracerProvider;\n  await provider.forceFlush?.();\n}\n"],"mappings":"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"}
+{"version":3,"file":"langfuse.mjs","names":["otelTrace","otelContext"],"sources":["../../src/langfuse.ts"],"mappings":"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"}

package/dist/esm/langfuseConfig.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"langfuseConfig.mjs","names":[],"sources":["../../src/langfuseConfig.ts"],"sourcesContent":["import type { ResolvedLangfuseToolOutputTracingConfig } from '@/langfuseRuntimeContext';\nimport type * as t from '@/types';\nimport { parseBooleanEnv } from '@/utils/misc';\n\nexport const LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT = '[tool output redacted]';\n\nfunction isPresent(value: unknown): value is string {\n  return typeof value === 'string' && value.trim() !== '';\n}\n\nexport function normalizeToolName(name: string): string {\n  return name.trim().toLowerCase();\n}\n\nexport function hasLangfuseConfigCredentials(\n  langfuse?: t.LangfuseConfig\n): langfuse is t.LangfuseConfig & {\n  publicKey: string;\n  secretKey: string;\n} {\n  return (\n    langfuse != null &&\n    isPresent(langfuse.publicKey) &&\n    isPresent(langfuse.secretKey)\n  );\n}\n\nexport function hasLangfuseEnvCredentials(): boolean {\n  return (\n    isPresent(process.env.LANGFUSE_SECRET_KEY) &&\n    isPresent(process.env.LANGFUSE_PUBLIC_KEY)\n  );\n}\n\nexport function hasLangfuseEnvConfig(): boolean {\n  return hasLangfuseEnvCredentials();\n}\n\nfunction normalizeToolNames(names: string[] | undefined): Set<string> {\n  const normalized = new Set<string>();\n  for (const name of names ?? []) {\n    if (isPresent(name)) {\n      normalized.add(normalizeToolName(name));\n    }\n  }\n  return normalized;\n}\n\nfunction parseToolNames(value: string | undefined): string[] | undefined {\n  if (!isPresent(value)) {\n    return undefined;\n  }\n\n  return value\n    .split(',')\n    .map((name) => name.trim())\n    .filter((name) => name !== '');\n}\n\nfunction getEnvToolOutputTracingEnabled(): boolean | undefined {\n  const traceToolOutputs = parseBooleanEnv(\n    process.env.LANGFUSE_TRACE_TOOL_OUTPUTS\n  );\n  if (traceToolOutputs != null) {\n    return traceToolOutputs;\n  }\n\n  const redactToolOutputs = parseBooleanEnv(\n    process.env.LANGFUSE_REDACT_TOOL_OUTPUTS\n  );\n  if (redactToolOutputs != null) {\n    return !redactToolOutputs;\n  }\n\n  return parseBooleanEnv(process.env.LANGFUSE_TOOL_OUTPUT_TRACING_ENABLED);\n}\n\nfunction getEnvRedactedToolNames(): string[] | undefined {\n  return (\n    parseToolNames(process.env.LANGFUSE_REDACT_TOOL_OUTPUT_NAMES) ??\n    parseToolNames(process.env.LANGFUSE_REDACT_TOOL_NAMES)\n  );\n}\n\nfunction getEnvRedactionText(): string | undefined {\n  return isPresent(process.env.LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT)\n    ? process.env.LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT\n    : undefined;\n}\n\nfunction getEnvToolNameMatchMode(): 'exact' | 'partial' | undefined {\n  const mode = (\n    process.env.LANGFUSE_REDACT_TOOL_OUTPUT_NAME_MATCH_MODE ??\n    process.env.LANGFUSE_REDACT_TOOL_NAME_MATCH_MODE\n  )\n    ?.trim()\n    .toLowerCase();\n  if (mode === 'exact' || mode === 'partial') {\n    return mode;\n  }\n  return undefined;\n}\n\nfunction hasEnvToolOutputTracingConfig(): boolean {\n  return (\n    getEnvToolOutputTracingEnabled() != null ||\n    getEnvRedactedToolNames() != null ||\n    getEnvRedactionText() != null ||\n    getEnvToolNameMatchMode() != null\n  );\n}\n\nfunction resolveToolOutputTracingEnabled(\n  runConfig?: t.LangfuseToolOutputTracingConfig,\n  agentConfig?: t.LangfuseToolOutputTracingConfig\n): boolean {\n  return (\n    agentConfig?.enabled ??\n    runConfig?.enabled ??\n    getEnvToolOutputTracingEnabled() ??\n    true\n  );\n}\n\nfunction resolveRedactedToolNames(\n  runConfig?: t.LangfuseToolOutputTracingConfig,\n  agentConfig?: t.LangfuseToolOutputTracingConfig\n): Set<string> {\n  return normalizeToolNames([\n    ...(getEnvRedactedToolNames() ?? []),\n    ...(runConfig?.redactedToolNames ?? []),\n    ...(agentConfig?.redactedToolNames ?? []),\n  ]);\n}\n\nfunction resolveToolNameMatchMode(\n  runConfig?: t.LangfuseToolOutputTracingConfig,\n  agentConfig?: t.LangfuseToolOutputTracingConfig\n): 'exact' | 'partial' {\n  const modes = [\n    getEnvToolNameMatchMode(),\n    runConfig?.redactedToolNameMatchMode,\n    agentConfig?.redactedToolNameMatchMode,\n  ];\n  return modes.includes('partial') ? 'partial' : 'exact';\n}\n\nexport function hasToolOutputTracingConfig(\n  runLangfuse?: t.LangfuseConfig,\n  agentLangfuse?: t.LangfuseConfig\n): boolean {\n  return (\n    runLangfuse?.toolOutputTracing != null ||\n    agentLangfuse?.toolOutputTracing != null ||\n    hasEnvToolOutputTracingConfig()\n  );\n}\n\nexport function resolveToolOutputTracingConfig(\n  runLangfuse?: t.LangfuseConfig,\n  agentLangfuse?: t.LangfuseConfig\n): ResolvedLangfuseToolOutputTracingConfig {\n  const runConfig = runLangfuse?.toolOutputTracing;\n  const agentConfig = agentLangfuse?.toolOutputTracing;\n\n  return {\n    enabled: resolveToolOutputTracingEnabled(runConfig, agentConfig),\n    redactedToolNames: resolveRedactedToolNames(runConfig, agentConfig),\n    redactedToolNameMatchMode: resolveToolNameMatchMode(runConfig, agentConfig),\n    redactionText:\n      agentConfig?.redactionText ??\n      runConfig?.redactionText ??\n      getEnvRedactionText() ??\n      LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT,\n  };\n}\n\nexport function resolveLangfuseConfig(\n  runLangfuse?: t.LangfuseConfig,\n  agentLangfuse?: t.LangfuseConfig\n): t.LangfuseConfig | undefined {\n  if (runLangfuse == null) {\n    return agentLangfuse;\n  }\n  if (agentLangfuse == null) {\n    return runLangfuse;\n  }\n\n  const toolNodeTracing =\n    runLangfuse.toolNodeTracing != null || agentLangfuse.toolNodeTracing != null\n      ? {\n        ...runLangfuse.toolNodeTracing,\n        ...agentLangfuse.toolNodeTracing,\n      }\n      : undefined;\n  const toolOutputTracing =\n    runLangfuse.toolOutputTracing != null ||\n    agentLangfuse.toolOutputTracing != null\n      ? {\n        ...runLangfuse.toolOutputTracing,\n        ...agentLangfuse.toolOutputTracing,\n      }\n      : undefined;\n  const metadata =\n    runLangfuse.metadata != null || agentLangfuse.metadata != null\n      ? {\n        ...runLangfuse.metadata,\n        ...agentLangfuse.metadata,\n      }\n      : undefined;\n  const librechatTraceAttributes =\n    runLangfuse.librechatTraceAttributes != null ||\n    agentLangfuse.librechatTraceAttributes != null\n      ? {\n        ...runLangfuse.librechatTraceAttributes,\n        ...agentLangfuse.librechatTraceAttributes,\n      }\n      : undefined;\n  const tags =\n    runLangfuse.tags != null || agentLangfuse.tags != null\n      ? [\n        ...new Set([\n          ...(runLangfuse.tags ?? []),\n          ...(agentLangfuse.tags ?? []),\n        ]),\n      ]\n      : undefined;\n\n  return {\n    ...runLangfuse,\n    ...agentLangfuse,\n    ...(metadata != null ? { metadata } : {}),\n    ...(librechatTraceAttributes != null ? { librechatTraceAttributes } : {}),\n    ...(tags != null ? { tags } : {}),\n    ...(toolNodeTracing != null ? { toolNodeTracing } : {}),\n    ...(toolOutputTracing != null ? { toolOutputTracing } : {}),\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"langfuseConfig.mjs","names":[],"sources":["../../src/langfuseConfig.ts"],"mappings":"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"}

package/dist/esm/langfuseRuntimeContext.mjs

@@ -8,7 +8,6 @@ function hasText(value) {
 function hasLangfuseRuntimeContextValue(context) {
 	return context.langfuse != null || hasText(context.traceIdSeed) || hasText(context.runId) || hasText(context.agentId) || context.toolOutputTracing != null;
 }
-/** sha256(seed) -> first 32 hex chars; matches `@langfuse/tracing` `createTraceId`. */
 function traceIdFromSeed(seed) {
 	return createHash("sha256").update(seed, "utf8").digest("hex").slice(0, 32);
 }
@@ -30,12 +29,6 @@ function getLangfuseScopeAgentId() {
 function getLangfuseRuntimeToolOutputTracingConfig() {
 	return getLangfuseRuntimeContext()?.toolOutputTracing;
 }
-/**
-* Runs `fn` with a merged Langfuse runtime context. Undefined fields inherit
-* from the parent scope; callers intentionally cannot clear parent values by
-* passing `undefined` — use `replaceLangfuseRuntimeContext` when the parent
-* scope must NOT leak through (a foreign concurrent run's scope).
-*/
 function runWithLangfuseRuntimeContext(context, fn) {
 	const next = {
 		...getLangfuseRuntimeContext() ?? {},
@@ -47,12 +40,6 @@ function runWithLangfuseRuntimeContext(context, fn) {
 	};
 	return hasLangfuseRuntimeContextValue(next) ? langfuseRuntimeContextStore.run(next, fn) : fn();
 }
-/**
-* Runs `fn` with EXACTLY the provided context — the surrounding scope's
-* fields do not leak through. A rejected foreign run's explicit destination
-* or seed must not survive via merge inheritance when this run has none of
-* its own (env-credential runs, non-deterministic runs).
-*/
 function replaceLangfuseRuntimeContext(context, fn) {
 	return langfuseRuntimeContextStore.run({ ...context }, fn);
 }

package/dist/esm/langfuseRuntimeContext.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"langfuseRuntimeContext.mjs","names":[],"sources":["../../src/langfuseRuntimeContext.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\nimport { AsyncLocalStorage } from 'node:async_hooks';\nimport type * as t from '@/types';\n\nexport type ResolvedLangfuseToolOutputTracingConfig = {\n  enabled: boolean;\n  redactedToolNames: Set<string>;\n  redactedToolNameMatchMode: 'exact' | 'partial';\n  redactionText: string;\n};\n\nexport type LangfuseRuntimeContext = {\n  langfuse?: t.LangfuseConfig;\n  traceIdSeed?: string;\n  toolOutputTracing?: ResolvedLangfuseToolOutputTracingConfig;\n  /**\n   * Identity of the run this scope belongs to. LangChain executes\n   * non-awaited callbacks on a shared background queue\n   * (`@langchain/core` `consumeCallback`, a process-wide `p-queue` with\n   * concurrency 1), so a callback can run inside a DIFFERENT concurrent\n   * run's async context. Handlers compare this id against their own run to\n   * decide whether an ambient scope is theirs to adopt.\n   */\n  runId?: string;\n  /**\n   * Identity of the agent whose overlay this scope carries, for per-agent\n   * scopes inside a run. Fan-out agents execute concurrently with distinct\n   * Langfuse overlays, so handlers additionally compare this against the\n   * agent a callback reports via its inherited `langgraph_node` metadata.\n   */\n  agentId?: string;\n};\n\nconst langfuseRuntimeContextStore =\n  new AsyncLocalStorage<LangfuseRuntimeContext>();\n\nfunction hasText(value: string | undefined): value is string {\n  return value != null && value.trim() !== '';\n}\n\nexport function hasLangfuseRuntimeContextValue(\n  context: LangfuseRuntimeContext\n): boolean {\n  return (\n    context.langfuse != null ||\n    hasText(context.traceIdSeed) ||\n    hasText(context.runId) ||\n    hasText(context.agentId) ||\n    context.toolOutputTracing != null\n  );\n}\n\n/** sha256(seed) -> first 32 hex chars; matches `@langfuse/tracing` `createTraceId`. */\nexport function traceIdFromSeed(seed: string): string {\n  return createHash('sha256').update(seed, 'utf8').digest('hex').slice(0, 32);\n}\n\nexport function getLangfuseRuntimeContext():\n  | LangfuseRuntimeContext\n  | undefined {\n  return langfuseRuntimeContextStore.getStore();\n}\n\nexport function getLangfuseRuntimeConfig(): t.LangfuseConfig | undefined {\n  return getLangfuseRuntimeContext()?.langfuse;\n}\n\nexport function getTraceIdSeed(): string | undefined {\n  return getLangfuseRuntimeContext()?.traceIdSeed;\n}\n\nexport function getLangfuseScopeRunId(): string | undefined {\n  return getLangfuseRuntimeContext()?.runId;\n}\n\nexport function getLangfuseScopeAgentId(): string | undefined {\n  return getLangfuseRuntimeContext()?.agentId;\n}\n\nexport function getLangfuseRuntimeToolOutputTracingConfig():\n  | ResolvedLangfuseToolOutputTracingConfig\n  | undefined {\n  return getLangfuseRuntimeContext()?.toolOutputTracing;\n}\n\n/**\n * Runs `fn` with a merged Langfuse runtime context. Undefined fields inherit\n * from the parent scope; callers intentionally cannot clear parent values by\n * passing `undefined` — use `replaceLangfuseRuntimeContext` when the parent\n * scope must NOT leak through (a foreign concurrent run's scope).\n */\nexport function runWithLangfuseRuntimeContext<T>(\n  context: LangfuseRuntimeContext,\n  fn: () => T\n): T {\n  const current = getLangfuseRuntimeContext();\n  const next = {\n    ...(current ?? {}),\n    ...(context.langfuse !== undefined ? { langfuse: context.langfuse } : {}),\n    ...(hasText(context.traceIdSeed)\n      ? { traceIdSeed: context.traceIdSeed }\n      : {}),\n    ...(hasText(context.runId) ? { runId: context.runId } : {}),\n    ...(hasText(context.agentId) ? { agentId: context.agentId } : {}),\n    ...(context.toolOutputTracing !== undefined\n      ? { toolOutputTracing: context.toolOutputTracing }\n      : {}),\n  };\n\n  return hasLangfuseRuntimeContextValue(next)\n    ? langfuseRuntimeContextStore.run(next, fn)\n    : fn();\n}\n\n/**\n * Runs `fn` with EXACTLY the provided context — the surrounding scope's\n * fields do not leak through. A rejected foreign run's explicit destination\n * or seed must not survive via merge inheritance when this run has none of\n * its own (env-credential runs, non-deterministic runs).\n */\nexport function replaceLangfuseRuntimeContext<T>(\n  context: LangfuseRuntimeContext,\n  fn: () => T\n): T {\n  return langfuseRuntimeContextStore.run({ ...context }, fn);\n}\n\nexport function runWithTraceIdSeed<T>(\n  seed: string | undefined,\n  fn: () => T\n): T {\n  return hasText(seed)\n    ? runWithLangfuseRuntimeContext({ traceIdSeed: seed }, fn)\n    : fn();\n}\n"],"mappings":";;;AAiCA,MAAM,8BACJ,IAAI,kBAA0C;AAEhD,SAAS,QAAQ,OAA4C;CAC3D,OAAO,SAAS,QAAQ,MAAM,KAAK,MAAM;AAC3C;AAEA,SAAgB,+BACd,SACS;CACT,OACE,QAAQ,YAAY,QACpB,QAAQ,QAAQ,WAAW,KAC3B,QAAQ,QAAQ,KAAK,KACrB,QAAQ,QAAQ,OAAO,KACvB,QAAQ,qBAAqB;AAEjC;;AAGA,SAAgB,gBAAgB,MAAsB;CACpD,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,MAAM,MAAM,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,EAAE;AAC5E;AAEA,SAAgB,4BAEF;CACZ,OAAO,4BAA4B,SAAS;AAC9C;AAEA,SAAgB,2BAAyD;CACvE,OAAO,0BAA0B,CAAC,EAAE;AACtC;AAEA,SAAgB,iBAAqC;CACnD,OAAO,0BAA0B,CAAC,EAAE;AACtC;AAEA,SAAgB,wBAA4C;CAC1D,OAAO,0BAA0B,CAAC,EAAE;AACtC;AAEA,SAAgB,0BAA8C;CAC5D,OAAO,0BAA0B,CAAC,EAAE;AACtC;AAEA,SAAgB,4CAEF;CACZ,OAAO,0BAA0B,CAAC,EAAE;AACtC;;;;;;;AAQA,SAAgB,8BACd,SACA,IACG;CAEH,MAAM,OAAO;EACX,GAFc,0BAEJ,KAAK,CAAC;EAChB,GAAI,QAAQ,aAAa,KAAA,IAAY,EAAE,UAAU,QAAQ,SAAS,IAAI,CAAC;EACvE,GAAI,QAAQ,QAAQ,WAAW,IAC3B,EAAE,aAAa,QAAQ,YAAY,IACnC,CAAC;EACL,GAAI,QAAQ,QAAQ,KAAK,IAAI,EAAE,OAAO,QAAQ,MAAM,IAAI,CAAC;EACzD,GAAI,QAAQ,QAAQ,OAAO,IAAI,EAAE,SAAS,QAAQ,QAAQ,IAAI,CAAC;EAC/D,GAAI,QAAQ,sBAAsB,KAAA,IAC9B,EAAE,mBAAmB,QAAQ,kBAAkB,IAC/C,CAAC;CACP;CAEA,OAAO,+BAA+B,IAAI,IACtC,4BAA4B,IAAI,MAAM,EAAE,IACxC,GAAG;AACT;;;;;;;AAQA,SAAgB,8BACd,SACA,IACG;CACH,OAAO,4BAA4B,IAAI,EAAE,GAAG,QAAQ,GAAG,EAAE;AAC3D"}
+{"version":3,"file":"langfuseRuntimeContext.mjs","names":[],"sources":["../../src/langfuseRuntimeContext.ts"],"mappings":";;;AAiCA,MAAM,8BACJ,IAAI,kBAA0C;AAEhD,SAAS,QAAQ,OAA4C;CAC3D,OAAO,SAAS,QAAQ,MAAM,KAAK,MAAM;AAC3C;AAEA,SAAgB,+BACd,SACS;CACT,OACE,QAAQ,YAAY,QACpB,QAAQ,QAAQ,WAAW,KAC3B,QAAQ,QAAQ,KAAK,KACrB,QAAQ,QAAQ,OAAO,KACvB,QAAQ,qBAAqB;AAEjC;AAGA,SAAgB,gBAAgB,MAAsB;CACpD,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,MAAM,MAAM,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,EAAE;AAC5E;AAEA,SAAgB,4BAEF;CACZ,OAAO,4BAA4B,SAAS;AAC9C;AAEA,SAAgB,2BAAyD;CACvE,OAAO,0BAA0B,CAAC,EAAE;AACtC;AAEA,SAAgB,iBAAqC;CACnD,OAAO,0BAA0B,CAAC,EAAE;AACtC;AAEA,SAAgB,wBAA4C;CAC1D,OAAO,0BAA0B,CAAC,EAAE;AACtC;AAEA,SAAgB,0BAA8C;CAC5D,OAAO,0BAA0B,CAAC,EAAE;AACtC;AAEA,SAAgB,4CAEF;CACZ,OAAO,0BAA0B,CAAC,EAAE;AACtC;AAQA,SAAgB,8BACd,SACA,IACG;CAEH,MAAM,OAAO;EACX,GAFc,0BAEJ,KAAK,CAAC;EAChB,GAAI,QAAQ,aAAa,KAAA,IAAY,EAAE,UAAU,QAAQ,SAAS,IAAI,CAAC;EACvE,GAAI,QAAQ,QAAQ,WAAW,IAC3B,EAAE,aAAa,QAAQ,YAAY,IACnC,CAAC;EACL,GAAI,QAAQ,QAAQ,KAAK,IAAI,EAAE,OAAO,QAAQ,MAAM,IAAI,CAAC;EACzD,GAAI,QAAQ,QAAQ,OAAO,IAAI,EAAE,SAAS,QAAQ,QAAQ,IAAI,CAAC;EAC/D,GAAI,QAAQ,sBAAsB,KAAA,IAC9B,EAAE,mBAAmB,QAAQ,kBAAkB,IAC/C,CAAC;CACP;CAEA,OAAO,+BAA+B,IAAI,IACtC,4BAA4B,IAAI,MAAM,EAAE,IACxC,GAAG;AACT;AAQA,SAAgB,8BACd,SACA,IACG;CACH,OAAO,4BAA4B,IAAI,EAAE,GAAG,QAAQ,GAAG,EAAE;AAC3D"}

package/dist/esm/langfuseRuntimeScope.mjs

@@ -39,13 +39,9 @@ function getOtelScopeAgentId(activeContext) {
 	const value = activeContext.getValue(langfuseScopeAgentIdKey);
 	return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
-/** The run identity the active scope belongs to (see
-*  `LangfuseRuntimeContext.runId`), or `undefined` for unstamped scopes. */
 function resolveLangfuseScopeRunId(activeContext) {
 	return getLangfuseScopeRunId() ?? getOtelScopeRunId(activeContext);
 }
-/** The agent identity of a per-agent overlay scope (see
-*  `LangfuseRuntimeContext.agentId`), or `undefined` for run-level scopes. */
 function resolveLangfuseScopeAgentId(activeContext) {
 	return getLangfuseScopeAgentId() ?? getOtelScopeAgentId(activeContext);
 }