@librechat/agents 3.1.96 → 3.1.98

package/dist/cjs/graphs/Graph.cjs

@@ -54,7 +54,10 @@ var CloudflareSandboxTools = require('../tools/cloudflare/CloudflareSandboxTools
 var request = require('../llm/request.cjs');
 var init = require('../llm/init.cjs');
 var langfuse = require('../langfuse.cjs');
+var instrumentation = require('../instrumentation.cjs');
+var langfuseToolOutputTracing = require('../langfuseToolOutputTracing.cjs');
 var toolCache = require('../llm/openrouter/toolCache.cjs');
+var toolCache$1 = require('../llm/bedrock/toolCache.cjs');
 
 /* eslint-disable no-console */
 const { AGENT, TOOLS, SUMMARIZE } = _enum.GraphNodeKeys;
@@ -105,6 +108,10 @@ class Graph {
      * graph compiles.
      */
     toolOutputReferences;
+    /**
+     * Run-scoped Langfuse defaults. Per-agent config wins when present.
+     */
+    langfuse;
     /**
      * Run-scoped opt-in for eager event-driven tool execution. The stream
      * handler may prestart eligible event-driven tools; ToolNode later
@@ -325,10 +332,11 @@ class StandardGraph extends Graph {
     agentContexts = new Map();
     /** Default agent ID to use */
     defaultAgentId;
-    constructor({ runId, signal, agents, tokenCounter, indexTokenCountMap, calibrationRatio, }) {
+    constructor({ runId, signal, agents, langfuse, tokenCounter, indexTokenCountMap, calibrationRatio, }) {
         super();
         this.runId = runId;
         this.signal = signal;
+        this.langfuse = langfuse;
         if (agents.length === 0) {
             throw new Error('At least one agent configuration is required');
         }
@@ -559,6 +567,10 @@ class StandardGraph extends Graph {
     initializeTools({ currentTools, currentToolMap, agentContext, }) {
         const toolDefinitions = agentContext?.toolDefinitions;
         const eventDrivenMode = toolDefinitions != null && toolDefinitions.length > 0;
+        const traceToolNode = langfuseToolOutputTracing.shouldTraceToolNodeForLangfuse({
+            runLangfuse: this.langfuse,
+            agentLangfuse: agentContext?.langfuse,
+        });
         if (eventDrivenMode) {
             const schemaTools = schema.createSchemaOnlyTools(toolDefinitions);
             const toolDefMap = new Map(toolDefinitions.map((def) => [def.name, def]));
@@ -578,6 +590,9 @@ class StandardGraph extends Graph {
             const node = new ToolNode.ToolNode({
                 tools: allTools,
                 toolMap: allToolMap,
+                trace: traceToolNode,
+                runLangfuse: this.langfuse,
+                agentLangfuse: agentContext?.langfuse,
                 eventDrivenMode: true,
                 sessions: this.sessions,
                 toolDefinitions: toolDefMap,
@@ -616,6 +631,9 @@ class StandardGraph extends Graph {
         const node = new ToolNode.ToolNode({
             tools: allTraditionalTools,
             toolMap: traditionalToolMap,
+            trace: traceToolNode,
+            runLangfuse: this.langfuse,
+            agentLangfuse: agentContext?.langfuse,
             toolCallStepIds: this.toolCallStepIds,
             errorHandler: (data, metadata) => StandardGraph.handleToolCallErrorStatic(this, data, metadata),
             toolRegistry: agentContext?.toolRegistry,
@@ -703,6 +721,11 @@ class StandardGraph extends Graph {
                 toolsForBinding =
                     toolCache.partitionAndMarkOpenRouterToolCache(rawToolsForBinding, anthropicToolCache.makeIsDeferred(agentContext.toolDefinitions)) ?? rawToolsForBinding;
             }
+            else if (agentContext.provider === _enum.Providers.BEDROCK &&
+                agentContext.clientOptions?.promptCache === true) {
+                toolsForBinding =
+                    toolCache$1.partitionAndMarkBedrockToolCache(rawToolsForBinding, anthropicToolCache.makeIsDeferred(agentContext.toolDefinitions)) ?? rawToolsForBinding;
+            }
             let model = this.overrideModel ??
                 init.initializeModel({
                     tools: toolsForBinding,
@@ -975,41 +998,56 @@ class StandardGraph extends Graph {
                 messageCount: finalMessages.length,
                 provider: agentContext.provider,
             }, invokeMeta, { force: true });
-            const langfuseHandler = langfuse.createLangfuseHandler({
-                langfuse: agentContext.langfuse,
-                userId: config.configurable?.user_id,
-                sessionId: config.configurable?.thread_id,
-                traceMetadata: langfuse.createLangfuseTraceMetadata({
-                    messageId: this.runId,
-                    parentMessageId: config.configurable?.requestBody?.parentMessageId,
-                    agentId,
-                    agentName: agentContext.name,
-                }),
-                tags: ['librechat', 'agent'],
+            const langfuse$1 = langfuseToolOutputTracing.resolveLangfuseConfig(this.langfuse, agentContext.langfuse);
+            const traceMetadata = langfuse.createLangfuseTraceMetadata({
+                messageId: this.runId,
+                parentMessageId: config.configurable?.requestBody?.parentMessageId,
+                agentId,
+                agentName: agentContext.name,
             });
-            const invokeConfig = langfuseHandler
-                ? {
-                    ...config,
-                    callbacks: callbacks.appendCallbacks(config.callbacks, [langfuseHandler]),
+            let langfuseHandler;
+            let invokeConfig = {
+                ...config,
+                metadata: {
+                    ...(config.metadata ?? {}),
+                    ...traceMetadata,
+                },
+            };
+            instrumentation.initializeLangfuseTracing(langfuse$1);
+            if (callbacks.findCallback(config.callbacks, langfuse.isLangfuseCallbackHandler) == null) {
+                langfuseHandler = langfuse.createLangfuseHandler({
+                    langfuse: langfuse$1,
+                    userId: config.configurable?.user_id,
+                    sessionId: config.configurable?.thread_id,
+                    traceMetadata,
+                    tags: ['librechat', 'agent'],
+                });
+                if (langfuseHandler != null) {
+                    invokeConfig = {
+                        ...invokeConfig,
+                        callbacks: callbacks.appendCallbacks(invokeConfig.callbacks, [
+                            langfuseHandler,
+                        ]),
+                    };
                 }
-                : config;
+            }
             try {
-                result = await invoke.attemptInvoke({
+                result = await langfuseToolOutputTracing.withLangfuseToolOutputTracingConfig(this.langfuse, () => invoke.attemptInvoke({
                     model: (this.overrideModel ?? model),
                     messages: finalMessages,
                     provider: agentContext.provider,
                     context: this,
-                }, invokeConfig);
+                }, invokeConfig), agentContext.langfuse);
             }
             catch (primaryError) {
-                result = await invoke.tryFallbackProviders({
+                result = await langfuseToolOutputTracing.withLangfuseToolOutputTracingConfig(this.langfuse, () => invoke.tryFallbackProviders({
                     fallbacks,
                     tools: agentContext.tools,
                     messages: finalMessages,
                     config: invokeConfig,
                     primaryError,
                     context: this,
-                });
+                }), agentContext.langfuse);
             }
             finally {
                 await langfuse.disposeLangfuseHandler(langfuseHandler);
@@ -1167,6 +1205,7 @@ class StandardGraph extends Graph {
                     parentHandlerRegistry: getParentHandlerRegistry,
                     parentRunId: this.runId ?? '',
                     parentAgentId: agentContext.agentId,
+                    langfuse: this.langfuse,
                     tokenCounter: agentContext.tokenCounter,
                     maxDepth: effectiveSubagentDepth,
                     createChildGraph: (input) => {