@lobehub/chat 1.47.22 → 1.48.0

package/src/libs/agent-runtime/utils/streams/openai.test.ts

@@ -552,4 +552,207 @@ describe('OpenAIStream', () => {
       expect(onToolCallMock).toHaveBeenCalledTimes(2);
     });
   });
+
+  describe('Reasoning', () => {
+    it('should handle reasoning event', async () => {
+      const data = [
+        {
+          id: '1',
+          object: 'chat.completion.chunk',
+          created: 1737563070,
+          model: 'deepseek-reasoner',
+          system_fingerprint: 'fp_1c5d8833bc',
+          choices: [
+            {
+              index: 0,
+              delta: { role: 'assistant', content: null, reasoning_content: '' },
+              logprobs: null,
+              finish_reason: null,
+            },
+          ],
+        },
+        {
+          id: '1',
+          object: 'chat.completion.chunk',
+          created: 1737563070,
+          model: 'deepseek-reasoner',
+          system_fingerprint: 'fp_1c5d8833bc',
+          choices: [
+            {
+              index: 0,
+              delta: { content: null, reasoning_content: '您好' },
+              logprobs: null,
+              finish_reason: null,
+            },
+          ],
+        },
+        {
+          id: '1',
+          object: 'chat.completion.chunk',
+          created: 1737563070,
+          model: 'deepseek-reasoner',
+          system_fingerprint: 'fp_1c5d8833bc',
+          choices: [
+            {
+              index: 0,
+              delta: { content: null, reasoning_content: '！' },
+              logprobs: null,
+              finish_reason: null,
+            },
+          ],
+        },
+        {
+          id: '1',
+          object: 'chat.completion.chunk',
+          created: 1737563070,
+          model: 'deepseek-reasoner',
+          system_fingerprint: 'fp_1c5d8833bc',
+          choices: [
+            {
+              index: 0,
+              delta: { content: '你好', reasoning_content: null },
+              logprobs: null,
+              finish_reason: null,
+            },
+          ],
+        },
+        {
+          id: '1',
+          object: 'chat.completion.chunk',
+          created: 1737563070,
+          model: 'deepseek-reasoner',
+          system_fingerprint: 'fp_1c5d8833bc',
+          choices: [
+            {
+              index: 0,
+              delta: { content: '很高兴', reasoning_cont: null },
+              logprobs: null,
+              finish_reason: null,
+            },
+          ],
+        },
+        {
+          id: '1',
+          object: 'chat.completion.chunk',
+          created: 1737563070,
+          model: 'deepseek-reasoner',
+          system_fingerprint: 'fp_1c5d8833bc',
+          choices: [
+            {
+              index: 0,
+              delta: { content: '为您', reasoning_content: null },
+              logprobs: null,
+              finish_reason: null,
+            },
+          ],
+        },
+        {
+          id: '1',
+          object: 'chat.completion.chunk',
+          created: 1737563070,
+          model: 'deepseek-reasoner',
+          system_fingerprint: 'fp_1c5d8833bc',
+          choices: [
+            {
+              index: 0,
+              delta: { content: '提供', reasoning_content: null },
+              logprobs: null,
+              finish_reason: null,
+            },
+          ],
+        },
+        {
+          id: '1',
+          object: 'chat.completion.chunk',
+          created: 1737563070,
+          model: 'deepseek-reasoner',
+          system_fingerprint: 'fp_1c5d8833bc',
+          choices: [
+            {
+              index: 0,
+              delta: { content: '帮助。', reasoning_content: null },
+              logprobs: null,
+              finish_reason: null,
+            },
+          ],
+        },
+        {
+          id: '1',
+          object: 'chat.completion.chunk',
+          created: 1737563070,
+          model: 'deepseek-reasoner',
+          system_fingerprint: 'fp_1c5d8833bc',
+          choices: [
+            {
+              index: 0,
+              delta: { content: '', reasoning_content: null },
+              logprobs: null,
+              finish_reason: 'stop',
+            },
+          ],
+          usage: {
+            prompt_tokens: 6,
+            completion_tokens: 104,
+            total_tokens: 110,
+            prompt_tokens_details: { cached_tokens: 0 },
+            completion_tokens_details: { reasoning_tokens: 70 },
+            prompt_cache_hit_tokens: 0,
+            prompt_cache_miss_tokens: 6,
+          },
+        },
+      ];
+
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          data.forEach((chunk) => {
+            controller.enqueue(chunk);
+          });
+
+          controller.close();
+        },
+      });
+
+      const protocolStream = OpenAIStream(mockOpenAIStream);
+
+      const decoder = new TextDecoder();
+      const chunks = [];
+
+      // @ts-ignore
+      for await (const chunk of protocolStream) {
+        chunks.push(decoder.decode(chunk, { stream: true }));
+      }
+
+      expect(chunks).toEqual(
+        [
+          'id: 1',
+          'event: reasoning',
+          `data: ""\n`,
+          'id: 1',
+          'event: reasoning',
+          `data: "您好"\n`,
+          'id: 1',
+          'event: reasoning',
+          `data: "！"\n`,
+          'id: 1',
+          'event: text',
+          `data: "你好"\n`,
+          'id: 1',
+          'event: text',
+          `data: "很高兴"\n`,
+          'id: 1',
+          'event: text',
+          `data: "为您"\n`,
+          'id: 1',
+          'event: text',
+          `data: "提供"\n`,
+          'id: 1',
+          'event: text',
+          `data: "帮助。"\n`,
+          'id: 1',
+          'event: stop',
+          `data: "stop"\n`,
+        ].map((i) => `${i}\n`),
+      );
+    });
+  });
 });

package/src/libs/agent-runtime/utils/streams/openai.ts

@@ -45,6 +45,7 @@ export const transformOpenAIStream = (
       return { data: chunk, id: chunk.id, type: 'data' };
     }
 
+    // tools calling
     if (typeof item.delta?.tool_calls === 'object' && item.delta.tool_calls?.length > 0) {
       return {
         data: item.delta.tool_calls.map((value, index): StreamToolCallChunkData => {
@@ -91,7 +92,13 @@ export const transformOpenAIStream = (
       return { data: item.delta.content, id: chunk.id, type: 'text' };
     }
 
-    if (item.delta?.content === null) {
+    // 无内容情况
+    if (item.delta && item.delta.content === null) {
+      // deepseek reasoner 会将 thinking 放在 reasoning_content 字段中
+      if ('reasoning_content' in item.delta && typeof item.delta.reasoning_content === 'string') {
+        return { data: item.delta.reasoning_content, id: chunk.id, type: 'reasoning' };
+      }
+
       return { data: item.delta, id: chunk.id, type: 'data' };
     }
 

package/src/libs/agent-runtime/utils/streams/protocol.ts

@@ -15,7 +15,7 @@ export interface StreamStack {
 export interface StreamProtocolChunk {
   data: any;
   id?: string;
-  type: 'text' | 'tool_calls' | 'data' | 'stop' | 'error';
+  type: 'text' | 'tool_calls' | 'data' | 'stop' | 'error' | 'reasoning';
 }
 
 export interface StreamToolCallChunkData {

package/src/locales/default/chat.ts

@@ -84,6 +84,10 @@ export default {
       },
     },
   },
+  reasoning: {
+    thinking: '深度思考中',
+    thought: '已深度思考（用时 {{duration}} 秒）',
+  },
   regenerate: '重新生成',
   roleAndArchive: '角色与记录',
   searchAgentPlaceholder: '搜索助手...',

package/src/locales/default/components.ts

@@ -78,6 +78,7 @@ export default {
       custom: '自定义模型，默认设定同时支持函数调用与视觉识别，请根据实际情况验证上述能力的可用性',
       file: '该模型支持上传文件读取与识别',
       functionCall: '该模型支持函数调用（Function Call）',
+      reasoning: '该模型支持深度思考',
       tokens: '该模型单个会话最多支持 {{tokens}} Tokens',
       vision: '该模型支持视觉识别',
     },

package/src/server/routers/lambda/message.ts

@@ -63,10 +63,12 @@ export const messageRouter = router({
       return data.id;
     }),
 
+  // TODO: it will be removed in V2
   getAllMessages: messageProcedure.query(async ({ ctx }): Promise<ChatMessageList> => {
-    return ctx.messageModel.queryAll();
+    return ctx.messageModel.queryAll() as any;
   }),
 
+  // TODO: it will be removed in V2
   getAllMessagesInSession: messageProcedure
     .input(
       z.object({
@@ -74,7 +76,7 @@ export const messageRouter = router({
       }),
     )
     .query(async ({ ctx, input }): Promise<ChatMessageList> => {
-      return ctx.messageModel.queryBySessionId(input.sessionId);
+      return ctx.messageModel.queryBySessionId(input.sessionId) as any;
     }),
 
   getHeatmaps: messageProcedure.query(async ({ ctx }) => {

package/src/services/message/client.test.ts

@@ -5,7 +5,6 @@ import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { MessageModel } from '@/database/_deprecated/models/message';
 import { clientDB, initializeDB } from '@/database/client/db';
 import {
-  MessageItem,
   files,
   messagePlugins,
   messageTTS,
@@ -21,6 +20,7 @@ import {
   ChatTTS,
   ChatTranslate,
   CreateMessageParams,
+  MessageItem,
 } from '@/types/message';
 
 import { ClientService } from './client';

package/src/services/message/type.ts

@@ -1,12 +1,12 @@
 import type { HeatmapsProps } from '@lobehub/charts';
 
-import { MessageItem } from '@/database/schemas';
 import {
   ChatMessage,
   ChatMessageError,
   ChatTTS,
   ChatTranslate,
   CreateMessageParams,
+  MessageItem,
   ModelRankItem,
 } from '@/types/message';
 

package/src/store/chat/selectors.ts

@@ -1,3 +1,4 @@
+export { aiChatSelectors } from './slices/aiChat/selectors';
 export { chatToolSelectors } from './slices/builtinTool/selectors';
 export { chatSelectors } from './slices/message/selectors';
 export * from './slices/portal/selectors';

package/src/store/chat/slices/aiChat/actions/generateAIChat.ts

@@ -72,7 +72,7 @@ export interface AIGenerateAction {
    */
   internal_fetchAIChatMessage: (
     messages: ChatMessage[],
-    assistantMessageId: string,
+    messageId: string,
     params?: ProcessMessageParams,
   ) => Promise<{
     isFunctionCall: boolean;
@@ -102,6 +102,14 @@ export interface AIGenerateAction {
    * Controls the streaming state of tool calling processes, updating the UI accordingly
    */
   internal_toggleToolCallingStreaming: (id: string, streaming: boolean[] | undefined) => void;
+  /**
+   * Toggles the loading state for AI message reasoning, managing the UI feedback
+   */
+  internal_toggleChatReasoning: (
+    loading: boolean,
+    id?: string,
+    action?: string,
+  ) => AbortController | undefined;
 }
 
 export const generateAIChat: StateCreator<
@@ -357,19 +365,20 @@ export const generateAIChat: StateCreator<
       await get().internal_summaryHistory(historyMessages);
     }
   },
-  internal_fetchAIChatMessage: async (messages, assistantId, params) => {
+  internal_fetchAIChatMessage: async (messages, messageId, params) => {
     const {
       internal_toggleChatLoading,
       refreshMessages,
       internal_updateMessageContent,
       internal_dispatchMessage,
       internal_toggleToolCallingStreaming,
+      internal_toggleChatReasoning,
     } = get();
 
     const abortController = internal_toggleChatLoading(
       true,
-      assistantId,
-      n('generateMessage(start)', { assistantId, messages }) as string,
+      messageId,
+      n('generateMessage(start)', { messageId, messages }) as string,
     );
 
     const agentConfig = getAgentConfig();
@@ -414,6 +423,9 @@ export const generateAIChat: StateCreator<
     let isFunctionCall = false;
     let msgTraceId: string | undefined;
     let output = '';
+    let thinking = '';
+    let thinkingStartAt: number;
+    let duration: number;
 
     const historySummary = topicSelectors.currentActiveTopicSummary(get());
     await chatService.createAssistantMessageStream({
@@ -434,43 +446,74 @@ export const generateAIChat: StateCreator<
       },
       isWelcomeQuestion: params?.isWelcomeQuestion,
       onErrorHandle: async (error) => {
-        await messageService.updateMessageError(assistantId, error);
+        await messageService.updateMessageError(messageId, error);
         await refreshMessages();
       },
-      onFinish: async (content, { traceId, observationId, toolCalls }) => {
+      onFinish: async (content, { traceId, observationId, toolCalls, reasoning }) => {
         // if there is traceId, update it
         if (traceId) {
           msgTraceId = traceId;
-          await messageService.updateMessage(assistantId, {
+          await messageService.updateMessage(messageId, {
             traceId,
             observationId: observationId ?? undefined,
           });
         }
 
         if (toolCalls && toolCalls.length > 0) {
-          internal_toggleToolCallingStreaming(assistantId, undefined);
+          internal_toggleToolCallingStreaming(messageId, undefined);
         }
 
         // update the content after fetch result
-        await internal_updateMessageContent(assistantId, content, toolCalls);
+        await internal_updateMessageContent(
+          messageId,
+          content,
+          toolCalls,
+          !!reasoning ? { content: reasoning, duration } : undefined,
+        );
       },
       onMessageHandle: async (chunk) => {
         switch (chunk.type) {
           case 'text': {
             output += chunk.text;
+
+            // if there is no duration, it means the end of reasoning
+            if (!duration) {
+              duration = Date.now() - thinkingStartAt;
+              internal_toggleChatReasoning(false, messageId, n('generateMessage(end)') as string);
+            }
+
             internal_dispatchMessage({
-              id: assistantId,
+              id: messageId,
               type: 'updateMessage',
-              value: { content: output },
+              value: {
+                content: output,
+                reasoning: !!thinking ? { content: thinking, duration } : undefined,
+              },
+            });
+            break;
+          }
+          case 'reasoning': {
+            // if there is no thinkingStartAt, it means the start of reasoning
+            if (!thinkingStartAt) {
+              thinkingStartAt = Date.now();
+              internal_toggleChatReasoning(true, messageId, n('generateMessage(end)') as string);
+            }
+
+            thinking += chunk.text;
+
+            internal_dispatchMessage({
+              id: messageId,
+              type: 'updateMessage',
+              value: { reasoning: { content: thinking } },
             });
             break;
           }
 
           // is this message is just a tool call
           case 'tool_calls': {
-            internal_toggleToolCallingStreaming(assistantId, chunk.isAnimationActives);
+            internal_toggleToolCallingStreaming(messageId, chunk.isAnimationActives);
             internal_dispatchMessage({
-              id: assistantId,
+              id: messageId,
               type: 'updateMessage',
               value: { tools: get().internal_transformToolCalls(chunk.tool_calls) },
             });
@@ -480,7 +523,7 @@ export const generateAIChat: StateCreator<
       },
     });
 
-    internal_toggleChatLoading(false, assistantId, n('generateMessage(end)') as string);
+    internal_toggleChatLoading(false, messageId, n('generateMessage(end)') as string);
 
     return {
       isFunctionCall,
@@ -540,6 +583,9 @@ export const generateAIChat: StateCreator<
   internal_toggleChatLoading: (loading, id, action) => {
     return get().internal_toggleLoadingArrays('chatLoadingIds', loading, id, action);
   },
+  internal_toggleChatReasoning: (loading, id, action) => {
+    return get().internal_toggleLoadingArrays('reasoningLoadingIds', loading, id, action);
+  },
   internal_toggleToolCallingStreaming: (id, streaming) => {
     set(
       {

package/src/store/chat/slices/aiChat/initialState.ts

@@ -11,6 +11,10 @@ export interface ChatAIChatState {
    */
   messageRAGLoadingIds: string[];
   pluginApiLoadingIds: string[];
+  /**
+   * is the AI message is reasoning
+   */
+  reasoningLoadingIds: string[];
   /**
    * the tool calling stream ids
    */
@@ -23,5 +27,6 @@ export const initialAiChatState: ChatAIChatState = {
   inputMessage: '',
   messageRAGLoadingIds: [],
   pluginApiLoadingIds: [],
+  reasoningLoadingIds: [],
   toolCallingStreamIds: {},
 };

package/src/store/chat/slices/aiChat/selectors.ts

@@ -0,0 +1,9 @@
+
+import type { ChatStoreState } from '../../initialState';
+
+const isMessageInReasoning = (id: string) => (s: ChatStoreState) =>
+  s.reasoningLoadingIds.includes(id);
+
+export const aiChatSelectors = {
+  isMessageInReasoning,
+};

package/src/store/chat/slices/message/action.ts

@@ -17,6 +17,7 @@ import {
   ChatMessageError,
   CreateMessageParams,
   MessageToolCall,
+  ModelReasoning,
 } from '@/types/message';
 import { TraceEventPayloads } from '@/types/trace';
 import { setNamespace } from '@/utils/storeDebug';
@@ -73,6 +74,7 @@ export interface ChatMessageAction {
     id: string,
     content: string,
     toolCalls?: MessageToolCall[],
+    reasoning?: ModelReasoning,
   ) => Promise<void>;
   /**
    * update the message error with optimistic update
@@ -270,7 +272,7 @@ export const chatMessage: StateCreator<
     await messageService.updateMessage(id, { error });
     await get().refreshMessages();
   },
-  internal_updateMessageContent: async (id, content, toolCalls) => {
+  internal_updateMessageContent: async (id, content, toolCalls, reasoning) => {
     const { internal_dispatchMessage, refreshMessages, internal_transformToolCalls } = get();
 
     // Due to the async update method and refresh need about 100ms
@@ -289,6 +291,7 @@ export const chatMessage: StateCreator<
     await messageService.updateMessage(id, {
       content,
       tools: toolCalls ? internal_transformToolCalls(toolCalls) : undefined,
+      reasoning,
     });
     await refreshMessages();
   },

package/src/types/aiModel.ts

@@ -30,6 +30,10 @@ export interface ModelAbilities {
    * whether model supports function call
    */
   functionCall?: boolean;
+  /**
+   * whether model supports reasoning
+   */
+  reasoning?: boolean;
   /**
    *  whether model supports vision
    */
@@ -126,20 +130,7 @@ export interface AiModelConfig {
 }
 
 export interface AIChatModelCard extends AIBaseModelCard {
-  abilities?: {
-    /**
-     * whether model supports file upload
-     */
-    files?: boolean;
-    /**
-     * whether model supports function call
-     */
-    functionCall?: boolean;
-    /**
-     *  whether model supports vision
-     */
-    vision?: boolean;
-  };
+  abilities?: ModelAbilities;
   config?: AiModelConfig;
   maxOutput?: number;
   pricing?: ChatModelPricing;

package/src/types/message/base.ts

@@ -0,0 +1,59 @@
+export interface ModelReasoning {
+  content?: string;
+  duration?: number;
+}
+
+export type MessageRoleType = 'user' | 'system' | 'assistant' | 'tool';
+
+export interface MessageItem {
+  agentId: string | null;
+  clientId: string | null;
+  content: string | null;
+  createdAt: Date;
+  error: any | null;
+  favorite: boolean | null;
+  id: string;
+  model: string | null;
+  observationId: string | null;
+  parentId: string | null;
+  provider: string | null;
+  quotaId: string | null;
+  reasoning: ModelReasoning | null;
+  role: string;
+  sessionId: string | null;
+  threadId: string | null;
+  // jsonb type
+  tools: any | null;
+  topicId: string | null;
+  // jsonb type
+  traceId: string | null;
+  updatedAt: Date;
+  userId: string;
+}
+
+export interface NewMessage {
+  agentId?: string | null;
+  clientId?: string | null;
+  content?: string | null;
+  createdAt?: Date;
+  // optional because it has a default value
+  error?: any | null;
+  favorite?: boolean;
+  id?: string;
+  model?: string | null;
+  observationId?: string | null;
+  parentId?: string | null;
+  provider?: string | null;
+  quotaId?: string | null;
+  // optional because it has a default function
+  role: 'user' | 'system' | 'assistant' | 'tool';
+  // required because it's notNull
+  sessionId?: string | null;
+  threadId?: string | null;
+  tools?: any | null;
+  topicId?: string | null;
+  traceId?: string | null;
+  // optional because it's generated
+  updatedAt?: Date;
+  userId: string; // optional because it's generated
+}