@lobehub/chat 1.0.0 → 1.0.2

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

@@ -0,0 +1,73 @@
+import { t } from 'i18next';
+import { StateCreator } from 'zustand/vanilla';
+
+import { message } from '@/components/AntdStaticMethods';
+import { sessionService } from '@/services/session';
+import { SessionStore } from '@/store/session';
+import { SessionGroupItem } from '@/types/session';
+
+import { SessionGroupsDispatch, sessionGroupsReducer } from './reducer';
+
+/* eslint-disable typescript-sort-keys/interface */
+export interface SessionGroupAction {
+  addSessionGroup: (name: string) => Promise<string>;
+  clearSessionGroups: () => Promise<void>;
+  removeSessionGroup: (id: string) => Promise<void>;
+  updateSessionGroupName: (id: string, name: string) => Promise<void>;
+  updateSessionGroupSort: (items: SessionGroupItem[]) => Promise<void>;
+  internal_dispatchSessionGroups: (payload: SessionGroupsDispatch) => void;
+}
+/* eslint-enable */
+
+export const createSessionGroupSlice: StateCreator<
+  SessionStore,
+  [['zustand/devtools', never]],
+  [],
+  SessionGroupAction
+> = (set, get) => ({
+  addSessionGroup: async (name) => {
+    const id = await sessionService.createSessionGroup(name);
+
+    await get().refreshSessions();
+
+    return id;
+  },
+
+  clearSessionGroups: async () => {
+    await sessionService.removeSessionGroups();
+    await get().refreshSessions();
+  },
+
+  removeSessionGroup: async (id) => {
+    await sessionService.removeSessionGroup(id);
+    await get().refreshSessions();
+  },
+
+  updateSessionGroupName: async (id, name) => {
+    await sessionService.updateSessionGroup(id, { name });
+    await get().refreshSessions();
+  },
+  updateSessionGroupSort: async (items) => {
+    const sortMap = items.map((item, index) => ({ id: item.id, sort: index }));
+
+    get().internal_dispatchSessionGroups({ sortMap, type: 'updateSessionGroupOrder' });
+
+    message.loading({
+      content: t('sessionGroup.sorting', { ns: 'chat' }),
+      duration: 0,
+      key: 'updateSessionGroupSort',
+    });
+
+    await sessionService.updateSessionGroupOrder(sortMap);
+    message.destroy('updateSessionGroupSort');
+    message.success(t('sessionGroup.sortSuccess', { ns: 'chat' }));
+
+    await get().refreshSessions();
+  },
+
+  /* eslint-disable sort-keys-fix/sort-keys-fix */
+  internal_dispatchSessionGroups: (payload) => {
+    const nextSessionGroups = sessionGroupsReducer(get().sessionGroups, payload);
+    get().internal_processSessions(get().sessions, nextSessionGroups, 'updateSessionGroups');
+  },
+});

package/src/store/session/slices/sessionGroup/initialState.ts

@@ -0,0 +1,12 @@
+import { CustomSessionGroup, LobeSessionGroups } from '@/types/session';
+
+export interface SessionGroupState {
+  activeGroupId?: string;
+  customSessionGroups: CustomSessionGroup[];
+  sessionGroups: LobeSessionGroups;
+}
+
+export const initSessionGroupState: SessionGroupState = {
+  customSessionGroups: [],
+  sessionGroups: [],
+};

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

@@ -0,0 +1,86 @@
+import { nanoid } from 'nanoid';
+import { describe, expect, it } from 'vitest';
+
+import { SessionGroupItem } from '@/types/session';
+
+import { sessionGroupsReducer } from './reducer';
+
+describe('sessionGroupsReducer', () => {
+  const initialState: SessionGroupItem[] = [
+    {
+      id: nanoid(),
+      name: 'Group 1',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    },
+    {
+      id: nanoid(),
+      name: 'Group 2',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      sort: 1,
+    },
+  ];
+
+  it('should add a new session group item', () => {
+    const newItem: SessionGroupItem = {
+      id: nanoid(),
+      name: 'New Group',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+
+    const result = sessionGroupsReducer(initialState, {
+      type: 'addSessionGroupItem',
+      item: newItem,
+    });
+
+    expect(result).toHaveLength(3);
+    expect(result).toContainEqual(newItem);
+  });
+
+  it('should delete a session group item', () => {
+    const itemToDelete = initialState[0].id;
+
+    const result = sessionGroupsReducer(initialState, {
+      type: 'deleteSessionGroupItem',
+      id: itemToDelete,
+    });
+
+    expect(result).toHaveLength(1);
+    expect(result).not.toContainEqual(expect.objectContaining({ id: itemToDelete }));
+  });
+
+  it('should update a session group item', () => {
+    const itemToUpdate = initialState[0].id;
+    const updatedItem = { name: 'Updated Group' };
+
+    const result = sessionGroupsReducer(initialState, {
+      type: 'updateSessionGroupItem',
+      id: itemToUpdate,
+      item: updatedItem,
+    });
+
+    expect(result).toHaveLength(2);
+    expect(result).toContainEqual(expect.objectContaining({ id: itemToUpdate, ...updatedItem }));
+  });
+
+  it('should update session group order', () => {
+    const sortMap = [
+      { id: initialState[1].id, sort: 0 },
+      { id: initialState[0].id, sort: 1 },
+    ];
+
+    const result = sessionGroupsReducer(initialState, { type: 'updateSessionGroupOrder', sortMap });
+
+    expect(result).toHaveLength(2);
+    expect(result[0].id).toBe(initialState[1].id);
+    expect(result[1].id).toBe(initialState[0].id);
+  });
+
+  it('should return the initial state for unknown action', () => {
+    const result = sessionGroupsReducer(initialState, { type: 'unknown' } as any);
+
+    expect(result).toEqual(initialState);
+  });
+});

package/src/store/session/slices/sessionGroup/reducer.ts

@@ -0,0 +1,56 @@
+import { SessionGroupItem } from '@/types/session';
+
+export type AddSessionGroupAction = { item: SessionGroupItem; type: 'addSessionGroupItem' };
+export type DeleteSessionGroupAction = { id: string; type: 'deleteSessionGroupItem' };
+export type UpdateSessionGroupAction = {
+  id: string;
+  item: Partial<SessionGroupItem>;
+  type: 'updateSessionGroupItem';
+};
+export type UpdateSessionGroupOrderAction = {
+  sortMap: { id: string; sort?: number }[];
+  type: 'updateSessionGroupOrder';
+};
+
+export type SessionGroupsDispatch =
+  | AddSessionGroupAction
+  | DeleteSessionGroupAction
+  | UpdateSessionGroupAction
+  | UpdateSessionGroupOrderAction;
+
+export const sessionGroupsReducer = (
+  state: SessionGroupItem[],
+  payload: SessionGroupsDispatch,
+): SessionGroupItem[] => {
+  switch (payload.type) {
+    case 'addSessionGroupItem': {
+      return [...state, payload.item];
+    }
+
+    case 'deleteSessionGroupItem': {
+      return state.filter((item) => item.id !== payload.id);
+    }
+
+    case 'updateSessionGroupItem': {
+      return state.map((item) => {
+        if (item.id === payload.id) {
+          return { ...item, ...payload.item };
+        }
+        return item;
+      });
+    }
+
+    case 'updateSessionGroupOrder': {
+      return state
+        .map((item) => {
+          const sort = payload.sortMap.find((i) => i.id === item.id)?.sort;
+          return { ...item, sort };
+        })
+        .sort((a, b) => (a.sort || 0) - (b.sort || 0));
+    }
+
+    default: {
+      return state;
+    }
+  }
+};

package/src/store/session/slices/sessionGroup/selectors.ts

@@ -0,0 +1,11 @@
+import { SessionStore } from '@/store/session';
+
+const sessionGroupItems = (s: SessionStore) => s.sessionGroups;
+
+const getGroupById = (id: string) => (s: SessionStore) =>
+  sessionGroupItems(s).find((group) => group.id === id);
+
+export const sessionGroupSelectors = {
+  getGroupById,
+  sessionGroupItems,
+};

package/src/store/session/store.ts

@@ -1,17 +1,33 @@
+import { subscribeWithSelector } from 'zustand/middleware';
+import { shallow } from 'zustand/shallow';
+import { createWithEqualityFn } from 'zustand/traditional';
 import { StateCreator } from 'zustand/vanilla';
 
+import { isDev } from '@/utils/env';
+
+import { createDevtools } from '../middleware/createDevtools';
 import { SessionStoreState, initialState } from './initialState';
-import { AgentAction, createAgentSlice } from './slices/agentConfig';
-import { ChatAction, createChatSlice } from './slices/chat';
-import { SessionAction, createSessionSlice } from './slices/session';
+import { SessionAction, createSessionSlice } from './slices/session/action';
+import { SessionGroupAction, createSessionGroupSlice } from './slices/sessionGroup/action';
+
+//  ===============  聚合 createStoreFn ============ //
 
-export type SessionStore = SessionAction & AgentAction & ChatAction & SessionStoreState;
+export interface SessionStore extends SessionAction, SessionGroupAction, SessionStoreState {}
 
-export const createStore: StateCreator<SessionStore, [['zustand/devtools', never]]> = (
-  ...parameters
-) => ({
+const createStore: StateCreator<SessionStore, [['zustand/devtools', never]]> = (...parameters) => ({
   ...initialState,
-  ...createAgentSlice(...parameters),
   ...createSessionSlice(...parameters),
-  ...createChatSlice(...parameters),
+  ...createSessionGroupSlice(...parameters),
 });
+
+//  ===============  implement useStore ============ //
+const devtools = createDevtools('session');
+
+export const useSessionStore = createWithEqualityFn<SessionStore>()(
+  subscribeWithSelector(
+    devtools(createStore, {
+      name: 'LobeChat_Session' + (isDev ? '_DEV' : ''),
+    }),
+  ),
+  shallow,
+);

package/src/store/tool/helpers.ts

@@ -0,0 +1,28 @@
+import { PluginSchema } from '@lobehub/chat-plugin-sdk';
+
+import { MetaData } from '@/types/meta';
+import { LobeTool } from '@/types/tool';
+
+const getPluginFormList = (list: LobeTool[], id: string) => list?.find((p) => p.identifier === id);
+
+const getPluginTitle = (meta?: MetaData) => meta?.title;
+const getPluginDesc = (meta?: MetaData) => meta?.description;
+
+const getPluginTags = (meta?: MetaData) => meta?.tags;
+const getPluginAvatar = (meta?: MetaData) => meta?.avatar || '🧩';
+
+const isCustomPlugin = (id: string, pluginList: LobeTool[]) =>
+  pluginList.some((i) => i.identifier === id && i.type === 'customPlugin');
+
+const isSettingSchemaNonEmpty = (schema?: PluginSchema) =>
+  schema?.properties && Object.keys(schema.properties).length > 0;
+
+export const pluginHelpers = {
+  getPluginAvatar,
+  getPluginDesc,
+  getPluginFormList,
+  getPluginTags,
+  getPluginTitle,
+  isCustomPlugin,
+  isSettingSchemaNonEmpty,
+};

package/src/store/tool/index.ts

@@ -0,0 +1,2 @@
+export * from './helpers';
+export { useToolStore } from './store';

package/src/store/tool/initialState.ts

@@ -0,0 +1,13 @@
+import { BuiltinToolState, initialBuiltinToolState } from './slices/builtin';
+import { CustomPluginState, initialCustomPluginState } from './slices/customPlugin';
+import { PluginState, initialPluginState } from './slices/plugin';
+import { PluginStoreState, initialPluginStoreState } from './slices/store';
+
+export type ToolStoreState = PluginState & CustomPluginState & PluginStoreState & BuiltinToolState;
+
+export const initialState: ToolStoreState = {
+  ...initialPluginState,
+  ...initialCustomPluginState,
+  ...initialPluginStoreState,
+  ...initialBuiltinToolState,
+};

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

@@ -0,0 +1,5 @@
+export { builtinToolSelectors } from '../slices/builtin/selectors';
+export { customPluginSelectors } from '../slices/customPlugin/selectors';
+export { pluginSelectors } from '../slices/plugin/selectors';
+export { pluginStoreSelectors } from '../slices/store/selectors';
+export { toolSelectors } from './tool';

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

@@ -0,0 +1,233 @@
+import { LobeChatPluginManifest, LobeChatPluginMeta } from '@lobehub/chat-plugin-sdk';
+import { describe, expect, it } from 'vitest';
+
+import { initialState } from '../initialState';
+import { ToolStoreState } from '../initialState';
+import { toolSelectors } from './tool';
+
+const mockState = {
+  ...initialState,
+  installedPlugins: [
+    {
+      identifier: 'plugin-1',
+      manifest: {
+        identifier: 'plugin-1',
+        api: [{ name: 'api-1' }],
+        meta: { title: 'Plugin 1', description: 'Plugin 1 description' },
+      } as LobeChatPluginManifest,
+      type: 'plugin',
+    },
+    {
+      identifier: 'plugin-2',
+      manifest: {
+        identifier: 'plugin-2',
+        api: [{ name: 'api-2' }],
+      } as LobeChatPluginManifest,
+      type: 'plugin',
+    },
+    {
+      identifier: 'plugin-3',
+      manifest: {
+        identifier: 'plugin-3',
+        api: [
+          {
+            name: 'api-3',
+            url: 'bac',
+            description: '123123',
+            parameters: { type: 'object', properties: { a: { type: 'string' } } },
+          },
+        ],
+      },
+      type: 'customPlugin',
+    },
+  ],
+  builtinTools: [
+    {
+      type: 'builtin',
+      identifier: 'builtin-1',
+      manifest: {
+        identifier: 'builtin-1',
+        api: [{ name: 'builtin-api-1' }],
+        meta: { title: 'Builtin 1', description: 'Builtin 1 description' },
+      } as LobeChatPluginManifest,
+    },
+  ],
+  pluginInstallLoading: {
+    'plugin-1': false,
+    'plugin-2': true,
+  },
+} as ToolStoreState;
+
+describe('toolSelectors', () => {
+  describe('enabledSchema', () => {
+    it('enabledSchema should return correct ChatCompletionFunctions array', () => {
+      const result = toolSelectors.enabledSchema(['plugin-1', 'plugin-2'])(mockState);
+      expect(result).toEqual([
+        {
+          type: 'function',
+          function: {
+            name: 'plugin-1____api-1',
+          },
+        },
+        {
+          type: 'function',
+          function: {
+            name: 'plugin-2____api-2',
+          },
+        },
+      ]);
+    });
+
+    it('enabledSchema should return with standalone plugin', () => {
+      const result = toolSelectors.enabledSchema(['plugin-4'])({
+        ...mockState,
+        installedPlugins: [
+          ...mockState.installedPlugins,
+          {
+            identifier: 'plugin-4',
+            manifest: {
+              identifier: 'plugin-4',
+              api: [{ name: 'api-4' }],
+              type: 'standalone',
+            },
+            type: 'plugin',
+          },
+        ],
+      } as ToolStoreState);
+      expect(result).toEqual([
+        {
+          type: 'function',
+          function: {
+            name: 'plugin-4____api-4____standalone',
+          },
+        },
+      ]);
+    });
+
+    it('enabledSchema should return md5 hash apiName', () => {
+      const result = toolSelectors.enabledSchema(['long-long-plugin-with-id'])({
+        ...mockState,
+        installedPlugins: [
+          ...mockState.installedPlugins,
+          {
+            identifier: 'long-long-plugin-with-id',
+            manifest: {
+              identifier: 'long-long-plugin-with-id',
+              api: [{ name: 'long-long-manifest-long-long-apiName' }],
+            },
+            type: 'plugin',
+          },
+        ],
+      } as ToolStoreState);
+      expect(result).toEqual([
+        {
+          type: 'function',
+          function: {
+            name: 'long-long-plugin-with-id____MD5HASH_396eae4c671da3fb642c49ad2b9e8790',
+          },
+        },
+      ]);
+    });
+
+    it('enabledSchema should return empty', () => {
+      const result = toolSelectors.enabledSchema([])(mockState);
+      expect(result).toEqual([]);
+    });
+
+    // fix https://github.com/lobehub/lobe-chat/issues/2036
+    it('should not contain url', () => {
+      const result = toolSelectors.enabledSchema(['plugin-3'])(mockState);
+      expect(result[0].function).toEqual({
+        description: '123123',
+        name: 'plugin-3____api-3',
+        parameters: {
+          properties: {
+            a: {
+              type: 'string',
+            },
+          },
+          type: 'object',
+        },
+      });
+
+      expect(result[0].function).not.toHaveProperty('url');
+    });
+  });
+
+  describe('getPluginManifestLoadingStatus', () => {
+    it('should return "loading" if the plugin manifest is being loaded', () => {
+      const result = toolSelectors.getManifestLoadingStatus('plugin-2')(mockState);
+      expect(result).toBe('loading');
+    });
+
+    it('should return "error" if the plugin manifest is not found', () => {
+      const result = toolSelectors.getManifestLoadingStatus('non-existing-plugin')(mockState);
+      expect(result).toBe('error');
+    });
+
+    it('should return "success" if the plugin manifest is loaded', () => {
+      const result = toolSelectors.getManifestLoadingStatus('plugin-1')(mockState);
+      expect(result).toBe('success');
+    });
+  });
+
+  describe('metaList and getMetaById', () => {
+    it('should return the correct list of tool metadata', () => {
+      const result = toolSelectors.metaList()(mockState);
+      expect(result).toEqual([
+        {
+          type: 'builtin',
+          author: 'LobeHub',
+          identifier: 'builtin-1',
+          meta: { title: 'Builtin 1', description: 'Builtin 1 description' },
+        },
+        {
+          identifier: 'plugin-1',
+          type: 'plugin',
+          meta: { title: 'Plugin 1', description: 'Plugin 1 description' },
+        },
+        {
+          type: 'plugin',
+          identifier: 'plugin-2',
+          meta: undefined,
+        },
+        {
+          identifier: 'plugin-3',
+          type: 'customPlugin',
+        },
+      ]);
+    });
+
+    it('should return the correct metadata by identifier', () => {
+      const result = toolSelectors.getMetaById('plugin-1')(mockState);
+      expect(result).toEqual({ title: 'Plugin 1', description: 'Plugin 1 description' });
+    });
+
+    it('should return undefined for non-existent identifier', () => {
+      const result = toolSelectors.getMetaById('non-existent')(mockState);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getManifestById and getManifestLoadingStatus', () => {
+    it('should return the correct manifest by identifier', () => {
+      const result = toolSelectors.getManifestById('plugin-1')(mockState);
+      expect(result).toEqual({
+        identifier: 'plugin-1',
+        api: [{ name: 'api-1' }],
+        meta: { title: 'Plugin 1', description: 'Plugin 1 description' },
+      });
+    });
+
+    it('should return undefined for non-existent identifier', () => {
+      const result = toolSelectors.getManifestById('non-existent')(mockState);
+      expect(result).toBeUndefined();
+    });
+
+    it('should return the correct loading status for a plugin', () => {
+      expect(toolSelectors.getManifestLoadingStatus('plugin-1')(mockState)).toBe('success');
+      expect(toolSelectors.getManifestLoadingStatus('plugin-2')(mockState)).toBe('loading');
+      expect(toolSelectors.getManifestLoadingStatus('non-existent')(mockState)).toBe('error');
+    });
+  });
+});

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

@@ -0,0 +1,110 @@
+import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
+import { uniqBy } from 'lodash-es';
+
+import { MetaData } from '@/types/meta';
+import { ChatCompletionTool } from '@/types/openai/chat';
+import { LobeToolMeta } from '@/types/tool/tool';
+import { genToolCallingName } from '@/utils/toolCall';
+
+import { pluginHelpers } from '../helpers';
+import { ToolStoreState } from '../initialState';
+import { builtinToolSelectors } from '../slices/builtin/selectors';
+import { pluginSelectors } from '../slices/plugin/selectors';
+
+const enabledSchema =
+  (tools: string[] = []) =>
+  (s: ToolStoreState): ChatCompletionTool[] => {
+    const list = pluginSelectors
+      .installedPluginManifestList(s)
+      .concat(s.builtinTools.map((b) => b.manifest as LobeChatPluginManifest))
+      // 如果存在 enabledPlugins，那么只启用 enabledPlugins 中的插件
+      .filter((m) => tools.includes(m?.identifier))
+      .flatMap((manifest) =>
+        manifest.api.map((m) => ({
+          description: m.description,
+          name: genToolCallingName(manifest.identifier, m.name, manifest.type),
+          parameters: m.parameters,
+        })),
+      );
+
+    return uniqBy(list, 'name').map((i) => ({ function: i, type: 'function' }));
+  };
+
+const enabledSystemRoles =
+  (tools: string[] = []) =>
+  (s: ToolStoreState) => {
+    const toolsSystemRole = pluginSelectors
+      .installedPluginManifestList(s)
+      .concat(s.builtinTools.map((b) => b.manifest as LobeChatPluginManifest))
+      // 如果存在 enabledPlugins，那么只启用 enabledPlugins 中的插件
+      .filter((m) => tools.includes(m?.identifier))
+      .map((manifest) => {
+        if (!manifest) return '';
+
+        const meta = manifest.meta || {};
+
+        const title = pluginHelpers.getPluginTitle(meta) || manifest.identifier;
+        const systemRole = manifest.systemRole || pluginHelpers.getPluginDesc(meta);
+
+        const methods = manifest.api
+          .map((m) =>
+            [
+              `#### ${genToolCallingName(manifest.identifier, m.name, manifest.type)}`,
+              m.description,
+            ].join('\n\n'),
+          )
+          .join('\n\n');
+
+        return [`### ${title}`, systemRole, 'The APIs you can use:', methods].join('\n\n');
+      })
+      .filter(Boolean);
+
+    if (toolsSystemRole.length > 0) {
+      return ['## Tools', 'You can use these tools below:', ...toolsSystemRole]
+        .filter(Boolean)
+        .join('\n\n');
+    }
+
+    return '';
+  };
+
+const metaList =
+  (showDalle?: boolean) =>
+  (s: ToolStoreState): LobeToolMeta[] => {
+    const pluginList = pluginSelectors.installedPluginMetaList(s) as LobeToolMeta[];
+
+    return builtinToolSelectors.metaList(showDalle)(s).concat(pluginList);
+  };
+
+const getMetaById =
+  (id: string, showDalle: boolean = true) =>
+  (s: ToolStoreState): MetaData | undefined =>
+    metaList(showDalle)(s).find((m) => m.identifier === id)?.meta;
+
+const getManifestById =
+  (id: string) =>
+  (s: ToolStoreState): LobeChatPluginManifest | undefined =>
+    pluginSelectors
+      .installedPluginManifestList(s)
+      .concat(s.builtinTools.map((b) => b.manifest as LobeChatPluginManifest))
+      .find((i) => i.identifier === id);
+
+// 获取插件 manifest 加载状态
+const getManifestLoadingStatus = (id: string) => (s: ToolStoreState) => {
+  const manifest = getManifestById(id)(s);
+
+  if (s.pluginInstallLoading[id]) return 'loading';
+
+  if (!manifest) return 'error';
+
+  if (!!manifest) return 'success';
+};
+
+export const toolSelectors = {
+  enabledSchema,
+  enabledSystemRoles,
+  getManifestById,
+  getManifestLoadingStatus,
+  getMetaById,
+  metaList,
+};