@librechat/agents 3.2.0 → 3.2.2

package/dist/esm/graphs/Graph.mjs

@@ -11,7 +11,7 @@ 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, StepTypes, GraphEvents } from '../common/enum.mjs';
+import { GraphNodeKeys, ContentTypes, Providers, GraphEvents, StepTypes } from '../common/enum.mjs';
 import { resetIfNotEmpty, joinKeys } from '../utils/graph.mjs';
 import { isAnthropicLike, isOpenAILike, isGoogleLike } from '../utils/llm.mjs';
 import '../stream.mjs';
@@ -64,6 +64,112 @@ const CALIBRATION_VARIANCE_THRESHOLD = 0.15;
 function getHandlerDispatchedEventKey(eventName, stepId) {
     return `${eventName}:${stepId}`;
 }
+function getReasoningText(value) {
+    if (typeof value === 'string') {
+        return value !== '' ? value : undefined;
+    }
+    const summaryText = value?.summary
+        ?.map((summary) => summary.text ?? '')
+        .filter((text) => text !== '')
+        .join('');
+    return summaryText != null && summaryText !== '' ? summaryText : undefined;
+}
+function getReasoningDetailsText(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const reasoningText = value
+        .filter((detail) => detail.type === 'reasoning.text')
+        .map((detail) => detail.text ?? '')
+        .filter((text) => text !== '')
+        .join('');
+    return reasoningText !== '' ? reasoningText : undefined;
+}
+function getResponseReasoningContent({ responseMessage, reasoningKey, }) {
+    const additionalKwargs = responseMessage?.additional_kwargs;
+    if (additionalKwargs == null) {
+        return undefined;
+    }
+    const keyedReasoning = getReasoningText(additionalKwargs[reasoningKey]);
+    if (keyedReasoning != null) {
+        return keyedReasoning;
+    }
+    const reasoningContent = getReasoningText(additionalKwargs.reasoning_content);
+    if (reasoningContent != null) {
+        return reasoningContent;
+    }
+    const reasoning = getReasoningText(additionalKwargs.reasoning);
+    if (reasoning != null) {
+        return reasoning;
+    }
+    return getReasoningDetailsText(additionalKwargs.reasoning_details);
+}
+function getTextMessageDeltaContent(content) {
+    if (content == null) {
+        return undefined;
+    }
+    if (typeof content === 'string') {
+        return content !== ''
+            ? [{ type: ContentTypes.TEXT, text: content }]
+            : undefined;
+    }
+    if (content.length === 0) {
+        return undefined;
+    }
+    if (!content.every((contentPart) => typeof contentPart === 'object' &&
+        'type' in contentPart &&
+        typeof contentPart.type === 'string' &&
+        contentPart.type.startsWith('text'))) {
+        return undefined;
+    }
+    return content;
+}
+async function dispatchTextMessageContent({ graph, stepKey, content, metadata, }) {
+    const messageId = getMessageId(stepKey, graph) ?? '';
+    if (!messageId) {
+        return false;
+    }
+    await graph.dispatchRunStep(stepKey, {
+        type: StepTypes.MESSAGE_CREATION,
+        message_creation: { message_id: messageId },
+    }, metadata);
+    const stepId = graph.getStepIdByKey(stepKey);
+    await graph.dispatchMessageDelta(stepId, { content }, metadata);
+    return true;
+}
+async function dispatchReasoningContent({ graph, agentContext, reasoningContent, metadata, }) {
+    const previousTokenType = agentContext.currentTokenType;
+    const previousTokenTypeSwitch = agentContext.tokenTypeSwitch;
+    const previousTransitionCount = agentContext.reasoningTransitionCount;
+    agentContext.currentTokenType = ContentTypes.THINK;
+    agentContext.tokenTypeSwitch = 'reasoning';
+    const stepKey = graph.getStepKey(metadata);
+    const messageId = getMessageId(stepKey, graph) ?? '';
+    if (!messageId) {
+        agentContext.currentTokenType = previousTokenType;
+        agentContext.tokenTypeSwitch = previousTokenTypeSwitch;
+        agentContext.reasoningTransitionCount = previousTransitionCount;
+        return false;
+    }
+    await graph.dispatchRunStep(stepKey, {
+        type: StepTypes.MESSAGE_CREATION,
+        message_creation: { message_id: messageId },
+    }, metadata);
+    const stepId = graph.getStepIdByKey(stepKey);
+    await graph.dispatchReasoningDelta(stepId, {
+        content: [{ type: ContentTypes.THINK, think: reasoningContent }],
+    }, metadata);
+    return true;
+}
+function markPostReasoningContent(agentContext) {
+    if (agentContext.tokenTypeSwitch !== 'reasoning' ||
+        agentContext.currentTokenType === ContentTypes.TEXT) {
+        return;
+    }
+    agentContext.currentTokenType = ContentTypes.TEXT;
+    agentContext.tokenTypeSwitch = 'content';
+    agentContext.reasoningTransitionCount++;
+}
 class Graph {
     messageStepHasToolCalls = new Map();
     messageIdsByStepKey = new Map();
@@ -1072,80 +1178,61 @@ 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);
             if (hasToolCalls) {
-                const metadata = config.metadata;
-                const stepKey = this.getStepKey(metadata);
-                const content = responseMessage?.content;
-                const hasTextContent = content != null &&
-                    (typeof content === 'string'
-                        ? content !== ''
-                        : Array.isArray(content) && content.length > 0);
-                /**
-                 * Dispatch text content BEFORE creating TOOL_CALLS steps.
-                 * getMessageId returns a new ID only on the first call for a step key;
-                 * if the for-await consumer already claimed it, this is a no-op.
-                 */
-                if (hasTextContent) {
-                    const messageId = getMessageId(stepKey, this) ?? '';
-                    if (messageId) {
-                        await this.dispatchRunStep(stepKey, {
-                            type: StepTypes.MESSAGE_CREATION,
-                            message_creation: { message_id: messageId },
-                        }, metadata);
-                        const stepId = this.getStepIdByKey(stepKey);
-                        if (typeof content === 'string') {
-                            await this.dispatchMessageDelta(stepId, {
-                                content: [{ type: ContentTypes.TEXT, text: content }],
-                            }, metadata);
-                        }
-                        else if (Array.isArray(content) &&
-                            content.every((c) => typeof c === 'object' &&
-                                'type' in c &&
-                                typeof c.type === 'string' &&
-                                c.type.startsWith('text'))) {
-                            await this.dispatchMessageDelta(stepId, {
-                                content: content,
-                            }, metadata);
-                        }
+                const dispatchedReasoning = responseReasoningContent != null &&
+                    (await dispatchReasoningContent({
+                        graph: this,
+                        agentContext,
+                        reasoningContent: responseReasoningContent,
+                        metadata,
+                    }));
+                if (dispatchedReasoning) {
+                    markPostReasoningContent(agentContext);
+                }
+                if (textMessageContent != null) {
+                    const stepKey = this.getStepKey(metadata);
+                    const dispatchedText = await dispatchTextMessageContent({
+                        graph: this,
+                        stepKey,
+                        content: textMessageContent,
+                        metadata,
+                    });
+                    if (dispatchedText) {
+                        markPostReasoningContent(agentContext);
                     }
                 }
                 await handleToolCalls(toolCalls, metadata, this);
             }
             /**
-             * When streaming is disabled, on_chat_model_stream events are never
-             * emitted so ChatModelStreamHandler never fires. Dispatch the text
-             * content as MESSAGE_CREATION + MESSAGE_DELTA here.
+             * When streaming events are unavailable, ChatModelStreamHandler never
+             * fires. Dispatch final reasoning/text content here. getMessageId makes
+             * this a no-op when the streaming path already handled the same step.
              */
-            const disableStreaming = agentContext.clientOptions
-                ?.disableStreaming === true;
-            if (disableStreaming &&
-                !hasToolCalls &&
-                responseMessage != null &&
-                responseMessage.content != null) {
-                const metadata = config.metadata;
-                const stepKey = this.getStepKey(metadata);
-                const messageId = getMessageId(stepKey, this) ?? '';
-                if (messageId) {
-                    await this.dispatchRunStep(stepKey, {
-                        type: StepTypes.MESSAGE_CREATION,
-                        message_creation: { message_id: messageId },
-                    }, metadata);
-                    const stepId = this.getStepIdByKey(stepKey);
-                    const content = responseMessage.content;
-                    if (typeof content === 'string') {
-                        await this.dispatchMessageDelta(stepId, {
-                            content: [{ type: ContentTypes.TEXT, text: content }],
-                        }, metadata);
-                    }
-                    else if (Array.isArray(content) &&
-                        content.every((c) => typeof c === 'object' &&
-                            'type' in c &&
-                            typeof c.type === 'string' &&
-                            c.type.startsWith('text'))) {
-                        await this.dispatchMessageDelta(stepId, {
-                            content: content,
-                        }, metadata);
-                    }
+            if (!hasToolCalls && responseMessage != null) {
+                const dispatchedReasoning = responseReasoningContent != null &&
+                    (await dispatchReasoningContent({
+                        graph: this,
+                        agentContext,
+                        reasoningContent: responseReasoningContent,
+                        metadata,
+                    }));
+                if (dispatchedReasoning && textMessageContent != null) {
+                    markPostReasoningContent(agentContext);
+                }
+                if (textMessageContent != null) {
+                    const stepKey = this.getStepKey(metadata);
+                    await dispatchTextMessageContent({
+                        graph: this,
+                        stepKey,
+                        content: textMessageContent,
+                        metadata,
+                    });
                 }
             }
             const invokeElapsed = ((Date.now() - invokeStart) / 1000).toFixed(2);