@lobehub/chat 1.69.6 → 1.70.1

package/src/libs/agent-runtime/anthropic/index.test.ts

@@ -1,7 +1,7 @@
 // @vitest-environment node
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { ChatCompletionTool } from '@/libs/agent-runtime';
+import { ChatCompletionTool, ChatStreamPayload } from '@/libs/agent-runtime';
 
 import * as anthropicHelpers from '../utils/anthropicHelpers';
 import * as debugStreamModule from '../utils/debugStream';
@@ -511,5 +511,319 @@ describe('LobeAnthropicAI', () => {
         ).resolves.toBeInstanceOf(Response);
       });
     });
+
+    describe('buildAnthropicPayload', () => {
+      it('should correctly build payload with user messages only', async () => {
+        const payload: ChatStreamPayload = {
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.5,
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result).toEqual({
+          max_tokens: 4096,
+          messages: [
+            {
+              content: [{ cache_control: { type: 'ephemeral' }, text: 'Hello', type: 'text' }],
+              role: 'user',
+            },
+          ],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.25,
+        });
+      });
+
+      it('should correctly build payload with system message', async () => {
+        const payload: ChatStreamPayload = {
+          messages: [
+            { content: 'You are a helpful assistant', role: 'system' },
+            { content: 'Hello', role: 'user' },
+          ],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.7,
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result).toEqual({
+          max_tokens: 4096,
+          messages: [
+            {
+              content: [{ cache_control: { type: 'ephemeral' }, text: 'Hello', type: 'text' }],
+              role: 'user',
+            },
+          ],
+          model: 'claude-3-haiku-20240307',
+          system: [
+            {
+              cache_control: { type: 'ephemeral' },
+              text: 'You are a helpful assistant',
+              type: 'text',
+            },
+          ],
+          temperature: 0.35,
+        });
+      });
+
+      it('should correctly build payload with tools', async () => {
+        const tools: ChatCompletionTool[] = [
+          { function: { name: 'tool1', description: 'desc1' }, type: 'function' },
+        ];
+
+        const spyOn = vi.spyOn(anthropicHelpers, 'buildAnthropicTools').mockReturnValueOnce([
+          {
+            name: 'tool1',
+            description: 'desc1',
+          },
+        ] as any);
+
+        const payload: ChatStreamPayload = {
+          messages: [{ content: 'Use a tool', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.8,
+          tools,
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result).toEqual({
+          max_tokens: 4096,
+          messages: [
+            {
+              content: [{ cache_control: { type: 'ephemeral' }, text: 'Use a tool', type: 'text' }],
+              role: 'user',
+            },
+          ],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.4,
+          tools: [{ name: 'tool1', description: 'desc1' }],
+        });
+
+        expect(spyOn).toHaveBeenCalledWith(tools, {
+          enabledContextCaching: true,
+        });
+      });
+
+      it('should correctly build payload with thinking mode enabled', async () => {
+        const payload: ChatStreamPayload = {
+          messages: [{ content: 'Solve this problem', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.9,
+          thinking: { type: 'enabled', budget_tokens: 0 },
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result).toEqual({
+          max_tokens: 64000,
+          messages: [
+            {
+              content: [
+                { cache_control: { type: 'ephemeral' }, text: 'Solve this problem', type: 'text' },
+              ],
+              role: 'user',
+            },
+          ],
+          model: 'claude-3-haiku-20240307',
+          thinking: { type: 'enabled', budget_tokens: 0 },
+        });
+      });
+
+      it('should respect max_tokens in thinking mode when provided', async () => {
+        const payload: ChatStreamPayload = {
+          max_tokens: 1000,
+          messages: [{ content: 'Solve this problem', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.7,
+          thinking: { type: 'enabled', budget_tokens: 0 },
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result).toEqual({
+          max_tokens: 1000,
+          messages: [
+            {
+              content: [
+                { cache_control: { type: 'ephemeral' }, text: 'Solve this problem', type: 'text' },
+              ],
+              role: 'user',
+            },
+          ],
+          model: 'claude-3-haiku-20240307',
+          thinking: { type: 'enabled', budget_tokens: 0 },
+        });
+      });
+
+      it('should use budget_tokens in thinking mode when provided', async () => {
+        const payload: ChatStreamPayload = {
+          max_tokens: 1000,
+          messages: [{ content: 'Solve this problem', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.5,
+          thinking: { type: 'enabled', budget_tokens: 2000 },
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result).toEqual({
+          max_tokens: 3000, // budget_tokens + max_tokens
+          messages: [
+            {
+              content: [
+                { cache_control: { type: 'ephemeral' }, text: 'Solve this problem', type: 'text' },
+              ],
+              role: 'user',
+            },
+          ],
+          model: 'claude-3-haiku-20240307',
+          thinking: { type: 'enabled', budget_tokens: 2000 },
+        });
+      });
+
+      it('should cap max_tokens at 64000 in thinking mode', async () => {
+        const payload: ChatStreamPayload = {
+          max_tokens: 10000,
+          messages: [{ content: 'Solve this problem', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.6,
+          thinking: { type: 'enabled', budget_tokens: 60000 },
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result).toEqual({
+          max_tokens: 64000, // capped at 64000
+          messages: [
+            {
+              content: [
+                { cache_control: { type: 'ephemeral' }, text: 'Solve this problem', type: 'text' },
+              ],
+              role: 'user',
+            },
+          ],
+          model: 'claude-3-haiku-20240307',
+          thinking: { type: 'enabled', budget_tokens: 60000 },
+        });
+      });
+
+      it('should set correct max_tokens based on model for claude-3 models', async () => {
+        const payload: ChatStreamPayload = {
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.7,
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result.max_tokens).toBe(4096);
+      });
+
+      it('should set correct max_tokens based on model for non claude-3 models', async () => {
+        const payload: ChatStreamPayload = {
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'claude-2.1',
+          temperature: 0.7,
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result.max_tokens).toBe(8192);
+      });
+
+      it('should respect max_tokens when explicitly provided', async () => {
+        const payload: ChatStreamPayload = {
+          max_tokens: 2000,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.7,
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result.max_tokens).toBe(2000);
+      });
+
+      it('should correctly handle temperature scaling', async () => {
+        const payload: ChatStreamPayload = {
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 1.0,
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result.temperature).toBe(0.5); // Anthropic uses 0-1 scale, so divide by 2
+      });
+
+      it('should not include temperature when not provided in payload', async () => {
+        // We need to create a partial payload without temperature
+        // but since the type requires it, we'll use type assertion
+        const partialPayload = {
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+        } as ChatStreamPayload;
+
+        // Delete the temperature property to simulate it not being provided
+        delete (partialPayload as any).temperature;
+
+        const result = await instance['buildAnthropicPayload'](partialPayload);
+
+        expect(result.temperature).toBeUndefined();
+      });
+
+      it('should not include top_p when thinking is enabled', async () => {
+        const payload: ChatStreamPayload = {
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.7,
+          thinking: { type: 'enabled', budget_tokens: 0 },
+          top_p: 0.9,
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result.top_p).toBeUndefined();
+      });
+
+      it('should include top_p when thinking is not enabled', async () => {
+        const payload: ChatStreamPayload = {
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.7,
+          top_p: 0.9,
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        expect(result.top_p).toBe(0.9);
+      });
+
+      it('should handle thinking with type disabled', async () => {
+        const payload: ChatStreamPayload = {
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.7,
+          thinking: { type: 'disabled', budget_tokens: 0 },
+        };
+
+        const result = await instance['buildAnthropicPayload'](payload);
+
+        // When thinking is disabled, it should be treated as if thinking wasn't provided
+        expect(result).toEqual({
+          max_tokens: 4096,
+          messages: [
+            {
+              content: [{ cache_control: { type: 'ephemeral' }, text: 'Hello', type: 'text' }],
+              role: 'user',
+            },
+          ],
+          model: 'claude-3-haiku-20240307',
+          temperature: 0.35,
+        });
+      });
+    });
   });
 });

package/src/libs/agent-runtime/anthropic/index.ts

@@ -100,10 +100,13 @@ export class LobeAnthropicAI implements LobeRuntimeAI {
 
     const postTools = buildAnthropicTools(tools, { enabledContextCaching });
 
-    if (!!thinking) {
-      const maxTokens =
-        // claude 3.7 thinking has max output of 64000 tokens
-        max_tokens ?? (thinking?.budget_tokens ? thinking?.budget_tokens + 64_000 : 8192);
+    if (!!thinking && thinking.type === 'enabled') {
+      // claude 3.7 thinking has max output of 64000 tokens
+      const maxTokens = !!max_tokens
+        ? thinking?.budget_tokens && thinking?.budget_tokens > max_tokens
+          ? Math.min(thinking?.budget_tokens + max_tokens, 64_000)
+          : max_tokens
+        : 64_000;
 
       // `temperature` may only be set to 1 when thinking is enabled.
       // `top_p` must be unset when thinking is enabled.

package/src/locales/default/chat.ts

@@ -65,6 +65,9 @@ export default {
     stop: '停止',
     warp: '换行',
   },
+  intentUnderstanding: {
+    title: '正在理解并分析您的意图...',
+  },
   knowledgeBase: {
     all: '所有内容',
     allFiles: '所有文件',
@@ -142,13 +145,11 @@ export default {
       searchQueries: '搜索关键词',
       title: '已搜索到 {{count}} 个结果',
     },
-
     mode: {
       auto: {
         desc: '根据对话内容智能判断是否需要搜索',
         title: '智能联网',
       },
-      disable: '当前模型不支持函数调用，因此无法使用智能联网功能',
       off: {
         desc: '仅使用模型的基础知识，不进行网络搜索',
         title: '关闭联网',
@@ -159,7 +160,10 @@ export default {
       },
       useModelBuiltin: '使用模型内置搜索引擎',
     },
-
+    searchModel: {
+      desc: '当前模型不支持函数调用，因此需要搭配支持函数调用的模型才能联网搜索',
+      title: '搜索辅助模型',
+    },
     title: '联网搜索',
   },
   searchAgentPlaceholder: '搜索助手...',

package/src/server/routers/tools/search.ts

@@ -20,7 +20,14 @@ export const searchRouter = router({
       }),
     )
     .mutation(async ({ input }) => {
-      const crawler = new Crawler();
+      const envString = toolsEnv.CRAWLER_IMPLS || '';
+
+      // 处理全角逗号和多余空格
+      let envValue = envString.replaceAll('，', ',').trim();
+
+      const impls = envValue.split(',').filter(Boolean);
+
+      const crawler = new Crawler({ impls });
 
       const results = await pMap(
         input.urls,

package/src/services/__tests__/chat.test.ts

@@ -877,6 +877,7 @@ describe('ChatService', () => {
         // 重新模拟模块，设置 isServerMode 为 true
         vi.doMock('@/const/version', () => ({
           isServerMode: true,
+          isDeprecatedEdition: false,
         }));
 
         // 需要在修改模拟后重新导入相关模块

package/src/services/chat.ts

@@ -32,6 +32,7 @@ import {
   userProfileSelectors,
 } from '@/store/user/selectors';
 import { WebBrowsingManifest } from '@/tools/web-browsing';
+import { WorkingModel } from '@/types/agent';
 import { ChatErrorType } from '@/types/fetch';
 import { ChatMessage, MessageToolCall } from '@/types/message';
 import type { ChatStreamPayload, OpenAIChatMessage } from '@/types/openai/chat';
@@ -201,17 +202,10 @@ class ChatService {
 
     // ============  2. preprocess tools   ============ //
 
-    let filterTools = toolSelectors.enabledSchema(pluginIds)(getToolStoreState());
-
-    // check this model can use function call
-    const canUseFC = isCanUseFC(payload.model, payload.provider!);
-
-    // the rule that model can use tools:
-    // 1. tools is not empty
-    // 2. model can use function call
-    const shouldUseTools = filterTools.length > 0 && canUseFC;
-
-    const tools = shouldUseTools ? filterTools : undefined;
+    const tools = this.prepareTools(pluginIds, {
+      model: payload.model,
+      provider: payload.provider!,
+    });
 
     // ============  3. process extend params   ============ //
 
@@ -433,16 +427,30 @@ class ChatService {
     onLoadingChange?.(true);
 
     try {
-      await this.getChatCompletion(params, {
-        onErrorHandle: (error) => {
-          errorHandle(new Error(error.message), error);
-        },
-        onFinish,
-        onMessageHandle,
-        signal: abortController?.signal,
-        trace: this.mapTrace(trace, TraceTagMap.SystemChain),
+      const oaiMessages = this.processMessages({
+        messages: params.messages as any,
+        model: params.model!,
+        provider: params.provider!,
+        tools: params.plugins,
+      });
+      const tools = this.prepareTools(params.plugins || [], {
+        model: params.model!,
+        provider: params.provider!,
       });
 
+      await this.getChatCompletion(
+        { ...params, messages: oaiMessages, tools },
+        {
+          onErrorHandle: (error) => {
+            errorHandle(new Error(error.message), error);
+          },
+          onFinish,
+          onMessageHandle,
+          signal: abortController?.signal,
+          trace: this.mapTrace(trace, TraceTagMap.SystemChain),
+        },
+      );
+
       onLoadingChange?.(false);
     } catch (e) {
       errorHandle(e as Error);
@@ -451,7 +459,7 @@ class ChatService {
 
   private processMessages = (
     {
-      messages,
+      messages = [],
       tools,
       model,
       provider,
@@ -483,6 +491,7 @@ class ChatService {
     };
 
     let postMessages = messages.map((m): OpenAIChatMessage => {
+      const supportTools = isCanUseFC(model, provider);
       switch (m.role) {
         case 'user': {
           return { content: getContent(m), role: m.role };
@@ -492,17 +501,23 @@ class ChatService {
           // signature is a signal of anthropic thinking mode
           const shouldIncludeThinking = m.reasoning && !!m.reasoning?.signature;
 
+          const content = shouldIncludeThinking
+            ? [
+                {
+                  signature: m.reasoning!.signature,
+                  thinking: m.reasoning!.content,
+                  type: 'thinking',
+                } as any,
+                { text: m.content, type: 'text' },
+              ]
+            : m.content;
+
+          if (!supportTools) {
+            return { content, role: m.role };
+          }
+
           return {
-            content: shouldIncludeThinking
-              ? [
-                  {
-                    signature: m.reasoning!.signature,
-                    thinking: m.reasoning!.content,
-                    type: 'thinking',
-                  } as any,
-                  { text: m.content, type: 'text' },
-                ]
-              : m.content,
+            content,
             role: m.role,
             tool_calls: m.tools?.map(
               (tool): MessageToolCall => ({
@@ -518,6 +533,10 @@ class ChatService {
         }
 
         case 'tool': {
+          if (!supportTools) {
+            return { content: m.content, role: 'user' };
+          }
+
           return {
             content: m.content,
             name: genToolCallingName(m.plugin!.identifier, m.plugin!.apiName, m.plugin?.type),
@@ -669,6 +688,20 @@ class ChatService {
 
     return reorderedMessages;
   };
+
+  private prepareTools = (pluginIds: string[], { model, provider }: WorkingModel) => {
+    let filterTools = toolSelectors.enabledSchema(pluginIds)(getToolStoreState());
+
+    // check this model can use function call
+    const canUseFC = isCanUseFC(model, provider!);
+
+    // the rule that model can use tools:
+    // 1. tools is not empty
+    // 2. model can use function call
+    const shouldUseTools = filterTools.length > 0 && canUseFC;
+
+    return shouldUseTools ? filterTools : undefined;
+  };
 }
 
 export const chatService = new ChatService();

package/src/services/session/type.ts

@@ -53,7 +53,7 @@ export interface ISessionService {
 
   updateSessionChatConfig(
     id: string,
-    config: DeepPartial<LobeAgentChatConfig>,
+    config: Partial<LobeAgentChatConfig>,
     signal?: AbortSignal,
   ): Promise<any>;
 

package/src/store/agent/slices/chat/selectors/__snapshots__/agent.test.ts.snap

@@ -11,6 +11,10 @@ exports[`agentSelectors > defaultAgentConfig > should merge DEFAULT_AGENT_CONFIG
     "enableReasoning": false,
     "historyCount": 8,
     "reasoningBudgetToken": 1024,
+    "searchFCModel": {
+      "model": "gpt-4o-mini",
+      "provider": "openai",
+    },
     "searchMode": "off",
   },
   "model": "gpt-3.5-turbo",

package/src/store/agent/slices/chat/selectors/chatConfig.ts

@@ -1,5 +1,5 @@
 import { contextCachingModels, thinkingWithToolClaudeModels } from '@/const/models';
-import { DEFAULT_AGENT_CHAT_CONFIG } from '@/const/settings';
+import { DEFAULT_AGENT_CHAT_CONFIG, DEFAULT_AGENT_SEARCH_FC_MODEL } from '@/const/settings';
 import { AgentStoreState } from '@/store/agent/initialState';
 import { LobeAgentChatConfig } from '@/types/agent';
 
@@ -14,6 +14,9 @@ const isAgentEnableSearch = (s: AgentStoreState) => agentSearchMode(s) !== 'off'
 const useModelBuiltinSearch = (s: AgentStoreState) =>
   currentAgentChatConfig(s).useModelBuiltinSearch;
 
+const searchFCModel = (s: AgentStoreState) =>
+  currentAgentChatConfig(s).searchFCModel || DEFAULT_AGENT_SEARCH_FC_MODEL;
+
 const enableHistoryCount = (s: AgentStoreState) => {
   const config = currentAgentConfig(s);
   const chatConfig = currentAgentChatConfig(s);
@@ -62,5 +65,6 @@ export const agentChatConfigSelectors = {
   enableHistoryDivider,
   historyCount,
   isAgentEnableSearch,
+  searchFCModel,
   useModelBuiltinSearch,
 };

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

@@ -765,10 +765,12 @@ describe('chatMessage actions', () => {
       (fetch as Mock).mockResolvedValueOnce(new Response(aiResponse));
 
       await act(async () => {
-        const response = await result.current.internal_fetchAIChatMessage(
+        const response = await result.current.internal_fetchAIChatMessage({
           messages,
-          assistantMessageId,
-        );
+          messageId: assistantMessageId,
+          model: 'gpt-4o-mini',
+          provider: 'openai',
+        });
         expect(response.isFunctionCall).toEqual(false);
       });
     });
@@ -784,7 +786,13 @@ describe('chatMessage actions', () => {
 
       await act(async () => {
         expect(
-          await result.current.internal_fetchAIChatMessage(messages, assistantMessageId),
+          await result.current.internal_fetchAIChatMessage({
+            model: 'gpt-4o-mini',
+            provider: 'openai',
+
+            messages,
+            messageId: assistantMessageId,
+          }),
         ).toEqual({
           isFunctionCall: false,
         });