@lobehub/chat 1.64.3 → 1.65.1

package/src/types/aiModel.ts

@@ -138,17 +138,12 @@ export interface AiModelConfig {
   enabledSearch?: boolean;
 }
 
-export interface ExtendedControl {
-  key: string;
-  requestParams: string | string[];
-  type: 'params' | 'tool';
-  valueType: 'boolean';
-}
-
 export type ModelSearchImplementType = 'tool' | 'params' | 'internal';
 
+export type ExtendParamsType = 'reasoningBudgetToken' | 'enableReasoning';
+
 export interface AiModelSettings {
-  extendControls?: ExtendedControl[];
+  extendParams?: ExtendParamsType[];
   /**
    * 模型层实现搜索的方式
    */

package/src/types/message/base.ts

@@ -10,6 +10,7 @@ export interface CitationItem {
 export interface ModelReasoning {
   content?: string;
   duration?: number;
+  signature?: string;
 }
 
 export type MessageRoleType = 'user' | 'system' | 'assistant' | 'tool';

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

@@ -154,16 +154,119 @@ describe('fetchSSE', () => {
     });
   });
 
-  it('should handle reasoning event with smoothing correctly', async () => {
+  describe('reasoning', () => {
+    it('should handle reasoning event without smoothing', 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,
+      });
+
+      expect(mockOnMessageHandle).toHaveBeenNthCalledWith(1, { text: 'Hello', type: 'reasoning' });
+      expect(mockOnMessageHandle).toHaveBeenNthCalledWith(2, { text: ' World', type: 'reasoning' });
+
+      expect(mockOnFinish).toHaveBeenCalledWith('hi', {
+        observationId: null,
+        toolCalls: undefined,
+        reasoning: { content: 'Hello World' },
+        traceId: null,
+        type: 'done',
+      });
+    });
+
+    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: { content: 'Hello World' },
+        traceId: null,
+        type: 'done',
+      });
+    });
+    it('should handle reasoning with signature', 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);
+          options.onmessage!({
+            event: 'reasoning_signature',
+            data: JSON.stringify('abcbcd'),
+          } 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: { content: 'Hello World', signature: 'abcbcd' },
+        traceId: null,
+        type: 'done',
+      });
+    });
+  });
+
+  it('should handle grounding event', 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);
+        options.onmessage!({ event: 'grounding', data: JSON.stringify('Hello') } as any);
         await sleep(100);
         options.onmessage!({ event: 'text', data: JSON.stringify('hi') } as any);
       },
@@ -172,17 +275,17 @@ describe('fetchSSE', () => {
     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(mockOnMessageHandle).toHaveBeenNthCalledWith(1, {
+      grounding: 'Hello',
+      type: 'grounding',
+    });
+
     expect(mockOnFinish).toHaveBeenCalledWith('hi', {
       observationId: null,
       toolCalls: undefined,
-      reasoning: 'Hello World',
+      grounding: 'Hello',
       traceId: null,
       type: 'done',
     });

package/src/utils/fetch/fetchSSE.ts

@@ -9,6 +9,7 @@ import {
   MessageToolCall,
   MessageToolCallChunk,
   MessageToolCallSchema,
+  ModelReasoning,
 } from '@/types/message';
 import { GroundingSearch } from '@/types/search';
 
@@ -23,7 +24,7 @@ export type OnFinishHandler = (
   context: {
     grounding?: GroundingSearch;
     observationId?: string | null;
-    reasoning?: string;
+    reasoning?: ModelReasoning;
     toolCalls?: MessageToolCall[];
     traceId?: string | null;
     type?: SSEFinishType;
@@ -36,7 +37,8 @@ export interface MessageTextChunk {
 }
 
 export interface MessageReasoningChunk {
-  text: string;
+  signature?: string;
+  text?: string;
   type: 'reasoning';
 }
 
@@ -271,6 +273,8 @@ export const fetchSSE = async (url: string, options: RequestInit & FetchSSEOptio
   });
 
   let thinking = '';
+  let thinkingSignature: string | undefined;
+
   const thinkingController = createSmoothMessage({
     onTextUpdate: (delta, text) => {
       thinking = text;
@@ -365,6 +369,11 @@ export const fetchSSE = async (url: string, options: RequestInit & FetchSSEOptio
           break;
         }
 
+        case 'reasoning_signature': {
+          thinkingSignature = data;
+          break;
+        }
+
         case 'reasoning': {
           if (textSmoothing) {
             thinkingController.pushToQueue(data);
@@ -436,7 +445,7 @@ export const fetchSSE = async (url: string, options: RequestInit & FetchSSEOptio
       await options?.onFinish?.(output, {
         grounding,
         observationId,
-        reasoning: !!thinking ? thinking : undefined,
+        reasoning: !!thinking ? { content: thinking, signature: thinkingSignature } : undefined,
         toolCalls,
         traceId,
         type: finishedType,

package/src/features/ChatInput/ActionBar/Model/ExtendControls.tsx

@@ -1,40 +0,0 @@
-import { ActionIcon } from '@lobehub/ui';
-import { Popover } from 'antd';
-import { Settings2Icon } from 'lucide-react';
-import { memo } from 'react';
-import { useTranslation } from 'react-i18next';
-import { Flexbox } from 'react-layout-kit';
-
-import { useIsMobile } from '@/hooks/useIsMobile';
-
-import ControlsForm from './ControlsForm';
-
-const ExtendControls = memo(() => {
-  const { t } = useTranslation('chat');
-
-  const isMobile = useIsMobile();
-  return (
-    <Flexbox style={{ marginInlineStart: -4 }}>
-      <Popover
-        arrow={false}
-        content={<ControlsForm />}
-        open
-        styles={{
-          body: {
-            minWidth: isMobile ? undefined : 250,
-            width: isMobile ? '100vw' : undefined,
-          },
-        }}
-      >
-        <ActionIcon
-          icon={Settings2Icon}
-          placement={'bottom'}
-          style={{ borderRadius: 20 }}
-          title={t('extendControls.title')}
-        />
-      </Popover>
-    </Flexbox>
-  );
-});
-
-export default ExtendControls;