@librechat/agents 3.2.32 → 3.2.34

package/dist/esm/hooks/types.mjs

@@ -1,26 +1,28 @@
+//#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.
- */
+* 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',
-    'PreToolUse',
-    'PostToolUse',
-    'PostToolUseFailure',
-    'PostToolBatch',
-    'PermissionDenied',
-    'SubagentStart',
-    'SubagentStop',
-    'Stop',
-    'StopFailure',
-    'PreCompact',
-    'PostCompact',
+	"RunStart",
+	"UserPromptSubmit",
+	"PreToolUse",
+	"PostToolUse",
+	"PostToolUseFailure",
+	"PostToolBatch",
+	"PermissionDenied",
+	"SubagentStart",
+	"SubagentStop",
+	"Stop",
+	"StopFailure",
+	"PreCompact",
+	"PostCompact"
 ];
-
+//#endregion
 export { HOOK_EVENTS };
-//# sourceMappingURL=types.mjs.map
+
+//# sourceMappingURL=types.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","sources":["../../../src/hooks/types.ts"],"sourcesContent":["// src/hooks/types.ts\nimport type { BaseMessage } from '@langchain/core/messages';\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  'PermissionDenied',\n  'SubagentStart',\n  'SubagentStop',\n  'Stop',\n  'StopFailure',\n  'PreCompact',\n  'PostCompact',\n] as const;\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.\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\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  | 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  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  /** 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\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 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  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  | 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  /** 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"],"names":[],"mappings":"AAGA;;;;;;;AAOG;AACI,MAAM,WAAW,GAAG;IACzB,UAAU;IACV,kBAAkB;IAClB,YAAY;IACZ,aAAa;IACb,oBAAoB;IACpB,eAAe;IACf,kBAAkB;IAClB,eAAe;IACf,cAAc;IACd,MAAM;IACN,aAAa;IACb,YAAY;IACZ,aAAa;;;;;"}
+{"version":3,"file":"types.mjs","names":[],"sources":["../../../src/hooks/types.ts"],"sourcesContent":["// src/hooks/types.ts\nimport type { BaseMessage } from '@langchain/core/messages';\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  'PermissionDenied',\n  'SubagentStart',\n  'SubagentStop',\n  'Stop',\n  'StopFailure',\n  'PreCompact',\n  'PostCompact',\n] as const;\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.\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\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  | 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  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  /** 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\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 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  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  | 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  /** 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":";;;;;;;;;AAWA,MAAa,cAAc;CACzB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF"}

package/dist/esm/instrumentation.mjs

@@ -1,155 +1,132 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { randomBytes, createHash } from 'node:crypto';
-import { setLangfuseTracerProvider } from '@langfuse/tracing';
-import { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
-import { createContextKey, context, ROOT_CONTEXT } from '@opentelemetry/api';
-import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
-import { hasLangfuseEnvConfig, hasLangfuseEnvCredentials, hasLangfuseConfigCredentials } from './langfuse.mjs';
-import { createLangfuseSpanProcessor, getContextLangfuseConfig } from './langfuseToolOutputTracing.mjs';
-import { isPresent } from './utils/misc.mjs';
-
+import { isPresent } from "./utils/misc.mjs";
+import { hasLangfuseConfigCredentials, hasLangfuseEnvConfig, hasLangfuseEnvCredentials } from "./langfuse.mjs";
+import { createLangfuseSpanProcessor, getContextLangfuseConfig } from "./langfuseToolOutputTracing.mjs";
+import { setLangfuseTracerProvider } from "@langfuse/tracing";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { ROOT_CONTEXT, context, createContextKey } from "@opentelemetry/api";
+import { createHash, 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, …)` 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.
- */
+* Per-run seed for deterministic Langfuse trace ids. When a run opts in
+* (`LangfuseConfig.deterministicTraceId`), it executes its stream inside
+* `runWithTraceIdSeed(runId, …)` 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.
+*/
 const traceIdSeedStore = new AsyncLocalStorage();
 function runWithTraceIdSeed(seed, fn) {
-    return isPresent(seed) ? traceIdSeedStore.run(seed, fn) : fn();
+	return isPresent(seed) ? traceIdSeedStore.run(seed, fn) : fn();
 }
 /** sha256(seed) → first 32 hex chars; matches `@langfuse/tracing` `createTraceId`. */
 function traceIdFromSeed(seed) {
-    return createHash('sha256').update(seed, 'utf8').digest('hex').slice(0, 32);
-}
-class SeededTraceIdGenerator {
-    generateTraceId() {
-        const seed = traceIdSeedStore.getStore();
-        return isPresent(seed)
-            ? traceIdFromSeed(seed)
-            : randomBytes(16).toString('hex');
-    }
-    generateSpanId() {
-        return randomBytes(8).toString('hex');
-    }
+	return createHash("sha256").update(seed, "utf8").digest("hex").slice(0, 32);
 }
+var SeededTraceIdGenerator = class {
+	generateTraceId() {
+		const seed = traceIdSeedStore.getStore();
+		return isPresent(seed) ? traceIdFromSeed(seed) : randomBytes(16).toString("hex");
+	}
+	generateSpanId() {
+		return randomBytes(8).toString("hex");
+	}
+};
 let langfuseTracerProvider;
 let langfuseRoutingSpanProcessor;
-const contextManagerProbeKey = createContextKey('langfuse-context-manager-probe');
+const contextManagerProbeKey = createContextKey("langfuse-context-manager-probe");
 function hasActiveContextManager() {
-    return context.with(ROOT_CONTEXT.setValue(contextManagerProbeKey, true), () => context.active().getValue(contextManagerProbeKey) === true);
+	return context.with(ROOT_CONTEXT.setValue(contextManagerProbeKey, true), () => context.active().getValue(contextManagerProbeKey) === true);
 }
 function ensureOpenTelemetryContextManager() {
-    if (hasActiveContextManager()) {
-        return;
-    }
-    const contextManager = new AsyncLocalStorageContextManager();
-    contextManager.enable();
-    if (!context.setGlobalContextManager(contextManager)) {
-        contextManager.disable();
-    }
+	if (hasActiveContextManager()) return;
+	const contextManager = new AsyncLocalStorageContextManager();
+	contextManager.enable();
+	if (!context.setGlobalContextManager(contextManager)) contextManager.disable();
 }
 function getLangfuseSpanProcessorParams(langfuse) {
-    if (langfuse?.enabled === false) {
-        return undefined;
-    }
-    if (hasLangfuseConfigCredentials(langfuse)) {
-        return {
-            publicKey: langfuse.publicKey,
-            secretKey: langfuse.secretKey,
-            ...(isPresent(langfuse.baseUrl) ? { baseUrl: langfuse.baseUrl } : {}),
-        };
-    }
-    if (hasLangfuseEnvConfig()) {
-        const baseUrl = langfuse?.baseUrl ??
-            process.env.LANGFUSE_BASE_URL ??
-            process.env.LANGFUSE_BASEURL;
-        return {
-            publicKey: process.env.LANGFUSE_PUBLIC_KEY,
-            secretKey: process.env.LANGFUSE_SECRET_KEY,
-            ...(isPresent(baseUrl) ? { baseUrl } : {}),
-        };
-    }
-    if (isPresent(langfuse?.baseUrl) && hasLangfuseEnvCredentials()) {
-        return {
-            publicKey: process.env.LANGFUSE_PUBLIC_KEY,
-            secretKey: process.env.LANGFUSE_SECRET_KEY,
-            baseUrl: langfuse.baseUrl,
-        };
-    }
-    return undefined;
+	if (langfuse?.enabled === false) return;
+	if (hasLangfuseConfigCredentials(langfuse)) return {
+		publicKey: langfuse.publicKey,
+		secretKey: langfuse.secretKey,
+		...isPresent(langfuse.baseUrl) ? { baseUrl: langfuse.baseUrl } : {}
+	};
+	if (hasLangfuseEnvConfig()) {
+		const baseUrl = langfuse?.baseUrl ?? process.env.LANGFUSE_BASE_URL ?? process.env.LANGFUSE_BASEURL;
+		return {
+			publicKey: process.env.LANGFUSE_PUBLIC_KEY,
+			secretKey: process.env.LANGFUSE_SECRET_KEY,
+			...isPresent(baseUrl) ? { baseUrl } : {}
+		};
+	}
+	if (isPresent(langfuse?.baseUrl) && hasLangfuseEnvCredentials()) return {
+		publicKey: process.env.LANGFUSE_PUBLIC_KEY,
+		secretKey: process.env.LANGFUSE_SECRET_KEY,
+		baseUrl: langfuse.baseUrl
+	};
 }
 function getLangfuseTracerProviderKey(params, langfuse) {
-    return JSON.stringify({
-        publicKey: params.publicKey,
-        secretKey: params.secretKey,
-        baseUrl: params.baseUrl,
-        environment: params.environment,
-        toolOutputTracing: langfuse?.toolOutputTracing,
-    });
-}
-class RoutingLangfuseSpanProcessor {
-    processors = new Map();
-    spanProcessors = new WeakMap();
-    ensureProcessor(langfuse) {
-        const params = getLangfuseSpanProcessorParams(langfuse);
-        if (params == null) {
-            return undefined;
-        }
-        const processorKey = getLangfuseTracerProviderKey(params, langfuse);
-        const existing = this.processors.get(processorKey);
-        if (existing != null) {
-            return existing;
-        }
-        const processor = createLangfuseSpanProcessor(params, langfuse);
-        this.processors.set(processorKey, processor);
-        return processor;
-    }
-    onStart(span, parentContext) {
-        const processor = this.ensureProcessor(getContextLangfuseConfig(parentContext));
-        if (processor == null) {
-            return;
-        }
-        this.spanProcessors.set(span, processor);
-        processor.onStart(span, parentContext);
-    }
-    onEnd(span) {
-        this.spanProcessors.get(span)?.onEnd(span);
-    }
-    async forceFlush() {
-        await Promise.all(Array.from(this.processors.values(), (processor) => processor.forceFlush()));
-    }
-    async shutdown() {
-        await Promise.all(Array.from(this.processors.values(), (processor) => processor.shutdown()));
-    }
+	return JSON.stringify({
+		publicKey: params.publicKey,
+		secretKey: params.secretKey,
+		baseUrl: params.baseUrl,
+		environment: params.environment,
+		toolOutputTracing: langfuse?.toolOutputTracing
+	});
 }
+var RoutingLangfuseSpanProcessor = class {
+	processors = /* @__PURE__ */ new Map();
+	spanProcessors = /* @__PURE__ */ new WeakMap();
+	ensureProcessor(langfuse) {
+		const params = getLangfuseSpanProcessorParams(langfuse);
+		if (params == null) return;
+		const processorKey = getLangfuseTracerProviderKey(params, langfuse);
+		const existing = this.processors.get(processorKey);
+		if (existing != null) return existing;
+		const processor = createLangfuseSpanProcessor(params, langfuse);
+		this.processors.set(processorKey, processor);
+		return processor;
+	}
+	onStart(span, parentContext) {
+		const processor = this.ensureProcessor(getContextLangfuseConfig(parentContext));
+		if (processor == null) return;
+		this.spanProcessors.set(span, processor);
+		processor.onStart(span, parentContext);
+	}
+	onEnd(span) {
+		this.spanProcessors.get(span)?.onEnd(span);
+	}
+	async forceFlush() {
+		await Promise.all(Array.from(this.processors.values(), (processor) => processor.forceFlush()));
+	}
+	async shutdown() {
+		await Promise.all(Array.from(this.processors.values(), (processor) => processor.shutdown()));
+	}
+};
 function initializeLangfuseTracing(langfuse) {
-    const params = getLangfuseSpanProcessorParams(langfuse);
-    if (params == null) {
-        return undefined;
-    }
-    if (langfuseTracerProvider != null) {
-        langfuseRoutingSpanProcessor?.ensureProcessor(langfuse);
-        return langfuseTracerProvider;
-    }
-    ensureOpenTelemetryContextManager();
-    langfuseRoutingSpanProcessor = new RoutingLangfuseSpanProcessor();
-    langfuseRoutingSpanProcessor.ensureProcessor(langfuse);
-    langfuseTracerProvider = new BasicTracerProvider({
-        spanProcessors: [langfuseRoutingSpanProcessor],
-        idGenerator: new SeededTraceIdGenerator(),
-    });
-    setLangfuseTracerProvider(langfuseTracerProvider);
-    return langfuseTracerProvider;
+	if (getLangfuseSpanProcessorParams(langfuse) == null) return;
+	if (langfuseTracerProvider != null) {
+		langfuseRoutingSpanProcessor?.ensureProcessor(langfuse);
+		return langfuseTracerProvider;
+	}
+	ensureOpenTelemetryContextManager();
+	langfuseRoutingSpanProcessor = new RoutingLangfuseSpanProcessor();
+	langfuseRoutingSpanProcessor.ensureProcessor(langfuse);
+	langfuseTracerProvider = new BasicTracerProvider({
+		spanProcessors: [langfuseRoutingSpanProcessor],
+		idGenerator: new SeededTraceIdGenerator()
+	});
+	setLangfuseTracerProvider(langfuseTracerProvider);
+	return langfuseTracerProvider;
 }
 function initializeLangfuseTracingFromEnv() {
-    return initializeLangfuseTracing();
+	return initializeLangfuseTracing();
 }
 initializeLangfuseTracingFromEnv();
+//#endregion
+export { initializeLangfuseTracing, runWithTraceIdSeed };
 
-export { ensureOpenTelemetryContextManager, initializeLangfuseTracing, initializeLangfuseTracingFromEnv, runWithTraceIdSeed };
-//# sourceMappingURL=instrumentation.mjs.map
+//# sourceMappingURL=instrumentation.mjs.map

package/dist/esm/instrumentation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.mjs","sources":["../../src/instrumentation.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport { createHash, 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  hasLangfuseConfigCredentials,\n  hasLangfuseEnvCredentials,\n  hasLangfuseEnvConfig,\n} from '@/langfuse';\nimport {\n  createLangfuseSpanProcessor,\n  getContextLangfuseConfig,\n} from '@/langfuseToolOutputTracing';\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, …)` and the IdGenerator below derives the root\n * trace id from that seed instead of a random one. This lets external systems\n * (e.g. a host app recording user feedback after the fact) attach scores or\n * observations to the trace by regenerating the same id from the run/message\n * id — no trace lookup required. With no active seed it falls back to random\n * ids, so default behavior is unchanged.\n */\nconst traceIdSeedStore = new AsyncLocalStorage<string>();\n\nexport function runWithTraceIdSeed<T>(\n  seed: string | undefined,\n  fn: () => T\n): T {\n  return isPresent(seed) ? traceIdSeedStore.run(seed, fn) : fn();\n}\n\n/** sha256(seed) → first 32 hex chars; matches `@langfuse/tracing` `createTraceId`. */\nfunction traceIdFromSeed(seed: string): string {\n  return createHash('sha256').update(seed, 'utf8').digest('hex').slice(0, 32);\n}\n\nclass SeededTraceIdGenerator implements IdGenerator {\n  generateTraceId(): string {\n    const seed = traceIdSeedStore.getStore();\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\nfunction getLangfuseSpanProcessorParams(\n  langfuse?: t.LangfuseConfig\n): LangfuseSpanProcessorParams | undefined {\n  if (langfuse?.enabled === false) {\n    return undefined;\n  }\n  if (hasLangfuseConfigCredentials(langfuse)) {\n    return {\n      publicKey: langfuse.publicKey,\n      secretKey: langfuse.secretKey,\n      ...(isPresent(langfuse.baseUrl) ? { baseUrl: langfuse.baseUrl } : {}),\n    };\n  }\n  if (hasLangfuseEnvConfig()) {\n    const baseUrl =\n      langfuse?.baseUrl ??\n      process.env.LANGFUSE_BASE_URL ??\n      process.env.LANGFUSE_BASEURL;\n    return {\n      publicKey: process.env.LANGFUSE_PUBLIC_KEY as string,\n      secretKey: process.env.LANGFUSE_SECRET_KEY as string,\n      ...(isPresent(baseUrl) ? { baseUrl } : {}),\n    };\n  }\n  if (isPresent(langfuse?.baseUrl) && hasLangfuseEnvCredentials()) {\n    return {\n      publicKey: process.env.LANGFUSE_PUBLIC_KEY as string,\n      secretKey: process.env.LANGFUSE_SECRET_KEY as string,\n      baseUrl: langfuse.baseUrl,\n    };\n  }\n  return undefined;\n}\n\nfunction getLangfuseTracerProviderKey(\n  params: LangfuseSpanProcessorParams,\n  langfuse?: t.LangfuseConfig\n): string {\n  return JSON.stringify({\n    publicKey: params.publicKey,\n    secretKey: params.secretKey,\n    baseUrl: params.baseUrl,\n    environment: params.environment,\n    toolOutputTracing: langfuse?.toolOutputTracing,\n  });\n}\n\nclass RoutingLangfuseSpanProcessor implements SpanProcessor {\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\n    const processorKey = getLangfuseTracerProviderKey(params, langfuse);\n    const existing = this.processors.get(processorKey);\n    if (existing != null) {\n      return existing;\n    }\n\n    const processor = createLangfuseSpanProcessor(params, langfuse);\n    this.processors.set(processorKey, processor);\n    return processor;\n  }\n\n  onStart(span: Span, parentContext: Context): void {\n    const processor = this.ensureProcessor(\n      getContextLangfuseConfig(parentContext)\n    );\n    if (processor == null) {\n      return;\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"],"names":[],"mappings":"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"}
+{"version":3,"file":"instrumentation.mjs","names":[],"sources":["../../src/instrumentation.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport { createHash, 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  hasLangfuseConfigCredentials,\n  hasLangfuseEnvCredentials,\n  hasLangfuseEnvConfig,\n} from '@/langfuse';\nimport {\n  createLangfuseSpanProcessor,\n  getContextLangfuseConfig,\n} from '@/langfuseToolOutputTracing';\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, …)` and the IdGenerator below derives the root\n * trace id from that seed instead of a random one. This lets external systems\n * (e.g. a host app recording user feedback after the fact) attach scores or\n * observations to the trace by regenerating the same id from the run/message\n * id — no trace lookup required. With no active seed it falls back to random\n * ids, so default behavior is unchanged.\n */\nconst traceIdSeedStore = new AsyncLocalStorage<string>();\n\nexport function runWithTraceIdSeed<T>(\n  seed: string | undefined,\n  fn: () => T\n): T {\n  return isPresent(seed) ? traceIdSeedStore.run(seed, fn) : fn();\n}\n\n/** sha256(seed) → first 32 hex chars; matches `@langfuse/tracing` `createTraceId`. */\nfunction traceIdFromSeed(seed: string): string {\n  return createHash('sha256').update(seed, 'utf8').digest('hex').slice(0, 32);\n}\n\nclass SeededTraceIdGenerator implements IdGenerator {\n  generateTraceId(): string {\n    const seed = traceIdSeedStore.getStore();\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\nfunction getLangfuseSpanProcessorParams(\n  langfuse?: t.LangfuseConfig\n): LangfuseSpanProcessorParams | undefined {\n  if (langfuse?.enabled === false) {\n    return undefined;\n  }\n  if (hasLangfuseConfigCredentials(langfuse)) {\n    return {\n      publicKey: langfuse.publicKey,\n      secretKey: langfuse.secretKey,\n      ...(isPresent(langfuse.baseUrl) ? { baseUrl: langfuse.baseUrl } : {}),\n    };\n  }\n  if (hasLangfuseEnvConfig()) {\n    const baseUrl =\n      langfuse?.baseUrl ??\n      process.env.LANGFUSE_BASE_URL ??\n      process.env.LANGFUSE_BASEURL;\n    return {\n      publicKey: process.env.LANGFUSE_PUBLIC_KEY as string,\n      secretKey: process.env.LANGFUSE_SECRET_KEY as string,\n      ...(isPresent(baseUrl) ? { baseUrl } : {}),\n    };\n  }\n  if (isPresent(langfuse?.baseUrl) && hasLangfuseEnvCredentials()) {\n    return {\n      publicKey: process.env.LANGFUSE_PUBLIC_KEY as string,\n      secretKey: process.env.LANGFUSE_SECRET_KEY as string,\n      baseUrl: langfuse.baseUrl,\n    };\n  }\n  return undefined;\n}\n\nfunction getLangfuseTracerProviderKey(\n  params: LangfuseSpanProcessorParams,\n  langfuse?: t.LangfuseConfig\n): string {\n  return JSON.stringify({\n    publicKey: params.publicKey,\n    secretKey: params.secretKey,\n    baseUrl: params.baseUrl,\n    environment: params.environment,\n    toolOutputTracing: langfuse?.toolOutputTracing,\n  });\n}\n\nclass RoutingLangfuseSpanProcessor implements SpanProcessor {\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\n    const processorKey = getLangfuseTracerProviderKey(params, langfuse);\n    const existing = this.processors.get(processorKey);\n    if (existing != null) {\n      return existing;\n    }\n\n    const processor = createLangfuseSpanProcessor(params, langfuse);\n    this.processors.set(processorKey, processor);\n    return processor;\n  }\n\n  onStart(span: Span, parentContext: Context): void {\n    const processor = this.ensureProcessor(\n      getContextLangfuseConfig(parentContext)\n    );\n    if (processor == null) {\n      return;\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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"}

package/dist/esm/langchain/google-common.mjs

@@ -1,2 +1 @@
-
-//# sourceMappingURL=google-common.mjs.map
+export {};

package/dist/esm/langchain/index.mjs

@@ -1,5 +1,5 @@
-export { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, HumanMessage, SystemMessage, ToolMessage, getBufferString, isAIMessage, isBaseMessage, isToolMessage } from '@langchain/core/messages';
-export { PromptTemplate } from '@langchain/core/prompts';
-export { Runnable, RunnableLambda, RunnableSequence } from '@langchain/core/runnables';
-export { DynamicStructuredTool, StructuredTool, Tool, tool } from '@langchain/core/tools';
-//# sourceMappingURL=index.mjs.map
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, HumanMessage, SystemMessage, ToolMessage, getBufferString, isAIMessage, isBaseMessage, isToolMessage } from "./messages.mjs";
+import { PromptTemplate } from "./prompts.mjs";
+import { Runnable, RunnableLambda, RunnableSequence } from "./runnables.mjs";
+import { DynamicStructuredTool, StructuredTool, Tool, tool } from "./tools.mjs";
+export { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, DynamicStructuredTool, HumanMessage, PromptTemplate, Runnable, RunnableLambda, RunnableSequence, StructuredTool, SystemMessage, Tool, ToolMessage, getBufferString, isAIMessage, isBaseMessage, isToolMessage, tool };

package/dist/esm/langchain/language_models/chat_models.mjs

@@ -1,2 +1 @@
-
-//# sourceMappingURL=chat_models.mjs.map
+export {};

package/dist/esm/langchain/messages/tool.mjs

@@ -1,2 +1 @@
-
-//# sourceMappingURL=tool.mjs.map
+export {};

package/dist/esm/langchain/messages.mjs

@@ -1,2 +1,2 @@
-export { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, HumanMessage, SystemMessage, ToolMessage, getBufferString, isAIMessage, isBaseMessage, isToolMessage } from '@langchain/core/messages';
-//# sourceMappingURL=messages.mjs.map
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, HumanMessage, SystemMessage, ToolMessage, getBufferString, isAIMessage, isBaseMessage, isToolMessage } from "@langchain/core/messages";
+export { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, HumanMessage, SystemMessage, ToolMessage, getBufferString, isAIMessage, isBaseMessage, isToolMessage };

package/dist/esm/langchain/openai.mjs

@@ -1,2 +1 @@
-
-//# sourceMappingURL=openai.mjs.map
+export {};

package/dist/esm/langchain/prompts.mjs

@@ -1,2 +1,2 @@
-export { PromptTemplate } from '@langchain/core/prompts';
-//# sourceMappingURL=prompts.mjs.map
+import { PromptTemplate } from "@langchain/core/prompts";
+export { PromptTemplate };

package/dist/esm/langchain/runnables.mjs

@@ -1,2 +1,2 @@
-export { Runnable, RunnableLambda, RunnableSequence } from '@langchain/core/runnables';
-//# sourceMappingURL=runnables.mjs.map
+import { Runnable, RunnableLambda, RunnableSequence } from "@langchain/core/runnables";
+export { Runnable, RunnableLambda, RunnableSequence };

package/dist/esm/langchain/tools.mjs

@@ -1,2 +1,2 @@
-export { DynamicStructuredTool, StructuredTool, Tool, tool } from '@langchain/core/tools';
-//# sourceMappingURL=tools.mjs.map
+import { DynamicStructuredTool, StructuredTool, Tool, tool } from "@langchain/core/tools";
+export { DynamicStructuredTool, StructuredTool, Tool, tool };

package/dist/esm/langchain/utils/env.mjs

@@ -1,2 +1,2 @@
-export { getEnvironmentVariable } from '@langchain/core/utils/env';
-//# sourceMappingURL=env.mjs.map
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+export { getEnvironmentVariable };