@librechat/agents 3.2.32 → 3.2.33

package/dist/esm/run.mjs

@@ -1,1126 +1,918 @@
-import { HumanMessage } from '@langchain/core/messages';
-import { PromptTemplate } from '@langchain/core/prompts';
-import { RunnableLambda } from '@langchain/core/runnables';
-import { ChatOpenAI as ChatOpenAI$1, AzureChatOpenAI as AzureChatOpenAI$1 } from '@langchain/openai';
-import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
-import { MemorySaver, Command, isInterrupted, INTERRUPT } from '@langchain/langgraph';
-import { createLangfuseTraceMetadata, getLangfuseTraceName, createLangfuseHandler, withLangfuseAttributes, disposeLangfuseHandler, isLangfuseCallbackHandler } from './langfuse.mjs';
-import { resolveLangfuseConfig, withLangfuseToolOutputTracingConfig } from './langfuseToolOutputTracing.mjs';
-import { appendCallbacks, findCallback } from './utils/callbacks.mjs';
-import { createCompletionTitleRunnable, createTitleRunnable } from './utils/title.mjs';
-import { initializeLangfuseTracing, runWithTraceIdSeed } from './instrumentation.mjs';
-import { createTokenCounter, encodingForModel } from './utils/tokens.mjs';
-import { GraphEvents, Callback, TitleMethod } from './common/enum.mjs';
-import { MultiAgentGraph } from './graphs/MultiAgentGraph.mjs';
-import { StandardGraph } from './graphs/Graph.mjs';
-import { initializeModel } from './llm/init.mjs';
-import { HandlerRegistry } from './events.mjs';
-import { isOpenAILike } from './utils/llm.mjs';
-import { executeHooks } from './hooks/executeHooks.mjs';
-import './hooks/createWorkspacePolicyHook.mjs';
-
-// src/run.ts
+import { createLangfuseHandler, createLangfuseTraceMetadata, disposeLangfuseHandler, getLangfuseTraceName, isLangfuseCallbackHandler, withLangfuseAttributes } from "./langfuse.mjs";
+import { resolveLangfuseConfig, withLangfuseToolOutputTracingConfig } from "./langfuseToolOutputTracing.mjs";
+import { appendCallbacks, findCallback } from "./utils/callbacks.mjs";
+import "./common/enum.mjs";
+import "./common/index.mjs";
+import { createCompletionTitleRunnable, createTitleRunnable } from "./utils/title.mjs";
+import { initializeLangfuseTracing, runWithTraceIdSeed } from "./instrumentation.mjs";
+import { createTokenCounter, encodingForModel } from "./utils/tokens.mjs";
+import { isOpenAILike } from "./utils/llm.mjs";
+import { HandlerRegistry } from "./events.mjs";
+import { executeHooks } from "./hooks/executeHooks.mjs";
+import "./hooks/index.mjs";
+import { initializeModel } from "./llm/init.mjs";
+import { StandardGraph } from "./graphs/Graph.mjs";
+import { MultiAgentGraph } from "./graphs/MultiAgentGraph.mjs";
+import { HumanMessage } from "@langchain/core/messages";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { RunnableLambda } from "@langchain/core/runnables";
+import { AzureChatOpenAI, ChatOpenAI } from "@langchain/openai";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { Command, INTERRUPT, MemorySaver, isInterrupted } from "@langchain/langgraph";
+//#region src/run.ts
 const defaultOmitOptions = new Set([
-    'stream',
-    'thinking',
-    'streaming',
-    'maxTokens',
-    'clientOptions',
-    'thinkingConfig',
-    'thinkingBudget',
-    'includeThoughts',
-    'maxOutputTokens',
-    'additionalModelRequestFields',
+	"stream",
+	"thinking",
+	"streaming",
+	"maxTokens",
+	"clientOptions",
+	"thinkingConfig",
+	"thinkingBudget",
+	"includeThoughts",
+	"maxOutputTokens",
+	"additionalModelRequestFields"
 ]);
 const CUSTOM_GRAPH_EVENTS = new Set([
-    GraphEvents.ON_AGENT_UPDATE,
-    GraphEvents.ON_RUN_STEP,
-    GraphEvents.ON_RUN_STEP_DELTA,
-    GraphEvents.ON_RUN_STEP_COMPLETED,
-    GraphEvents.ON_MESSAGE_DELTA,
-    GraphEvents.ON_REASONING_DELTA,
-    GraphEvents.ON_TOOL_EXECUTE,
-    GraphEvents.ON_SUMMARIZE_START,
-    GraphEvents.ON_SUMMARIZE_DELTA,
-    GraphEvents.ON_SUMMARIZE_COMPLETE,
-    GraphEvents.ON_SUBAGENT_UPDATE,
-    GraphEvents.ON_AGENT_LOG,
-    GraphEvents.ON_CUSTOM_EVENT,
+	"on_agent_update",
+	"on_run_step",
+	"on_run_step_delta",
+	"on_run_step_completed",
+	"on_message_delta",
+	"on_reasoning_delta",
+	"on_tool_execute",
+	"on_summarize_start",
+	"on_summarize_delta",
+	"on_summarize_complete",
+	"on_subagent_update",
+	"on_agent_log",
+	"on_custom_event"
 ]);
 const DIRECT_DISPATCHED_STEP_EVENTS = new Set([
-    GraphEvents.ON_RUN_STEP,
-    GraphEvents.ON_RUN_STEP_DELTA,
-    GraphEvents.ON_MESSAGE_DELTA,
-    GraphEvents.ON_REASONING_DELTA,
+	"on_run_step",
+	"on_run_step_delta",
+	"on_message_delta",
+	"on_reasoning_delta"
 ]);
 function getStepScopedEventId(data) {
-    if (data == null || typeof data !== 'object') {
-        return undefined;
-    }
-    const candidate = data;
-    return typeof candidate.id === 'string' ? candidate.id : undefined;
+	if (data == null || typeof data !== "object") return;
+	const candidate = data;
+	return typeof candidate.id === "string" ? candidate.id : void 0;
 }
 function isLangGraphResumeMapForInterrupt(value, interruptId) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-        return false;
-    }
-    return Object.prototype.hasOwnProperty.call(value, interruptId);
-}
-class Run {
-    id;
-    tokenCounter;
-    handlerRegistry;
-    hookRegistry;
-    humanInTheLoop;
-    langfuse;
-    toolOutputReferences;
-    eagerEventToolExecution;
-    toolExecution;
-    indexTokenCountMap;
-    calibrationRatio = 1;
-    graphRunnable;
-    Graph;
-    returnContent = false;
-    skipCleanup = false;
-    _streamResult;
-    /**
-     * Captured interrupt payload typed as `unknown` because the SDK
-     * does not validate the runtime shape — custom graph nodes can
-     * raise interrupts with arbitrary payloads (not just the SDK's
-     * `HumanInterruptPayload` union). The public `getInterrupt<T>()`
-     * lets callers assert the type they expect.
-     */
-    _interrupt;
-    _haltedReason;
-    constructor(config) {
-        const runId = config.runId ?? '';
-        if (!runId) {
-            throw new Error('Run ID not provided');
-        }
-        this.id = runId;
-        this.tokenCounter = config.tokenCounter;
-        this.indexTokenCountMap = config.indexTokenCountMap;
-        if (config.calibrationRatio != null && config.calibrationRatio > 0) {
-            this.calibrationRatio = config.calibrationRatio;
-        }
-        const handlerRegistry = new HandlerRegistry();
-        if (config.customHandlers) {
-            for (const [eventType, handler] of Object.entries(config.customHandlers)) {
-                handlerRegistry.register(eventType, handler);
-            }
-        }
-        this.handlerRegistry = handlerRegistry;
-        this.hookRegistry = config.hooks;
-        this.humanInTheLoop = config.humanInTheLoop;
-        this.langfuse = config.langfuse;
-        this.toolOutputReferences = config.toolOutputReferences;
-        this.eagerEventToolExecution = config.eagerEventToolExecution;
-        this.toolExecution = config.toolExecution;
-        if (!config.graphConfig) {
-            throw new Error('Graph config not provided');
-        }
-        /** Handle different graph types */
-        if (config.graphConfig.type === 'multi-agent') {
-            this.graphRunnable = this.createMultiAgentGraph(config.graphConfig);
-            if (this.Graph) {
-                this.Graph.handlerRegistry = handlerRegistry;
-            }
-        }
-        else {
-            /** Default to legacy graph for 'standard' or undefined type */
-            this.graphRunnable = this.createLegacyGraph(config.graphConfig);
-            if (this.Graph) {
-                this.Graph.compileOptions =
-                    config.graphConfig.compileOptions ?? this.Graph.compileOptions;
-                this.Graph.handlerRegistry = handlerRegistry;
-            }
-        }
-        if (config.initialSessions && this.Graph) {
-            for (const [key, value] of config.initialSessions) {
-                this.Graph.sessions.set(key, value);
-            }
-        }
-        this.returnContent = config.returnContent ?? false;
-        this.skipCleanup = config.skipCleanup ?? false;
-    }
-    createLegacyGraph(config) {
-        let agentConfig;
-        let signal;
-        /** Check if this is a multi-agent style config (has agents array) */
-        if ('agents' in config && Array.isArray(config.agents)) {
-            if (config.agents.length === 0) {
-                throw new Error('At least one agent must be provided');
-            }
-            agentConfig = config.agents[0];
-            signal = config.signal;
-        }
-        else {
-            /** Legacy path: build agent config from llmConfig */
-            const { type: _type, llmConfig, signal: legacySignal, tools = [], ...agentInputs } = config;
-            const { provider, ...clientOptions } = llmConfig;
-            agentConfig = {
-                ...agentInputs,
-                tools,
-                provider,
-                clientOptions,
-                agentId: 'default',
-            };
-            signal = legacySignal;
-        }
-        const standardGraph = new StandardGraph({
-            signal,
-            runId: this.id,
-            agents: [agentConfig],
-            langfuse: this.langfuse,
-            tokenCounter: this.tokenCounter,
-            indexTokenCountMap: this.indexTokenCountMap,
-            calibrationRatio: this.calibrationRatio,
-        });
-        /** Propagate compile options from graph config */
-        standardGraph.compileOptions = this.applyHITLCheckpointerFallback(config.compileOptions);
-        standardGraph.hookRegistry = this.hookRegistry;
-        standardGraph.humanInTheLoop = this.humanInTheLoop;
-        standardGraph.toolOutputReferences = this.toolOutputReferences;
-        standardGraph.eagerEventToolExecution = this.eagerEventToolExecution;
-        standardGraph.toolExecution = this.toolExecution;
-        this.Graph = standardGraph;
-        return standardGraph.createWorkflow();
-    }
-    createMultiAgentGraph(config) {
-        const { agents, edges, compileOptions } = config;
-        const multiAgentGraph = new MultiAgentGraph({
-            runId: this.id,
-            agents,
-            edges,
-            langfuse: this.langfuse,
-            tokenCounter: this.tokenCounter,
-            indexTokenCountMap: this.indexTokenCountMap,
-            calibrationRatio: this.calibrationRatio,
-        });
-        multiAgentGraph.compileOptions =
-            this.applyHITLCheckpointerFallback(compileOptions);
-        multiAgentGraph.hookRegistry = this.hookRegistry;
-        multiAgentGraph.humanInTheLoop = this.humanInTheLoop;
-        multiAgentGraph.toolOutputReferences = this.toolOutputReferences;
-        multiAgentGraph.eagerEventToolExecution = this.eagerEventToolExecution;
-        multiAgentGraph.toolExecution = this.toolExecution;
-        this.Graph = multiAgentGraph;
-        return multiAgentGraph.createWorkflow();
-    }
-    /**
-     * When the host opted into HITL via `humanInTheLoop: { enabled: true }`
-     * and did not supply a checkpointer, install an in-memory `MemorySaver`
-     * so `interrupt()` can persist checkpoints and `Command({ resume })`
-     * can rebuild state. The fallback is intentionally process-local:
-     * production hosts that need durable resumption across processes /
-     * restarts must provide their own checkpointer (Redis, Postgres, etc.)
-     * on `compileOptions.checkpointer`.
-     *
-     * No-op when HITL is off (the default — omitted, or
-     * `{ enabled: false }`) or the host already supplied a checkpointer
-     * of their own. See `HumanInTheLoopConfig` JSDoc for the rationale
-     * behind the default-off stance.
-     */
-    applyHITLCheckpointerFallback(compileOptions) {
-        if (this.humanInTheLoop?.enabled !== true) {
-            return compileOptions;
-        }
-        if (compileOptions?.checkpointer != null) {
-            return compileOptions;
-        }
-        return {
-            ...(compileOptions ?? {}),
-            checkpointer: new MemorySaver(),
-        };
-    }
-    /**
-     * Run RunStart + UserPromptSubmit hooks before the graph stream
-     * begins, accumulate any `additionalContext` strings into the input
-     * messages, and short-circuit when a hook signals the run should not
-     * proceed (deny / ask decision on the prompt, or `preventContinuation`
-     * on either hook).
-     *
-     * Returns `true` when the caller should bail with `undefined` (run
-     * was halted before any model call); returns `false` to proceed
-     * into the stream loop.
-     *
-     * ## Side effects
-     *
-     * On the success path:
-     *   - Mutates `stateInputs.messages` in place to append a
-     *     consolidated `HumanMessage` carrying any hook
-     *     `additionalContext` strings. Safe because the host owns the
-     *     array and `processStream` is the only consumer until LangGraph
-     *     reads it.
-     *
-     * On the halt path (returning `true`):
-     *   - Sets `this._haltedReason` so callers (and the eventual host)
-     *     can distinguish a hook-driven halt from a natural completion.
-     *   - Calls `registry.clearSession(this.id)` and
-     *     `registry.clearHaltSignal(this.id)` because no resume is
-     *     expected from a pre-stream halt — the run never entered the
-     *     graph, so the session/halt state for this run would otherwise
-     *     leak to the next `processStream` invocation on the same
-     *     registry. Other concurrent runs on the same registry are
-     *     untouched (halt signals are scoped per session id).
-     *   - Sets `config.callbacks = undefined` to drop the callback
-     *     references the caller built (langfuse handler, custom event
-     *     handler, etc.) since they won't be exercised. Mirrors the
-     *     equivalent cleanup the `processStream` `finally` block does
-     *     on the natural-completion path.
-     */
-    async runPreStreamHooks(stateInputs, threadId, config) {
-        const registry = this.hookRegistry;
-        /**
-         * Defensive guard: `processStream` already validated `this.Graph`
-         * before calling this helper, but TypeScript can't propagate that
-         * narrowing across method boundaries. The check keeps the body
-         * free of `this.Graph!` non-null assertions.
-         */
-        if (registry == null || this.Graph == null) {
-            return false;
-        }
-        const preStreamContexts = [];
-        const runStartResult = await executeHooks({
-            registry,
-            input: {
-                hook_event_name: 'RunStart',
-                runId: this.id,
-                threadId,
-                agentId: this.Graph.defaultAgentId,
-                messages: stateInputs.messages,
-            },
-            sessionId: this.id,
-        });
-        for (const ctx of runStartResult.additionalContexts) {
-            preStreamContexts.push(ctx);
-        }
-        /**
-         * Honor `preventContinuation` from RunStart before the stream
-         * starts. Mid-flight halts (from tool/compact/subagent hooks)
-         * route through `HookRegistry.haltRun` and are polled by the
-         * stream loop in `processStream` — different mechanism, same
-         * intent.
-         */
-        if (runStartResult.preventContinuation === true) {
-            this._haltedReason = runStartResult.stopReason ?? 'preventContinuation';
-            registry.clearSession(this.id);
-            registry.clearHaltSignal(this.id);
-            config.callbacks = undefined;
-            return true;
-        }
-        const lastHuman = findLastMessageOfType(stateInputs.messages, 'human');
-        if (lastHuman != null) {
-            const promptResult = await executeHooks({
-                registry,
-                input: {
-                    hook_event_name: 'UserPromptSubmit',
-                    runId: this.id,
-                    threadId,
-                    agentId: this.Graph.defaultAgentId,
-                    prompt: extractPromptText(lastHuman),
-                    // attachments: not yet wired — Phase 2 will extract
-                    // non-text content blocks (images, files) from messages
-                },
-                sessionId: this.id,
-            });
-            if (promptResult.decision === 'deny' ||
-                promptResult.decision === 'ask' ||
-                promptResult.preventContinuation === true) {
-                /**
-                 * Always set `_haltedReason` so the host can call
-                 * `getHaltReason()` and distinguish a hook-blocked prompt
-                 * from a natural empty-output completion. Three signals can
-                 * land here, each with its own canonical reason string when
-                 * the hook didn't supply one.
-                 */
-                if (promptResult.preventContinuation === true) {
-                    this._haltedReason = promptResult.stopReason ?? 'preventContinuation';
-                }
-                else if (promptResult.decision === 'deny') {
-                    this._haltedReason = promptResult.reason ?? 'prompt_denied';
-                }
-                else {
-                    this._haltedReason =
-                        promptResult.reason ?? 'prompt_requires_approval';
-                }
-                registry.clearSession(this.id);
-                registry.clearHaltSignal(this.id);
-                config.callbacks = undefined;
-                return true;
-            }
-            for (const ctx of promptResult.additionalContexts) {
-                preStreamContexts.push(ctx);
-            }
-        }
-        if (preStreamContexts.length > 0) {
-            /**
-             * Wraps the joined hook contexts as a `HumanMessage` even though
-             * the intent is system-level guidance. Using a `SystemMessage`
-             * mid-conversation is rejected by Anthropic and Google providers
-             * (system messages must be the leading entry), so the LangChain
-             * convention — also used by `ToolNode.convertInjectedMessages`
-             * — is `HumanMessage` carrying `additional_kwargs.role` as a
-             * marker for hosts inspecting state. The model still sees a
-             * user-role message; the `role: 'system'` field is metadata
-             * only. Hosts that want a true system message should compose
-             * it into the agent's `instructions` config instead.
-             */
-            stateInputs.messages.push(new HumanMessage({
-                content: preStreamContexts.join('\n\n'),
-                additional_kwargs: { role: 'system', source: 'hook' },
-            }));
-        }
-        return false;
-    }
-    static async create(config) {
-        /** Create tokenCounter if indexTokenCountMap is provided but tokenCounter is not */
-        if (config.indexTokenCountMap && !config.tokenCounter) {
-            const gc = config.graphConfig;
-            const clientOpts = 'agents' in gc ? gc.agents[0]?.clientOptions : gc.clientOptions;
-            const model = clientOpts?.model ?? '';
-            config.tokenCounter = await createTokenCounter(encodingForModel(model));
-        }
-        return new Run(config);
-    }
-    getRunMessages() {
-        if (!this.Graph) {
-            throw new Error('Graph not initialized. Make sure to use Run.create() to instantiate the Run.');
-        }
-        return this.Graph.getRunMessages();
-    }
-    /**
-     * Returns the current calibration ratio (EMA of provider-vs-estimate token ratios).
-     * Hosts should persist this value and pass it back as `RunConfig.calibrationRatio`
-     * on the next run for the same conversation so the pruner starts with an accurate
-     * scaling factor instead of the default (1).
-     */
-    getCalibrationRatio() {
-        return this.calibrationRatio;
-    }
-    getResolvedInstructionOverhead() {
-        return this.Graph?.getResolvedInstructionOverhead();
-    }
-    getToolCount() {
-        return this.Graph?.getToolCount() ?? 0;
-    }
-    /**
-     * Creates a custom event callback handler that intercepts custom events
-     * and processes them through our handler registry instead of EventStreamCallbackHandler
-     */
-    createCustomEventCallback() {
-        return async (eventName, data, runId, tags, metadata) => {
-            // Step-scoped SDK events are dispatched directly via the handler
-            // registry first. Skip callback-based echoes to prevent double
-            // handling when LangGraph invokes custom callbacks more than once.
-            const stepScopedEventId = getStepScopedEventId(data);
-            if (DIRECT_DISPATCHED_STEP_EVENTS.has(eventName) &&
-                this.Graph != null &&
-                stepScopedEventId != null &&
-                this.Graph.hasHandlerDispatchedEvent(eventName, stepScopedEventId)) {
-                return;
-            }
-            const handler = this.handlerRegistry?.getHandler(eventName);
-            if (handler && this.Graph) {
-                return await handler.handle(eventName, data, metadata, this.Graph);
-            }
-        };
-    }
-    shouldClearHookSession(streamThrew) {
-        return this._interrupt == null || this._haltedReason != null || streamThrew;
-    }
-    isAwaitingResume(streamThrew) {
-        return (this._interrupt != null && this._haltedReason == null && !streamThrew);
-    }
-    getStreamLangfuseConfig(graph) {
-        const primaryContext = graph.agentContexts.get(graph.defaultAgentId);
-        if (primaryContext != null) {
-            return resolveLangfuseConfig(this.langfuse, primaryContext.langfuse);
-        }
-        for (const context of graph.agentContexts.values()) {
-            const langfuse = resolveLangfuseConfig(this.langfuse, context.langfuse);
-            if (langfuse != null) {
-                return langfuse;
-            }
-        }
-        return this.langfuse;
-    }
-    getStreamToolOutputTracingLangfuseConfig(graph) {
-        const toolOutputTracingConfigs = Array.from(graph.agentContexts.values())
-            .map((context) => {
-            return resolveLangfuseConfig(this.langfuse, context.langfuse)
-                ?.toolOutputTracing;
-        })
-            .filter((config) => {
-            return config != null;
-        });
-        if (toolOutputTracingConfigs.length === 0) {
-            return this.langfuse?.toolOutputTracing != null
-                ? { toolOutputTracing: this.langfuse.toolOutputTracing }
-                : undefined;
-        }
-        if (toolOutputTracingConfigs.length === 1) {
-            return { toolOutputTracing: toolOutputTracingConfigs[0] };
-        }
-        let enabled;
-        let redactionText;
-        let redactedToolNameMatchMode;
-        const redactedToolNames = new Set();
-        for (const config of toolOutputTracingConfigs) {
-            if (config.enabled === false) {
-                enabled = false;
-            }
-            else if (enabled !== false && config.enabled != null) {
-                enabled = config.enabled;
-            }
-            redactionText ??= config.redactionText;
-            if (config.redactedToolNameMatchMode === 'partial') {
-                redactedToolNameMatchMode = 'partial';
-            }
-            else {
-                redactedToolNameMatchMode ??= config.redactedToolNameMatchMode;
-            }
-            for (const toolName of config.redactedToolNames ?? []) {
-                redactedToolNames.add(toolName);
-            }
-        }
-        return {
-            toolOutputTracing: {
-                ...(enabled != null ? { enabled } : {}),
-                ...(redactedToolNames.size > 0
-                    ? { redactedToolNames: Array.from(redactedToolNames) }
-                    : {}),
-                ...(redactedToolNameMatchMode != null
-                    ? { redactedToolNameMatchMode }
-                    : {}),
-                ...(redactionText != null ? { redactionText } : {}),
-            },
-        };
-    }
-    async processStream(inputs, callerConfig, streamOptions) {
-        if (this.graphRunnable == null) {
-            throw new Error('Run not initialized. Make sure to use Run.create() to instantiate the Run.');
-        }
-        if (!this.Graph) {
-            throw new Error('Graph not initialized. Make sure to use Run.create() to instantiate the Run.');
-        }
-        const graphRunnable = this.graphRunnable;
-        const graph = this.Graph;
-        /**
-         * `Command` inputs (currently only `Command({ resume })`) are
-         * resume-mode invocations: LangGraph rebuilds graph state from the
-         * checkpointer, so we skip RunStart / UserPromptSubmit hooks (no
-         * new prompt to evaluate) and read run-state from the Graph wrapper
-         * instead of `inputs.messages`.
-         */
-        const isResume = inputs instanceof Command;
-        const stateInputs = isResume ? undefined : inputs;
-        const config = {
-            recursionLimit: 50,
-            ...callerConfig,
-            configurable: { ...callerConfig.configurable },
-        };
-        /**
-         * Skip `resetValues` on resume — we're continuing an in-flight
-         * run, not starting a fresh one. Resetting would wipe the
-         * sidecars (`toolCallStepIds`, `stepKeyIds`, accumulated
-         * `messages`, etc.) the resumed `ToolNode` needs to dispatch
-         * tool completions with the correct step ids and re-resolve
-         * `{{tool<i>turn<n>}}` references. Pairs with the
-         * `awaitingResume` gate on `clearHeavyState` in the `finally`
-         * block so the sidecars survive both ends of the interrupt
-         * boundary.
-         */
-        if (!isResume) {
-            graph.resetValues(streamOptions?.keepContent);
-        }
-        this._interrupt = undefined;
-        this._haltedReason = undefined;
-        this.hookRegistry?.clearHaltSignal(this.id);
-        /** Custom event callback to intercept and handle custom events */
-        const customEventCallback = this.createCustomEventCallback();
-        const streamCallbacks = streamOptions?.callbacks
-            ? this.getCallbacks(streamOptions.callbacks)
-            : undefined;
-        const customHandler = BaseCallbackHandler.fromMethods({
-            [Callback.CUSTOM_EVENT]: customEventCallback,
-        });
-        customHandler.awaitHandlers = true;
-        config.callbacks = appendCallbacks(config.callbacks, streamCallbacks ? [streamCallbacks, customHandler] : [customHandler]);
-        const primaryContext = graph.agentContexts.get(graph.defaultAgentId);
-        const userId = typeof config.configurable?.user_id === 'string'
-            ? config.configurable.user_id
-            : undefined;
-        const sessionId = typeof config.configurable?.thread_id === 'string'
-            ? config.configurable.thread_id
-            : undefined;
-        const traceMetadata = createLangfuseTraceMetadata({
-            messageId: this.id,
-            parentMessageId: config.configurable?.requestBody?.parentMessageId,
-            agentId: graph.defaultAgentId,
-            agentName: primaryContext?.name,
-        });
-        const traceName = config.runName ?? getLangfuseTraceName(traceMetadata);
-        const streamLangfuseConfig = this.getStreamLangfuseConfig(graph);
-        initializeLangfuseTracing(streamLangfuseConfig);
-        const langfuseHandler = createLangfuseHandler({
-            langfuse: streamLangfuseConfig,
-            userId,
-            sessionId,
-            traceMetadata,
-            tags: ['librechat', 'agent'],
-        });
-        if (langfuseHandler != null) {
-            config.runName = traceName;
-            config.callbacks = appendCallbacks(config.callbacks, [langfuseHandler]);
-        }
-        if (!this.id) {
-            throw new Error('Run ID not provided');
-        }
-        config.run_id = this.id;
-        config.configurable = Object.assign(config.configurable ?? {}, {
-            run_id: this.id,
-        });
-        const threadId = config.configurable.thread_id;
-        if (this.hookRegistry != null && stateInputs != null) {
-            const shouldHalt = await this.runPreStreamHooks(stateInputs, threadId, config);
-            if (shouldHalt) {
-                return undefined;
-            }
-        }
-        /**
-         * Tracks whether the stream loop threw. Used by the `finally`
-         * block to decide whether to honor the interrupt-preservation
-         * guard for session hooks: a captured `_interrupt` is only
-         * meaningful if the stream completed cleanly. If the loop errored
-         * after stashing an interrupt (e.g. a downstream handler throws
-         * after the interrupt event landed), the interrupt is stale —
-         * preserving session hooks would leak them into the next run.
-         */
-        let streamThrew = false;
-        const consumeStream = async () => {
-            /**
-             * `streamEvents` accepts both state inputs and `Command` (resume) at
-             * runtime, but our `CompiledStateWorkflow` type narrows the first
-             * arg to `BaseGraphState`. Cast on the call so the resume path
-             * type-checks without widening the wrapper for every caller.
-             */
-            const stream = graphRunnable.streamEvents(inputs, config, {
-                raiseError: true,
-                /**
-                 * Prevent EventStreamCallbackHandler from processing custom events.
-                 * Custom events are already handled via our createCustomEventCallback()
-                 * which routes them through the handlerRegistry.
-                 * Without this flag, EventStreamCallbackHandler throws errors when
-                 * custom events are dispatched for run IDs not in its internal map
-                 * (due to timing issues in parallel execution or after run cleanup).
-                 */
-                ignoreCustomEvent: true,
-            });
-            for await (const event of stream) {
-                const { data, metadata, ...info } = event;
-                const eventName = info.event;
-                /** Skip custom events as they're handled by our callback */
-                if (CUSTOM_GRAPH_EVENTS.has(eventName)) {
-                    continue;
-                }
-                /**
-                 * Detect interrupts surfaced by LangGraph as a synthetic
-                 * `__interrupt__` field on the streamed chunk and stash the
-                 * first one for the host to read via `run.getInterrupt()`
-                 * once the stream drains. Captured as `unknown` because the
-                 * SDK does not validate the runtime payload shape — the
-                 * built-in ToolNode raises a `HumanInterruptPayload`
-                 * (`tool_approval` / `ask_user_question`), but custom nodes
-                 * can pass any payload to `interrupt()`. Callers narrow with
-                 * the `isToolApprovalInterrupt` / `isAskUserQuestionInterrupt`
-                 * guards or assert via `getInterrupt<T>()`.
-                 */
-                if (this._interrupt == null &&
-                    data.chunk != null &&
-                    isInterrupted(data.chunk)) {
-                    const interrupts = data.chunk[INTERRUPT];
-                    if (interrupts.length > 0) {
-                        const first = interrupts[0];
-                        /**
-                         * Capture the interrupt unconditionally — `interrupt(null)`
-                         * and `interrupt(undefined)` are valid pauses (a custom
-                         * node may want to pause without metadata) and the host
-                         * still needs to know the run is awaiting resume. Gating
-                         * on `payload != null` would silently downgrade a paused
-                         * run to "completed" and let the `Stop` hook fire,
-                         * breaking host resume handling.
-                         */
-                        this._interrupt = {
-                            interruptId: first.id ?? '',
-                            threadId,
-                            payload: first.value,
-                        };
-                    }
-                }
-                const handler = this.handlerRegistry?.getHandler(eventName);
-                if (handler) {
-                    await handler.handle(eventName, data, metadata, this.Graph);
-                }
-                /**
-                 * Mid-flight halt: any hook (PreToolUse, PostToolUse,
-                 * PostToolBatch, SubagentStart/Stop, PreCompact, PostCompact)
-                 * that returned `preventContinuation: true` raises a halt
-                 * signal on the registry via `executeHooks`. We poll between
-                 * stream events and break out as soon as one is set so the
-                 * graph doesn't take another model turn after the halting
-                 * operation completes.
-                 *
-                 * Limitation: the current step (in-flight model call, ongoing
-                 * tool batch) is not aborted — only the next step is skipped.
-                 * This matches Claude Code's `continue: false` semantic where
-                 * the active operation finishes before halting takes effect.
-                 */
-                const haltSignal = this.hookRegistry?.getHaltSignal(this.id);
-                if (haltSignal != null) {
-                    this._haltedReason = haltSignal.reason;
-                    break;
-                }
-            }
-            if (this._interrupt != null) {
-                await this.resolveInterruptResumeConfig(config);
-            }
-            /**
-             * Skip the Stop hook when the run paused on a HITL interrupt
-             * (still pending human input) or was halted by a hook (the host
-             * already chose to stop, so a Stop hook firing now would be
-             * misleading). The host fires Stop on the resumed-and-completed
-             * run instead.
-             */
-            if (this._interrupt == null &&
-                this._haltedReason == null &&
-                this.hookRegistry?.hasHookFor('Stop', this.id) === true) {
-                await executeHooks({
-                    registry: this.hookRegistry,
-                    input: {
-                        hook_event_name: 'Stop',
-                        runId: this.id,
-                        threadId,
-                        agentId: graph.defaultAgentId,
-                        messages: graph.getRunMessages() ?? stateInputs?.messages ?? [],
-                        stopHookActive: false, // will be true when stop is triggered by a hook (Phase 2)
-                    },
-                    sessionId: this.id,
-                }).catch(() => {
-                    /* Stop hook errors must not masquerade as stream failures */
-                });
-            }
-        };
-        try {
-            // When opted in, seed the root trace id from this run's id so feedback /
-            // other external signals can be attached to the trace later without a
-            // lookup (see SeededTraceIdGenerator in ./instrumentation).
-            await runWithTraceIdSeed(streamLangfuseConfig?.deterministicTraceId === true
-                ? this.id
-                : undefined, () => withLangfuseToolOutputTracingConfig(streamLangfuseConfig, () => withLangfuseAttributes({
-                langfuse: streamLangfuseConfig,
-                userId,
-                sessionId,
-                traceName,
-                traceMetadata,
-                tags: ['librechat', 'agent'],
-            }, consumeStream), this.getStreamToolOutputTracingLangfuseConfig(graph)));
-        }
-        catch (err) {
-            streamThrew = true;
-            if (this.hookRegistry?.hasHookFor('StopFailure', this.id) === true) {
-                const runMessages = this.Graph.getRunMessages() ?? [];
-                await executeHooks({
-                    registry: this.hookRegistry,
-                    input: {
-                        hook_event_name: 'StopFailure',
-                        runId: this.id,
-                        threadId,
-                        agentId: this.Graph.defaultAgentId,
-                        error: err instanceof Error ? err.message : String(err),
-                        lastAssistantMessage: findLastMessageOfType(runMessages, 'ai'),
-                    },
-                    sessionId: this.id,
-                }).catch(() => {
-                    /* swallow hook errors — the original error must propagate */
-                });
-            }
-            throw err;
-        }
-        finally {
-            /**
-             * Preserve session-scoped hooks when the run paused on a HITL
-             * interrupt — the very next call will be `Run.resume()`, which
-             * needs the same policy hooks (e.g., the `PreToolUse` matcher
-             * that triggered the interrupt) to fire on the re-executed node
-             * and uphold the approval flow. Clearing here would leak the
-             * approval gate on resume. The session is cleared instead at
-             * natural completion, error (including errors that happen AFTER
-             * an interrupt was captured — those interrupts are stale), or
-             * hook-driven halt (including hooks that returned BOTH `ask`
-             * and `preventContinuation` — the halt wins, no resume is
-             * expected, sessions must drop). Every state where no resume
-             * is expected clears.
-             */
-            if (this.shouldClearHookSession(streamThrew)) {
-                this.hookRegistry?.clearSession(this.id);
-            }
-            /**
-             * Drop any halt signal raised mid-stream for this run so a
-             * subsequent `processStream` / `resume` starts with clean state.
-             * The Run captured `_haltedReason` already; the registry entry
-             * for this `sessionId` would otherwise spuriously trip the next
-             * loop. Other concurrent runs sharing this registry are
-             * unaffected — their entries live under their own session ids.
-             */
-            this.hookRegistry?.clearHaltSignal(this.id);
-            await disposeLangfuseHandler(langfuseHandler);
-            /**
-             * Break the reference chain that keeps heavy data alive via
-             * LangGraph's internal `__pregel_scratchpad.currentTaskInput` →
-             * `@langchain/core` `RunTree.extra[lc:child_config]` →
-             * Node.js `AsyncLocalStorage` context captured by timers/promises.
-             *
-             * Without this, base64-encoded images/PDFs in message content remain
-             * reachable from lingering `Timeout` handles until GC runs.
-             */
-            if (!this.skipCleanup) {
-                if (config.configurable != null) {
-                    for (const key of Object.getOwnPropertySymbols(config.configurable)) {
-                        const val = config.configurable[key];
-                        if (val != null &&
-                            typeof val === 'object' &&
-                            'currentTaskInput' in val) {
-                            val.currentTaskInput = undefined;
-                        }
-                        delete config.configurable[key];
-                    }
-                    config.configurable = undefined;
-                }
-                config.callbacks = undefined;
-            }
-            const result = this.returnContent
-                ? this.Graph.getContentParts()
-                : undefined;
-            this.calibrationRatio = this.Graph.getCalibrationRatio();
-            /**
-             * Skip `clearHeavyState()` when the run paused on a clean HITL
-             * interrupt awaiting resume — `Run.resume()` re-enters the same
-             * `ToolNode` instance and needs the sidecars `clearHeavyState`
-             * would wipe (`toolCallStepIds` for completion-event step ids,
-             * the `_toolOutputRegistry` for `{{tool<i>turn<n>}}`
-             * substitutions, `sessions` for code-env continuity, plus the
-             * `hookRegistry` and `humanInTheLoop` config the interrupt
-             * branch itself relies on). Without preservation, the resumed
-             * tool completion would dispatch `ON_RUN_STEP_COMPLETED` with
-             * an empty step id and downstream stream consumers would drop
-             * the result.
-             *
-             * The natural-completion / error / hook-driven-halt paths still
-             * clean up — `_haltedReason != null` or `streamThrew` mean no
-             * resume is expected. Cross-process resume (host rebuilds the
-             * Run from scratch) is a separate concern; see
-             * `HumanInTheLoopConfig` JSDoc.
-             */
-            const awaitingResume = this.isAwaitingResume(streamThrew);
-            if (!this.skipCleanup && !awaitingResume) {
-                this.Graph.clearHeavyState();
-            }
-            this._streamResult = result;
-        }
-        return this._streamResult;
-    }
-    /**
-     * Returns the pending interrupt captured during the most recent
-     * `processStream` (or `resume`) invocation. `undefined` when the run
-     * either has not been streamed yet or completed without pausing.
-     *
-     * Hosts call this immediately after `processStream` returns to decide
-     * whether the run is awaiting human input. Persist the returned
-     * descriptor (alongside `thread_id` and the agent run config) so a
-     * later `resume(decisions)` can rebuild the run.
-     *
-     * The default `TPayload` is the SDK's `HumanInterruptPayload` union
-     * (`tool_approval` / `ask_user_question`), suitable for the common
-     * case where interrupts come from the built-in ToolNode or
-     * `askUserQuestion()` helper. Hosts that raise custom interrupts
-     * from custom graph nodes pass their own type — the SDK does not
-     * validate the runtime shape, it just transports whatever the
-     * `interrupt()` call carried. When in doubt, narrow with the
-     * `isToolApprovalInterrupt` / `isAskUserQuestionInterrupt` type
-     * guards (which accept `unknown`) before reading variant-specific
-     * fields.
-     */
-    getInterrupt() {
-        return this._interrupt;
-    }
-    /**
-     * Returns the reason a hook halted the run via
-     * `preventContinuation: true`, or `undefined` if no hook halted.
-     *
-     * Hosts inspect this after `processStream` returns to distinguish a
-     * natural completion (`undefined`) from a hook-driven halt (a
-     * truthy string). Independent from `getInterrupt()` — a halted run
-     * has no interrupt; an interrupted run has no halt reason.
-     */
-    getHaltReason() {
-        return this._haltedReason;
-    }
-    /**
-     * Resume a paused HITL run with the value the user (or whatever
-     * decided the interrupt) supplied. The default `TResume` covers the
-     * `tool_approval` interrupt (the common case): an array of decisions
-     * in `action_requests` order, or a record keyed by `tool_call_id`.
-     *
-     * For other interrupt types (e.g., `ask_user_question` →
-     * `AskUserQuestionResolution`, or any custom interrupt a host raises
-     * from a custom node), pass the type parameter and the SDK forwards
-     * the value through unchanged. LangGraph delivers it as the return
-     * value of the original `interrupt()` call inside the paused node.
-     *
-     * The host MUST construct this Run with the same `thread_id` and the
-     * same checkpointer as the original paused run; LangGraph rebuilds
-     * graph state from the checkpoint and re-enters the interrupted node
-     * from the start.
-     */
-    /**
-     * Returns the per-Run file checkpointer when
-     * `toolExecution.local.fileCheckpointing === true` was set on the
-     * RunConfig. Hosts can capture extra paths or call `rewind()`
-     * directly. Returns undefined when checkpointing is disabled.
-     *
-     * Construction-time invariant: the checkpointer is shared across
-     * every ToolNode the graph compiles (single-agent and multi-agent),
-     * so a `rewind()` call here unwinds writes made by ANY agent in the
-     * run.
-     */
-    getFileCheckpointer() {
-        return this.Graph?.getOrCreateFileCheckpointer();
-    }
-    /**
-     * Convenience wrapper that calls `rewind()` on the per-Run file
-     * checkpointer. Restores every file the local engine snapshotted
-     * during this Run to its pre-write content (and deletes any path
-     * that didn't exist before being created). Returns the count of
-     * paths processed; returns 0 when checkpointing is disabled.
-     */
-    async rewindFiles() {
-        const cp = this.getFileCheckpointer();
-        return cp == null ? 0 : cp.rewind();
-    }
-    async resume(resumeValue, callerConfig, streamOptions) {
-        const interruptId = this._interrupt?.interruptId;
-        const scopedResume = typeof interruptId === 'string' &&
-            interruptId.length > 0 &&
-            !isLangGraphResumeMapForInterrupt(resumeValue, interruptId)
-            ? { [interruptId]: resumeValue }
-            : resumeValue;
-        const resumeConfig = await this.resolveInterruptResumeConfig(callerConfig);
-        return this.processStream(new Command({ resume: scopedResume }), resumeConfig, streamOptions);
-    }
-    async resolveInterruptResumeConfig(callerConfig) {
-        const interrupt = this._interrupt;
-        const interruptId = interrupt?.interruptId;
-        const workflow = this.graphRunnable;
-        const stateHistory = workflow?.getStateHistory;
-        if (interrupt?.checkpointId != null && interrupt.checkpointId.length > 0) {
-            return {
-                ...callerConfig,
-                configurable: {
-                    ...callerConfig.configurable,
-                    checkpoint_id: interrupt.checkpointId,
-                    ...(typeof interrupt.checkpointNs === 'string'
-                        ? { checkpoint_ns: interrupt.checkpointNs }
-                        : {}),
-                },
-            };
-        }
-        if (interrupt == null ||
-            typeof interruptId !== 'string' ||
-            interruptId.length === 0 ||
-            typeof stateHistory !== 'function') {
-            return callerConfig;
-        }
-        for await (const snapshot of stateHistory.call(this.graphRunnable, callerConfig)) {
-            const hasMatchingInterrupt = snapshot.tasks?.some((task) => task.interrupts?.some((interrupt) => interrupt.id === interruptId) === true) === true;
-            const checkpointConfigurable = snapshot.config?.configurable;
-            if (!hasMatchingInterrupt || checkpointConfigurable == null) {
-                continue;
-            }
-            const checkpointId = checkpointConfigurable.checkpoint_id;
-            const checkpointNs = checkpointConfigurable.checkpoint_ns;
-            if (typeof checkpointId === 'string' && checkpointId.length > 0) {
-                this._interrupt = {
-                    ...interrupt,
-                    checkpointId,
-                    ...(typeof checkpointNs === 'string' ? { checkpointNs } : {}),
-                };
-                return {
-                    ...callerConfig,
-                    configurable: {
-                        ...callerConfig.configurable,
-                        checkpoint_id: checkpointId,
-                        ...(typeof checkpointNs === 'string'
-                            ? { checkpoint_ns: checkpointNs }
-                            : {}),
-                    },
-                };
-            }
-        }
-        return callerConfig;
-    }
-    createSystemCallback(clientCallbacks, key) {
-        return ((...args) => {
-            const clientCallback = clientCallbacks[key];
-            if (clientCallback && this.Graph) {
-                clientCallback(this.Graph, ...args);
-            }
-        });
-    }
-    getCallbacks(clientCallbacks) {
-        return {
-            [Callback.TOOL_ERROR]: this.createSystemCallback(clientCallbacks, Callback.TOOL_ERROR),
-            [Callback.TOOL_START]: this.createSystemCallback(clientCallbacks, Callback.TOOL_START),
-            [Callback.TOOL_END]: this.createSystemCallback(clientCallbacks, Callback.TOOL_END),
-        };
-    }
-    async generateTitle({ provider, inputText, contentParts, titlePrompt, clientOptions, chainOptions, skipLanguage, titleMethod = TitleMethod.COMPLETION, titlePromptTemplate, }) {
-        let titleLangfuseHandler;
-        let titleLangfuseConfig;
-        let titleUserId;
-        let titleSessionId;
-        const titleContext = this.Graph == null
-            ? undefined
-            : this.Graph.agentContexts.get(this.Graph.defaultAgentId);
-        const traceMetadata = createLangfuseTraceMetadata({
-            messageId: 'title-' + this.id,
-            agentName: titleContext?.name,
-        });
-        const titleRunName = getLangfuseTraceName(traceMetadata, 'LibreChat Title');
-        if (chainOptions != null) {
-            titleUserId =
-                typeof chainOptions.configurable?.user_id === 'string'
-                    ? chainOptions.configurable.user_id
-                    : undefined;
-            titleSessionId =
-                typeof chainOptions.configurable?.thread_id === 'string'
-                    ? chainOptions.configurable.thread_id
-                    : undefined;
-            titleLangfuseConfig = resolveLangfuseConfig(this.langfuse, titleContext?.langfuse);
-            initializeLangfuseTracing(titleLangfuseConfig);
-            titleLangfuseHandler = createLangfuseHandler({
-                langfuse: titleLangfuseConfig,
-                userId: titleUserId,
-                sessionId: titleSessionId,
-                traceMetadata,
-                tags: ['librechat', 'title'],
-            });
-            if (titleLangfuseHandler != null) {
-                chainOptions.callbacks = appendCallbacks(chainOptions.callbacks, [
-                    titleLangfuseHandler,
-                ]);
-            }
-        }
-        const convoTemplate = PromptTemplate.fromTemplate(titlePromptTemplate ?? 'User: {input}\nAI: {output}');
-        const response = contentParts
-            .map((part) => {
-            if (part?.type === 'text')
-                return part.text;
-            return '';
-        })
-            .join('\n');
-        const model = initializeModel({
-            provider,
-            clientOptions,
-        });
-        if (isOpenAILike(provider) &&
-            (model instanceof ChatOpenAI$1 || model instanceof AzureChatOpenAI$1)) {
-            model.temperature = clientOptions
-                ?.temperature;
-            model.topP = clientOptions
-                ?.topP;
-            model.frequencyPenalty = clientOptions?.frequencyPenalty;
-            model.presencePenalty = clientOptions?.presencePenalty;
-            model.n = clientOptions
-                ?.n;
-        }
-        const convoToTitleInput = new RunnableLambda({
-            func: (promptValue) => ({
-                convo: promptValue.value,
-                inputText,
-                skipLanguage,
-            }),
-        }).withConfig({ runName: 'ConvoTransform' });
-        const titleChain = titleMethod === TitleMethod.COMPLETION
-            ? await createCompletionTitleRunnable(model, titlePrompt)
-            : await createTitleRunnable(model, titlePrompt);
-        /** Pipes `convoTemplate` -> `transformer` -> `titleChain` */
-        const fullChain = convoTemplate
-            .withConfig({ runName: 'ConvoTemplate' })
-            .pipe(convoToTitleInput)
-            .pipe(titleChain)
-            .withConfig({ runName: 'TitleChain' });
-        const invokeConfig = Object.assign({}, chainOptions, {
-            run_id: this.id,
-            runId: this.id,
-            runName: chainOptions?.runName ?? titleRunName,
-        });
-        const invokeTitleChain = (runtimeConfig) => withLangfuseAttributes({
-            langfuse: titleLangfuseConfig,
-            userId: titleUserId,
-            sessionId: titleSessionId,
-            traceName: runtimeConfig.runName ?? titleRunName,
-            traceMetadata,
-            tags: ['librechat', 'title'],
-        }, () => fullChain.invoke({ input: inputText, output: response }, runtimeConfig));
-        try {
-            try {
-                return await withLangfuseToolOutputTracingConfig(this.langfuse, () => invokeTitleChain(invokeConfig), titleContext?.langfuse);
-            }
-            catch (_e) {
-                // Fallback: strip callbacks to avoid EventStream tracer errors in certain environments
-                // but preserve Langfuse tracing if it exists.
-                const langfuseHandler = findCallback(invokeConfig.callbacks, isLangfuseCallbackHandler);
-                const { callbacks: _cb, ...rest } = invokeConfig;
-                const safeConfig = Object.assign({}, rest, {
-                    callbacks: langfuseHandler ? [langfuseHandler] : [],
-                });
-                return await withLangfuseToolOutputTracingConfig(this.langfuse, () => invokeTitleChain(safeConfig), titleContext?.langfuse);
-            }
-        }
-        finally {
-            await disposeLangfuseHandler(titleLangfuseHandler);
-        }
-    }
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	return Object.prototype.hasOwnProperty.call(value, interruptId);
 }
+var Run = class Run {
+	id;
+	tokenCounter;
+	handlerRegistry;
+	hookRegistry;
+	humanInTheLoop;
+	langfuse;
+	toolOutputReferences;
+	eagerEventToolExecution;
+	toolExecution;
+	indexTokenCountMap;
+	calibrationRatio = 1;
+	graphRunnable;
+	Graph;
+	returnContent = false;
+	skipCleanup = false;
+	_streamResult;
+	/**
+	* Captured interrupt payload typed as `unknown` because the SDK
+	* does not validate the runtime shape — custom graph nodes can
+	* raise interrupts with arbitrary payloads (not just the SDK's
+	* `HumanInterruptPayload` union). The public `getInterrupt<T>()`
+	* lets callers assert the type they expect.
+	*/
+	_interrupt;
+	_haltedReason;
+	constructor(config) {
+		const runId = config.runId ?? "";
+		if (!runId) throw new Error("Run ID not provided");
+		this.id = runId;
+		this.tokenCounter = config.tokenCounter;
+		this.indexTokenCountMap = config.indexTokenCountMap;
+		if (config.calibrationRatio != null && config.calibrationRatio > 0) this.calibrationRatio = config.calibrationRatio;
+		const handlerRegistry = new HandlerRegistry();
+		if (config.customHandlers) for (const [eventType, handler] of Object.entries(config.customHandlers)) handlerRegistry.register(eventType, handler);
+		this.handlerRegistry = handlerRegistry;
+		this.hookRegistry = config.hooks;
+		this.humanInTheLoop = config.humanInTheLoop;
+		this.langfuse = config.langfuse;
+		this.toolOutputReferences = config.toolOutputReferences;
+		this.eagerEventToolExecution = config.eagerEventToolExecution;
+		this.toolExecution = config.toolExecution;
+		if (!config.graphConfig) throw new Error("Graph config not provided");
+		/** Handle different graph types */
+		if (config.graphConfig.type === "multi-agent") {
+			this.graphRunnable = this.createMultiAgentGraph(config.graphConfig);
+			if (this.Graph) this.Graph.handlerRegistry = handlerRegistry;
+		} else {
+			/** Default to legacy graph for 'standard' or undefined type */
+			this.graphRunnable = this.createLegacyGraph(config.graphConfig);
+			if (this.Graph) {
+				this.Graph.compileOptions = config.graphConfig.compileOptions ?? this.Graph.compileOptions;
+				this.Graph.handlerRegistry = handlerRegistry;
+			}
+		}
+		if (config.initialSessions && this.Graph) for (const [key, value] of config.initialSessions) this.Graph.sessions.set(key, value);
+		this.returnContent = config.returnContent ?? false;
+		this.skipCleanup = config.skipCleanup ?? false;
+	}
+	createLegacyGraph(config) {
+		let agentConfig;
+		let signal;
+		/** Check if this is a multi-agent style config (has agents array) */
+		if ("agents" in config && Array.isArray(config.agents)) {
+			if (config.agents.length === 0) throw new Error("At least one agent must be provided");
+			agentConfig = config.agents[0];
+			signal = config.signal;
+		} else {
+			/** Legacy path: build agent config from llmConfig */
+			const { type: _type, llmConfig, signal: legacySignal, tools = [], ...agentInputs } = config;
+			const { provider, ...clientOptions } = llmConfig;
+			agentConfig = {
+				...agentInputs,
+				tools,
+				provider,
+				clientOptions,
+				agentId: "default"
+			};
+			signal = legacySignal;
+		}
+		const standardGraph = new StandardGraph({
+			signal,
+			runId: this.id,
+			agents: [agentConfig],
+			langfuse: this.langfuse,
+			tokenCounter: this.tokenCounter,
+			indexTokenCountMap: this.indexTokenCountMap,
+			calibrationRatio: this.calibrationRatio
+		});
+		/** Propagate compile options from graph config */
+		standardGraph.compileOptions = this.applyHITLCheckpointerFallback(config.compileOptions);
+		standardGraph.hookRegistry = this.hookRegistry;
+		standardGraph.humanInTheLoop = this.humanInTheLoop;
+		standardGraph.toolOutputReferences = this.toolOutputReferences;
+		standardGraph.eagerEventToolExecution = this.eagerEventToolExecution;
+		standardGraph.toolExecution = this.toolExecution;
+		this.Graph = standardGraph;
+		return standardGraph.createWorkflow();
+	}
+	createMultiAgentGraph(config) {
+		const { agents, edges, compileOptions } = config;
+		const multiAgentGraph = new MultiAgentGraph({
+			runId: this.id,
+			agents,
+			edges,
+			langfuse: this.langfuse,
+			tokenCounter: this.tokenCounter,
+			indexTokenCountMap: this.indexTokenCountMap,
+			calibrationRatio: this.calibrationRatio
+		});
+		multiAgentGraph.compileOptions = this.applyHITLCheckpointerFallback(compileOptions);
+		multiAgentGraph.hookRegistry = this.hookRegistry;
+		multiAgentGraph.humanInTheLoop = this.humanInTheLoop;
+		multiAgentGraph.toolOutputReferences = this.toolOutputReferences;
+		multiAgentGraph.eagerEventToolExecution = this.eagerEventToolExecution;
+		multiAgentGraph.toolExecution = this.toolExecution;
+		this.Graph = multiAgentGraph;
+		return multiAgentGraph.createWorkflow();
+	}
+	/**
+	* When the host opted into HITL via `humanInTheLoop: { enabled: true }`
+	* and did not supply a checkpointer, install an in-memory `MemorySaver`
+	* so `interrupt()` can persist checkpoints and `Command({ resume })`
+	* can rebuild state. The fallback is intentionally process-local:
+	* production hosts that need durable resumption across processes /
+	* restarts must provide their own checkpointer (Redis, Postgres, etc.)
+	* on `compileOptions.checkpointer`.
+	*
+	* No-op when HITL is off (the default — omitted, or
+	* `{ enabled: false }`) or the host already supplied a checkpointer
+	* of their own. See `HumanInTheLoopConfig` JSDoc for the rationale
+	* behind the default-off stance.
+	*/
+	applyHITLCheckpointerFallback(compileOptions) {
+		if (this.humanInTheLoop?.enabled !== true) return compileOptions;
+		if (compileOptions?.checkpointer != null) return compileOptions;
+		return {
+			...compileOptions ?? {},
+			checkpointer: new MemorySaver()
+		};
+	}
+	/**
+	* Run RunStart + UserPromptSubmit hooks before the graph stream
+	* begins, accumulate any `additionalContext` strings into the input
+	* messages, and short-circuit when a hook signals the run should not
+	* proceed (deny / ask decision on the prompt, or `preventContinuation`
+	* on either hook).
+	*
+	* Returns `true` when the caller should bail with `undefined` (run
+	* was halted before any model call); returns `false` to proceed
+	* into the stream loop.
+	*
+	* ## Side effects
+	*
+	* On the success path:
+	*   - Mutates `stateInputs.messages` in place to append a
+	*     consolidated `HumanMessage` carrying any hook
+	*     `additionalContext` strings. Safe because the host owns the
+	*     array and `processStream` is the only consumer until LangGraph
+	*     reads it.
+	*
+	* On the halt path (returning `true`):
+	*   - Sets `this._haltedReason` so callers (and the eventual host)
+	*     can distinguish a hook-driven halt from a natural completion.
+	*   - Calls `registry.clearSession(this.id)` and
+	*     `registry.clearHaltSignal(this.id)` because no resume is
+	*     expected from a pre-stream halt — the run never entered the
+	*     graph, so the session/halt state for this run would otherwise
+	*     leak to the next `processStream` invocation on the same
+	*     registry. Other concurrent runs on the same registry are
+	*     untouched (halt signals are scoped per session id).
+	*   - Sets `config.callbacks = undefined` to drop the callback
+	*     references the caller built (langfuse handler, custom event
+	*     handler, etc.) since they won't be exercised. Mirrors the
+	*     equivalent cleanup the `processStream` `finally` block does
+	*     on the natural-completion path.
+	*/
+	async runPreStreamHooks(stateInputs, threadId, config) {
+		const registry = this.hookRegistry;
+		/**
+		* Defensive guard: `processStream` already validated `this.Graph`
+		* before calling this helper, but TypeScript can't propagate that
+		* narrowing across method boundaries. The check keeps the body
+		* free of `this.Graph!` non-null assertions.
+		*/
+		if (registry == null || this.Graph == null) return false;
+		const preStreamContexts = [];
+		const runStartResult = await executeHooks({
+			registry,
+			input: {
+				hook_event_name: "RunStart",
+				runId: this.id,
+				threadId,
+				agentId: this.Graph.defaultAgentId,
+				messages: stateInputs.messages
+			},
+			sessionId: this.id
+		});
+		for (const ctx of runStartResult.additionalContexts) preStreamContexts.push(ctx);
+		/**
+		* Honor `preventContinuation` from RunStart before the stream
+		* starts. Mid-flight halts (from tool/compact/subagent hooks)
+		* route through `HookRegistry.haltRun` and are polled by the
+		* stream loop in `processStream` — different mechanism, same
+		* intent.
+		*/
+		if (runStartResult.preventContinuation === true) {
+			this._haltedReason = runStartResult.stopReason ?? "preventContinuation";
+			registry.clearSession(this.id);
+			registry.clearHaltSignal(this.id);
+			config.callbacks = void 0;
+			return true;
+		}
+		const lastHuman = findLastMessageOfType(stateInputs.messages, "human");
+		if (lastHuman != null) {
+			const promptResult = await executeHooks({
+				registry,
+				input: {
+					hook_event_name: "UserPromptSubmit",
+					runId: this.id,
+					threadId,
+					agentId: this.Graph.defaultAgentId,
+					prompt: extractPromptText(lastHuman)
+				},
+				sessionId: this.id
+			});
+			if (promptResult.decision === "deny" || promptResult.decision === "ask" || promptResult.preventContinuation === true) {
+				/**
+				* Always set `_haltedReason` so the host can call
+				* `getHaltReason()` and distinguish a hook-blocked prompt
+				* from a natural empty-output completion. Three signals can
+				* land here, each with its own canonical reason string when
+				* the hook didn't supply one.
+				*/
+				if (promptResult.preventContinuation === true) this._haltedReason = promptResult.stopReason ?? "preventContinuation";
+				else if (promptResult.decision === "deny") this._haltedReason = promptResult.reason ?? "prompt_denied";
+				else this._haltedReason = promptResult.reason ?? "prompt_requires_approval";
+				registry.clearSession(this.id);
+				registry.clearHaltSignal(this.id);
+				config.callbacks = void 0;
+				return true;
+			}
+			for (const ctx of promptResult.additionalContexts) preStreamContexts.push(ctx);
+		}
+		if (preStreamContexts.length > 0)
+ /**
+		* Wraps the joined hook contexts as a `HumanMessage` even though
+		* the intent is system-level guidance. Using a `SystemMessage`
+		* mid-conversation is rejected by Anthropic and Google providers
+		* (system messages must be the leading entry), so the LangChain
+		* convention — also used by `ToolNode.convertInjectedMessages`
+		* — is `HumanMessage` carrying `additional_kwargs.role` as a
+		* marker for hosts inspecting state. The model still sees a
+		* user-role message; the `role: 'system'` field is metadata
+		* only. Hosts that want a true system message should compose
+		* it into the agent's `instructions` config instead.
+		*/
+		stateInputs.messages.push(new HumanMessage({
+			content: preStreamContexts.join("\n\n"),
+			additional_kwargs: {
+				role: "system",
+				source: "hook"
+			}
+		}));
+		return false;
+	}
+	static async create(config) {
+		/** Create tokenCounter if indexTokenCountMap is provided but tokenCounter is not */
+		if (config.indexTokenCountMap && !config.tokenCounter) {
+			const gc = config.graphConfig;
+			config.tokenCounter = await createTokenCounter(encodingForModel(("agents" in gc ? gc.agents[0]?.clientOptions : gc.clientOptions)?.model ?? ""));
+		}
+		return new Run(config);
+	}
+	getRunMessages() {
+		if (!this.Graph) throw new Error("Graph not initialized. Make sure to use Run.create() to instantiate the Run.");
+		return this.Graph.getRunMessages();
+	}
+	/**
+	* Returns the current calibration ratio (EMA of provider-vs-estimate token ratios).
+	* Hosts should persist this value and pass it back as `RunConfig.calibrationRatio`
+	* on the next run for the same conversation so the pruner starts with an accurate
+	* scaling factor instead of the default (1).
+	*/
+	getCalibrationRatio() {
+		return this.calibrationRatio;
+	}
+	getResolvedInstructionOverhead() {
+		return this.Graph?.getResolvedInstructionOverhead();
+	}
+	getToolCount() {
+		return this.Graph?.getToolCount() ?? 0;
+	}
+	/**
+	* Creates a custom event callback handler that intercepts custom events
+	* and processes them through our handler registry instead of EventStreamCallbackHandler
+	*/
+	createCustomEventCallback() {
+		return async (eventName, data, runId, tags, metadata) => {
+			const stepScopedEventId = getStepScopedEventId(data);
+			if (DIRECT_DISPATCHED_STEP_EVENTS.has(eventName) && this.Graph != null && stepScopedEventId != null && this.Graph.hasHandlerDispatchedEvent(eventName, stepScopedEventId)) return;
+			const handler = this.handlerRegistry?.getHandler(eventName);
+			if (handler && this.Graph) return await handler.handle(eventName, data, metadata, this.Graph);
+		};
+	}
+	shouldClearHookSession(streamThrew) {
+		return this._interrupt == null || this._haltedReason != null || streamThrew;
+	}
+	isAwaitingResume(streamThrew) {
+		return this._interrupt != null && this._haltedReason == null && !streamThrew;
+	}
+	getStreamLangfuseConfig(graph) {
+		const primaryContext = graph.agentContexts.get(graph.defaultAgentId);
+		if (primaryContext != null) return resolveLangfuseConfig(this.langfuse, primaryContext.langfuse);
+		for (const context of graph.agentContexts.values()) {
+			const langfuse = resolveLangfuseConfig(this.langfuse, context.langfuse);
+			if (langfuse != null) return langfuse;
+		}
+		return this.langfuse;
+	}
+	getStreamToolOutputTracingLangfuseConfig(graph) {
+		const toolOutputTracingConfigs = Array.from(graph.agentContexts.values()).map((context) => {
+			return resolveLangfuseConfig(this.langfuse, context.langfuse)?.toolOutputTracing;
+		}).filter((config) => {
+			return config != null;
+		});
+		if (toolOutputTracingConfigs.length === 0) return this.langfuse?.toolOutputTracing != null ? { toolOutputTracing: this.langfuse.toolOutputTracing } : void 0;
+		if (toolOutputTracingConfigs.length === 1) return { toolOutputTracing: toolOutputTracingConfigs[0] };
+		let enabled;
+		let redactionText;
+		let redactedToolNameMatchMode;
+		const redactedToolNames = /* @__PURE__ */ new Set();
+		for (const config of toolOutputTracingConfigs) {
+			if (config.enabled === false) enabled = false;
+			else if (enabled !== false && config.enabled != null) enabled = config.enabled;
+			redactionText ??= config.redactionText;
+			if (config.redactedToolNameMatchMode === "partial") redactedToolNameMatchMode = "partial";
+			else redactedToolNameMatchMode ??= config.redactedToolNameMatchMode;
+			for (const toolName of config.redactedToolNames ?? []) redactedToolNames.add(toolName);
+		}
+		return { toolOutputTracing: {
+			...enabled != null ? { enabled } : {},
+			...redactedToolNames.size > 0 ? { redactedToolNames: Array.from(redactedToolNames) } : {},
+			...redactedToolNameMatchMode != null ? { redactedToolNameMatchMode } : {},
+			...redactionText != null ? { redactionText } : {}
+		} };
+	}
+	async processStream(inputs, callerConfig, streamOptions) {
+		if (this.graphRunnable == null) throw new Error("Run not initialized. Make sure to use Run.create() to instantiate the Run.");
+		if (!this.Graph) throw new Error("Graph not initialized. Make sure to use Run.create() to instantiate the Run.");
+		const graphRunnable = this.graphRunnable;
+		const graph = this.Graph;
+		/**
+		* `Command` inputs (currently only `Command({ resume })`) are
+		* resume-mode invocations: LangGraph rebuilds graph state from the
+		* checkpointer, so we skip RunStart / UserPromptSubmit hooks (no
+		* new prompt to evaluate) and read run-state from the Graph wrapper
+		* instead of `inputs.messages`.
+		*/
+		const isResume = inputs instanceof Command;
+		const stateInputs = isResume ? void 0 : inputs;
+		const config = {
+			recursionLimit: 50,
+			...callerConfig,
+			configurable: { ...callerConfig.configurable }
+		};
+		/**
+		* Skip `resetValues` on resume — we're continuing an in-flight
+		* run, not starting a fresh one. Resetting would wipe the
+		* sidecars (`toolCallStepIds`, `stepKeyIds`, accumulated
+		* `messages`, etc.) the resumed `ToolNode` needs to dispatch
+		* tool completions with the correct step ids and re-resolve
+		* `{{tool<i>turn<n>}}` references. Pairs with the
+		* `awaitingResume` gate on `clearHeavyState` in the `finally`
+		* block so the sidecars survive both ends of the interrupt
+		* boundary.
+		*/
+		if (!isResume) graph.resetValues(streamOptions?.keepContent);
+		this._interrupt = void 0;
+		this._haltedReason = void 0;
+		this.hookRegistry?.clearHaltSignal(this.id);
+		/** Custom event callback to intercept and handle custom events */
+		const customEventCallback = this.createCustomEventCallback();
+		const streamCallbacks = streamOptions?.callbacks ? this.getCallbacks(streamOptions.callbacks) : void 0;
+		const customHandler = BaseCallbackHandler.fromMethods({ ["handleCustomEvent"]: customEventCallback });
+		customHandler.awaitHandlers = true;
+		config.callbacks = appendCallbacks(config.callbacks, streamCallbacks ? [streamCallbacks, customHandler] : [customHandler]);
+		const primaryContext = graph.agentContexts.get(graph.defaultAgentId);
+		const userId = typeof config.configurable?.user_id === "string" ? config.configurable.user_id : void 0;
+		const sessionId = typeof config.configurable?.thread_id === "string" ? config.configurable.thread_id : void 0;
+		const traceMetadata = createLangfuseTraceMetadata({
+			messageId: this.id,
+			parentMessageId: config.configurable?.requestBody?.parentMessageId,
+			agentId: graph.defaultAgentId,
+			agentName: primaryContext?.name
+		});
+		const traceName = config.runName ?? getLangfuseTraceName(traceMetadata);
+		const streamLangfuseConfig = this.getStreamLangfuseConfig(graph);
+		initializeLangfuseTracing(streamLangfuseConfig);
+		const langfuseHandler = createLangfuseHandler({
+			langfuse: streamLangfuseConfig,
+			userId,
+			sessionId,
+			traceMetadata,
+			tags: ["librechat", "agent"]
+		});
+		if (langfuseHandler != null) {
+			config.runName = traceName;
+			config.callbacks = appendCallbacks(config.callbacks, [langfuseHandler]);
+		}
+		if (!this.id) throw new Error("Run ID not provided");
+		config.run_id = this.id;
+		config.configurable = Object.assign(config.configurable ?? {}, { run_id: this.id });
+		const threadId = config.configurable.thread_id;
+		if (this.hookRegistry != null && stateInputs != null) {
+			if (await this.runPreStreamHooks(stateInputs, threadId, config)) return;
+		}
+		/**
+		* Tracks whether the stream loop threw. Used by the `finally`
+		* block to decide whether to honor the interrupt-preservation
+		* guard for session hooks: a captured `_interrupt` is only
+		* meaningful if the stream completed cleanly. If the loop errored
+		* after stashing an interrupt (e.g. a downstream handler throws
+		* after the interrupt event landed), the interrupt is stale —
+		* preserving session hooks would leak them into the next run.
+		*/
+		let streamThrew = false;
+		const consumeStream = async () => {
+			/**
+			* `streamEvents` accepts both state inputs and `Command` (resume) at
+			* runtime, but our `CompiledStateWorkflow` type narrows the first
+			* arg to `BaseGraphState`. Cast on the call so the resume path
+			* type-checks without widening the wrapper for every caller.
+			*/
+			const stream = graphRunnable.streamEvents(inputs, config, {
+				raiseError: true,
+				/**
+				* Prevent EventStreamCallbackHandler from processing custom events.
+				* Custom events are already handled via our createCustomEventCallback()
+				* which routes them through the handlerRegistry.
+				* Without this flag, EventStreamCallbackHandler throws errors when
+				* custom events are dispatched for run IDs not in its internal map
+				* (due to timing issues in parallel execution or after run cleanup).
+				*/
+				ignoreCustomEvent: true
+			});
+			for await (const event of stream) {
+				const { data, metadata, ...info } = event;
+				const eventName = info.event;
+				/** Skip custom events as they're handled by our callback */
+				if (CUSTOM_GRAPH_EVENTS.has(eventName)) continue;
+				/**
+				* Detect interrupts surfaced by LangGraph as a synthetic
+				* `__interrupt__` field on the streamed chunk and stash the
+				* first one for the host to read via `run.getInterrupt()`
+				* once the stream drains. Captured as `unknown` because the
+				* SDK does not validate the runtime payload shape — the
+				* built-in ToolNode raises a `HumanInterruptPayload`
+				* (`tool_approval` / `ask_user_question`), but custom nodes
+				* can pass any payload to `interrupt()`. Callers narrow with
+				* the `isToolApprovalInterrupt` / `isAskUserQuestionInterrupt`
+				* guards or assert via `getInterrupt<T>()`.
+				*/
+				if (this._interrupt == null && data.chunk != null && isInterrupted(data.chunk)) {
+					const interrupts = data.chunk[INTERRUPT];
+					if (interrupts.length > 0) {
+						const first = interrupts[0];
+						/**
+						* Capture the interrupt unconditionally — `interrupt(null)`
+						* and `interrupt(undefined)` are valid pauses (a custom
+						* node may want to pause without metadata) and the host
+						* still needs to know the run is awaiting resume. Gating
+						* on `payload != null` would silently downgrade a paused
+						* run to "completed" and let the `Stop` hook fire,
+						* breaking host resume handling.
+						*/
+						this._interrupt = {
+							interruptId: first.id ?? "",
+							threadId,
+							payload: first.value
+						};
+					}
+				}
+				const handler = this.handlerRegistry?.getHandler(eventName);
+				if (handler) await handler.handle(eventName, data, metadata, this.Graph);
+				/**
+				* Mid-flight halt: any hook (PreToolUse, PostToolUse,
+				* PostToolBatch, SubagentStart/Stop, PreCompact, PostCompact)
+				* that returned `preventContinuation: true` raises a halt
+				* signal on the registry via `executeHooks`. We poll between
+				* stream events and break out as soon as one is set so the
+				* graph doesn't take another model turn after the halting
+				* operation completes.
+				*
+				* Limitation: the current step (in-flight model call, ongoing
+				* tool batch) is not aborted — only the next step is skipped.
+				* This matches Claude Code's `continue: false` semantic where
+				* the active operation finishes before halting takes effect.
+				*/
+				const haltSignal = this.hookRegistry?.getHaltSignal(this.id);
+				if (haltSignal != null) {
+					this._haltedReason = haltSignal.reason;
+					break;
+				}
+			}
+			if (this._interrupt != null) await this.resolveInterruptResumeConfig(config);
+			/**
+			* Skip the Stop hook when the run paused on a HITL interrupt
+			* (still pending human input) or was halted by a hook (the host
+			* already chose to stop, so a Stop hook firing now would be
+			* misleading). The host fires Stop on the resumed-and-completed
+			* run instead.
+			*/
+			if (this._interrupt == null && this._haltedReason == null && this.hookRegistry?.hasHookFor("Stop", this.id) === true) await executeHooks({
+				registry: this.hookRegistry,
+				input: {
+					hook_event_name: "Stop",
+					runId: this.id,
+					threadId,
+					agentId: graph.defaultAgentId,
+					messages: graph.getRunMessages() ?? stateInputs?.messages ?? [],
+					stopHookActive: false
+				},
+				sessionId: this.id
+			}).catch(() => {});
+		};
+		try {
+			await runWithTraceIdSeed(streamLangfuseConfig?.deterministicTraceId === true ? this.id : void 0, () => withLangfuseToolOutputTracingConfig(streamLangfuseConfig, () => withLangfuseAttributes({
+				langfuse: streamLangfuseConfig,
+				userId,
+				sessionId,
+				traceName,
+				traceMetadata,
+				tags: ["librechat", "agent"]
+			}, consumeStream), this.getStreamToolOutputTracingLangfuseConfig(graph)));
+		} catch (err) {
+			streamThrew = true;
+			if (this.hookRegistry?.hasHookFor("StopFailure", this.id) === true) {
+				const runMessages = this.Graph.getRunMessages() ?? [];
+				await executeHooks({
+					registry: this.hookRegistry,
+					input: {
+						hook_event_name: "StopFailure",
+						runId: this.id,
+						threadId,
+						agentId: this.Graph.defaultAgentId,
+						error: err instanceof Error ? err.message : String(err),
+						lastAssistantMessage: findLastMessageOfType(runMessages, "ai")
+					},
+					sessionId: this.id
+				}).catch(() => {});
+			}
+			throw err;
+		} finally {
+			/**
+			* Preserve session-scoped hooks when the run paused on a HITL
+			* interrupt — the very next call will be `Run.resume()`, which
+			* needs the same policy hooks (e.g., the `PreToolUse` matcher
+			* that triggered the interrupt) to fire on the re-executed node
+			* and uphold the approval flow. Clearing here would leak the
+			* approval gate on resume. The session is cleared instead at
+			* natural completion, error (including errors that happen AFTER
+			* an interrupt was captured — those interrupts are stale), or
+			* hook-driven halt (including hooks that returned BOTH `ask`
+			* and `preventContinuation` — the halt wins, no resume is
+			* expected, sessions must drop). Every state where no resume
+			* is expected clears.
+			*/
+			if (this.shouldClearHookSession(streamThrew)) this.hookRegistry?.clearSession(this.id);
+			/**
+			* Drop any halt signal raised mid-stream for this run so a
+			* subsequent `processStream` / `resume` starts with clean state.
+			* The Run captured `_haltedReason` already; the registry entry
+			* for this `sessionId` would otherwise spuriously trip the next
+			* loop. Other concurrent runs sharing this registry are
+			* unaffected — their entries live under their own session ids.
+			*/
+			this.hookRegistry?.clearHaltSignal(this.id);
+			await disposeLangfuseHandler(langfuseHandler);
+			/**
+			* Break the reference chain that keeps heavy data alive via
+			* LangGraph's internal `__pregel_scratchpad.currentTaskInput` →
+			* `@langchain/core` `RunTree.extra[lc:child_config]` →
+			* Node.js `AsyncLocalStorage` context captured by timers/promises.
+			*
+			* Without this, base64-encoded images/PDFs in message content remain
+			* reachable from lingering `Timeout` handles until GC runs.
+			*/
+			if (!this.skipCleanup) {
+				if (config.configurable != null) {
+					for (const key of Object.getOwnPropertySymbols(config.configurable)) {
+						const val = config.configurable[key];
+						if (val != null && typeof val === "object" && "currentTaskInput" in val) val.currentTaskInput = void 0;
+						delete config.configurable[key];
+					}
+					config.configurable = void 0;
+				}
+				config.callbacks = void 0;
+			}
+			const result = this.returnContent ? this.Graph.getContentParts() : void 0;
+			this.calibrationRatio = this.Graph.getCalibrationRatio();
+			/**
+			* Skip `clearHeavyState()` when the run paused on a clean HITL
+			* interrupt awaiting resume — `Run.resume()` re-enters the same
+			* `ToolNode` instance and needs the sidecars `clearHeavyState`
+			* would wipe (`toolCallStepIds` for completion-event step ids,
+			* the `_toolOutputRegistry` for `{{tool<i>turn<n>}}`
+			* substitutions, `sessions` for code-env continuity, plus the
+			* `hookRegistry` and `humanInTheLoop` config the interrupt
+			* branch itself relies on). Without preservation, the resumed
+			* tool completion would dispatch `ON_RUN_STEP_COMPLETED` with
+			* an empty step id and downstream stream consumers would drop
+			* the result.
+			*
+			* The natural-completion / error / hook-driven-halt paths still
+			* clean up — `_haltedReason != null` or `streamThrew` mean no
+			* resume is expected. Cross-process resume (host rebuilds the
+			* Run from scratch) is a separate concern; see
+			* `HumanInTheLoopConfig` JSDoc.
+			*/
+			const awaitingResume = this.isAwaitingResume(streamThrew);
+			if (!this.skipCleanup && !awaitingResume) this.Graph.clearHeavyState();
+			this._streamResult = result;
+		}
+		return this._streamResult;
+	}
+	/**
+	* Returns the pending interrupt captured during the most recent
+	* `processStream` (or `resume`) invocation. `undefined` when the run
+	* either has not been streamed yet or completed without pausing.
+	*
+	* Hosts call this immediately after `processStream` returns to decide
+	* whether the run is awaiting human input. Persist the returned
+	* descriptor (alongside `thread_id` and the agent run config) so a
+	* later `resume(decisions)` can rebuild the run.
+	*
+	* The default `TPayload` is the SDK's `HumanInterruptPayload` union
+	* (`tool_approval` / `ask_user_question`), suitable for the common
+	* case where interrupts come from the built-in ToolNode or
+	* `askUserQuestion()` helper. Hosts that raise custom interrupts
+	* from custom graph nodes pass their own type — the SDK does not
+	* validate the runtime shape, it just transports whatever the
+	* `interrupt()` call carried. When in doubt, narrow with the
+	* `isToolApprovalInterrupt` / `isAskUserQuestionInterrupt` type
+	* guards (which accept `unknown`) before reading variant-specific
+	* fields.
+	*/
+	getInterrupt() {
+		return this._interrupt;
+	}
+	/**
+	* Returns the reason a hook halted the run via
+	* `preventContinuation: true`, or `undefined` if no hook halted.
+	*
+	* Hosts inspect this after `processStream` returns to distinguish a
+	* natural completion (`undefined`) from a hook-driven halt (a
+	* truthy string). Independent from `getInterrupt()` — a halted run
+	* has no interrupt; an interrupted run has no halt reason.
+	*/
+	getHaltReason() {
+		return this._haltedReason;
+	}
+	/**
+	* Resume a paused HITL run with the value the user (or whatever
+	* decided the interrupt) supplied. The default `TResume` covers the
+	* `tool_approval` interrupt (the common case): an array of decisions
+	* in `action_requests` order, or a record keyed by `tool_call_id`.
+	*
+	* For other interrupt types (e.g., `ask_user_question` →
+	* `AskUserQuestionResolution`, or any custom interrupt a host raises
+	* from a custom node), pass the type parameter and the SDK forwards
+	* the value through unchanged. LangGraph delivers it as the return
+	* value of the original `interrupt()` call inside the paused node.
+	*
+	* The host MUST construct this Run with the same `thread_id` and the
+	* same checkpointer as the original paused run; LangGraph rebuilds
+	* graph state from the checkpoint and re-enters the interrupted node
+	* from the start.
+	*/
+	/**
+	* Returns the per-Run file checkpointer when
+	* `toolExecution.local.fileCheckpointing === true` was set on the
+	* RunConfig. Hosts can capture extra paths or call `rewind()`
+	* directly. Returns undefined when checkpointing is disabled.
+	*
+	* Construction-time invariant: the checkpointer is shared across
+	* every ToolNode the graph compiles (single-agent and multi-agent),
+	* so a `rewind()` call here unwinds writes made by ANY agent in the
+	* run.
+	*/
+	getFileCheckpointer() {
+		return this.Graph?.getOrCreateFileCheckpointer();
+	}
+	/**
+	* Convenience wrapper that calls `rewind()` on the per-Run file
+	* checkpointer. Restores every file the local engine snapshotted
+	* during this Run to its pre-write content (and deletes any path
+	* that didn't exist before being created). Returns the count of
+	* paths processed; returns 0 when checkpointing is disabled.
+	*/
+	async rewindFiles() {
+		const cp = this.getFileCheckpointer();
+		return cp == null ? 0 : cp.rewind();
+	}
+	async resume(resumeValue, callerConfig, streamOptions) {
+		const interruptId = this._interrupt?.interruptId;
+		const scopedResume = typeof interruptId === "string" && interruptId.length > 0 && !isLangGraphResumeMapForInterrupt(resumeValue, interruptId) ? { [interruptId]: resumeValue } : resumeValue;
+		const resumeConfig = await this.resolveInterruptResumeConfig(callerConfig);
+		return this.processStream(new Command({ resume: scopedResume }), resumeConfig, streamOptions);
+	}
+	async resolveInterruptResumeConfig(callerConfig) {
+		const interrupt = this._interrupt;
+		const interruptId = interrupt?.interruptId;
+		const stateHistory = this.graphRunnable?.getStateHistory;
+		if (interrupt?.checkpointId != null && interrupt.checkpointId.length > 0) return {
+			...callerConfig,
+			configurable: {
+				...callerConfig.configurable,
+				checkpoint_id: interrupt.checkpointId,
+				...typeof interrupt.checkpointNs === "string" ? { checkpoint_ns: interrupt.checkpointNs } : {}
+			}
+		};
+		if (interrupt == null || typeof interruptId !== "string" || interruptId.length === 0 || typeof stateHistory !== "function") return callerConfig;
+		for await (const snapshot of stateHistory.call(this.graphRunnable, callerConfig)) {
+			const hasMatchingInterrupt = snapshot.tasks?.some((task) => task.interrupts?.some((interrupt) => interrupt.id === interruptId) === true) === true;
+			const checkpointConfigurable = snapshot.config?.configurable;
+			if (!hasMatchingInterrupt || checkpointConfigurable == null) continue;
+			const checkpointId = checkpointConfigurable.checkpoint_id;
+			const checkpointNs = checkpointConfigurable.checkpoint_ns;
+			if (typeof checkpointId === "string" && checkpointId.length > 0) {
+				this._interrupt = {
+					...interrupt,
+					checkpointId,
+					...typeof checkpointNs === "string" ? { checkpointNs } : {}
+				};
+				return {
+					...callerConfig,
+					configurable: {
+						...callerConfig.configurable,
+						checkpoint_id: checkpointId,
+						...typeof checkpointNs === "string" ? { checkpoint_ns: checkpointNs } : {}
+					}
+				};
+			}
+		}
+		return callerConfig;
+	}
+	createSystemCallback(clientCallbacks, key) {
+		return ((...args) => {
+			const clientCallback = clientCallbacks[key];
+			if (clientCallback && this.Graph) clientCallback(this.Graph, ...args);
+		});
+	}
+	getCallbacks(clientCallbacks) {
+		return {
+			["handleToolError"]: this.createSystemCallback(clientCallbacks, "handleToolError"),
+			["handleToolStart"]: this.createSystemCallback(clientCallbacks, "handleToolStart"),
+			["handleToolEnd"]: this.createSystemCallback(clientCallbacks, "handleToolEnd")
+		};
+	}
+	async generateTitle({ provider, inputText, contentParts, titlePrompt, clientOptions, chainOptions, skipLanguage, titleMethod = "completion", titlePromptTemplate }) {
+		let titleLangfuseHandler;
+		let titleLangfuseConfig;
+		let titleUserId;
+		let titleSessionId;
+		const titleContext = this.Graph == null ? void 0 : this.Graph.agentContexts.get(this.Graph.defaultAgentId);
+		const traceMetadata = createLangfuseTraceMetadata({
+			messageId: "title-" + this.id,
+			agentName: titleContext?.name
+		});
+		const titleRunName = getLangfuseTraceName(traceMetadata, "LibreChat Title");
+		if (chainOptions != null) {
+			titleUserId = typeof chainOptions.configurable?.user_id === "string" ? chainOptions.configurable.user_id : void 0;
+			titleSessionId = typeof chainOptions.configurable?.thread_id === "string" ? chainOptions.configurable.thread_id : void 0;
+			titleLangfuseConfig = resolveLangfuseConfig(this.langfuse, titleContext?.langfuse);
+			initializeLangfuseTracing(titleLangfuseConfig);
+			titleLangfuseHandler = createLangfuseHandler({
+				langfuse: titleLangfuseConfig,
+				userId: titleUserId,
+				sessionId: titleSessionId,
+				traceMetadata,
+				tags: ["librechat", "title"]
+			});
+			if (titleLangfuseHandler != null) chainOptions.callbacks = appendCallbacks(chainOptions.callbacks, [titleLangfuseHandler]);
+		}
+		const convoTemplate = PromptTemplate.fromTemplate(titlePromptTemplate ?? "User: {input}\nAI: {output}");
+		const response = contentParts.map((part) => {
+			if (part?.type === "text") return part.text;
+			return "";
+		}).join("\n");
+		const model = initializeModel({
+			provider,
+			clientOptions
+		});
+		if (isOpenAILike(provider) && (model instanceof ChatOpenAI || model instanceof AzureChatOpenAI)) {
+			model.temperature = clientOptions?.temperature;
+			model.topP = clientOptions?.topP;
+			model.frequencyPenalty = clientOptions?.frequencyPenalty;
+			model.presencePenalty = clientOptions?.presencePenalty;
+			model.n = clientOptions?.n;
+		}
+		const convoToTitleInput = new RunnableLambda({ func: (promptValue) => ({
+			convo: promptValue.value,
+			inputText,
+			skipLanguage
+		}) }).withConfig({ runName: "ConvoTransform" });
+		const titleChain = titleMethod === "completion" ? await createCompletionTitleRunnable(model, titlePrompt) : await createTitleRunnable(model, titlePrompt);
+		/** Pipes `convoTemplate` -> `transformer` -> `titleChain` */
+		const fullChain = convoTemplate.withConfig({ runName: "ConvoTemplate" }).pipe(convoToTitleInput).pipe(titleChain).withConfig({ runName: "TitleChain" });
+		const invokeConfig = Object.assign({}, chainOptions, {
+			run_id: this.id,
+			runId: this.id,
+			runName: chainOptions?.runName ?? titleRunName
+		});
+		const invokeTitleChain = (runtimeConfig) => withLangfuseAttributes({
+			langfuse: titleLangfuseConfig,
+			userId: titleUserId,
+			sessionId: titleSessionId,
+			traceName: runtimeConfig.runName ?? titleRunName,
+			traceMetadata,
+			tags: ["librechat", "title"]
+		}, () => fullChain.invoke({
+			input: inputText,
+			output: response
+		}, runtimeConfig));
+		try {
+			try {
+				return await withLangfuseToolOutputTracingConfig(this.langfuse, () => invokeTitleChain(invokeConfig), titleContext?.langfuse);
+			} catch (_e) {
+				const langfuseHandler = findCallback(invokeConfig.callbacks, isLangfuseCallbackHandler);
+				const { callbacks: _cb, ...rest } = invokeConfig;
+				const safeConfig = Object.assign({}, rest, { callbacks: langfuseHandler ? [langfuseHandler] : [] });
+				return await withLangfuseToolOutputTracingConfig(this.langfuse, () => invokeTitleChain(safeConfig), titleContext?.langfuse);
+			}
+		} finally {
+			await disposeLangfuseHandler(titleLangfuseHandler);
+		}
+	}
+};
 function findLastMessageOfType(messages, type) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i].getType() === type) {
-            return messages[i];
-        }
-    }
-    return undefined;
+	for (let i = messages.length - 1; i >= 0; i--) if (messages[i].getType() === type) return messages[i];
 }
 function extractPromptText(message) {
-    const content = message.content;
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (!Array.isArray(content)) {
-        return String(content);
-    }
-    const parts = [];
-    for (const block of content) {
-        if (typeof block === 'object' &&
-            'type' in block &&
-            block.type === 'text' &&
-            'text' in block &&
-            typeof block.text === 'string') {
-            parts.push(block.text);
-        }
-    }
-    return parts.join('\n');
+	const content = message.content;
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return String(content);
+	const parts = [];
+	for (const block of content) if (typeof block === "object" && "type" in block && block.type === "text" && "text" in block && typeof block.text === "string") parts.push(block.text);
+	return parts.join("\n");
 }
-
+//#endregion
 export { Run, defaultOmitOptions };
-//# sourceMappingURL=run.mjs.map
+
+//# sourceMappingURL=run.mjs.map