@lobehub/chat 1.47.23 → 1.48.0

package/src/utils/fetch/__tests__/fetchSSE.test.ts

@@ -154,6 +154,40 @@ describe('fetchSSE', () => {
     });
   });
 
+  it('should handle reasoning event with smoothing correctly', async () => {
+    const mockOnMessageHandle = vi.fn();
+    const mockOnFinish = vi.fn();
+
+    (fetchEventSource as any).mockImplementationOnce(
+      async (url: string, options: FetchEventSourceInit) => {
+        options.onopen!({ clone: () => ({ ok: true, headers: new Headers() }) } as any);
+        options.onmessage!({ event: 'reasoning', data: JSON.stringify('Hello') } as any);
+        await sleep(100);
+        options.onmessage!({ event: 'reasoning', data: JSON.stringify(' World') } as any);
+        await sleep(100);
+        options.onmessage!({ event: 'text', data: JSON.stringify('hi') } as any);
+      },
+    );
+
+    await fetchSSE('/', {
+      onMessageHandle: mockOnMessageHandle,
+      onFinish: mockOnFinish,
+      smoothing: true,
+    });
+
+    expect(mockOnMessageHandle).toHaveBeenNthCalledWith(1, { text: 'Hell', type: 'reasoning' });
+    expect(mockOnMessageHandle).toHaveBeenNthCalledWith(2, { text: 'o', type: 'reasoning' });
+    expect(mockOnMessageHandle).toHaveBeenNthCalledWith(3, { text: ' Wor', type: 'reasoning' });
+    // more assertions for each character...
+    expect(mockOnFinish).toHaveBeenCalledWith('hi', {
+      observationId: null,
+      toolCalls: undefined,
+      reasoning: 'Hello World',
+      traceId: null,
+      type: 'done',
+    });
+  });
+
   it('should handle tool_calls event with smoothing correctly', async () => {
     const mockOnMessageHandle = vi.fn();
     const mockOnFinish = vi.fn();

package/src/utils/fetch/fetchSSE.ts

@@ -21,6 +21,7 @@ export type OnFinishHandler = (
   text: string,
   context: {
     observationId?: string | null;
+    reasoning?: string;
     toolCalls?: MessageToolCall[];
     traceId?: string | null;
     type?: SSEFinishType;
@@ -32,6 +33,11 @@ export interface MessageTextChunk {
   type: 'text';
 }
 
+export interface MessageReasoningChunk {
+  text: string;
+  type: 'reasoning';
+}
+
 interface MessageToolCallsChunk {
   isAnimationActives?: boolean[];
   tool_calls: MessageToolCall[];
@@ -43,7 +49,9 @@ export interface FetchSSEOptions {
   onAbort?: (text: string) => Promise<void>;
   onErrorHandle?: (error: ChatMessageError) => void;
   onFinish?: OnFinishHandler;
-  onMessageHandle?: (chunk: MessageTextChunk | MessageToolCallsChunk) => void;
+  onMessageHandle?: (
+    chunk: MessageTextChunk | MessageToolCallsChunk | MessageReasoningChunk,
+  ) => void;
   smoothing?: SmoothingParams | boolean;
 }
 
@@ -233,7 +241,6 @@ const createSmoothToolCalls = (params: {
  */
 // eslint-disable-next-line no-undef
 export const fetchSSE = async (url: string, options: RequestInit & FetchSSEOptions = {}) => {
-  let output = '';
   let toolCalls: undefined | MessageToolCall[];
   let triggerOnMessageHandler = false;
 
@@ -247,6 +254,7 @@ export const fetchSSE = async (url: string, options: RequestInit & FetchSSEOptio
     typeof smoothing === 'boolean' ? smoothing : (smoothing?.toolsCalling ?? true);
   const smoothingSpeed = isObject(smoothing) ? smoothing.speed : undefined;
 
+  let output = '';
   const textController = createSmoothMessage({
     onTextUpdate: (delta, text) => {
       output = text;
@@ -255,6 +263,15 @@ export const fetchSSE = async (url: string, options: RequestInit & FetchSSEOptio
     startSpeed: smoothingSpeed,
   });
 
+  let thinking = '';
+  const thinkingController = createSmoothMessage({
+    onTextUpdate: (delta, text) => {
+      thinking = text;
+      options.onMessageHandle?.({ text: delta, type: 'reasoning' });
+    },
+    startSpeed: smoothingSpeed,
+  });
+
   const toolCallsController = createSmoothToolCalls({
     onToolCallsUpdate: (toolCalls, isAnimationActives) => {
       options.onMessageHandle?.({ isAnimationActives, tool_calls: toolCalls, type: 'tool_calls' });
@@ -333,6 +350,18 @@ export const fetchSSE = async (url: string, options: RequestInit & FetchSSEOptio
 
           break;
         }
+        case 'reasoning': {
+          if (textSmoothing) {
+            thinkingController.pushToQueue(data);
+
+            if (!thinkingController.isAnimationActive) thinkingController.startAnimation();
+          } else {
+            thinking += data;
+            options.onMessageHandle?.({ text: data, type: 'reasoning' });
+          }
+
+          break;
+        }
 
         case 'tool_calls': {
           // get finial
@@ -389,7 +418,13 @@ export const fetchSSE = async (url: string, options: RequestInit & FetchSSEOptio
         await toolCallsController.startAnimations(END_ANIMATION_SPEED);
       }
 
-      await options?.onFinish?.(output, { observationId, toolCalls, traceId, type: finishedType });
+      await options?.onFinish?.(output, {
+        observationId,
+        reasoning: !!thinking ? thinking : undefined,
+        toolCalls,
+        traceId,
+        type: finishedType,
+      });
     }
   }