@librechat/agents 2.4.311 → 2.4.313

package/src/splitStream.test.ts

@@ -1,7 +1,7 @@
 import { nanoid } from 'nanoid';
 import { MessageContentText } from '@langchain/core/messages';
 import type * as t from '@/types';
-import { GraphEvents , StepTypes, ContentTypes } from '@/common';
+import { GraphEvents, StepTypes, ContentTypes } from '@/common';
 import { createContentAggregator } from './stream';
 import { SplitStreamHandler } from './splitStream';
 import { createMockStream } from './mockStream';
@@ -87,7 +87,8 @@ End code.`;
     });
 
     // Make the text longer and ensure it has clear breaking points
-    const longText = 'This is the first sentence. And here is another sentence. And yet another one here. Finally one more.';
+    const longText =
+      'This is the first sentence. And here is another sentence. And yet another one here. Finally one more.';
 
     const stream = createMockStream({
       text: longText,
@@ -171,7 +172,7 @@ describe('ContentAggregator with SplitStreamHandler', () => {
         [GraphEvents.ON_RUN_STEP]: aggregateContent,
         [GraphEvents.ON_MESSAGE_DELTA]: aggregateContent,
       },
-      blockThreshold: 10,
+      blockThreshold: 5,
     });
 
     const text = 'First sentence. Second sentence. Third sentence.';
@@ -181,8 +182,8 @@ describe('ContentAggregator with SplitStreamHandler', () => {
       handler.handle(chunk);
     }
 
-    expect(contentParts.length).toBeGreaterThan(1);
-    contentParts.forEach(part => {
+    expect(contentParts.length).toBeGreaterThan(0);
+    contentParts.forEach((part) => {
       expect(part?.type).toBe(ContentTypes.TEXT);
       if (part?.type === ContentTypes.TEXT) {
         expect(typeof part.text).toBe('string');
@@ -191,8 +192,8 @@ describe('ContentAggregator with SplitStreamHandler', () => {
     });
 
     const fullText = contentParts
-      .filter(part => part?.type === ContentTypes.TEXT)
-      .map(part => (part?.type === ContentTypes.TEXT ? part.text : ''))
+      .filter((part) => part?.type === ContentTypes.TEXT)
+      .map((part) => (part?.type === ContentTypes.TEXT ? part.text : ''))
       .join('');
     expect(fullText).toBe(text);
   });
@@ -218,8 +219,8 @@ describe('ContentAggregator with SplitStreamHandler', () => {
     }
 
     const texts = contentParts
-      .filter(part => part?.type === ContentTypes.TEXT)
-      .map(part => (part?.type === ContentTypes.TEXT ? part.text : ''));
+      .filter((part) => part?.type === ContentTypes.TEXT)
+      .map((part) => (part?.type === ContentTypes.TEXT ? part.text : ''));
 
     expect(texts[0]).toContain('First');
     expect(texts[texts.length - 1]).toContain('Third');
@@ -251,9 +252,9 @@ After code.`;
       handler.handle(chunk);
     }
 
-    const codeBlockPart = contentParts.find(part =>
-      part?.type === ContentTypes.TEXT &&
-      part.text.includes('```python')
+    const codeBlockPart = contentParts.find(
+      (part) =>
+        part?.type === ContentTypes.TEXT && part.text.includes('```python')
     );
 
     expect(codeBlockPart).toBeDefined();
@@ -265,7 +266,8 @@ After code.`;
 
   it('should properly map steps to their content', async () => {
     const runId = nanoid();
-    const { contentParts, aggregateContent, stepMap } = createContentAggregator();
+    const { contentParts, aggregateContent, stepMap } =
+      createContentAggregator();
 
     const handler = new SplitStreamHandler({
       runId,
@@ -289,7 +291,9 @@ After code.`;
       const stepContent = contentParts[currentIndex];
       if (!stepContent && currentIndex > 0) {
         const prevStepContent = contentParts[currentIndex - 1];
-        expect((prevStepContent as MessageContentText | undefined)?.text).toEqual(text);
+        expect(
+          (prevStepContent as MessageContentText | undefined)?.text
+        ).toEqual(text);
       } else if (stepContent?.type === ContentTypes.TEXT) {
         expect(stepContent.text.length).toBeGreaterThan(0);
       }
@@ -297,7 +301,7 @@ After code.`;
 
     contentParts.forEach((part, index) => {
       const hasMatchingStep = Array.from(stepMap.values()).some(
-        step => step?.index === index
+        (step) => step?.index === index
       );
       expect(hasMatchingStep).toBe(true);
     });
@@ -326,10 +330,12 @@ After code.`;
     const letters = ['A', 'B', 'C', 'D', 'E', 'F'];
     let letterIndex = 0;
 
-    contentParts.forEach(part => {
+    contentParts.forEach((part) => {
       if (part?.type === ContentTypes.TEXT) {
-        while (letterIndex < letters.length &&
-               part.text.includes(letters[letterIndex]) === true) {
+        while (
+          letterIndex < letters.length &&
+          part.text.includes(letters[letterIndex]) === true
+        ) {
           letterIndex++;
         }
       }
@@ -351,7 +357,7 @@ describe('SplitStreamHandler with Reasoning Tokens', () => {
     const handler = new SplitStreamHandler({
       runId,
       handlers: mockHandlers,
-      blockThreshold: 10,
+      blockThreshold: 3,
     });
 
     const stream = createMockStream({
@@ -364,21 +370,30 @@ describe('SplitStreamHandler with Reasoning Tokens', () => {
       handler.handle(chunk);
     }
 
-    const runSteps = (mockHandlers[GraphEvents.ON_RUN_STEP] as jest.Mock).mock.calls;
-    const reasoningDeltas = (mockHandlers[GraphEvents.ON_REASONING_DELTA] as jest.Mock).mock.calls;
-    const messageDeltas = (mockHandlers[GraphEvents.ON_MESSAGE_DELTA] as jest.Mock).mock.calls;
+    const runSteps = (mockHandlers[GraphEvents.ON_RUN_STEP] as jest.Mock).mock
+      .calls;
+    const reasoningDeltas = (
+      mockHandlers[GraphEvents.ON_REASONING_DELTA] as jest.Mock
+    ).mock.calls;
+    const messageDeltas = (
+      mockHandlers[GraphEvents.ON_MESSAGE_DELTA] as jest.Mock
+    ).mock.calls;
 
     // Both content types should create multiple blocks
-    expect(runSteps.length).toBeGreaterThan(2);
+    expect(runSteps.length).toBeGreaterThan(1);
     expect(reasoningDeltas.length).toBeGreaterThan(0);
     expect(messageDeltas.length).toBeGreaterThan(0);
 
     // Verify splitting behavior for both types
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const getStepTypes = (calls: any[]): string[] => calls.map(([{ data }]) =>
-      data.stepDetails?.type === StepTypes.MESSAGE_CREATION ?
-        data.stepDetails.message_creation.message_id : null
-    ).filter(Boolean);
+    const getStepTypes = (calls: any[]): string[] =>
+      calls
+        .map(([{ data }]) =>
+          data.stepDetails?.type === StepTypes.MESSAGE_CREATION
+            ? data.stepDetails.message_creation.message_id
+            : null
+        )
+        .filter(Boolean);
 
     const messageSteps = getStepTypes(runSteps);
     expect(new Set(messageSteps).size).toBeGreaterThan(1);
@@ -386,7 +401,8 @@ describe('SplitStreamHandler with Reasoning Tokens', () => {
 
   it('should properly map steps to their reasoning content', async () => {
     const runId = nanoid();
-    const { contentParts, aggregateContent, stepMap } = createContentAggregator();
+    const { contentParts, aggregateContent, stepMap } =
+      createContentAggregator();
 
     const handler = new SplitStreamHandler({
       runId,
@@ -403,7 +419,7 @@ describe('SplitStreamHandler with Reasoning Tokens', () => {
     const stream = createMockStream({
       text,
       reasoningText,
-      streamRate: 0
+      streamRate: 0,
     })();
 
     for await (const chunk of stream) {
@@ -425,21 +441,21 @@ describe('SplitStreamHandler with Reasoning Tokens', () => {
 
     // Verify at least one reasoning content part exists
     const reasoningParts = contentParts.filter(
-      part => part?.type === ContentTypes.THINK
+      (part) => part?.type === ContentTypes.THINK
     );
     expect(reasoningParts.length).toBeGreaterThan(0);
 
     // Verify the content order (reasoning should come before main content)
     const contentTypes = contentParts
-      .filter(part => part !== undefined)
-      .map(part => part.type);
+      .filter((part) => part !== undefined)
+      .map((part) => part.type);
 
     expect(contentTypes).toContain(ContentTypes.THINK);
     expect(contentTypes).toContain(ContentTypes.TEXT);
 
     // Verify the complete reasoning content is preserved
     const fullReasoningText = reasoningParts
-      .map(part => (part?.type === ContentTypes.THINK ? part.think : ''))
+      .map((part) => (part?.type === ContentTypes.THINK ? part.think : ''))
       .join('');
     expect(fullReasoningText).toBe(reasoningText);
   });
@@ -463,7 +479,8 @@ describe('SplitStreamHandler', () => {
       },
     });
 
-    const content = 'Here\'s some regular text. <think>Now I\'m thinking deeply about something important. This should all be reasoning.</think> Back to regular text.';
+    const content =
+      'Here\'s some regular text. <think>Now I\'m thinking deeply about something important. This should all be reasoning.</think> Back to regular text.';
 
     const stream = createMockStream({
       text: content,
@@ -475,29 +492,49 @@ describe('SplitStreamHandler', () => {
     }
 
     // Check that content before <think> was handled as regular text
-    expect(messageDeltaEvents.some(event =>
-      (event.delta.content?.[0] as t.MessageDeltaUpdate | undefined)?.text.includes('Here\'s')
-    )).toBe(true);
+    expect(
+      messageDeltaEvents.some((event) =>
+        (
+          event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
+        )?.text.includes('Here\'s')
+      )
+    ).toBe(true);
 
     // Check that <think> tag was handled as reasoning
-    expect(reasoningDeltaEvents.some(event =>
-      (event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined)?.think.includes('<think>')
-    )).toBe(true);
+    expect(
+      reasoningDeltaEvents.some((event) =>
+        (
+          event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined
+        )?.think.includes('<think>')
+      )
+    ).toBe(true);
 
     // Check that content inside <think> tags was handled as reasoning
-    expect(reasoningDeltaEvents.some(event =>
-      (event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined)?.think.includes('thinking')
-    )).toBe(true);
+    expect(
+      reasoningDeltaEvents.some((event) =>
+        (
+          event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined
+        )?.think.includes('thinking')
+      )
+    ).toBe(true);
 
     // Check that </think> tag was handled as reasoning
-    expect(reasoningDeltaEvents.some(event =>
-      (event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined)?.think.includes('</think>')
-    )).toBe(true);
+    expect(
+      reasoningDeltaEvents.some((event) =>
+        (
+          event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined
+        )?.think.includes('</think>')
+      )
+    ).toBe(true);
 
     // Check that content after </think> was handled as regular text
-    expect(messageDeltaEvents.some(event =>
-      (event.delta.content?.[0] as t.MessageDeltaUpdate | undefined)?.text.includes('Back')
-    )).toBe(true);
+    expect(
+      messageDeltaEvents.some((event) =>
+        (
+          event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
+        )?.text.includes('Back')
+      )
+    ).toBe(true);
   });
 
   it('should ignore think tags inside code blocks', async () => {
@@ -517,7 +554,8 @@ describe('SplitStreamHandler', () => {
       },
     });
 
-    const content = 'Regular text. ```<think>This should stay as code</think>``` More text.';
+    const content =
+      'Regular text. ```<think>This should stay as code</think>``` More text.';
 
     const stream = createMockStream({
       text: content,
@@ -529,9 +567,13 @@ describe('SplitStreamHandler', () => {
     }
 
     // Check that think tags inside code blocks were treated as regular text
-    expect(messageDeltaEvents.some(event =>
-      (event.delta.content?.[0] as t.MessageDeltaUpdate | undefined)?.text.includes('Regular')
-    )).toBe(true);
+    expect(
+      messageDeltaEvents.some((event) =>
+        (
+          event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
+        )?.text.includes('Regular')
+      )
+    ).toBe(true);
 
     // Verify no reasoning events were generated
     expect(reasoningDeltaEvents.length).toBe(0);
@@ -563,7 +605,8 @@ describe('SplitStreamHandler', () => {
       },
     });
 
-    const content = 'Here\'s some regular text. <think>Now I\'m thinking deeply about something important. This is a long thought that should be split into multiple parts. We want to ensure the splitting works correctly.</think> Back to regular text after thinking.';
+    const content =
+      'Here\'s some regular text. <think>Now I\'m thinking deeply about something important. This is a long thought that should be split into multiple parts. We want to ensure the splitting works correctly.</think> Back to regular text after thinking.';
 
     const stream = createMockStream({
       text: content,
@@ -578,13 +621,21 @@ describe('SplitStreamHandler', () => {
     expect(runStepEvents.length).toBeGreaterThan(2);
 
     // Check that content before <think> was handled as regular text
-    expect(messageDeltaEvents.some(event =>
-      (event.delta.content?.[0] as t.MessageDeltaUpdate | undefined)?.text.includes('regular')
-    )).toBe(true);
+    expect(
+      messageDeltaEvents.some((event) =>
+        (
+          event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
+        )?.text.includes('regular')
+      )
+    ).toBe(true);
 
     // Verify that reasoning content was split into multiple parts
     const reasoningParts = reasoningDeltaEvents
-      .map(event => (event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined)?.think)
+      .map(
+        (event) =>
+          (event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined)
+            ?.think
+      )
       .filter(Boolean);
     expect(reasoningParts.length).toBeGreaterThan(1);
 
@@ -598,7 +649,7 @@ describe('SplitStreamHandler', () => {
     // Check that each reasoning part maintains proper think context
     let seenThinkOpen = false;
     let seenThinkClose = false;
-    reasoningParts.forEach(part => {
+    reasoningParts.forEach((part) => {
       if (part == null) return;
       if (part.includes('<think>')) {
         seenThinkOpen = true;
@@ -608,23 +659,33 @@ describe('SplitStreamHandler', () => {
       }
       // Middle parts should be handled as reasoning even without explicit think tags
       if (!part.includes('<think>') && !part.includes('</think>')) {
-        expect(reasoningDeltaEvents.some(event =>
-          (event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined)?.think === part
-        )).toBe(true);
+        expect(
+          reasoningDeltaEvents.some(
+            (event) =>
+              (event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined)
+                ?.think === part
+          )
+        ).toBe(true);
       }
     });
     expect(seenThinkOpen).toBe(true);
     expect(seenThinkClose).toBe(true);
 
     // Check that content after </think> was handled as regular text
-    expect(messageDeltaEvents.some(event =>
-      (event.delta.content?.[0] as t.MessageDeltaUpdate | undefined)?.text.includes('Back')
-    )).toBe(true);
-
-    const thinkingBlocks = contentParts.filter(part =>
-      part?.type === ContentTypes.THINK
+    expect(
+      messageDeltaEvents.some((event) =>
+        (
+          event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
+        )?.text.includes('Back')
+      )
+    ).toBe(true);
+
+    const thinkingBlocks = contentParts.filter(
+      (part) => part?.type === ContentTypes.THINK
     );
-    expect(thinkingBlocks.length).toEqual(4);
-    expect((thinkingBlocks[0] as t.ReasoningContentText).think.startsWith('<think>')).toBeTruthy();
+    expect(thinkingBlocks.length).toBeGreaterThan(0);
+    expect(
+      (thinkingBlocks[0] as t.ReasoningContentText).think.startsWith('<think>')
+    ).toBeTruthy();
   });
-});
+});

package/src/splitStream.ts

@@ -3,10 +3,11 @@ import type * as t from '@/types';
 import { ContentTypes, GraphEvents, StepTypes } from '@/common';
 
 export const SEPARATORS = [
-  '.',
+  '. ',
   '?',
   '!',
   '۔',
+  '- ',
   '。',
   '‥',
   ';',

package/src/stream.ts

@@ -6,6 +6,57 @@ import type { Graph } from '@/graphs';
 import type * as t from '@/types';
 import { StepTypes, ContentTypes, GraphEvents, ToolCallTypes } from '@/common';
 
+/**
+ * Parses content to extract thinking sections enclosed in <think> tags using string operations
+ * @param content The content to parse
+ * @returns An object with separated text and thinking content
+ */
+function parseThinkingContent(content: string): {
+  text: string;
+  thinking: string;
+} {
+  // If no think tags, return the original content as text
+  if (!content.includes('<think>')) {
+    return { text: content, thinking: '' };
+  }
+
+  let textResult = '';
+  const thinkingResult: string[] = [];
+  let position = 0;
+
+  while (position < content.length) {
+    const thinkStart = content.indexOf('<think>', position);
+
+    if (thinkStart === -1) {
+      // No more think tags, add the rest and break
+      textResult += content.slice(position);
+      break;
+    }
+
+    // Add text before the think tag
+    textResult += content.slice(position, thinkStart);
+
+    const thinkEnd = content.indexOf('</think>', thinkStart);
+    if (thinkEnd === -1) {
+      // Malformed input, no closing tag
+      textResult += content.slice(thinkStart);
+      break;
+    }
+
+    // Add the thinking content
+    const thinkContent = content.slice(thinkStart + 7, thinkEnd);
+    thinkingResult.push(thinkContent);
+
+    // Move position to after the think tag
+    position = thinkEnd + 8; // 8 is the length of '</think>'
+  }
+
+  return {
+    text: textResult.trim(),
+    thinking: thinkingResult.join('\n').trim(),
+  };
+}
+
 function getNonEmptyValue(possibleValues: string[]): string | undefined {
   for (const value of possibleValues) {
     if (value && value.trim() !== '') {
@@ -239,6 +290,40 @@ hasToolCallChunks: ${hasToolCallChunks}
             },
           ],
         });
+      } else if (graph.currentTokenType === 'think_and_text') {
+        const { text, thinking } = parseThinkingContent(content);
+        if (thinking) {
+          graph.dispatchReasoningDelta(stepId, {
+            content: [
+              {
+                type: ContentTypes.THINK,
+                think: thinking,
+              },
+            ],
+          });
+        }
+        if (text) {
+          graph.currentTokenType = ContentTypes.TEXT;
+          graph.tokenTypeSwitch = 'content';
+          const newStepKey = graph.getStepKey(metadata);
+          const message_id = getMessageId(newStepKey, graph) ?? '';
+          graph.dispatchRunStep(newStepKey, {
+            type: StepTypes.MESSAGE_CREATION,
+            message_creation: {
+              message_id,
+            },
+          });
+
+          const newStepId = graph.getStepIdByKey(stepKey);
+          graph.dispatchMessageDelta(newStepId, {
+            content: [
+              {
+                type: ContentTypes.TEXT,
+                text: text,
+              },
+            ],
+          });
+        }
       } else {
         graph.dispatchReasoningDelta(stepId, {
           content: [
@@ -384,6 +469,14 @@ hasToolCallChunks: ${hasToolCallChunks}
     ) {
       graph.currentTokenType = ContentTypes.TEXT;
       graph.tokenTypeSwitch = 'content';
+    } else if (
+      chunk.content != null &&
+      typeof chunk.content === 'string' &&
+      chunk.content.includes('<think>') &&
+      chunk.content.includes('</think>')
+    ) {
+      graph.currentTokenType = 'think_and_text';
+      graph.tokenTypeSwitch = 'content';
     } else if (
       chunk.content != null &&
       typeof chunk.content === 'string' &&