@lobehub/chat 1.69.5 → 1.69.6

package/src/features/ModelSwitchPanel/index.tsx

@@ -1,8 +1,9 @@
-import { Icon } from '@lobehub/ui';
+import { ActionIcon, Icon } from '@lobehub/ui';
 import { Dropdown } from 'antd';
 import { createStyles } from 'antd-style';
 import type { ItemType } from 'antd/es/menu/interface';
-import { LucideArrowRight } from 'lucide-react';
+import { LucideArrowRight, LucideBolt } from 'lucide-react';
+import Link from 'next/link';
 import { useRouter } from 'next/navigation';
 import { PropsWithChildren, memo, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -86,17 +87,45 @@ const ModelSwitchPanel = memo<PropsWithChildren>(({ children }) => {
       return items;
     };
 
+    if (enabledList.length === 0)
+      return [
+        {
+          key: `no-provider`,
+          label: (
+            <Flexbox gap={8} horizontal style={{ color: theme.colorTextTertiary }}>
+              {t('ModelSwitchPanel.emptyProvider')}
+              <Icon icon={LucideArrowRight} />
+            </Flexbox>
+          ),
+          onClick: () => {
+            router.push(isDeprecatedEdition ? '/settings/llm' : `/settings/provider`);
+          },
+        },
+      ];
+
     // otherwise show with provider group
     return enabledList.map((provider) => ({
       children: getModelItems(provider),
       key: provider.id,
       label: (
-        <ProviderItemRender
-          logo={provider.logo}
-          name={provider.name}
-          provider={provider.id}
-          source={provider.source}
-        />
+        <Flexbox horizontal justify="space-between">
+          <ProviderItemRender
+            logo={provider.logo}
+            name={provider.name}
+            provider={provider.id}
+            source={provider.source}
+          />
+          <Link
+            href={isDeprecatedEdition ? '/settings/llm' : `/settings/provider/${provider.id}`}
+            prefetch={false}
+          >
+            <ActionIcon
+              icon={LucideBolt}
+              size={'small'}
+              title={t('ModelSwitchPanel.goToSettings')}
+            />
+          </Link>
+        </Flexbox>
       ),
       type: 'group',
     }));

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

@@ -102,7 +102,8 @@ export class LobeAnthropicAI implements LobeRuntimeAI {
 
     if (!!thinking) {
       const maxTokens =
-        max_tokens ?? (thinking?.budget_tokens ? thinking?.budget_tokens + 4096 : 4096);
+        // claude 3.7 thinking has max output of 64000 tokens
+        max_tokens ?? (thinking?.budget_tokens ? thinking?.budget_tokens + 64_000 : 8192);
 
       // `temperature` may only be set to 1 when thinking is enabled.
       // `top_p` must be unset when thinking is enabled.
@@ -117,7 +118,9 @@ export class LobeAnthropicAI implements LobeRuntimeAI {
     }
 
     return {
-      max_tokens: max_tokens ?? 4096,
+      // claude 3 series model hax max output token of 4096, 3.x series has 8192
+      // https://docs.anthropic.com/en/docs/about-claude/models/all-models#:~:text=200K-,Max%20output,-Normal%3A
+      max_tokens: max_tokens ?? (model.startsWith('claude-3-') ? 4096 : 8192),
       messages: postMessages,
       model,
       system: systemPrompts,

package/src/locales/default/components.ts

@@ -87,7 +87,9 @@ export default {
   },
   ModelSwitchPanel: {
     emptyModel: '没有启用的模型，请前往设置开启',
-    provider: '提供商',
+    emptyProvider: '没有启用的服务商，请前往设置开启',
+    goToSettings: '前往设置',
+    provider: '服务商',
   },
   OllamaSetupGuide: {
     cors: {

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

@@ -26,12 +26,16 @@ import {
   ModelProvider,
 } from '@/libs/agent-runtime';
 import { AgentRuntime } from '@/libs/agent-runtime';
+import { agentChatConfigSelectors } from '@/store/agent/selectors';
+import { aiModelSelectors } from '@/store/aiInfra';
 import { useToolStore } from '@/store/tool';
+import { toolSelectors } from '@/store/tool/selectors';
 import { UserStore } from '@/store/user';
 import { useUserStore } from '@/store/user';
 import { modelConfigSelectors } from '@/store/user/selectors';
 import { UserSettingsState, initialSettingsState } from '@/store/user/slices/settings/initialState';
 import { DalleManifest } from '@/tools/dalle';
+import { WebBrowsingManifest } from '@/tools/web-browsing';
 import { ChatMessage } from '@/types/message';
 import { ChatStreamPayload, type OpenAIChatMessage } from '@/types/openai/chat';
 import { LobeTool } from '@/types/tool';
@@ -480,6 +484,125 @@ describe('ChatService', () => {
         expect(calls![1]).toBeUndefined();
       });
     });
+
+    describe('search functionality', () => {
+      it('should add WebBrowsingManifest when search is enabled and not using model built-in search', async () => {
+        const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
+
+        const messages = [{ content: 'Search for something', role: 'user' }] as ChatMessage[];
+
+        // Mock agent store state with search enabled
+        vi.spyOn(agentChatConfigSelectors, 'currentChatConfig').mockReturnValueOnce({
+          searchMode: 'auto', // not 'off'
+          useModelBuiltinSearch: false,
+        } as any);
+
+        // Mock AI infra store state
+        vi.spyOn(aiModelSelectors, 'isModelHasBuiltinSearch').mockReturnValueOnce(() => false);
+        vi.spyOn(aiModelSelectors, 'isModelHasExtendParams').mockReturnValueOnce(() => false);
+
+        // Mock tool selectors
+        vi.spyOn(toolSelectors, 'enabledSchema').mockReturnValueOnce(() => [
+          {
+            type: 'function',
+            function: {
+              name: WebBrowsingManifest.identifier + '____search',
+              description: 'Search the web',
+            },
+          },
+        ]);
+
+        await chatService.createAssistantMessage({ messages, plugins: [] });
+
+        // Verify tools were passed to getChatCompletion
+        expect(getChatCompletionSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            tools: expect.arrayContaining([
+              expect.objectContaining({
+                function: expect.objectContaining({
+                  name: expect.stringContaining(WebBrowsingManifest.identifier),
+                }),
+              }),
+            ]),
+          }),
+          undefined,
+        );
+      });
+
+      it('should enable built-in search when model supports it and useModelBuiltinSearch is true', async () => {
+        const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
+
+        const messages = [{ content: 'Search for something', role: 'user' }] as ChatMessage[];
+
+        // Mock agent store state with search enabled and useModelBuiltinSearch enabled
+        vi.spyOn(agentChatConfigSelectors, 'currentChatConfig').mockReturnValueOnce({
+          searchMode: 'auto', // not 'off'
+          useModelBuiltinSearch: true,
+        } as any);
+
+        // Mock AI infra store state - model has built-in search
+        vi.spyOn(aiModelSelectors, 'isModelHasBuiltinSearch').mockReturnValueOnce(() => true);
+        vi.spyOn(aiModelSelectors, 'isModelHasExtendParams').mockReturnValueOnce(() => false);
+
+        // Mock tool selectors
+        vi.spyOn(toolSelectors, 'enabledSchema').mockReturnValueOnce(() => [
+          {
+            type: 'function',
+            function: {
+              name: WebBrowsingManifest.identifier + '____search',
+              description: 'Search the web',
+            },
+          },
+        ]);
+
+        await chatService.createAssistantMessage({ messages, plugins: [] });
+
+        // Verify enabledSearch was set to true
+        expect(getChatCompletionSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            enabledSearch: true,
+          }),
+          undefined,
+        );
+      });
+
+      it('should not enable search when searchMode is off', async () => {
+        const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
+
+        const messages = [{ content: 'Search for something', role: 'user' }] as ChatMessage[];
+
+        // Mock agent store state with search disabled
+        vi.spyOn(agentChatConfigSelectors, 'currentChatConfig').mockReturnValueOnce({
+          searchMode: 'off',
+          useModelBuiltinSearch: true,
+        } as any);
+
+        // Mock AI infra store state
+        vi.spyOn(aiModelSelectors, 'isModelHasBuiltinSearch').mockReturnValueOnce(() => true);
+        vi.spyOn(aiModelSelectors, 'isModelHasExtendParams').mockReturnValueOnce(() => false);
+
+        // Mock tool selectors
+        vi.spyOn(toolSelectors, 'enabledSchema').mockReturnValueOnce(() => [
+          {
+            type: 'function',
+            function: {
+              name: WebBrowsingManifest.identifier + '____search',
+              description: 'Search the web',
+            },
+          },
+        ]);
+
+        await chatService.createAssistantMessage({ messages, plugins: [] });
+
+        // Verify enabledSearch was not set
+        expect(getChatCompletionSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            enabledSearch: undefined,
+          }),
+          undefined,
+        );
+      });
+    });
   });
 
   describe('getChatCompletion', () => {

package/src/services/chat.ts

@@ -19,12 +19,7 @@ import { filesPrompts } from '@/prompts/files';
 import { BuiltinSystemRolePrompts } from '@/prompts/systemRole';
 import { getAgentStoreState } from '@/store/agent';
 import { agentChatConfigSelectors } from '@/store/agent/selectors';
-import {
-  aiModelSelectors,
-  aiProviderSelectors,
-  getAiInfraStoreState,
-  useAiInfraStore,
-} from '@/store/aiInfra';
+import { aiModelSelectors, aiProviderSelectors, getAiInfraStoreState } from '@/store/aiInfra';
 import { getSessionStoreState } from '@/store/session';
 import { sessionMetaSelectors } from '@/store/session/selectors';
 import { getToolStoreState } from '@/store/tool';
@@ -74,9 +69,9 @@ const findDeploymentName = (model: string, provider: string) => {
     if (deploymentName) deploymentId = deploymentName;
   } else {
     // find the model by id
-    const modelItem = useAiInfraStore
-      .getState()
-      .enabledAiModels?.find((i) => i.id === model && i.providerId === provider);
+    const modelItem = getAiInfraStoreState().enabledAiModels?.find(
+      (i) => i.id === model && i.providerId === provider,
+    );
 
     if (modelItem && modelItem.config?.deploymentName) {
       deploymentId = modelItem.config?.deploymentName;
@@ -91,7 +86,7 @@ const isEnableFetchOnClient = (provider: string) => {
   if (isDeprecatedEdition) {
     return modelConfigSelectors.isProviderFetchOnClient(provider)(useUserStore.getState());
   } else {
-    return aiProviderSelectors.isProviderFetchOnClient(provider)(useAiInfraStore.getState());
+    return aiProviderSelectors.isProviderFetchOnClient(provider)(getAiInfraStoreState());
   }
 };
 
@@ -181,10 +176,10 @@ class ChatService {
     const isModelHasBuiltinSearch = aiModelSelectors.isModelHasBuiltinSearch(
       payload.model,
       payload.provider!,
-    )(useAiInfraStore.getState());
+    )(getAiInfraStoreState());
 
-    const useApplicationBuiltinSearchTool =
-      enabledSearch && !(isModelHasBuiltinSearch && chatConfig.useModelBuiltinSearch);
+    const useModelSearch = isModelHasBuiltinSearch && chatConfig.useModelBuiltinSearch;
+    const useApplicationBuiltinSearchTool = enabledSearch && !useModelSearch;
 
     const pluginIds = [...(enabledPlugins || [])];
 
@@ -225,14 +220,14 @@ class ChatService {
     const isModelHasExtendParams = aiModelSelectors.isModelHasExtendParams(
       payload.model,
       payload.provider!,
-    )(useAiInfraStore.getState());
+    )(getAiInfraStoreState());
 
     // model
     if (isModelHasExtendParams) {
       const modelExtendParams = aiModelSelectors.modelExtendParams(
         payload.model,
         payload.provider!,
-      )(useAiInfraStore.getState());
+      )(getAiInfraStoreState());
       // if model has extended params, then we need to check if the model can use reasoning
 
       if (modelExtendParams!.includes('enableReasoning') && chatConfig.enableReasoning) {
@@ -241,13 +236,19 @@ class ChatService {
           type: 'enabled',
         };
       }
+      if (
+        modelExtendParams!.includes('disableContextCaching') &&
+        chatConfig.disableContextCaching
+      ) {
+        extendParams.enabledContextCaching = false;
+      }
     }
 
     return this.getChatCompletion(
       {
         ...params,
         ...extendParams,
-        enabledSearch: enabledSearch && isModelHasBuiltinSearch ? true : undefined,
+        enabledSearch: enabledSearch && useModelSearch ? true : undefined,
         messages: oaiMessages,
         tools,
       },
@@ -351,9 +352,8 @@ class ChatService {
 
     // TODO: remove `!isDeprecatedEdition` condition in V2.0
     if (!isDeprecatedEdition && !isBuiltin) {
-      const providerConfig = aiProviderSelectors.providerConfigById(provider)(
-        useAiInfraStore.getState(),
-      );
+      const providerConfig =
+        aiProviderSelectors.providerConfigById(provider)(getAiInfraStoreState());
 
       sdkType = providerConfig?.settings.sdkType || 'openai';
     }

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

@@ -159,7 +159,7 @@ describe('fetchSSE', () => {
     expectedMessages.forEach((message, index) => {
       expect(mockOnMessageHandle).toHaveBeenNthCalledWith(index + 1, message);
     });
-    
+
     // more assertions for each character...
     expect(mockOnFinish).toHaveBeenCalledWith('Hello World', {
       observationId: null,
@@ -188,6 +188,7 @@ describe('fetchSSE', () => {
       await fetchSSE('/', {
         onMessageHandle: mockOnMessageHandle,
         onFinish: mockOnFinish,
+        smoothing: false,
       });
 
       expect(mockOnMessageHandle).toHaveBeenNthCalledWith(1, { text: 'Hello', type: 'reasoning' });
@@ -225,7 +226,7 @@ describe('fetchSSE', () => {
       grounding: 'Hello',
       type: 'grounding',
     });
-    
+
     expect(mockOnFinish).toHaveBeenCalledWith('hi', {
       observationId: null,
       toolCalls: undefined,

package/src/utils/fetch/fetchSSE.ts

@@ -296,7 +296,7 @@ export const fetchSSE = async (url: string, options: RequestInit & FetchSSEOptio
 
   const { smoothing } = options;
 
-  const textSmoothing = typeof smoothing === 'boolean' ? smoothing : smoothing?.text;
+  const textSmoothing = typeof smoothing === 'boolean' ? smoothing : (smoothing?.text ?? true);
   const toolsCallingSmoothing =
     typeof smoothing === 'boolean' ? smoothing : (smoothing?.toolsCalling ?? true);
   const smoothingSpeed = isObject(smoothing) ? smoothing.speed : undefined;