@librechat/agents 3.1.96 → 3.1.98

package/dist/esm/run.mjs

@@ -1,8 +1,8 @@
-import './instrumentation.mjs';
+import { initializeLangfuseTracing } from './instrumentation.mjs';
 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 { MemorySaver, isInterrupted, INTERRUPT, Command } from '@langchain/langgraph';
+import { MemorySaver, Command, isInterrupted, INTERRUPT } from '@langchain/langgraph';
 import { HumanMessage } from '@langchain/core/messages';
 import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 import { createCompletionTitleRunnable, createTitleRunnable } from './utils/title.mjs';
@@ -16,7 +16,8 @@ import { executeHooks } from './hooks/executeHooks.mjs';
 import './hooks/createWorkspacePolicyHook.mjs';
 import { isOpenAILike } from './utils/llm.mjs';
 import { appendCallbacks, findCallback } from './utils/callbacks.mjs';
-import { hasLangfuseEnvConfig, hasExplicitLangfuseConfig, createLangfuseTraceMetadata, createLegacyLangfuseHandler, getLangfuseTraceName, createLangfuseHandler, isLangfuseCallbackHandler, disposeLangfuseHandler } from './langfuse.mjs';
+import { createLangfuseTraceMetadata, createLangfuseHandler, getLangfuseTraceName, disposeLangfuseHandler, isLangfuseCallbackHandler } from './langfuse.mjs';
+import { resolveLangfuseConfig, withLangfuseToolOutputTracingConfig } from './langfuseToolOutputTracing.mjs';
 
 // src/run.ts
 const defaultOmitOptions = new Set([
@@ -71,6 +72,7 @@ class Run {
     handlerRegistry;
     hookRegistry;
     humanInTheLoop;
+    langfuse;
     toolOutputReferences;
     eagerEventToolExecution;
     toolExecution;
@@ -110,6 +112,7 @@ class Run {
         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;
@@ -168,6 +171,7 @@ class Run {
             signal,
             runId: this.id,
             agents: [agentConfig],
+            langfuse: this.langfuse,
             tokenCounter: this.tokenCounter,
             indexTokenCountMap: this.indexTokenCountMap,
             calibrationRatio: this.calibrationRatio,
@@ -188,6 +192,7 @@ class Run {
             runId: this.id,
             agents,
             edges,
+            langfuse: this.langfuse,
             tokenCounter: this.tokenCounter,
             indexTokenCountMap: this.indexTokenCountMap,
             calibrationRatio: this.calibrationRatio,
@@ -421,6 +426,77 @@ class Run {
             }
         };
     }
+    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.');
@@ -428,6 +504,8 @@ class 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
@@ -454,7 +532,7 @@ class Run {
          * boundary.
          */
         if (!isResume) {
-            this.Graph.resetValues(streamOptions?.keepContent);
+            graph.resetValues(streamOptions?.keepContent);
         }
         this._interrupt = undefined;
         this._haltedReason = undefined;
@@ -469,28 +547,31 @@ class Run {
         });
         customHandler.awaitHandlers = true;
         config.callbacks = appendCallbacks(config.callbacks, streamCallbacks ? [streamCallbacks, customHandler] : [customHandler]);
-        if (hasLangfuseEnvConfig() &&
-            !hasExplicitLangfuseConfig(this.Graph.agentContexts.values())) {
-            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 primaryContext = this.Graph.agentContexts.get(this.Graph.defaultAgentId);
-            const traceMetadata = createLangfuseTraceMetadata({
-                messageId: this.id,
-                parentMessageId: config.configurable?.requestBody?.parentMessageId,
-                agentName: primaryContext?.name,
-            });
-            const handler = createLegacyLangfuseHandler({
-                userId,
-                sessionId,
-                traceMetadata,
-                tags: ['librechat', 'agent'],
-            });
+        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 streamLangfuseConfig = this.getStreamLangfuseConfig(graph);
+        initializeLangfuseTracing(streamLangfuseConfig);
+        const langfuseHandler = createLangfuseHandler({
+            langfuse: streamLangfuseConfig,
+            userId,
+            sessionId,
+            traceMetadata,
+            tags: ['librechat', 'agent'],
+        });
+        if (langfuseHandler != null) {
             config.runName = config.runName ?? getLangfuseTraceName(traceMetadata);
-            config.callbacks = appendCallbacks(config.callbacks, [handler]);
+            config.callbacks = appendCallbacks(config.callbacks, [langfuseHandler]);
         }
         if (!this.id) {
             throw new Error('Run ID not provided');
@@ -506,24 +587,6 @@ class Run {
                 return undefined;
             }
         }
-        /**
-         * `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 = this.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,
-        });
         /**
          * Tracks whether the stream loop threw. Used by the `finally`
          * block to decide whether to honor the interrupt-preservation
@@ -534,7 +597,25 @@ class Run {
          * preserving session hooks would leak them into the next run.
          */
         let streamThrew = false;
-        try {
+        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;
@@ -619,8 +700,8 @@ class Run {
                         hook_event_name: 'Stop',
                         runId: this.id,
                         threadId,
-                        agentId: this.Graph.defaultAgentId,
-                        messages: this.Graph.getRunMessages() ?? stateInputs?.messages ?? [],
+                        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,
@@ -628,6 +709,9 @@ class Run {
                     /* Stop hook errors must not masquerade as stream failures */
                 });
             }
+        };
+        try {
+            await withLangfuseToolOutputTracingConfig(streamLangfuseConfig, consumeStream, this.getStreamToolOutputTracingLangfuseConfig(graph));
         }
         catch (err) {
             streamThrew = true;
@@ -665,9 +749,7 @@ class Run {
              * expected, sessions must drop). Every state where no resume
              * is expected clears.
              */
-            if (this._interrupt == null ||
-                this._haltedReason != null ||
-                streamThrew) {
+            if (this.shouldClearHookSession(streamThrew)) {
                 this.hookRegistry?.clearSession(this.id);
             }
             /**
@@ -679,6 +761,7 @@ class Run {
              * 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` →
@@ -726,7 +809,7 @@ class Run {
              * Run from scratch) is a separate concern; see
              * `HumanInTheLoopConfig` JSDoc.
              */
-            const awaitingResume = this._interrupt != null && this._haltedReason == null && !streamThrew;
+            const awaitingResume = this.isAwaitingResume(streamThrew);
             if (!this.skipCleanup && !awaitingResume) {
                 this.Graph.clearHeavyState();
             }
@@ -905,25 +988,15 @@ class Run {
             const sessionId = typeof chainOptions.configurable?.thread_id === 'string'
                 ? chainOptions.configurable.thread_id
                 : undefined;
-            const hasExplicitLangfuse = this.Graph != null &&
-                hasExplicitLangfuseConfig(this.Graph.agentContexts.values());
-            if (titleContext?.langfuse != null) {
-                titleLangfuseHandler = createLangfuseHandler({
-                    langfuse: titleContext.langfuse,
-                    userId,
-                    sessionId,
-                    traceMetadata,
-                    tags: ['librechat', 'title'],
-                });
-            }
-            else if (hasLangfuseEnvConfig() && !hasExplicitLangfuse) {
-                titleLangfuseHandler = createLegacyLangfuseHandler({
-                    userId,
-                    sessionId,
-                    traceMetadata,
-                    tags: ['librechat', 'title'],
-                });
-            }
+            const titleLangfuseConfig = resolveLangfuseConfig(this.langfuse, titleContext?.langfuse);
+            initializeLangfuseTracing(titleLangfuseConfig);
+            titleLangfuseHandler = createLangfuseHandler({
+                langfuse: titleLangfuseConfig,
+                userId,
+                sessionId,
+                traceMetadata,
+                tags: ['librechat', 'title'],
+            });
             if (titleLangfuseHandler != null) {
                 chainOptions.callbacks = appendCallbacks(chainOptions.callbacks, [
                     titleLangfuseHandler,
@@ -976,7 +1049,7 @@ class Run {
         });
         try {
             try {
-                return await fullChain.invoke({ input: inputText, output: response }, invokeConfig);
+                return await withLangfuseToolOutputTracingConfig(this.langfuse, () => fullChain.invoke({ input: inputText, output: response }, invokeConfig), titleContext?.langfuse);
             }
             catch (_e) {
                 // Fallback: strip callbacks to avoid EventStream tracer errors in certain environments
@@ -986,7 +1059,7 @@ class Run {
                 const safeConfig = Object.assign({}, rest, {
                     callbacks: langfuseHandler ? [langfuseHandler] : [],
                 });
-                return await fullChain.invoke({ input: inputText, output: response }, safeConfig);
+                return await withLangfuseToolOutputTracingConfig(this.langfuse, () => fullChain.invoke({ input: inputText, output: response }, safeConfig), titleContext?.langfuse);
             }
         }
         finally {