@librechat/agents 3.2.21 → 3.2.32

package/dist/esm/graphs/Graph.mjs

@@ -11,51 +11,50 @@ import { partitionAndMarkAnthropicToolCache, makeIsDeferred } from '../messages/
 import { formatContentStrings } from '../messages/content.mjs';
 import { extractToolDiscoveries } from '../messages/tools.mjs';
 import { messagesStateReducer } from '../messages/reducer.mjs';
-import { GraphNodeKeys, ContentTypes, Providers, GraphEvents, StepTypes } from '../common/enum.mjs';
+import { shouldTraceToolNodeForLangfuse, resolveLangfuseConfig, withLangfuseToolOutputTracingConfig } from '../langfuseToolOutputTracing.mjs';
+import { createLangfuseTraceMetadata, createLangfuseHandler, disposeLangfuseHandler, isLangfuseCallbackHandler } from '../langfuse.mjs';
 import { resetIfNotEmpty, joinKeys } from '../utils/graph.mjs';
 import { isAnthropicLike, isOpenAILike, isGoogleLike } from '../utils/llm.mjs';
 import '../stream.mjs';
+import { GraphNodeKeys, ContentTypes, Providers, GraphEvents, StepTypes } from '../common/enum.mjs';
 import { sleep } from '../utils/run.mjs';
 import 'ai-tokenizer';
 import 'zod-to-json-schema';
-import { resolveSubagentConfigs, SubagentExecutor } from '../tools/subagent/SubagentExecutor.mjs';
-import { buildSubagentToolParams } from '../tools/SubagentTool.mjs';
+import { findCallback, appendCallbacks } from '../utils/callbacks.mjs';
+import { partitionAndMarkOpenRouterToolCache } from '../llm/openrouter/toolCache.mjs';
 import { ToolNode, toolsCondition } from '../tools/ToolNode.mjs';
+import { createLocalCodingToolBundle } from '../tools/local/LocalCodingTools.mjs';
+import { resolveSubagentConfigs, SubagentExecutor } from '../tools/subagent/SubagentExecutor.mjs';
 import { ToolOutputReferenceRegistry } from '../tools/toolOutputReferences.mjs';
+import { partitionAndMarkBedrockToolCache } from '../llm/bedrock/toolCache.mjs';
 import { emitAgentLog, safeDispatchCustomEvent } from '../utils/events.mjs';
+import 'path';
+import '../tools/cloudflare/CloudflareProgrammaticToolCalling.mjs';
+import 'stream';
+import 'events';
+import '../tools/local/LocalExecutionEngine.mjs';
+import { createCloudflareCodingToolBundle } from '../tools/cloudflare/CloudflareSandboxTools.mjs';
 import { attemptInvoke, tryFallbackProviders } from '../llm/invoke.mjs';
+import { buildSubagentToolParams } from '../tools/SubagentTool.mjs';
+import { initializeLangfuseTracing } from '../instrumentation.mjs';
 import { shouldTriggerSummarization } from '../summarization/index.mjs';
-import { createSummarizeNode } from '../summarization/node.mjs';
-import { findCallback, appendCallbacks } from '../utils/callbacks.mjs';
-import { createSchemaOnlyTools } from '../tools/schema.mjs';
-import { AgentContext } from '../agents/AgentContext.mjs';
-import { createFakeStreamingLLM } from '../llm/fake.mjs';
-import { handleToolCalls } from '../tools/handlers.mjs';
 import '../tools/local/CompileCheckTool.mjs';
-import 'path';
 import 'fs/promises';
-import { createLocalCodingToolBundle } from '../tools/local/LocalCodingTools.mjs';
-import '../tools/local/LocalExecutionEngine.mjs';
-import '../tools/CodeExecutor.mjs';
 import '../tools/BashExecutor.mjs';
-import 'crypto';
+import '../tools/CodeExecutor.mjs';
 import 'http';
-import '../hooks/createWorkspacePolicyHook.mjs';
+import 'crypto';
 import '../tools/ProgrammaticToolCalling.mjs';
 import '../tools/BashProgrammaticToolCalling.mjs';
+import '../hooks/createWorkspacePolicyHook.mjs';
 import { resolveLocalToolsForBinding } from '../tools/local/resolveLocalExecutionTools.mjs';
-import '../tools/local/attachments.mjs';
-import '../tools/cloudflare/CloudflareProgrammaticToolCalling.mjs';
-import 'events';
-import 'stream';
-import { createCloudflareCodingToolBundle } from '../tools/cloudflare/CloudflareSandboxTools.mjs';
+import { createSummarizeNode } from '../summarization/node.mjs';
+import { createSchemaOnlyTools } from '../tools/schema.mjs';
+import { AgentContext } from '../agents/AgentContext.mjs';
+import { createFakeStreamingLLM } from '../llm/fake.mjs';
+import { handleToolCalls } from '../tools/handlers.mjs';
 import { isThinkingEnabled } from '../llm/request.mjs';
 import { initializeModel } from '../llm/init.mjs';
-import { createLangfuseTraceMetadata, createLangfuseHandler, disposeLangfuseHandler, isLangfuseCallbackHandler } from '../langfuse.mjs';
-import { initializeLangfuseTracing } from '../instrumentation.mjs';
-import { shouldTraceToolNodeForLangfuse, resolveLangfuseConfig, withLangfuseToolOutputTracingConfig } from '../langfuseToolOutputTracing.mjs';
-import { partitionAndMarkOpenRouterToolCache } from '../llm/openrouter/toolCache.mjs';
-import { partitionAndMarkBedrockToolCache } from '../llm/bedrock/toolCache.mjs';
 
 /* eslint-disable no-console */
 const { AGENT, TOOLS, SUMMARIZE } = GraphNodeKeys;
@@ -104,7 +103,23 @@ function getResponseReasoningContent({ responseMessage, reasoningKey, }) {
     }
     return getReasoningDetailsText(additionalKwargs.reasoning_details);
 }
-function getTextMessageDeltaContent(content) {
+function isTextMessageContentPart(contentPart) {
+    return (typeof contentPart === 'object' &&
+        'type' in contentPart &&
+        typeof contentPart.type === 'string' &&
+        contentPart.type.startsWith('text'));
+}
+function isGoogleServerSideToolMessageContentPart(contentPart) {
+    return (typeof contentPart === 'object' &&
+        'type' in contentPart &&
+        (contentPart.type === 'toolCall' || contentPart.type === 'toolResponse'));
+}
+function hasGoogleServerSideToolDeltaContent(provider, content) {
+    return (isGoogleLike(provider) &&
+        Array.isArray(content) &&
+        content.some((contentPart) => isGoogleServerSideToolMessageContentPart(contentPart)));
+}
+function getMessageDeltaContent(provider, content) {
     if (content == null) {
         return undefined;
     }
@@ -116,24 +131,91 @@ function getTextMessageDeltaContent(content) {
     if (content.length === 0) {
         return undefined;
     }
-    if (!content.every((contentPart) => typeof contentPart === 'object' &&
-        'type' in contentPart &&
-        typeof contentPart.type === 'string' &&
-        contentPart.type.startsWith('text'))) {
+    const hasGoogleServerSideToolPart = isGoogleLike(provider) &&
+        content.some((contentPart) => isGoogleServerSideToolMessageContentPart(contentPart));
+    if (content.every((contentPart) => isTextMessageContentPart(contentPart))) {
+        return content;
+    }
+    if (!hasGoogleServerSideToolPart) {
         return undefined;
     }
-    return content;
+    const messageContent = content.filter((contentPart) => isTextMessageContentPart(contentPart) ||
+        isGoogleServerSideToolMessageContentPart(contentPart));
+    return messageContent.length > 0
+        ? messageContent
+        : undefined;
 }
-async function dispatchTextMessageContent({ graph, stepKey, content, metadata, }) {
-    const messageId = getMessageId(stepKey, graph) ?? '';
-    if (!messageId) {
+function hasTextDeltaContent(content) {
+    if (content == null) {
         return false;
     }
+    return content.some((contentPart) => {
+        if (contentPart.type?.startsWith(ContentTypes.TEXT) !== true) {
+            return false;
+        }
+        const text = contentPart.text;
+        return typeof text === 'string' && text !== '';
+    });
+}
+function hasReasoningDeltaContent(content) {
+    if (content == null) {
+        return false;
+    }
+    return content.some((contentPart) => contentPart.type === ContentTypes.THINK && contentPart.think !== '');
+}
+function getCurrentStepIds({ graph, metadata, }) {
+    const baseStepKey = graph.getStepBaseKey(metadata);
+    const currentStepIds = [];
+    for (const [stepKey, stepIds] of graph.stepKeyIds) {
+        if (stepKey !== baseStepKey && !stepKey.startsWith(`${baseStepKey}_`)) {
+            continue;
+        }
+        currentStepIds.push(...stepIds);
+    }
+    return currentStepIds;
+}
+function hasCurrentTextDeltaStep({ graph, metadata, }) {
+    return getCurrentStepIds({ graph, metadata }).some((stepId) => graph.messageStepHasTextDeltas.has(stepId));
+}
+function hasCurrentReasoningDeltaStep({ graph, metadata, }) {
+    return getCurrentStepIds({ graph, metadata }).some((stepId) => graph.reasoningStepHasDeltas.has(stepId));
+}
+function clearCurrentDeltaStepMarkers({ graph, metadata, }) {
+    for (const stepId of getCurrentStepIds({ graph, metadata })) {
+        graph.messageStepHasTextDeltas.delete(stepId);
+        graph.reasoningStepHasDeltas.delete(stepId);
+    }
+}
+async function dispatchMessageCreationStep({ graph, stepKey, messageId, metadata, }) {
     await graph.dispatchRunStep(stepKey, {
         type: StepTypes.MESSAGE_CREATION,
         message_creation: { message_id: messageId },
     }, metadata);
-    const stepId = graph.getStepIdByKey(stepKey);
+    return graph.getStepIdByKey(stepKey);
+}
+async function dispatchTextMessageContent({ graph, stepKey, provider, content, metadata, }) {
+    const messageId = getMessageId(stepKey, graph) ?? '';
+    if (!messageId) {
+        return false;
+    }
+    if (hasGoogleServerSideToolDeltaContent(provider, content)) {
+        for (const contentPart of content) {
+            const stepId = await dispatchMessageCreationStep({
+                graph,
+                stepKey,
+                messageId,
+                metadata,
+            });
+            await graph.dispatchMessageDelta(stepId, { content: [contentPart] }, metadata);
+        }
+        return true;
+    }
+    const stepId = await dispatchMessageCreationStep({
+        graph,
+        stepKey,
+        messageId,
+        metadata,
+    });
     await graph.dispatchMessageDelta(stepId, { content }, metadata);
     return true;
 }
@@ -170,7 +252,18 @@ function markPostReasoningContent(agentContext) {
     agentContext.tokenTypeSwitch = 'content';
     agentContext.reasoningTransitionCount++;
 }
+function getDispatchableFinalReasoningContent({ agentContext, responseReasoningContent, hasStreamedTextDeltaStep, hasStreamedReasoningDeltaStep, }) {
+    if (responseReasoningContent == null || hasStreamedReasoningDeltaStep) {
+        return undefined;
+    }
+    if (agentContext.provider === Providers.OPENROUTER &&
+        hasStreamedTextDeltaStep) {
+        return undefined;
+    }
+    return responseReasoningContent;
+}
 class Graph {
+    messageStepHasTextDeltas = new Set();
     messageStepHasToolCalls = new Map();
     messageIdsByStepKey = new Map();
     prelimMessageIdsByStepKey = new Map();
@@ -185,6 +278,7 @@ class Graph {
      * the same step are scoped to the active custom event dispatch.
      */
     handlerDispatchedStepIds = new Set();
+    reasoningStepHasDeltas = new Set();
     handlerDispatchedEventCounts = new Map();
     signal;
     /** Set of invoked tool call IDs from non-message run steps completed mid-run, if any */
@@ -257,6 +351,8 @@ class Graph {
         this.stepKeyIds = new Map();
         this.toolCallStepIds.clear();
         this.messageIdsByStepKey = new Map();
+        this.messageStepHasTextDeltas = new Set();
+        this.reasoningStepHasDeltas = new Set();
         this.messageStepHasToolCalls = new Map();
         this.prelimMessageIdsByStepKey = new Map();
         this.invokedToolIds = undefined;
@@ -477,6 +573,8 @@ class StandardGraph extends Graph {
         this.handlerDispatchedEventCounts = resetIfNotEmpty(this.handlerDispatchedEventCounts, new Map());
         this.messageIdsByStepKey = resetIfNotEmpty(this.messageIdsByStepKey, new Map());
         this.messageStepHasToolCalls = resetIfNotEmpty(this.messageStepHasToolCalls, new Map());
+        this.messageStepHasTextDeltas = resetIfNotEmpty(this.messageStepHasTextDeltas, new Set());
+        this.reasoningStepHasDeltas = resetIfNotEmpty(this.reasoningStepHasDeltas, new Set());
         this.prelimMessageIdsByStepKey = resetIfNotEmpty(this.prelimMessageIdsByStepKey, new Map());
         this.invokedToolIds = resetIfNotEmpty(this.invokedToolIds, undefined);
         for (const context of this.agentContexts.values()) {
@@ -524,6 +622,15 @@ class StandardGraph extends Graph {
         }
         return agentContext;
     }
+    getStepBaseKey(metadata) {
+        if (!metadata)
+            return '';
+        const keyList = this.getInvocationKeyList(metadata);
+        if (this.checkKeyList(keyList)) {
+            throw new Error('Missing metadata');
+        }
+        return joinKeys(keyList);
+    }
     getStepKey(metadata) {
         if (!metadata)
             return '';
@@ -562,6 +669,25 @@ class StandardGraph extends Graph {
     getKeyList(metadata) {
         if (!metadata)
             return [];
+        const keyList = this.getInvocationKeyList(metadata);
+        const agentContext = this.getAgentContext(metadata);
+        if (agentContext.currentTokenType === ContentTypes.THINK ||
+            agentContext.currentTokenType === 'think_and_text') {
+            keyList.push('reasoning');
+        }
+        else if (agentContext.tokenTypeSwitch === 'content') {
+            keyList.push(`post-reasoning-${agentContext.reasoningTransitionCount}`);
+        }
+        return keyList;
+    }
+    getInvocationKeyList(metadata) {
+        const keyList = this.getBaseKeyList(metadata);
+        if (this.invokedToolIds != null && this.invokedToolIds.size > 0) {
+            keyList.push(this.invokedToolIds.size + '');
+        }
+        return keyList;
+    }
+    getBaseKeyList(metadata) {
         const configurable = this.config?.configurable;
         const runId = metadata.run_id ??
             configurable?.run_id ??
@@ -579,17 +705,6 @@ class StandardGraph extends Graph {
             metadata.langgraph_step,
             checkpointNs,
         ];
-        const agentContext = this.getAgentContext(metadata);
-        if (agentContext.currentTokenType === ContentTypes.THINK ||
-            agentContext.currentTokenType === 'think_and_text') {
-            keyList.push('reasoning');
-        }
-        else if (agentContext.tokenTypeSwitch === 'content') {
-            keyList.push(`post-reasoning-${agentContext.reasoningTransitionCount}`);
-        }
-        if (this.invokedToolIds != null && this.invokedToolIds.size > 0) {
-            keyList.push(this.invokedToolIds.size + '');
-        }
         return keyList;
     }
     checkKeyList(keyList) {
@@ -701,6 +816,7 @@ class StandardGraph extends Graph {
                 sessions: this.sessions,
                 toolDefinitions: toolDefMap,
                 agentId: agentContext?.agentId,
+                executingAgentId: agentContext?.agentId,
                 toolCallStepIds: this.toolCallStepIds,
                 toolRegistry: agentContext?.toolRegistry,
                 hookRegistry: this.hookRegistry,
@@ -738,6 +854,10 @@ class StandardGraph extends Graph {
             trace: traceToolNode,
             runLangfuse: this.langfuse,
             agentLangfuse: agentContext?.langfuse,
+            // `agentId` is intentionally left unset on this path (it is the
+            // subagent-scope marker); `executingAgentId` always identifies the owning
+            // agent so hooks can attribute the batch even at the top level.
+            executingAgentId: agentContext?.agentId,
             toolCallStepIds: this.toolCallStepIds,
             errorHandler: (data, metadata) => StandardGraph.handleToolCallErrorStatic(this, data, metadata),
             toolRegistry: agentContext?.toolRegistry,
@@ -1135,6 +1255,7 @@ class StandardGraph extends Graph {
                     };
                 }
             }
+            const metadata = config.metadata;
             try {
                 result = await withLangfuseToolOutputTracingConfig(this.langfuse, () => attemptInvoke({
                     model: (this.overrideModel ?? model),
@@ -1144,6 +1265,10 @@ class StandardGraph extends Graph {
                 }, invokeConfig), agentContext.langfuse);
             }
             catch (primaryError) {
+                clearCurrentDeltaStepMarkers({
+                    graph: this,
+                    metadata,
+                });
                 result = await withLangfuseToolOutputTracingConfig(this.langfuse, () => tryFallbackProviders({
                     fallbacks,
                     tools: agentContext.tools,
@@ -1178,28 +1303,42 @@ class StandardGraph extends Graph {
             const toolCalls = responseMessage
                 ?.tool_calls;
             const hasToolCalls = Array.isArray(toolCalls) && toolCalls.length > 0;
-            const metadata = config.metadata;
             const responseReasoningContent = getResponseReasoningContent({
                 responseMessage: responseMessage,
                 reasoningKey: agentContext.reasoningKey,
             });
-            const textMessageContent = getTextMessageDeltaContent(responseMessage?.content);
+            const textMessageContent = getMessageDeltaContent(agentContext.provider, responseMessage?.content);
+            const hasStreamedTextDeltaStep = hasCurrentTextDeltaStep({
+                graph: this,
+                metadata,
+            });
+            const hasStreamedReasoningDeltaStep = hasCurrentReasoningDeltaStep({
+                graph: this,
+                metadata,
+            });
+            const dispatchableFinalReasoningContent = getDispatchableFinalReasoningContent({
+                agentContext,
+                responseReasoningContent,
+                hasStreamedTextDeltaStep,
+                hasStreamedReasoningDeltaStep,
+            });
             if (hasToolCalls) {
-                const dispatchedReasoning = responseReasoningContent != null &&
+                const dispatchedReasoning = dispatchableFinalReasoningContent != null &&
                     (await dispatchReasoningContent({
                         graph: this,
                         agentContext,
-                        reasoningContent: responseReasoningContent,
+                        reasoningContent: dispatchableFinalReasoningContent,
                         metadata,
                     }));
                 if (dispatchedReasoning) {
                     markPostReasoningContent(agentContext);
                 }
-                if (textMessageContent != null) {
+                if (textMessageContent != null && !hasStreamedTextDeltaStep) {
                     const stepKey = this.getStepKey(metadata);
                     const dispatchedText = await dispatchTextMessageContent({
                         graph: this,
                         stepKey,
+                        provider: agentContext.provider,
                         content: textMessageContent,
                         metadata,
                     });
@@ -1215,21 +1354,22 @@ class StandardGraph extends Graph {
              * this a no-op when the streaming path already handled the same step.
              */
             if (!hasToolCalls && responseMessage != null) {
-                const dispatchedReasoning = responseReasoningContent != null &&
+                const dispatchedReasoning = dispatchableFinalReasoningContent != null &&
                     (await dispatchReasoningContent({
                         graph: this,
                         agentContext,
-                        reasoningContent: responseReasoningContent,
+                        reasoningContent: dispatchableFinalReasoningContent,
                         metadata,
                     }));
                 if (dispatchedReasoning && textMessageContent != null) {
                     markPostReasoningContent(agentContext);
                 }
-                if (textMessageContent != null) {
+                if (textMessageContent != null && !hasStreamedTextDeltaStep) {
                     const stepKey = this.getStepKey(metadata);
                     await dispatchTextMessageContent({
                         graph: this,
                         stepKey,
+                        provider: agentContext.provider,
                         content: textMessageContent,
                         metadata,
                     });
@@ -1646,6 +1786,9 @@ class StandardGraph extends Graph {
             id,
             delta,
         };
+        if (hasTextDeltaContent(delta.content)) {
+            this.messageStepHasTextDeltas.add(id);
+        }
         const handler = this.handlerRegistry?.getHandler(GraphEvents.ON_MESSAGE_DELTA);
         if (handler) {
             await handler.handle(GraphEvents.ON_MESSAGE_DELTA, messageDelta, metadata, this);
@@ -1669,6 +1812,9 @@ class StandardGraph extends Graph {
             id: stepId,
             delta,
         };
+        if (hasReasoningDeltaContent(delta.content)) {
+            this.reasoningStepHasDeltas.add(stepId);
+        }
         const handler = this.handlerRegistry?.getHandler(GraphEvents.ON_REASONING_DELTA);
         if (handler) {
             await handler.handle(GraphEvents.ON_REASONING_DELTA, reasoningDelta, metadata, this);