@librechat/agents 2.4.31 → 2.4.34

package/src/events.ts

@@ -1,9 +1,12 @@
 /* eslint-disable no-console */
 // src/events.ts
-import type { UsageMetadata, BaseMessageFields } from '@langchain/core/messages';
+import type {
+  UsageMetadata,
+  BaseMessageFields,
+} from '@langchain/core/messages';
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
-import { handleToolCalls } from '@/stream';
+import { handleToolCalls } from '@/tools/handlers';
 import { Providers } from '@/common';
 
 export class HandlerRegistry {
@@ -27,7 +30,12 @@ export class ModelEndHandler implements t.EventHandler {
     this.collectedUsage = collectedUsage;
   }
 
-  handle(event: string, data: t.ModelEndData, metadata?: Record<string, unknown>, graph?: Graph): void {
+  handle(
+    event: string,
+    data: t.ModelEndData,
+    metadata?: Record<string, unknown>,
+    graph?: Graph
+  ): void {
     if (!graph || !metadata) {
       console.warn(`Graph or metadata not found in ${event} event`);
       return;
@@ -43,9 +51,12 @@ export class ModelEndHandler implements t.EventHandler {
     }
 
     console.log(`====== ${event.toUpperCase()} ======`);
-    console.dir({
-      usage,
-    }, { depth: null });
+    console.dir(
+      {
+        usage,
+      },
+      { depth: null }
+    );
 
     if (metadata.provider !== Providers.GOOGLE) {
       return;
@@ -60,7 +71,12 @@ export class ToolEndHandler implements t.EventHandler {
   constructor(callback?: t.ToolEndCallback) {
     this.callback = callback;
   }
-  handle(event: string, data: t.StreamEventData | undefined, metadata?: Record<string, unknown>, graph?: Graph): void {
+  handle(
+    event: string,
+    data: t.StreamEventData | undefined,
+    metadata?: Record<string, unknown>,
+    graph?: Graph
+  ): void {
     if (!graph || !metadata) {
       console.warn(`Graph or metadata not found in ${event} event`);
       return;
@@ -74,14 +90,17 @@ export class ToolEndHandler implements t.EventHandler {
 
     this.callback?.(toolEndData, metadata);
 
-    graph.handleToolCallCompleted({ input: toolEndData.input, output: toolEndData.output }, metadata);
+    graph.handleToolCallCompleted(
+      { input: toolEndData.input, output: toolEndData.output },
+      metadata
+    );
   }
 }
 
 export class TestLLMStreamHandler implements t.EventHandler {
   handle(event: string, data: t.StreamEventData | undefined): void {
     const chunk = data?.chunk;
-    const  isMessageChunk = !!(chunk && 'message' in chunk);
+    const isMessageChunk = !!(chunk && 'message' in chunk);
     const msg = isMessageChunk ? chunk.message : undefined;
     if (msg && msg.tool_call_chunks && msg.tool_call_chunks.length > 0) {
       console.log(msg.tool_call_chunks);
@@ -116,11 +135,17 @@ export class TestChatStreamHandler implements t.EventHandler {
 }
 
 export class LLMStreamHandler implements t.EventHandler {
-  handle(event: string, data: t.StreamEventData | undefined, metadata?: Record<string, unknown>): void {
+  handle(
+    event: string,
+    data: t.StreamEventData | undefined,
+    metadata?: Record<string, unknown>
+  ): void {
     const chunk = data?.chunk;
-    const  isMessageChunk = !!(chunk && 'message' in chunk);
+    const isMessageChunk = !!(chunk && 'message' in chunk);
     const msg = isMessageChunk && chunk.message;
-    if (metadata) { console.log(metadata); }
+    if (metadata) {
+      console.log(metadata);
+    }
     if (msg && msg.tool_call_chunks && msg.tool_call_chunks.length > 0) {
       console.log(msg.tool_call_chunks);
     } else if (msg && msg.content) {
@@ -133,12 +158,21 @@ export class LLMStreamHandler implements t.EventHandler {
   }
 }
 
-export const createMetadataAggregator = (_collected?: Record<string, NonNullable<BaseMessageFields['response_metadata']>>[]): t.MetadataAggregatorResult => {
+export const createMetadataAggregator = (
+  _collected?: Record<
+    string,
+    NonNullable<BaseMessageFields['response_metadata']>
+  >[]
+): t.MetadataAggregatorResult => {
   const collected = _collected || [];
 
   const handleLLMEnd: t.HandleLLMEnd = (output) => {
     const { generations } = output;
-    const lastMessageOutput = (generations[generations.length - 1] as (t.StreamGeneration | undefined)[] | undefined)?.[0];
+    const lastMessageOutput = (
+      generations[generations.length - 1] as
+        | (t.StreamGeneration | undefined)[]
+        | undefined
+    )?.[0];
     if (!lastMessageOutput) {
       return;
     }
@@ -149,4 +183,4 @@ export const createMetadataAggregator = (_collected?: Record<string, NonNullable
   };
 
   return { handleLLMEnd, collected };
-};
+};

package/src/graphs/Graph.ts

@@ -105,7 +105,8 @@ export abstract class Graph<
   lastToken?: string;
   tokenTypeSwitch?: 'reasoning' | 'content';
   reasoningKey: 'reasoning_content' | 'reasoning' = 'reasoning_content';
-  currentTokenType: ContentTypes.TEXT | ContentTypes.THINK = ContentTypes.TEXT;
+  currentTokenType: ContentTypes.TEXT | ContentTypes.THINK | 'think_and_text' =
+    ContentTypes.TEXT;
   messageStepHasToolCalls: Map<string, boolean> = new Map();
   messageIdsByStepKey: Map<string, string> = new Map();
   prelimMessageIdsByStepKey: Map<string, string> = new Map();
@@ -303,7 +304,10 @@ export class StandardGraph extends Graph<t.BaseGraphState, GraphNode> {
       metadata.langgraph_step as number,
       metadata.checkpoint_ns as string,
     ];
-    if (this.currentTokenType === ContentTypes.THINK) {
+    if (
+      this.currentTokenType === ContentTypes.THINK ||
+      this.currentTokenType === 'think_and_text'
+    ) {
       keyList.push('reasoning');
     }
 

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './graphs';
 
 /* Tools */
 export * from './tools/CodeExecutor';
+export * from './tools/handlers';
 export * from './tools/search';
 
 /* Misc. */

package/src/messages/ids.ts

@@ -0,0 +1,26 @@
+// src/stream.ts
+import { nanoid } from 'nanoid';
+import type { Graph } from '@/graphs';
+import type * as t from '@/types';
+
+export const getMessageId = (
+  stepKey: string,
+  graph: Graph<t.BaseGraphState>,
+  returnExistingId = false
+): string | undefined => {
+  const messageId = graph.messageIdsByStepKey.get(stepKey);
+  if (messageId != null && messageId) {
+    return returnExistingId ? messageId : undefined;
+  }
+
+  const prelimMessageId = graph.prelimMessageIdsByStepKey.get(stepKey);
+  if (prelimMessageId != null && prelimMessageId) {
+    graph.prelimMessageIdsByStepKey.delete(stepKey);
+    graph.messageIdsByStepKey.set(stepKey, prelimMessageId);
+    return prelimMessageId;
+  }
+
+  const message_id = `msg_${nanoid()}`;
+  graph.messageIdsByStepKey.set(stepKey, message_id);
+  return message_id;
+};

package/src/messages/index.ts

@@ -1,3 +1,4 @@
 export * from './core';
+export * from './ids';
 export * from './prune';
 export * from './format';

package/src/scripts/search.ts

@@ -86,7 +86,7 @@ async function testStandardStreaming(): Promise<void> {
       tools: [createSearchTool()],
       instructions:
         'You are a friendly AI assistant. Always address the user by their name.',
-      additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      // additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
     },
     returnContent: true,
     customHandlers,
@@ -101,7 +101,7 @@ async function testStandardStreaming(): Promise<void> {
     version: 'v2' as const,
   };
 
-  console.log('Test 1: Weather query (content parts test)');
+  console.log('Test 1: Search query (search tool test)');
 
   // const userMessage = `
   // Make a search for the weather in ${location} today, which is ${currentDate}.
@@ -109,7 +109,12 @@ async function testStandardStreaming(): Promise<void> {
   // Make sure to always refer to me by name, which is ${userName}.
   // After giving me a thorough summary, tell me a joke about the weather forecast we went over.
   // `;
-  const userMessage = 'Are massage guns good?';
+  // const userMessage = 'Are massage guns good?';
+  // const userMessage = 'What is functional programming?';
+  const userMessage = "Get me today's trending news.";
+  // const userMessage = "search recent italy earthquake volcano activity";
+  // const userMessage =
+  //   "use 'Trump' as the exact search query and tell me what you find.";
 
   conversationHistory.push(new HumanMessage(userMessage));
 

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 = [
-  '.',
+  '. ',
   '?',
   '!',
   '۔',
+  '- ',
   '。',
   '‥',
   ';',