@lobehub/lobehub 2.0.0-next.5 → 2.0.0-next.50

package/src/store/global/initialState.ts

@@ -50,10 +50,13 @@ export enum ProfileTabs {
   Profile = 'profile',
   Security = 'security',
   Stats = 'stats',
+  Usage = 'usage',
 }
 
 export interface SystemStatus {
   chatInputHeight?: number;
+  disabledModelProvidersSortType?: string;
+  disabledModelsSortType?: string;
   expandInputActionbar?: boolean;
   // which sessionGroup should expand
   expandSessionGroupKeys: string[];
@@ -96,6 +99,10 @@ export interface SystemStatus {
    * theme mode
    */
   themeMode?: ThemeMode;
+  /**
+   * 是否使用短格式显示 token
+   */
+  tokenDisplayFormatShort?: boolean;
   zenMode?: boolean;
 }
 
@@ -124,6 +131,8 @@ export interface GlobalState {
 
 export const INITIAL_STATUS = {
   chatInputHeight: 64,
+  disabledModelProvidersSortType: 'default',
+  disabledModelsSortType: 'default',
   expandInputActionbar: true,
   expandSessionGroupKeys: [SessionDefaultGroup.Pinned, SessionDefaultGroup.Default],
   fileManagerViewMode: 'list' as const,
@@ -146,6 +155,7 @@ export const INITIAL_STATUS = {
   showSystemRole: false,
   systemRoleExpandedMap: {},
   themeMode: 'auto',
+  tokenDisplayFormatShort: true,
   zenMode: false,
 } satisfies SystemStatus;
 

package/src/store/global/selectors/systemStatus.ts

@@ -63,8 +63,16 @@ const getAgentSystemRoleExpanded =
     return map[agentId] !== false; // 角色设定默认为展开状态
   };
 
+const disabledModelProvidersSortType = (s: GlobalState) =>
+  s.status.disabledModelProvidersSortType || 'default';
+const disabledModelsSortType = (s: GlobalState) => s.status.disabledModelsSortType || 'default';
+const tokenDisplayFormatShort = (s: GlobalState) =>
+  s.status.tokenDisplayFormatShort !== undefined ? s.status.tokenDisplayFormatShort : true;
+
 export const systemStatusSelectors = {
   chatInputHeight,
+  disabledModelProvidersSortType,
+  disabledModelsSortType,
   expandInputActionbar,
   filePanelWidth,
   getAgentSystemRoleExpanded,
@@ -93,5 +101,6 @@ export const systemStatusSelectors = {
   showSystemRole,
   systemStatus,
   themeMode,
+  tokenDisplayFormatShort,
   wideScreen,
 };

package/src/store/global/store.ts

@@ -4,25 +4,19 @@ import { createWithEqualityFn } from 'zustand/traditional';
 import { StateCreator } from 'zustand/vanilla';
 
 import { createDevtools } from '../middleware/createDevtools';
-import { type GlobalClientDBAction, clientDBSlice } from './actions/clientDb';
 import { type GlobalGeneralAction, generalActionSlice } from './actions/general';
 import { type GlobalWorkspacePaneAction, globalWorkspaceSlice } from './actions/workspacePane';
 import { type GlobalState, initialState } from './initialState';
 
 //  ===============  聚合 createStoreFn ============ //
 
-export interface GlobalStore
-  extends GlobalState,
-    GlobalWorkspacePaneAction,
-    GlobalClientDBAction,
-    GlobalGeneralAction {
+export interface GlobalStore extends GlobalState, GlobalWorkspacePaneAction, GlobalGeneralAction {
   /* empty */
 }
 
 const createStore: StateCreator<GlobalStore, [['zustand/devtools', never]]> = (...parameters) => ({
   ...initialState,
   ...globalWorkspaceSlice(...parameters),
-  ...clientDBSlice(...parameters),
   ...generalActionSlice(...parameters),
 });
 

package/src/store/session/slices/sessionGroup/action.test.ts

@@ -42,7 +42,7 @@ describe('createSessionGroupSlice', () => {
     it('should clear session groups and refresh sessions', async () => {
       const spyOn = vi
         .spyOn(sessionService, 'removeSessionGroups')
-        .mockResolvedValueOnce(undefined);
+        .mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -59,7 +59,7 @@ describe('createSessionGroupSlice', () => {
   describe('removeSessionGroup', () => {
     it('should remove a session group and refresh sessions', async () => {
       const mockId = 'mock-id';
-      vi.spyOn(sessionService, 'removeSessionGroup').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'removeSessionGroup').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -77,7 +77,7 @@ describe('createSessionGroupSlice', () => {
     it('should update a session group id and refresh sessions', async () => {
       const mockSessionId = 'session-id';
       const mockGroupId = 'group-id';
-      vi.spyOn(sessionService, 'updateSession').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSession').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -98,7 +98,7 @@ describe('createSessionGroupSlice', () => {
       const mockId = 'mock-id';
       const mockName = 'New Name';
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
-      vi.spyOn(sessionService, 'updateSessionGroup').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSessionGroup').mockResolvedValueOnce(undefined as any);
 
       const { result } = renderHook(() => useSessionStore());
 
@@ -117,7 +117,7 @@ describe('createSessionGroupSlice', () => {
         { id: 'id1', sort: 0 },
         { id: 'id2', sort: 1 },
       ];
-      vi.spyOn(sessionService, 'updateSessionGroupOrder').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSessionGroupOrder').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());

package/src/store/tool/selectors/tool.test.ts

@@ -78,7 +78,7 @@ describe('toolSelectors', () => {
 
   describe('metaList and getMetaById', () => {
     it('should return the correct list of tool metadata', () => {
-      const result = toolSelectors.metaList()(mockState);
+      const result = toolSelectors.metaList(mockState);
       expect(result).toEqual([
         {
           type: 'builtin',

package/src/store/tool/selectors/tool.ts

@@ -53,18 +53,16 @@ const enabledSystemRoles =
     return '';
   };
 
-const metaList =
-  (showDalle?: boolean) =>
-  (s: ToolStoreState): LobeToolMeta[] => {
-    const pluginList = pluginSelectors.installedPluginMetaList(s) as LobeToolMeta[];
+const metaList = (s: ToolStoreState): LobeToolMeta[] => {
+  const pluginList = pluginSelectors.installedPluginMetaList(s) as LobeToolMeta[];
 
-    return builtinToolSelectors.metaList(showDalle)(s).concat(pluginList);
-  };
+  return builtinToolSelectors.metaList(s).concat(pluginList);
+};
 
 const getMetaById =
-  (id: string, showDalle: boolean = true) =>
+  (id: string) =>
   (s: ToolStoreState): MetaData | undefined => {
-    const item = metaList(showDalle)(s).find((m) => m.identifier === id);
+    const item = metaList(s).find((m) => m.identifier === id);
 
     if (!item) return;
 

package/src/store/tool/slices/builtin/action.test.ts

@@ -6,19 +6,20 @@ import { useToolStore } from '../../store';
 vi.mock('zustand/traditional');
 
 describe('createBuiltinToolSlice', () => {
-  describe('invokeBuiltinTool', () => {
-    it('should return if the tool is already loading', async () => {
+  describe('transformApiArgumentsToAiState', () => {
+    it('should return early if the tool is already loading', async () => {
       // Given
-      const key = 'text2image';
-      const params = {};
+      const key = 'mockTool';
+      const params = { test: 'data' };
 
       const mockFn = vi.fn();
       const { result } = renderHook(() => useToolStore());
 
       act(() => {
         useToolStore.setState({
-          text2image: mockFn,
-        });
+          builtinToolLoading: { [key]: true },
+          mockTool: mockFn,
+        } as any);
       });
 
       await act(async () => {
@@ -27,61 +28,108 @@ describe('createBuiltinToolSlice', () => {
         expect(data).toBeUndefined();
       });
 
-      // Then
-      expect(mockFn).toHaveBeenCalled();
+      // Then - should not call the action if already loading
+      expect(mockFn).not.toHaveBeenCalled();
     });
 
     it('should invoke the specified tool action and return the stringified result', async () => {
       // Given
-      const key = 'text2image';
-
-      const mockFn = vi.fn();
+      const key = 'mockTool';
+      const mockResult = { success: true, data: 'test result' };
+      const mockFn = vi.fn().mockResolvedValue(mockResult);
       const { result } = renderHook(() => useToolStore());
 
       const params = {
-        prompts: ['test prompt'],
-        size: '512x512',
-        quality: 'standard',
-        style: 'vivid',
+        input: 'test input',
+        option: 'value',
       };
 
       act(() => {
         useToolStore.setState({
           builtinToolLoading: { [key]: false },
-          text2image: mockFn,
+          mockTool: mockFn,
+        } as any);
+      });
+
+      // When
+      let resultData: string | undefined;
+      await act(async () => {
+        resultData = await result.current.transformApiArgumentsToAiState(key, params);
+      });
+
+      // Then
+      expect(mockFn).toHaveBeenCalledWith({
+        input: 'test input',
+        option: 'value',
+      });
+      expect(resultData).toBe(JSON.stringify(mockResult));
+    });
+
+    it('should return stringified params if action does not exist', async () => {
+      // Given
+      const key = 'nonExistentTool';
+      const params = { test: 'data' };
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        useToolStore.setState({
+          builtinToolLoading: {},
         });
       });
+
       // When
+      let resultData: string | undefined;
       await act(async () => {
-        await result.current.transformApiArgumentsToAiState(key, params);
+        resultData = await result.current.transformApiArgumentsToAiState(key, params);
       });
 
-      expect(mockFn).toBeCalledWith({
-        prompts: ['test prompt'],
-        quality: 'standard',
-        size: '512x512',
-        style: 'vivid',
+      // Then
+      expect(resultData).toBe(JSON.stringify(params));
+    });
+
+    it('should handle errors and toggle loading state', async () => {
+      // Given
+      const key = 'mockTool';
+      const params = { test: 'data' };
+      const error = new Error('Tool execution failed');
+      const mockFn = vi.fn().mockRejectedValue(error);
+      const { result } = renderHook(() => useToolStore());
+
+      act(() => {
+        useToolStore.setState({
+          builtinToolLoading: { [key]: false },
+          mockTool: mockFn,
+        } as any);
+      });
+
+      // When/Then
+      await act(async () => {
+        await expect(result.current.transformApiArgumentsToAiState(key, params)).rejects.toThrow(
+          'Tool execution failed',
+        );
       });
+
+      // Should have toggled loading state back to false
+      expect(result.current.builtinToolLoading[key]).toBe(false);
     });
   });
 
-  describe('text2image', () => {
-    it('should map the prompts to DallEImageItem objects', () => {
-      // When
+  describe('toggleBuiltinToolLoading', () => {
+    it('should toggle the loading state for a tool', () => {
       const { result } = renderHook(() => useToolStore());
+      const key = 'testTool';
+
+      act(() => {
+        result.current.toggleBuiltinToolLoading(key, true);
+      });
+
+      expect(result.current.builtinToolLoading[key]).toBe(true);
 
-      const data = result.current.text2image({
-        prompts: ['prompt1', 'prompt2'],
-        size: '1024x1024',
-        quality: 'standard',
-        style: 'vivid',
+      act(() => {
+        result.current.toggleBuiltinToolLoading(key, false);
       });
 
-      // Then
-      expect(data).toEqual([
-        { prompt: 'prompt1', quality: 'standard', size: '1024x1024', style: 'vivid' },
-        { prompt: 'prompt2', quality: 'standard', size: '1024x1024', style: 'vivid' },
-      ]);
+      expect(result.current.builtinToolLoading[key]).toBe(false);
     });
   });
 });

package/src/store/tool/slices/builtin/action.ts

@@ -1,22 +1,15 @@
 import { StateCreator } from 'zustand/vanilla';
 
-import { OpenAIImagePayload } from '@/types/openai/image';
-import { DallEImageItem } from '@/types/tool/dalle';
 import { setNamespace } from '@/utils/storeDebug';
 
 import { ToolStore } from '../../store';
 
 const n = setNamespace('builtinTool');
 
-interface Text2ImageParams extends Pick<OpenAIImagePayload, 'quality' | 'style' | 'size'> {
-  prompts: string[];
-}
-
 /**
  * 代理行为接口
  */
 export interface BuiltinToolAction {
-  text2image: (params: Text2ImageParams) => DallEImageItem[];
   toggleBuiltinToolLoading: (key: string, value: boolean) => void;
   transformApiArgumentsToAiState: (key: string, params: any) => Promise<string | undefined>;
 }
@@ -27,8 +20,6 @@ export const createBuiltinToolSlice: StateCreator<
   [],
   BuiltinToolAction
 > = (set, get) => ({
-  text2image: ({ prompts, size = '1024x1024' as const, quality = 'standard', style = 'vivid' }) =>
-    prompts.map((p) => ({ prompt: p, quality, size, style })),
   toggleBuiltinToolLoading: (key, value) => {
     set({ builtinToolLoading: { [key]: value } }, false, n('toggleBuiltinToolLoading'));
   },

package/src/store/tool/slices/builtin/selectors.test.ts

@@ -1,7 +1,5 @@
 import { describe, expect, it } from 'vitest';
 
-import { DalleManifest } from '@/tools/dalle';
-
 import { ToolStoreState, initialState } from '../../initialState';
 import { builtinToolSelectors } from './selectors';
 
@@ -10,34 +8,11 @@ describe('builtinToolSelectors', () => {
     it('should return meta list excluding Dalle when showDalle is false', () => {
       const state = {
         ...initialState,
-        builtinTools: [
-          { identifier: 'tool-1', manifest: { meta: { title: 'Tool 1' } } },
-          { identifier: DalleManifest.identifier, manifest: { meta: { title: 'Dalle' } } },
-        ],
-      } as ToolStoreState;
-      const result = builtinToolSelectors.metaList(false)(state);
-      expect(result).toEqual([
-        { author: 'LobeHub', identifier: 'tool-1', meta: { title: 'Tool 1' }, type: 'builtin' },
-      ]);
-    });
-
-    it('should include Dalle when showDalle is true', () => {
-      const state = {
-        ...initialState,
-        builtinTools: [
-          { identifier: 'tool-1', manifest: { meta: { title: 'Tool 1' } } },
-          { identifier: DalleManifest.identifier, manifest: { meta: { title: 'Dalle' } } },
-        ],
+        builtinTools: [{ identifier: 'tool-1', manifest: { meta: { title: 'Tool 1' } } }],
       } as ToolStoreState;
-      const result = builtinToolSelectors.metaList(true)(state);
+      const result = builtinToolSelectors.metaList(state);
       expect(result).toEqual([
         { author: 'LobeHub', identifier: 'tool-1', meta: { title: 'Tool 1' }, type: 'builtin' },
-        {
-          author: 'LobeHub',
-          identifier: DalleManifest.identifier,
-          meta: { title: 'Dalle' },
-          type: 'builtin',
-        },
       ]);
     });
 
@@ -46,10 +21,9 @@ describe('builtinToolSelectors', () => {
         ...initialState,
         builtinTools: [
           { identifier: 'tool-1', hidden: true, manifest: { meta: { title: 'Tool 1' } } },
-          { identifier: DalleManifest.identifier, manifest: { meta: { title: 'Dalle' } } },
         ],
       } as ToolStoreState;
-      const result = builtinToolSelectors.metaList(false)(state);
+      const result = builtinToolSelectors.metaList(state);
       expect(result).toEqual([]);
     });
 
@@ -58,7 +32,7 @@ describe('builtinToolSelectors', () => {
         ...initialState,
         builtinTools: [],
       };
-      const result = builtinToolSelectors.metaList(false)(state);
+      const result = builtinToolSelectors.metaList(state);
       expect(result).toEqual([]);
     });
   });

package/src/store/tool/slices/builtin/selectors.ts

@@ -1,32 +1,26 @@
 import { LobeToolMeta } from '@lobechat/types';
 
 import { shouldEnableTool } from '@/helpers/toolFilters';
-import { DalleManifest } from '@/tools/dalle';
 
 import type { ToolStoreState } from '../../initialState';
 
-const metaList =
-  (showDalle?: boolean) =>
-  (s: ToolStoreState): LobeToolMeta[] =>
-    s.builtinTools
-      .filter((item) => {
-        // Filter hidden tools
-        if (item.hidden) return false;
+const metaList = (s: ToolStoreState): LobeToolMeta[] =>
+  s.builtinTools
+    .filter((item) => {
+      // Filter hidden tools
+      if (item.hidden) return false;
 
-        // Filter Dalle if not enabled
-        if (!showDalle && item.identifier === DalleManifest.identifier) return false;
+      // Filter platform-specific tools (e.g., LocalSystem desktop-only)
+      if (!shouldEnableTool(item.identifier)) return false;
 
-        // Filter platform-specific tools (e.g., LocalSystem desktop-only)
-        if (!shouldEnableTool(item.identifier)) return false;
-
-        return true;
-      })
-      .map((t) => ({
-        author: 'LobeHub',
-        identifier: t.identifier,
-        meta: t.manifest.meta,
-        type: 'builtin',
-      }));
+      return true;
+    })
+    .map((t) => ({
+      author: 'LobeHub',
+      identifier: t.identifier,
+      meta: t.manifest.meta,
+      type: 'builtin',
+    }));
 
 export const builtinToolSelectors = {
   metaList,

package/src/store/tool/slices/mcpStore/action.test.ts

@@ -20,6 +20,44 @@ vi.mock('@/utils/sleep', () => ({
   sleep: vi.fn().mockResolvedValue(undefined),
 }));
 
+const ORIGINAL_DESKTOP_ENV = process.env.NEXT_PUBLIC_IS_DESKTOP_APP;
+
+const bootstrapToolStoreWithDesktop = async (isDesktopEnv: boolean) => {
+  vi.resetModules();
+  vi.mock('zustand/traditional');
+  process.env.NEXT_PUBLIC_IS_DESKTOP_APP = isDesktopEnv ? '1' : '0';
+
+  vi.doMock('@lobechat/const', async () => {
+    const actual = await vi.importActual<typeof import('@lobechat/const')>('@lobechat/const');
+    return {
+      ...actual,
+      isDesktop: isDesktopEnv,
+    };
+  });
+
+  const storeModule = await import('@/store/tool');
+  const discoverModule = await import('@/services/discover');
+  const helpersModule = await import('@/store/global/helpers');
+
+  const cleanup = () => {
+    vi.resetModules();
+    vi.doUnmock('@lobechat/const');
+    vi.mock('zustand/traditional');
+    if (ORIGINAL_DESKTOP_ENV === undefined) {
+      delete process.env.NEXT_PUBLIC_IS_DESKTOP_APP;
+    } else {
+      process.env.NEXT_PUBLIC_IS_DESKTOP_APP = ORIGINAL_DESKTOP_ENV;
+    }
+  };
+
+  return {
+    useToolStore: storeModule.useToolStore,
+    discoverService: discoverModule.discoverService,
+    globalHelpers: helpersModule.globalHelpers,
+    cleanup,
+  };
+};
+
 beforeEach(() => {
   vi.clearAllMocks();
 
@@ -48,6 +86,14 @@ afterEach(() => {
   vi.restoreAllMocks();
 });
 
+afterAll(() => {
+  if (ORIGINAL_DESKTOP_ENV === undefined) {
+    delete process.env.NEXT_PUBLIC_IS_DESKTOP_APP;
+  } else {
+    process.env.NEXT_PUBLIC_IS_DESKTOP_APP = ORIGINAL_DESKTOP_ENV;
+  }
+});
+
 describe('mcpStore actions', () => {
   describe('updateMCPInstallProgress', () => {
     it('should update install progress for an identifier', () => {
@@ -487,7 +533,9 @@ describe('mcpStore actions', () => {
         expect(result.current.data).toEqual(mockData);
       });
 
-      expect(discoverService.getMCPPluginList).toHaveBeenCalledWith({ page: 1, pageSize: 20 });
+      expect(discoverService.getMCPPluginList).toHaveBeenCalledWith(
+        expect.objectContaining({ page: 1, pageSize: 20, connectionType: 'http' }),
+      );
 
       const state = useToolStore.getState();
       expect(state.mcpPluginItems).toEqual(mockData.items);
@@ -542,7 +590,9 @@ describe('mcpStore actions', () => {
       renderHook(() => useToolStore.getState().useFetchMCPPluginList(params));
 
       await waitFor(() => {
-        expect(discoverService.getMCPPluginList).toHaveBeenCalledWith(params);
+        expect(discoverService.getMCPPluginList).toHaveBeenCalledWith(
+          expect.objectContaining({ ...params, connectionType: 'http' }),
+        );
       });
     });
 
@@ -561,9 +611,51 @@ describe('mcpStore actions', () => {
       renderHook(() => useToolStore.getState().useFetchMCPPluginList(params));
 
       await waitFor(() => {
-        expect(discoverService.getMCPPluginList).toHaveBeenCalledWith(params);
+        expect(discoverService.getMCPPluginList).toHaveBeenCalledWith(
+          expect.objectContaining({ ...params, connectionType: 'http' }),
+        );
       });
     });
+
+    it('should not append connectionType in desktop environment', async () => {
+      const {
+        useToolStore: desktopStore,
+        discoverService: desktopDiscoverService,
+        globalHelpers: desktopGlobalHelpers,
+        cleanup,
+      } = await bootstrapToolStoreWithDesktop(true);
+
+      const mockData = {
+        items: [{ identifier: 'desktop-plugin', name: 'Desktop Plugin' }] as PluginItem[],
+        categories: [],
+        totalCount: 1,
+        totalPages: 1,
+        currentPage: 1,
+        pageSize: 20,
+      };
+
+      try {
+        vi.spyOn(desktopGlobalHelpers, 'getCurrentLanguage').mockReturnValue('en-US');
+        const fetchSpy = vi
+          .spyOn(desktopDiscoverService, 'getMCPPluginList')
+          .mockResolvedValue(mockData);
+
+        const { result } = renderHook(() =>
+          desktopStore.getState().useFetchMCPPluginList({ page: 1, pageSize: 20 }),
+        );
+
+        await waitFor(() => {
+          expect(result.current.data).toEqual(mockData);
+        });
+
+        expect(fetchSpy).toHaveBeenCalledTimes(1);
+        const [firstCallArgs] = fetchSpy.mock.calls[0];
+        expect(firstCallArgs).toMatchObject({ page: 1, pageSize: 20 });
+        expect(firstCallArgs.connectionType).toBeUndefined();
+      } finally {
+        cleanup();
+      }
+    });
   });
 
   describe('installMCPPlugin', () => {