@lobehub/chat 0.105.2 → 0.107.0

package/src/store/{session/slices/chat → chat}/actions/plugin.ts

@@ -1,49 +1,48 @@
-import { PluginRequestPayload } from '@lobehub/chat-plugin-sdk';
 import { StateCreator } from 'zustand/vanilla';
 
 import { PLUGIN_SCHEMA_SEPARATOR } from '@/const/plugin';
 import { chatService } from '@/services/chat';
-import { SessionStore } from '@/store/session';
-import { OpenAIFunctionCall } from '@/types/chatMessage';
+import { messageService } from '@/services/message';
+import { ChatStore } from '@/store/chat/store';
+import { ChatPluginPayload } from '@/types/chatMessage';
+import { OpenAIFunctionCall } from '@/types/openai/functionCall';
 import { setNamespace } from '@/utils/storeDebug';
 
-import { sessionSelectors } from '../../session/selectors';
 import { chatSelectors } from '../selectors';
 
-const t = setNamespace('chat/plugin');
+const t = setNamespace('plugin');
 
-/**
- * 插件方法
- */
 export interface ChatPluginAction {
   fillPluginMessageContent: (id: string, content: string) => Promise<void>;
   runPluginDefaultType: (id: string, payload: any) => Promise<void>;
   triggerFunctionCall: (id: string) => Promise<void>;
-  updatePluginState: (id: string, key: string, value: any) => void;
+  updatePluginState: (id: string, key: string, value: any) => Promise<void>;
 }
 
 export const chatPlugin: StateCreator<
-  SessionStore,
+  ChatStore,
   [['zustand/devtools', never]],
   [],
   ChatPluginAction
 > = (set, get) => ({
   fillPluginMessageContent: async (id, content) => {
-    const { dispatchMessage, coreProcessMessage } = get();
+    const { coreProcessMessage, refreshMessages } = get();
 
-    dispatchMessage({ id, key: 'content', type: 'updateMessage', value: content });
+    await messageService.updateMessageContent(id, content);
+    await refreshMessages();
 
     const chats = chatSelectors.currentChats(get());
     await coreProcessMessage(chats, id);
   },
   runPluginDefaultType: async (id, payload) => {
-    const { dispatchMessage, coreProcessMessage, toggleChatLoading } = get();
+    const { refreshMessages, coreProcessMessage, toggleChatLoading } = get();
     let data: string;
     try {
       const abortController = toggleChatLoading(true, id, t('fetchPlugin') as string);
       data = await chatService.runPluginApi(payload, { signal: abortController?.signal });
     } catch (error) {
-      dispatchMessage({ id, key: 'error', type: 'updateMessage', value: error });
+      await messageService.updateMessageError(id, error as any);
+      await refreshMessages();
 
       data = '';
     }
@@ -51,21 +50,19 @@ export const chatPlugin: StateCreator<
     // 如果报错则结束了
     if (!data) return;
 
-    dispatchMessage({ id, key: 'content', type: 'updateMessage', value: data });
+    await messageService.updateMessageContent(id, data);
+    await refreshMessages();
 
     const chats = chatSelectors.currentChats(get());
     await coreProcessMessage(chats, id);
   },
   triggerFunctionCall: async (id) => {
-    const { dispatchMessage, runPluginDefaultType } = get();
-    const session = sessionSelectors.currentSession(get());
+    const { runPluginDefaultType, refreshMessages } = get();
 
-    if (!session) return;
-
-    const message = session.chats[id];
+    const message = chatSelectors.getMessageById(id)(get());
     if (!message) return;
 
-    let payload: PluginRequestPayload = { apiName: '', identifier: '' };
+    let payload = { apiName: '', identifier: '' } as ChatPluginPayload;
 
     // 识别到内容是 function_call 的情况下
     // 将 function_call 转换为 plugin request payload
@@ -80,30 +77,28 @@ export const chatPlugin: StateCreator<
         apiName,
         arguments: function_call.arguments,
         identifier,
-        type: type ?? 'default',
+        type: (type ?? 'default') as any,
       };
 
-      dispatchMessage({ id, key: 'plugin', type: 'updateMessage', value: payload });
-      dispatchMessage({ id, key: 'content', type: 'updateMessage', value: '' });
+      await messageService.updateMessageContent(id, '');
     } else {
-      if (message.plugin) {
-        payload = message.plugin;
-      }
+      if (message.plugin) payload = message.plugin;
     }
 
     if (!payload.apiName) return;
 
-    dispatchMessage({ id, key: 'role', type: 'updateMessage', value: 'function' });
-    dispatchMessage({ id, key: 'name', type: 'updateMessage', value: payload.identifier });
-    dispatchMessage({ id, key: 'plugin', type: 'updateMessage', value: payload });
+    await messageService.updateMessageRole(id, 'function');
+    await messageService.updateMessagePlugin(id, payload);
+    await refreshMessages();
 
     if (payload.type === 'standalone') {
-      // nothing to do
+      // TODO: need to auth user's settings
     } else runPluginDefaultType(id, payload);
   },
-  updatePluginState: (id, key, value) => {
-    const { dispatchMessage } = get();
+  updatePluginState: async (id, key, value) => {
+    const { refreshMessages } = get();
 
-    dispatchMessage({ id, key, type: 'updatePluginState', value });
+    await messageService.updateMessagePluginState(id, key, value);
+    await refreshMessages();
   },
 });

package/src/store/{session/slices/chat → chat}/actions/share.ts

@@ -4,12 +4,12 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { DEFAULT_USER_AVATAR_URL } from '@/const/meta';
 import { genShareGPTUrl } from '@/services/shareGPT';
-import { SessionStore } from '@/store/session';
+import { useSessionStore } from '@/store/session';
+import { agentSelectors } from '@/store/session/selectors';
 import { ShareGPTConversation } from '@/types/share';
 
-import { agentSelectors } from '../../agent';
-import { sessionSelectors } from '../../session/selectors';
 import { chatSelectors } from '../selectors';
+import { ChatStore } from '../store';
 
 interface ShareMessage {
   from: 'human' | 'gpt';
@@ -50,18 +50,14 @@ export interface ShareAction {
   }) => void;
 }
 
-export const chatShare: StateCreator<
-  SessionStore,
-  [['zustand/devtools', never]],
-  [],
-  ShareAction
-> = (set, get) => ({
+export const chatShare: StateCreator<ChatStore, [['zustand/devtools', never]], [], ShareAction> = (
+  set,
+  get,
+) => ({
   shareToShareGPT: async ({ withSystemRole, withPluginInfo, avatar }) => {
-    const session = sessionSelectors.currentSession(get());
-    if (!session) return;
     const messages = chatSelectors.currentChats(get());
-    const config = agentSelectors.currentAgentConfig(get());
-    const meta = agentSelectors.currentAgentMeta(get());
+    const config = agentSelectors.currentAgentConfig(useSessionStore.getState());
+    const meta = agentSelectors.currentAgentMeta(useSessionStore.getState());
 
     const defaultMsg: ShareGPTConversation['items'] = [];
     const showSystemRole = withSystemRole && !!config.systemRole;

package/src/store/chat/actions/topic.ts

@@ -0,0 +1,197 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
+// Note: To make the code more logic and readable, we just disable the auto sort key eslint rule
+// DON'T REMOVE THE FIRST LINE
+import { t } from 'i18next';
+import { produce } from 'immer';
+import useSWR, { SWRResponse, mutate } from 'swr';
+import { StateCreator } from 'zustand/vanilla';
+
+import { chainSummaryTitle } from '@/chains/summaryTitle';
+import { LOADING_FLAT } from '@/const/message';
+import { chatService } from '@/services/chat';
+import { messageService } from '@/services/message';
+import { topicService } from '@/services/topic';
+import { ChatStore } from '@/store/chat';
+import { ChatMessage } from '@/types/chatMessage';
+import { ChatTopic } from '@/types/topic';
+import { setNamespace } from '@/utils/storeDebug';
+
+import { chatSelectors, topicSelectors } from '../selectors';
+
+const n = setNamespace('topic');
+
+export interface ChatTopicAction {
+  favoriteTopic: (id: string, favState: boolean) => Promise<void>;
+  openNewTopicOrSaveTopic: () => void;
+  refreshTopic: () => Promise<void>;
+  removeAllTopics: () => Promise<void>;
+  removeSessionTopics: () => Promise<void>;
+  removeTopic: (id: string) => Promise<void>;
+  removeUnstarredTopic: () => void;
+  saveToTopic: () => Promise<string | undefined>;
+  summaryTopicTitle: (topicId: string, messages: ChatMessage[]) => Promise<void>;
+  switchTopic: (id?: string) => Promise<void>;
+  updateTopicTitleInSummary: (id: string, title: string) => void;
+  updateTopicLoading: (id?: string) => void;
+  updateTopicTitle: (id: string, title: string) => Promise<void>;
+  useFetchTopics: (sessionId: string) => SWRResponse<ChatTopic[]>;
+  useSearchTopics: (keywords?: string) => SWRResponse<ChatTopic[]>;
+}
+
+export const chatTopic: StateCreator<
+  ChatStore,
+  [['zustand/devtools', never]],
+  [],
+  ChatTopicAction
+> = (set, get) => ({
+  // create
+  openNewTopicOrSaveTopic: () => {
+    const { switchTopic, saveToTopic, activeTopicId } = get();
+    const hasTopic = !!activeTopicId;
+
+    if (hasTopic) switchTopic();
+    else {
+      saveToTopic();
+    }
+  },
+
+  saveToTopic: async () => {
+    // if there is no message, stop
+    const messages = chatSelectors.currentChats(get());
+    if (messages.length === 0) return;
+
+    const { activeId, summaryTopicTitle, refreshTopic, refreshMessages } = get();
+
+    // 1. create topic
+    const topicId = await topicService.createTopic({
+      sessionId: activeId,
+      title: t('topic.defaultTitle', { ns: 'chat' }),
+    });
+    await refreshTopic();
+
+    // 2.add topicId to these message
+    await messageService.bindMessagesToTopic(
+      topicId,
+      messages.map((m) => m.id),
+    );
+    await refreshMessages();
+
+    // 3. auto summary topic Title
+    // we don't need to wait for summary, just let it run async
+    summaryTopicTitle(topicId, messages);
+
+    return topicId;
+  },
+  // update
+  summaryTopicTitle: async (topicId, messages) => {
+    const { updateTopicTitleInSummary, updateTopicLoading, refreshTopic } = get();
+    const topic = topicSelectors.getTopicById(topicId)(get());
+    if (!topic) return;
+
+    updateTopicTitleInSummary(topicId, LOADING_FLAT);
+
+    let output = '';
+
+    // 自动总结话题标题
+    await chatService.fetchPresetTaskResult({
+      onError: () => {
+        updateTopicTitleInSummary(topicId, topic.title);
+      },
+      onFinish: (text) => {
+        topicService.updateTitle(topicId, text);
+      },
+      onLoadingChange: (loading) => {
+        updateTopicLoading(loading ? topicId : undefined);
+      },
+      onMessageHandle: (x) => {
+        output += x;
+        updateTopicTitleInSummary(topicId, output);
+      },
+      params: await chainSummaryTitle(messages),
+    });
+    await refreshTopic();
+  },
+  favoriteTopic: async (id, favState) => {
+    await topicService.updateFavorite(id, favState);
+    await get().refreshTopic();
+  },
+  updateTopicTitle: async (id, title) => {
+    await topicService.updateTitle(id, title);
+    await get().refreshTopic();
+  },
+  // query
+  useFetchTopics: (sessionId) =>
+    useSWR<ChatTopic[]>(sessionId, async (sessionId) => topicService.getTopics({ sessionId }), {
+      onSuccess: (topics) => {
+        set({ topics, topicsInit: true }, false, n('useFetchTopics(success)', { sessionId }));
+      },
+    }),
+  useSearchTopics: (keywords) =>
+    useSWR<ChatTopic[]>(keywords, topicService.searchTopics, {
+      onSuccess: (data) => {
+        set({ searchTopics: data }, false, n('useSearchTopics(success)', { keywords }));
+      },
+    }),
+  switchTopic: async (id) => {
+    set({ activeTopicId: id }, false, n('toggleTopic'));
+
+    await get().refreshMessages();
+  },
+  // delete
+  removeSessionTopics: async () => {
+    const { switchTopic, activeId, refreshTopic } = get();
+
+    await topicService.removeTopics(activeId);
+    await refreshTopic();
+
+    // switch to default topic
+    switchTopic();
+  },
+  removeAllTopics: async () => {
+    const { refreshTopic } = get();
+
+    await topicService.removeAllTopic();
+    await refreshTopic();
+  },
+  removeTopic: async (id) => {
+    const { activeId, switchTopic, refreshTopic } = get();
+
+    // remove messages in the topic
+    await messageService.removeMessages(activeId, id);
+
+    // remove topic
+    await topicService.removeTopic(id);
+    await refreshTopic();
+
+    // switch bach to default topic
+    switchTopic();
+  },
+  removeUnstarredTopic: async () => {
+    const { refreshTopic, switchTopic } = get();
+    const topics = topicSelectors.currentUnFavTopics(get());
+
+    await topicService.batchRemoveTopics(topics.map((t) => t.id));
+    await refreshTopic();
+
+    // 切换到默认 topic
+    switchTopic();
+  },
+
+  // Internal process method of the topics
+  updateTopicTitleInSummary: (id, title) => {
+    const topics = produce(get().topics, (draftState) => {
+      const topic = draftState.find((i) => i.id === id);
+
+      if (!topic) return;
+      topic.title = title;
+    });
+
+    set({ topics }, false, n(`updateTopicTitleInSummary`, { id, title }));
+  },
+  updateTopicLoading: (id) => {
+    set({ topicLoadingId: id }, false, n('updateTopicLoading'));
+  },
+  refreshTopic: async () => {
+    await mutate(get().activeId);
+  },
+});

package/src/store/chat/helpers.ts

@@ -0,0 +1,23 @@
+import { LobeAgentConfig } from '@/types/agent';
+import { ChatMessage } from '@/types/chatMessage';
+import { OpenAIChatMessage } from '@/types/openai/chat';
+import { encodeAsync } from '@/utils/tokenizer';
+
+export const getMessagesTokenCount = async (messages: OpenAIChatMessage[]) =>
+  encodeAsync(messages.map((m) => m.content).join(''));
+
+const getSlicedMessagesWithConfig = (
+  messages: ChatMessage[],
+  config: LobeAgentConfig,
+): ChatMessage[] => {
+  // 如果没有开启历史消息数限制，或者限制为 0，则直接返回
+  if (!config.enableHistoryCount || !config.historyCount) return messages;
+
+  // 如果开启了，则返回尾部的N条消息
+  return messages.reverse().slice(0, config.historyCount).reverse();
+};
+
+export const chatHelpers = {
+  getMessagesTokenCount,
+  getSlicedMessagesWithConfig,
+};

package/src/store/chat/index.ts

@@ -0,0 +1,3 @@
+export type { ChatStoreState } from './initialState';
+export type { ChatStore } from './store';
+export { useChatStore } from './store';

package/src/store/chat/initialState.ts

@@ -0,0 +1,48 @@
+import { ChatMessage } from '@/types/chatMessage';
+import { ChatTopic } from '@/types/topic';
+
+export interface ChatStoreState {
+  abortController?: AbortController;
+  /**
+   * @title 当前活动的会话
+   * @description 当前正在编辑或查看的会话
+   */
+  activeId: string;
+  activeTopicId?: string;
+  /**
+   * @deprecated
+   */
+  chatLoadingId?: string;
+  inputMessage: string;
+  isSearchingTopic: boolean;
+  messageLoadingIds: [];
+  messages: ChatMessage[];
+  /**
+   * whether messages have fetched
+   */
+  messagesInit: boolean;
+
+  searchTopics: ChatTopic[];
+  shareLoading?: boolean;
+  topicLoadingId?: string;
+  topicRenamingId?: string;
+  topicSearchKeywords: string;
+  topics: ChatTopic[];
+  /**
+   * whether topics have fetched
+   */
+  topicsInit: boolean;
+}
+
+export const initialState: ChatStoreState = {
+  activeId: 'inbox',
+  inputMessage: '',
+  isSearchingTopic: false,
+  messageLoadingIds: [],
+  messages: [],
+  messagesInit: false,
+  searchTopics: [],
+  topicSearchKeywords: '',
+  topics: [],
+  topicsInit: false,
+};

package/src/store/chat/reducers/message.test.ts

@@ -0,0 +1,83 @@
+import { ChatMessage, ChatMessageMap } from '@/types/chatMessage';
+
+import { MessageDispatch, messagesReducer } from './message';
+
+describe('messagesReducer', () => {
+  let initialState: ChatMessage[];
+
+  beforeEach(() => {
+    initialState = [
+      {
+        id: 'message1',
+        content: 'Hello World',
+        createdAt: 1629264000000,
+        updatedAt: 1629264000000,
+        role: 'user',
+        meta: {},
+      },
+      {
+        id: 'message2',
+        content: 'How are you?',
+        createdAt: 1629264000000,
+        updatedAt: 1629264000000,
+        role: 'system',
+        meta: {},
+      },
+    ];
+  });
+
+  describe('updateMessage', () => {
+    it('should update the specified message with the provided value', () => {
+      const payload: MessageDispatch = {
+        type: 'updateMessage',
+        id: 'message1',
+        key: 'content',
+        value: 'Updated Message',
+      };
+
+      const newState = messagesReducer(initialState, payload);
+      const newMessage = newState.find((i) => i.id === 'message1');
+
+      expect(newMessage).not.toBeUndefined();
+      expect(newMessage?.content).toBe('Updated Message');
+      expect(newMessage?.updatedAt).toBeGreaterThan(initialState[0].updatedAt);
+    });
+
+    it('should not modify the state if the specified message does not exist', () => {
+      const payload: MessageDispatch = {
+        type: 'updateMessage',
+        id: 'nonexistentMessage',
+        key: 'content',
+        value: 'Updated Message',
+      };
+
+      const newState = messagesReducer(initialState, payload);
+
+      expect(newState).toEqual(initialState);
+    });
+
+    it('should not modify the state if the specified message does not exist', () => {
+      const payload: MessageDispatch = {
+        type: 'updateMessage',
+        id: 'nonexistentMessage',
+        key: 'content',
+        value: 'Updated Message',
+      };
+
+      const newState = messagesReducer(initialState, payload);
+
+      expect(newState).toEqual(initialState);
+    });
+  });
+
+  describe('unimplemented type', () => {
+    it('should throw an error when an unimplemented type is provided', () => {
+      // @ts-ignore
+      const payload: MessageDispatch = { type: 'unimplementedType' };
+
+      expect(() => messagesReducer(initialState, payload)).toThrowError(
+        '暂未实现的 type，请检查 reducer',
+      );
+    });
+  });
+});

package/src/store/chat/reducers/message.ts

@@ -0,0 +1,83 @@
+import isEqual from 'fast-deep-equal';
+import { produce } from 'immer';
+
+import { ChatMessage } from '@/types/chatMessage';
+import { merge } from '@/utils/merge';
+
+interface UpdateMessage {
+  id: string;
+  key: keyof ChatMessage;
+  type: 'updateMessage';
+  value: ChatMessage[keyof ChatMessage];
+}
+
+interface UpdatePluginState {
+  id: string;
+  key: string;
+  type: 'updatePluginState';
+  value: any;
+}
+interface UpdateMessageExtra {
+  id: string;
+  key: string;
+  type: 'updateMessageExtra';
+  value: any;
+}
+
+export type MessageDispatch = UpdateMessage | UpdatePluginState | UpdateMessageExtra;
+
+export const messagesReducer = (state: ChatMessage[], payload: MessageDispatch): ChatMessage[] => {
+  switch (payload.type) {
+    case 'updateMessage': {
+      return produce(state, (draftState) => {
+        const { id, key, value } = payload;
+        const message = draftState.find((i) => i.id === id);
+        if (!message) return;
+
+        // @ts-ignore
+        message[key] = value;
+        message.updatedAt = Date.now();
+      });
+    }
+
+    case 'updateMessageExtra': {
+      return produce(state, (draftState) => {
+        const { id, key, value } = payload;
+        const message = draftState.find((i) => i.id === id);
+        if (!message) return;
+
+        if (!message.extra) {
+          message.extra = { [key]: value } as any;
+        } else {
+          message.extra[key] = value;
+        }
+
+        message.updateAt = Date.now();
+      });
+    }
+
+    case 'updatePluginState': {
+      return produce(state, (draftState) => {
+        const { id, key, value } = payload;
+        const message = draftState.find((i) => i.id === id);
+        if (!message) return;
+
+        let newState;
+        if (!message.pluginState) {
+          newState = { [key]: value } as any;
+        } else {
+          newState = merge(message.pluginState, { [key]: value });
+        }
+
+        if (isEqual(message.pluginState, newState)) return;
+
+        message.pluginState = newState;
+        message.updatedAt = Date.now();
+      });
+    }
+
+    default: {
+      throw new Error('暂未实现的 type，请检查 reducer');
+    }
+  }
+};

package/src/store/chat/selectors/__tests__/topic.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+
+import { ChatStore, ChatStoreState } from '@/store/chat';
+import { initialState } from '@/store/chat/initialState';
+import { merge } from '@/utils/merge';
+
+import { topicSelectors } from '..';
+
+const initialStore = initialState as ChatStore;
+
+const mockTopics = [
+  { id: 'topic1', name: 'Topic 1' },
+  { id: 'topic2', name: 'Topic 2' },
+];
+
+describe('topicSelectors', () => {
+  describe('currentTopics', () => {
+    it('should return an empty array if there are no topics', () => {
+      const topics = topicSelectors.currentTopics(initialStore);
+      expect(topics).toEqual([]);
+    });
+
+    it('should return all current topics from the store', () => {
+      const state = merge(initialStore, { topics: mockTopics });
+
+      const topics = topicSelectors.currentTopics(state);
+      expect(topics).toEqual(mockTopics);
+    });
+  });
+
+  describe('currentTopicLength', () => {
+    it('should return 0 if there are no topics', () => {
+      const length = topicSelectors.currentTopicLength(initialStore);
+      expect(length).toBe(0);
+    });
+
+    it('should return the number of current topics', () => {
+      const state = merge(initialStore, { topics: mockTopics });
+      const length = topicSelectors.currentTopicLength(state);
+      expect(length).toBe(mockTopics.length);
+    });
+  });
+});