@librechat/agents 3.1.67-dev.4 → 3.1.68

package/src/tools/__tests__/ToolNode.session.test.ts

@@ -216,7 +216,7 @@ describe('ToolNode code execution session management', () => {
         toolNode as unknown as {
           storeCodeSessionFromResults: (
             results: t.ToolExecuteResult[],
-            requestMap: Map<string, t.ToolCallRequest>
+            requests: t.ToolCallRequest[]
           ) => void;
         }
       ).storeCodeSessionFromResults.bind(toolNode);
@@ -233,7 +233,7 @@ describe('ToolNode code execution session management', () => {
             status: 'success',
           },
         ],
-        new Map([['tc1', { id: 'tc1', name: Constants.EXECUTE_CODE, args: {} }]])
+        [{ id: 'tc1', name: Constants.EXECUTE_CODE, args: {} }]
       );
 
       const stored = sessions.get(
@@ -265,7 +265,7 @@ describe('ToolNode code execution session management', () => {
         toolNode as unknown as {
           storeCodeSessionFromResults: (
             results: t.ToolExecuteResult[],
-            requestMap: Map<string, t.ToolCallRequest>
+            requests: t.ToolCallRequest[]
           ) => void;
         }
       ).storeCodeSessionFromResults.bind(toolNode);
@@ -279,7 +279,7 @@ describe('ToolNode code execution session management', () => {
             status: 'success',
           },
         ],
-        new Map([['tc2', { id: 'tc2', name: Constants.EXECUTE_CODE, args: {} }]])
+        [{ id: 'tc2', name: Constants.EXECUTE_CODE, args: {} }]
       );
 
       const stored = sessions.get(
@@ -312,7 +312,7 @@ describe('ToolNode code execution session management', () => {
         toolNode as unknown as {
           storeCodeSessionFromResults: (
             results: t.ToolExecuteResult[],
-            requestMap: Map<string, t.ToolCallRequest>
+            requests: t.ToolCallRequest[]
           ) => void;
         }
       ).storeCodeSessionFromResults.bind(toolNode);
@@ -329,7 +329,7 @@ describe('ToolNode code execution session management', () => {
             status: 'success',
           },
         ],
-        new Map([['tc3', { id: 'tc3', name: Constants.EXECUTE_CODE, args: {} }]])
+        [{ id: 'tc3', name: Constants.EXECUTE_CODE, args: {} }]
       );
 
       const stored = sessions.get(
@@ -365,7 +365,7 @@ describe('ToolNode code execution session management', () => {
         toolNode as unknown as {
           storeCodeSessionFromResults: (
             results: t.ToolExecuteResult[],
-            requestMap: Map<string, t.ToolCallRequest>
+            requests: t.ToolCallRequest[]
           ) => void;
         }
       ).storeCodeSessionFromResults.bind(toolNode);
@@ -379,7 +379,7 @@ describe('ToolNode code execution session management', () => {
             status: 'success',
           },
         ],
-        new Map([['tc4', { id: 'tc4', name: Constants.EXECUTE_CODE, args: {} }]])
+        [{ id: 'tc4', name: Constants.EXECUTE_CODE, args: {} }]
       );
 
       const stored = sessions.get(
@@ -404,7 +404,7 @@ describe('ToolNode code execution session management', () => {
         toolNode as unknown as {
           storeCodeSessionFromResults: (
             results: t.ToolExecuteResult[],
-            requestMap: Map<string, t.ToolCallRequest>
+            requests: t.ToolCallRequest[]
           ) => void;
         }
       ).storeCodeSessionFromResults.bind(toolNode);
@@ -418,7 +418,7 @@ describe('ToolNode code execution session management', () => {
             status: 'success',
           },
         ],
-        new Map([['tc5', { id: 'tc5', name: 'web_search', args: {} }]])
+        [{ id: 'tc5', name: 'web_search', args: {} }]
       );
 
       expect(sessions.has(Constants.EXECUTE_CODE)).toBe(false);
@@ -438,7 +438,7 @@ describe('ToolNode code execution session management', () => {
         toolNode as unknown as {
           storeCodeSessionFromResults: (
             results: t.ToolExecuteResult[],
-            requestMap: Map<string, t.ToolCallRequest>
+            requests: t.ToolCallRequest[]
           ) => void;
         }
       ).storeCodeSessionFromResults.bind(toolNode);
@@ -456,7 +456,7 @@ describe('ToolNode code execution session management', () => {
             errorMessage: 'execution failed',
           },
         ],
-        new Map([['tc6', { id: 'tc6', name: Constants.EXECUTE_CODE, args: {} }]])
+        [{ id: 'tc6', name: Constants.EXECUTE_CODE, args: {} }]
       );
 
       expect(sessions.has(Constants.EXECUTE_CODE)).toBe(false);

package/src/types/graph.ts

@@ -18,13 +18,7 @@ import type {
 import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
 import type { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { GoogleAIToolType } from '@langchain/google-common';
-import type {
-  ToolMap,
-  ToolEndEvent,
-  GenericTool,
-  LCTool,
-  ToolExecuteBatchRequest,
-} from '@/types/tools';
+import type { ToolMap, ToolEndEvent, GenericTool, LCTool } from '@/types/tools';
 import type { Providers, Callback, GraphNodeKeys } from '@/common';
 import type { StandardGraph, MultiAgentGraph } from '@/graphs';
 import type { ClientOptions } from '@/types/llm';
@@ -111,9 +105,7 @@ export interface EventHandler {
       | SummarizeStartEvent
       | SummarizeDeltaEvent
       | SummarizeCompleteEvent
-      | SubagentUpdateEvent
       | AgentLogEvent
-      | ToolExecuteBatchRequest
       | { result: ToolEndEvent },
     metadata?: Record<string, unknown>,
     graph?: StandardGraph | MultiAgentGraph
@@ -396,73 +388,6 @@ export type MultiAgentGraphInput = StandardGraphInput & {
   edges: GraphEdge[];
 };
 
-/** Configuration for a subagent type that can be spawned by a parent agent. */
-export type SubagentConfig = {
-  /** Identifier used in the tool's `subagent_type` enum (e.g. 'researcher', 'coder'). */
-  type: string;
-  /** Human-readable display name. */
-  name: string;
-  /** What this subagent specializes in — shown to the LLM. */
-  description: string;
-  /** Full agent config for the child graph. Omit when `self` is true. */
-  agentInputs?: AgentInputs;
-  /** When true, reuse the parent's AgentInputs (context isolation without separate config). */
-  self?: boolean;
-  /** Max AGENT→TOOLS cycles before forced stop (default: 25). */
-  maxTurns?: number;
-  /** Allow this subagent to spawn its own subagents (default: false). */
-  allowNested?: boolean;
-};
-
-/** SubagentConfig with agentInputs guaranteed present (self-spawn resolved). */
-export type ResolvedSubagentConfig = SubagentConfig & {
-  agentInputs: AgentInputs;
-};
-
-/** Lifecycle phase carried on {@link SubagentUpdateEvent}. */
-export type SubagentUpdatePhase =
-  | 'start'
-  | 'run_step'
-  | 'run_step_delta'
-  | 'run_step_completed'
-  | 'message_delta'
-  | 'reasoning_delta'
-  | 'stop'
-  | 'error';
-
-/**
- * Wrapper event emitted when a subagent's child graph dispatches activity.
- * Lets hosts show subagent progress in a UI surface separate from the parent
- * conversation without having to untangle events by agent ID.
- */
-export interface SubagentUpdateEvent {
-  /** Parent run ID. */
-  runId: string;
-  /** Child run ID (unique per subagent execution). */
-  subagentRunId: string;
-  /**
-   * Parent-side `tool_call_id` for the `subagent` tool invocation that
-   * triggered this run. Stable for the duration of the child; lets hosts
-   * correlate updates deterministically instead of inferring by ordering.
-   * Omitted when the executor was invoked outside of a tool-call context.
-   */
-  parentToolCallId?: string;
-  /** Subagent `type` identifier from the SubagentConfig. */
-  subagentType: string;
-  /** Child agent ID assigned to this subagent execution. */
-  subagentAgentId: string;
-  /** Parent agent ID that spawned this subagent. */
-  parentAgentId?: string;
-  /** Lifecycle phase carried by this update. */
-  phase: SubagentUpdatePhase;
-  /** Underlying event payload (shape depends on phase). */
-  data?: unknown;
-  /** Short human-readable description. Hosts can render this directly. */
-  label?: string;
-  /** ISO timestamp for ordering / display. */
-  timestamp: string;
-}
-
 export interface AgentInputs {
   agentId: string;
   /** Human-readable name for the agent (used in handoff context). Defaults to agentId if not provided. */
@@ -506,10 +431,6 @@ export interface AgentInputs {
   maxToolResultChars?: number;
   /** Pre-computed tool schema token count (from cache). Skips recalculation when provided. */
   toolSchemaTokens?: number;
-  /** Subagent configurations for hierarchical delegation. Each defines a child agent type. */
-  subagentConfigs?: SubagentConfig[];
-  /** Maximum subagent nesting depth. Default 1 means top-level agents can spawn subagents but subagents cannot nest further. */
-  maxSubagentDepth?: number;
 }
 
 export interface ContextPruningConfig {

package/src/types/index.ts

@@ -2,7 +2,6 @@
 export * from './graph';
 export * from './llm';
 export * from './run';
-export * from './skill';
 export * from './stream';
 export * from './tools';
 export * from './summarize';

package/src/types/run.ts

@@ -11,8 +11,6 @@ import type * as s from '@/types/stream';
 import type * as e from '@/common/enum';
 import type * as g from '@/types/graph';
 import type * as l from '@/types/llm';
-import type { ToolSessionMap } from '@/types/tools';
-import type { HookRegistry } from '@/hooks';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type ZodObjectAny = z.ZodObject<any, any, any, any>;
@@ -114,18 +112,6 @@ export type RunConfig = {
   runId: string;
   graphConfig: LegacyGraphConfig | StandardGraphConfig | MultiAgentGraphConfig;
   customHandlers?: Record<string, g.EventHandler>;
-  /**
-   * Pre-constructed hook registry for this run. Hooks fire at lifecycle
-   * points in `processStream` (RunStart, UserPromptSubmit, Stop,
-   * StopFailure) and around tool calls (PreToolUse, PostToolUse,
-   * PostToolUseFailure, PermissionDenied).
-   *
-   * Pass `undefined` (the default) to skip all hook dispatch. When a
-   * registry is provided, the run attaches it to the `Graph` so internal
-   * nodes can fire hooks too, and clears the session in the `finally`
-   * block to prevent leaks.
-   */
-  hooks?: HookRegistry;
   returnContent?: boolean;
   tokenCounter?: TokenCounter;
   indexTokenCountMap?: Record<string, number>;
@@ -140,12 +126,6 @@ export type RunConfig = {
   calibrationRatio?: number;
   /** Skip post-stream cleanup (clearHeavyState) — useful for tests that inspect graph state after processStream */
   skipCleanup?: boolean;
-  /**
-   * Initial session state to seed the Graph's ToolSessionMap.
-   * Used to carry over code environment sessions from skill file priming
-   * at run start, so ToolNode can inject session_id + files into tool calls.
-   */
-  initialSessions?: ToolSessionMap;
 };
 
 export type ProvidedCallbacks =

package/src/types/tools.ts

@@ -2,8 +2,7 @@
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type { RunnableToolLike } from '@langchain/core/runnables';
 import type { ToolCall } from '@langchain/core/messages/tool';
-import type { HookRegistry } from '@/hooks';
-import type { MessageContentComplex, ToolErrorData } from './stream';
+import type { ToolErrorData } from './stream';
 import { EnvVar } from '@/common';
 
 /** Replacement type for `import type { ToolCall } from '@langchain/core/messages/tool'` in order to have stringified args typed */
@@ -50,12 +49,6 @@ export type ToolNodeOptions = {
   agentId?: string;
   /** Tool names that must be executed directly (via runTool) even in event-driven mode (e.g., graph-managed handoff tools) */
   directToolNames?: Set<string>;
-  /**
-   * Hook registry for PreToolUse/PostToolUse lifecycle hooks.
-   * Only fires for event-driven tool calls (`dispatchToolEvents`). Tools
-   * routed through `directToolNames` bypass hook dispatch entirely.
-   */
-  hookRegistry?: HookRegistry;
   /** Max context tokens for the agent — used to compute tool result truncation limits. */
   maxContextTokens?: number;
   /**
@@ -193,26 +186,6 @@ export type ToolExecuteBatchRequest = {
   reject: (error: Error) => void;
 };
 
-/**
- * A message injected into graph state by any tool execution handler.
- * Generic mechanism: any tool returning `injectedMessages` in its `ToolExecuteResult`
- * will have these appended to state after the ToolMessage for this call.
- */
-export type InjectedMessage = {
-  /** 'user' for skill body injection, 'system' for context hints.
-   *  Both are converted to HumanMessage at runtime; the original role
-   *  is preserved in additional_kwargs.role. */
-  role: 'user' | 'system';
-  /** Message content: string for simple text, array for complex multi-part content */
-  content: string | MessageContentComplex[];
-  /** When true, the message is framework-internal: not shown in UI, not counted as a user turn */
-  isMeta?: boolean;
-  /** Origin tag for downstream consumers (UI, pruner, compaction) */
-  source?: 'skill' | 'hook' | 'system';
-  /** Only set when source is 'skill', for compaction preservation */
-  skillName?: string;
-};
-
 /** Result for a single tool call in event-driven execution */
 export type ToolExecuteResult = {
   /** Matches ToolCallRequest.id */
@@ -225,13 +198,6 @@ export type ToolExecuteResult = {
   status: 'success' | 'error';
   /** Error message if status is 'error' */
   errorMessage?: string;
-  /**
-   * Messages to inject into graph state after the ToolMessage for this call.
-   * Placed after tool results to respect provider message ordering (tool_call -> tool_result adjacency).
-   * The host's message formatter may merge injected user messages with the preceding tool_result turn.
-   * Generic mechanism: any tool execution handler can use this.
-   */
-  injectedMessages?: InjectedMessage[];
 };
 
 /** Map of tool names to tool definitions */
@@ -352,12 +318,6 @@ export type ProgrammaticExecutionArtifact = {
   files?: FileRefs;
 };
 
-/** Parameters for creating a bash execution tool (same API as CodeExecutor, bash-only) */
-export type BashExecutionToolParams = CodeExecutionToolParams;
-
-/** Parameters for creating a bash programmatic tool calling tool (same API as PTC, bash-only) */
-export type BashProgrammaticToolCallingParams = ProgrammaticToolCallingParams;
-
 /**
  * Initialization parameters for the PTC tool
  */

package/dist/cjs/hooks/HookRegistry.cjs

@@ -1,162 +0,0 @@
-'use strict';
-
-/**
- * Run-scoped storage for hook matchers with an additional layer for
- * session-scoped matchers that should be cleaned up between sessions.
- *
- * Hosts construct one registry per `Run` (mirroring how `HandlerRegistry` is
- * scoped) and register global matchers + per-session matchers against it.
- * Registration is strictly additive — nothing in this class mutates a
- * matcher's callbacks or flags after insertion.
- *
- * ## Why `Map<sessionId, MatcherBucket>` and not `Record`
- *
- * LibreChat runs thousands of parallel sessions in one Node process, and
- * hook registration happens inside hot paths (tool loading, agent spawning).
- * A `Record<sessionId, ...>` has to be spread on every insertion, which is
- * O(n) per call and O(n²) total for a batch of parallel registrations. A
- * Map mutates in place, keeping insertions O(1). This mirrors the reasoning
- * Claude Code documents at `utils/hooks/sessionHooks.ts:62`.
- */
-class HookRegistry {
-    global = {};
-    sessions = new Map();
-    /**
-     * Register a matcher for the lifetime of this registry (= one Run).
-     * Returns an unregister function that removes the matcher by reference.
-     */
-    register(event, matcher) {
-        const list = ensureList(this.global, event);
-        list.push(widen(matcher));
-        return () => {
-            removeFromList(list, matcher);
-        };
-    }
-    /**
-     * Register a matcher for a specific session. Cleared automatically when
-     * `clearSession(sessionId)` is called, or can be removed directly via the
-     * returned unregister function.
-     */
-    registerSession(sessionId, event, matcher) {
-        const bucket = this.ensureSessionBucket(sessionId);
-        const list = ensureList(bucket, event);
-        list.push(widen(matcher));
-        return () => {
-            removeFromList(list, matcher);
-        };
-    }
-    /**
-     * Returns all matchers registered for `event`, concatenating global first
-     * and then session-specific (when `sessionId` is supplied). The caller
-     * receives a fresh array, so iterating it is safe even if a matcher is
-     * removed mid-iteration (e.g. via `once: true`).
-     */
-    getMatchers(event, sessionId) {
-        const globalList = readList(this.global, event);
-        if (sessionId === undefined) {
-            return snapshot(globalList);
-        }
-        const bucket = this.sessions.get(sessionId);
-        if (bucket === undefined) {
-            return snapshot(globalList);
-        }
-        const sessionList = readList(bucket, event);
-        if (globalList.length === 0) {
-            return snapshot(sessionList);
-        }
-        if (sessionList.length === 0) {
-            return snapshot(globalList);
-        }
-        return snapshot([...globalList, ...sessionList]);
-    }
-    /**
-     * Removes `matcher` by reference from global storage first, falling back
-     * to the session bucket when `sessionId` is supplied. Used by
-     * `executeHooks` to drop `once: true` matchers after they fire.
-     */
-    removeMatcher(event, matcher, sessionId) {
-        if (removeFromList(readList(this.global, event), matcher)) {
-            return true;
-        }
-        if (sessionId === undefined) {
-            return false;
-        }
-        const bucket = this.sessions.get(sessionId);
-        if (bucket === undefined) {
-            return false;
-        }
-        return removeFromList(readList(bucket, event), matcher);
-    }
-    /**
-     * Drops every session-scoped matcher for `sessionId`. Call this in the
-     * `finally` block around a Run so a `once: true` hook that never fired
-     * cannot leak into the next session on the same registry.
-     */
-    clearSession(sessionId) {
-        this.sessions.delete(sessionId);
-    }
-    /** True if at least one matcher exists for `event` (global + session). */
-    hasHookFor(event, sessionId) {
-        if (readList(this.global, event).length > 0) {
-            return true;
-        }
-        if (sessionId === undefined) {
-            return false;
-        }
-        const bucket = this.sessions.get(sessionId);
-        if (bucket === undefined) {
-            return false;
-        }
-        return readList(bucket, event).length > 0;
-    }
-    ensureSessionBucket(sessionId) {
-        const existing = this.sessions.get(sessionId);
-        if (existing !== undefined) {
-            return existing;
-        }
-        const fresh = {};
-        this.sessions.set(sessionId, fresh);
-        return fresh;
-    }
-}
-function ensureList(bucket, event) {
-    const existing = bucket[event];
-    if (existing !== undefined) {
-        return existing;
-    }
-    const fresh = [];
-    bucket[event] = fresh;
-    return fresh;
-}
-function readList(bucket, event) {
-    return bucket[event] ?? [];
-}
-function removeFromList(list, matcher) {
-    const idx = list.indexOf(widen(matcher));
-    if (idx < 0) {
-        return false;
-    }
-    list.splice(idx, 1);
-    return true;
-}
-/**
- * Widen a per-event matcher to the storage's uniform slot type. Unsound at
- * the type level (function parameters are contravariant) but safe by
- * construction: `HookRegistry.register<E>` only ever puts matchers into the
- * bucket slot for their own event, and reads go through `snapshot<E>`
- * which is only called with the same `E`.
- */
-function widen(matcher) {
-    return matcher;
-}
-/**
- * Narrow a storage list back to a per-event matcher list on the way out.
- * Sound counterpart to `widen`: the list only contains matchers that were
- * registered against `E`, because the public API enforces it on insert.
- */
-function snapshot(list) {
-    return list.slice();
-}
-
-exports.HookRegistry = HookRegistry;
-//# sourceMappingURL=HookRegistry.cjs.map

package/dist/cjs/hooks/HookRegistry.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"HookRegistry.cjs","sources":["../../../src/hooks/HookRegistry.ts"],"sourcesContent":["// src/hooks/HookRegistry.ts\nimport type { HookEvent, HookMatcher } from './types';\n\n/**\n * Internal matcher storage type.\n *\n * Matchers registered via the public `register<E>` API are strictly typed\n * to a single `E`, but the storage needs one uniform slot type per event.\n * We store them as `HookMatcher<HookEvent>` and cast once at the variance\n * boundary — see `ensureList` and `snapshot` below. The invariant (every\n * matcher in `bucket[event]` was registered with that exact event) is\n * enforced by the public API; breaking it requires bypassing the types.\n */\ntype MatcherBucket = Partial<Record<HookEvent, HookMatcher<HookEvent>[]>>;\n\n/**\n * Run-scoped storage for hook matchers with an additional layer for\n * session-scoped matchers that should be cleaned up between sessions.\n *\n * Hosts construct one registry per `Run` (mirroring how `HandlerRegistry` is\n * scoped) and register global matchers + per-session matchers against it.\n * Registration is strictly additive — nothing in this class mutates a\n * matcher's callbacks or flags after insertion.\n *\n * ## Why `Map<sessionId, MatcherBucket>` and not `Record`\n *\n * LibreChat runs thousands of parallel sessions in one Node process, and\n * hook registration happens inside hot paths (tool loading, agent spawning).\n * A `Record<sessionId, ...>` has to be spread on every insertion, which is\n * O(n) per call and O(n²) total for a batch of parallel registrations. A\n * Map mutates in place, keeping insertions O(1). This mirrors the reasoning\n * Claude Code documents at `utils/hooks/sessionHooks.ts:62`.\n */\nexport class HookRegistry {\n  private readonly global: MatcherBucket = {};\n  private readonly sessions: Map<string, MatcherBucket> = new Map();\n\n  /**\n   * Register a matcher for the lifetime of this registry (= one Run).\n   * Returns an unregister function that removes the matcher by reference.\n   */\n  register<E extends HookEvent>(event: E, matcher: HookMatcher<E>): () => void {\n    const list = ensureList(this.global, event);\n    list.push(widen(matcher));\n    return () => {\n      removeFromList(list, matcher);\n    };\n  }\n\n  /**\n   * Register a matcher for a specific session. Cleared automatically when\n   * `clearSession(sessionId)` is called, or can be removed directly via the\n   * returned unregister function.\n   */\n  registerSession<E extends HookEvent>(\n    sessionId: string,\n    event: E,\n    matcher: HookMatcher<E>\n  ): () => void {\n    const bucket = this.ensureSessionBucket(sessionId);\n    const list = ensureList(bucket, event);\n    list.push(widen(matcher));\n    return () => {\n      removeFromList(list, matcher);\n    };\n  }\n\n  /**\n   * Returns all matchers registered for `event`, concatenating global first\n   * and then session-specific (when `sessionId` is supplied). The caller\n   * receives a fresh array, so iterating it is safe even if a matcher is\n   * removed mid-iteration (e.g. via `once: true`).\n   */\n  getMatchers<E extends HookEvent>(\n    event: E,\n    sessionId?: string\n  ): HookMatcher<E>[] {\n    const globalList = readList(this.global, event);\n    if (sessionId === undefined) {\n      return snapshot<E>(globalList);\n    }\n    const bucket = this.sessions.get(sessionId);\n    if (bucket === undefined) {\n      return snapshot<E>(globalList);\n    }\n    const sessionList = readList(bucket, event);\n    if (globalList.length === 0) {\n      return snapshot<E>(sessionList);\n    }\n    if (sessionList.length === 0) {\n      return snapshot<E>(globalList);\n    }\n    return snapshot<E>([...globalList, ...sessionList]);\n  }\n\n  /**\n   * Removes `matcher` by reference from global storage first, falling back\n   * to the session bucket when `sessionId` is supplied. Used by\n   * `executeHooks` to drop `once: true` matchers after they fire.\n   */\n  removeMatcher<E extends HookEvent>(\n    event: E,\n    matcher: HookMatcher<E>,\n    sessionId?: string\n  ): boolean {\n    if (removeFromList(readList(this.global, event), matcher)) {\n      return true;\n    }\n    if (sessionId === undefined) {\n      return false;\n    }\n    const bucket = this.sessions.get(sessionId);\n    if (bucket === undefined) {\n      return false;\n    }\n    return removeFromList(readList(bucket, event), matcher);\n  }\n\n  /**\n   * Drops every session-scoped matcher for `sessionId`. Call this in the\n   * `finally` block around a Run so a `once: true` hook that never fired\n   * cannot leak into the next session on the same registry.\n   */\n  clearSession(sessionId: string): void {\n    this.sessions.delete(sessionId);\n  }\n\n  /** True if at least one matcher exists for `event` (global + session). */\n  hasHookFor(event: HookEvent, sessionId?: string): boolean {\n    if (readList(this.global, event).length > 0) {\n      return true;\n    }\n    if (sessionId === undefined) {\n      return false;\n    }\n    const bucket = this.sessions.get(sessionId);\n    if (bucket === undefined) {\n      return false;\n    }\n    return readList(bucket, event).length > 0;\n  }\n\n  private ensureSessionBucket(sessionId: string): MatcherBucket {\n    const existing = this.sessions.get(sessionId);\n    if (existing !== undefined) {\n      return existing;\n    }\n    const fresh: MatcherBucket = {};\n    this.sessions.set(sessionId, fresh);\n    return fresh;\n  }\n}\n\nfunction ensureList(\n  bucket: MatcherBucket,\n  event: HookEvent\n): HookMatcher<HookEvent>[] {\n  const existing = bucket[event];\n  if (existing !== undefined) {\n    return existing;\n  }\n  const fresh: HookMatcher<HookEvent>[] = [];\n  bucket[event] = fresh;\n  return fresh;\n}\n\nfunction readList(\n  bucket: MatcherBucket,\n  event: HookEvent\n): HookMatcher<HookEvent>[] {\n  return bucket[event] ?? [];\n}\n\nfunction removeFromList<E extends HookEvent>(\n  list: HookMatcher<HookEvent>[],\n  matcher: HookMatcher<E>\n): boolean {\n  const idx = list.indexOf(widen(matcher));\n  if (idx < 0) {\n    return false;\n  }\n  list.splice(idx, 1);\n  return true;\n}\n\n/**\n * Widen a per-event matcher to the storage's uniform slot type. Unsound at\n * the type level (function parameters are contravariant) but safe by\n * construction: `HookRegistry.register<E>` only ever puts matchers into the\n * bucket slot for their own event, and reads go through `snapshot<E>`\n * which is only called with the same `E`.\n */\nfunction widen<E extends HookEvent>(\n  matcher: HookMatcher<E>\n): HookMatcher<HookEvent> {\n  return matcher as unknown as HookMatcher<HookEvent>;\n}\n\n/**\n * Narrow a storage list back to a per-event matcher list on the way out.\n * Sound counterpart to `widen`: the list only contains matchers that were\n * registered against `E`, because the public API enforces it on insert.\n */\nfunction snapshot<E extends HookEvent>(\n  list: readonly HookMatcher<HookEvent>[]\n): HookMatcher<E>[] {\n  return list.slice() as unknown as HookMatcher<E>[];\n}\n"],"names":[],"mappings":"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"}