@lobehub/chat 0.118.10 → 0.119.1

package/src/locales/default/chat.ts

@@ -8,6 +8,7 @@ export default {
   confirmRemoveSessionItemAlert: '即将删除该助手，删除后该将无法找回，请确认你的操作',
   defaultAgent: '自定义助手',
   defaultSession: '自定义助手',
+  duplicateTitle: '{{title}} 副本',
   historyRange: '历史范围',
   inbox: {
     defaultMessage:
@@ -15,9 +16,12 @@ export default {
     desc: '开启大脑集群，激发思维火花。你的智能助理，在这里与你交流一切',
     title: '随便聊聊',
   },
+  messageAction: {
+    delAndRegenerate: '删除并重新生成',
+    regenerate: '重新生成',
+  },
   newAgent: '新建助手',
   noDescription: '暂无描述',
-
   pin: '置顶',
   pinOff: '取消置顶',
   regenerate: '重新生成',
@@ -52,6 +56,11 @@ export default {
     used: '使用',
   },
   topic: {
+    actions: {
+      autoRename: '智能重命名',
+      duplicate: '创建副本',
+      export: '导出话题',
+    },
     confirmRemoveAll: '即将删除全部话题，删除后将不可恢复，请谨慎操作。',
     confirmRemoveTopic: '即将删除该话题，删除后将不可恢复，请谨慎操作。',
     confirmRemoveUnstarred: '即将删除未收藏话题，删除后将不可恢复，请谨慎操作。',

package/src/locales/default/common.ts

@@ -17,6 +17,7 @@ export default {
   defaultAgent: '自定义助手',
   defaultSession: '自定义助手',
   delete: '删除',
+  duplicate: '创建副本',
   edit: '编辑',
   export: '导出配置',
   exportType: {

package/src/services/config.ts

@@ -127,6 +127,28 @@ class ConfigService {
     exportConfigFile(config, `${session.meta?.title}-session`);
   };
 
+  /**
+   * export a topic
+   */
+  exportSingleTopic = async (sessionId: string, topicId: string) => {
+    const session = this.getSession(sessionId);
+    if (!session) return;
+
+    const messages = await messageService.getMessages(sessionId, topicId);
+    const topics = await topicService.getTopics({ sessionId });
+
+    const topic = topics.find((item) => item.id === topicId);
+    if (!topic) return;
+
+    const config = createConfigFile('singleSession', {
+      messages,
+      sessions: [session],
+      topics: [topic],
+    });
+
+    exportConfigFile(config, `${topic.title}-topic`);
+  };
+
   exportSingleAgent = async (id: string) => {
     const agent = this.getAgent(id);
     if (!agent) return;

package/src/services/session.ts

@@ -58,6 +58,12 @@ class SessionService {
   async searchSessions(keyword: string) {
     return SessionModel.queryByKeyword(keyword);
   }
+
+  async duplicateSession(id: string, newTitle: string): Promise<string | undefined> {
+    const res = await SessionModel.duplicate(id, newTitle);
+
+    if (res) return res?.id;
+  }
 }
 
 export const sessionService = new SessionService();

package/src/services/topic.ts

@@ -51,6 +51,10 @@ class TopicService {
   async searchTopics(keyword: string) {
     return TopicModel.queryByKeyword(keyword);
   }
+
+  async duplicateTopic(id: string, newTitle?: string) {
+    return TopicModel.duplicateTopic(id, newTitle);
+  }
 }
 
 export const topicService = new TopicService();

package/src/store/chat/slices/message/action.ts

@@ -71,6 +71,12 @@ export interface ChatMessageAction {
     action?: string,
   ) => AbortController | undefined;
   refreshMessages: () => Promise<void>;
+  createSmoothMessage: (id: string) => {
+    startAnimation: (speed?: number) => Promise<void>;
+    stopAnimation: () => void;
+    outputQueue: string[];
+    isAnimationActive: boolean;
+  };
 }
 
 const getAgentConfig = () => agentSelectors.currentAgentConfig(useSessionStore.getState());
@@ -297,7 +303,7 @@ export const chatMessage: StateCreator<
     set({ messages }, false, n(`dispatchMessage/${payload.type}`, payload));
   },
   fetchAIChatMessage: async (messages, assistantId) => {
-    const { toggleChatLoading, refreshMessages, updateMessageContent } = get();
+    const { toggleChatLoading, refreshMessages, updateMessageContent, createSmoothMessage } = get();
 
     const abortController = toggleChatLoading(
       true,
@@ -366,19 +372,35 @@ export const chatMessage: StateCreator<
     let functionCallAtEnd = false;
     let functionCallContent = '';
 
+    const { startAnimation, stopAnimation, outputQueue, isAnimationActive } =
+      createSmoothMessage(assistantId);
+
     await fetchSSE(fetcher, {
       onErrorHandle: async (error) => {
         await messageService.updateMessageError(assistantId, error);
         await refreshMessages();
       },
+      onAbort: async () => {
+        stopAnimation();
+      },
       onFinish: async (content) => {
+        stopAnimation();
+
+        // 如果还有内容没有显示，则继续动画
+        if (outputQueue.length > 0) {
+          await startAnimation(15);
+        }
+
+        // 如果没有剩余内容，直接更新消息内容
         // update the content after fetch result
         await updateMessageContent(assistantId, content);
       },
       onMessageHandle: async (text) => {
         output += text;
+        outputQueue.push(...text.split(''));
 
-        await updateMessageContent(assistantId, output);
+        // 如果是第一次接收到消息，启动打字动画
+        if (!isAnimationActive) startAnimation();
 
         // is this message is just a function call
         if (isFunctionMessageAtStart(output)) isFunctionCall = true;
@@ -416,4 +438,69 @@ export const chatMessage: StateCreator<
       window.removeEventListener('beforeunload', preventLeavingFn);
     }
   },
+
+  createSmoothMessage: (id) => {
+    const { dispatchMessage } = get();
+
+    let buffer = '';
+    // why use queue: https://shareg.pt/GLBrjpK
+    let outputQueue: string[] = [];
+
+    // eslint-disable-next-line no-undef
+    let animationTimeoutId: NodeJS.Timeout | null = null;
+    let isAnimationActive = false;
+
+    // when you need to stop the animation, call this function
+    const stopAnimation = () => {
+      isAnimationActive = false;
+      if (animationTimeoutId !== null) {
+        clearTimeout(animationTimeoutId);
+        animationTimeoutId = null;
+      }
+    };
+
+    // define startAnimation function to display the text in buffer smooth
+    // when you need to start the animation, call this function
+    const startAnimation = (speed = 2) =>
+      new Promise<void>((resolve) => {
+        if (isAnimationActive) {
+          resolve();
+          return;
+        }
+
+        isAnimationActive = true;
+
+        const updateText = () => {
+          // 如果动画已经不再激活，则停止更新文本
+          if (!isAnimationActive) {
+            clearTimeout(animationTimeoutId!);
+            animationTimeoutId = null;
+            resolve();
+          }
+
+          // 如果还有文本没有显示
+          // 检查队列中是否有字符待显示
+          if (outputQueue.length > 0) {
+            // 从队列中获取前两个字符（如果存在）
+            const charsToAdd = outputQueue.splice(0, speed).join('');
+            buffer += charsToAdd;
+
+            // 更新消息内容，这里可能需要结合实际情况调整
+            dispatchMessage({ id, key: 'content', type: 'updateMessage', value: buffer });
+
+            // 设置下一个字符的延迟
+            animationTimeoutId = setTimeout(updateText, 16); // 16 毫秒的延迟模拟打字机效果
+          } else {
+            // 当所有字符都显示完毕时，清除动画状态
+            isAnimationActive = false;
+            animationTimeoutId = null;
+            resolve();
+          }
+        };
+
+        updateText();
+      });
+
+    return { startAnimation, stopAnimation, outputQueue, isAnimationActive };
+  },
 });

package/src/store/chat/slices/message/selectors.ts

@@ -84,6 +84,12 @@ const currentChatsWithGuideMessage =
     return [emptyInboxGuideMessage];
   };
 
+const currentChatIDsWithGuideMessage = (s: ChatStore) => {
+  const meta = agentSelectors.currentAgentMeta(useSessionStore.getState());
+
+  return currentChatsWithGuideMessage(meta)(s).map((s) => s.id);
+};
+
 const currentChatsWithHistoryConfig = (s: ChatStore): ChatMessage[] => {
   const chats = currentChats(s);
   const config = agentSelectors.currentAgentConfig(useSessionStore.getState());
@@ -109,11 +115,15 @@ const getFunctionMessageProps =
 
 const getMessageById = (id: string) => (s: ChatStore) => chatHelpers.getMessageById(s.messages, id);
 
+const latestMessage = (s: ChatStore) => currentChats(s).at(-1);
+
 export const chatSelectors = {
   chatsMessageString,
+  currentChatIDsWithGuideMessage,
   currentChats,
   currentChatsWithGuideMessage,
   currentChatsWithHistoryConfig,
   getFunctionMessageProps,
   getMessageById,
+  latestMessage,
 };

package/src/store/chat/slices/topic/action.ts

@@ -30,6 +30,8 @@ export interface ChatTopicAction {
   removeTopic: (id: string) => Promise<void>;
   removeUnstarredTopic: () => void;
   saveToTopic: () => Promise<string | undefined>;
+  autoRenameTopicTitle: (id: string) => Promise<void>;
+  duplicateTopic: (id: string) => Promise<void>;
   summaryTopicTitle: (topicId: string, messages: ChatMessage[]) => Promise<void>;
   switchTopic: (id?: string) => Promise<void>;
   updateTopicTitleInSummary: (id: string, title: string) => void;
@@ -78,6 +80,19 @@ export const chatTopic: StateCreator<
 
     return topicId;
   },
+  duplicateTopic: async (id) => {
+    const { refreshTopic, switchTopic } = get();
+
+    const topic = topicSelectors.getTopicById(id)(get());
+    if (!topic) return;
+
+    const newTitle = t('duplicateTitle', { ns: 'chat', title: topic?.title });
+
+    const newTopicId = await topicService.duplicateTopic(id, newTitle);
+    await refreshTopic();
+
+    switchTopic(newTopicId);
+  },
   // update
   summaryTopicTitle: async (topicId, messages) => {
     const { updateTopicTitleInSummary, updateTopicLoading, refreshTopic } = get();
@@ -115,6 +130,13 @@ export const chatTopic: StateCreator<
     await topicService.updateTitle(id, title);
     await get().refreshTopic();
   },
+
+  autoRenameTopicTitle: async (id) => {
+    const { activeId: sessionId, summaryTopicTitle } = get();
+    const messages = await messageService.getMessages(sessionId, id);
+
+    await summaryTopicTitle(id, messages);
+  },
   // query
   useFetchTopics: (sessionId) =>
     useSWR<ChatTopic[]>(sessionId, async (sessionId) => topicService.getTopics({ sessionId }), {

package/src/store/global/slices/common/action.ts

@@ -75,6 +75,8 @@ export const createCommonSlice: StateCreator<
   },
   useCheckLatestVersion: () =>
     useSWR('checkLatestVersion', globalService.getLatestVersion, {
+      // check latest version every 30 minutes
+      focusThrottleInterval: 1000 * 60 * 30,
       onSuccess: (data: string) => {
         if (gt(data, CURRENT_VERSION))
           set({ hasNewVersion: true, latestVersion: data }, false, n('checkLatestVersion'));

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

@@ -0,0 +1,136 @@
+import { act, renderHook } from '@testing-library/react';
+import { AppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { INBOX_SESSION_ID } from '@/const/session';
+import { SESSION_CHAT_URL } from '@/const/url';
+import { sessionService } from '@/services/session';
+import { useSessionStore } from '@/store/session';
+import { LobeSessionType } from '@/types/session';
+
+// Mock sessionService 和其他依赖项
+vi.mock('@/services/session', () => ({
+  sessionService: {
+    removeAllSessions: vi.fn(),
+    createNewSession: vi.fn(),
+    duplicateSession: vi.fn(),
+    updateSessionGroup: vi.fn(),
+    removeSession: vi.fn(),
+    getSessions: vi.fn(),
+    searchSessions: vi.fn(),
+  },
+}));
+
+// Mock router
+const mockRouterPush = vi.fn();
+
+const mockRefresh = vi.fn();
+beforeEach(() => {
+  vi.clearAllMocks();
+  useSessionStore.setState({
+    refreshSessions: mockRefresh,
+    router: {
+      push: mockRouterPush,
+    } as unknown as AppRouterInstance,
+  });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('SessionAction', () => {
+  describe('clearSessions', () => {
+    it('should clear all sessions and refresh the list', async () => {
+      const { result } = renderHook(() => useSessionStore());
+
+      await act(async () => {
+        await result.current.clearSessions();
+      });
+
+      expect(sessionService.removeAllSessions).toHaveBeenCalled();
+      expect(mockRefresh).toHaveBeenCalled(); // 假设 refreshSessions 调用了 getSessions
+    });
+  });
+
+  describe('createSession', () => {
+    it('should create a new session and switch to it', async () => {
+      const { result } = renderHook(() => useSessionStore());
+      const newSessionId = 'new-session-id';
+      vi.mocked(sessionService.createNewSession).mockResolvedValue(newSessionId);
+
+      let createdSessionId;
+
+      await act(async () => {
+        createdSessionId = await result.current.createSession({ config: { displayMode: 'docs' } });
+      });
+
+      const call = vi.mocked(sessionService.createNewSession).mock.calls[0];
+      expect(call[0]).toEqual(LobeSessionType.Agent);
+      expect(call[1]).toMatchObject({ config: { displayMode: 'docs' } });
+
+      expect(createdSessionId).toBe(newSessionId);
+      expect(mockRouterPush).toHaveBeenCalledWith(
+        SESSION_CHAT_URL(newSessionId, result.current.isMobile),
+      );
+    });
+  });
+
+  describe('duplicateSession', () => {
+    it('should duplicate a session and switch to the new one', async () => {
+      const { result } = renderHook(() => useSessionStore());
+      const sessionId = 'session-id';
+      const duplicatedSessionId = 'duplicated-session-id';
+      vi.mocked(sessionService.duplicateSession).mockResolvedValue(duplicatedSessionId);
+
+      await act(async () => {
+        await result.current.duplicateSession(sessionId);
+      });
+
+      expect(sessionService.duplicateSession).toHaveBeenCalledWith(sessionId, undefined);
+    });
+  });
+
+  describe('removeSession', () => {
+    it('should remove a session and refresh the list', async () => {
+      const { result } = renderHook(() => useSessionStore());
+      const sessionId = 'session-id';
+
+      await act(async () => {
+        await result.current.removeSession(sessionId);
+      });
+
+      expect(sessionService.removeSession).toHaveBeenCalledWith(sessionId);
+      expect(mockRefresh).toHaveBeenCalled();
+    });
+  });
+
+  describe('switchSession', () => {
+    it('should switch to the provided session id', async () => {
+      const { result } = renderHook(() => useSessionStore());
+      const sessionId = 'session-id';
+
+      act(() => {
+        result.current.switchSession(sessionId);
+      });
+
+      expect(result.current.activeId).toBe(sessionId);
+      expect(mockRouterPush).toHaveBeenCalledWith(
+        SESSION_CHAT_URL(sessionId, result.current.isMobile),
+      );
+    });
+
+    it('should switch to the inbox session id if none is provided', async () => {
+      const { result } = renderHook(() => useSessionStore());
+
+      act(() => {
+        result.current.switchSession();
+      });
+
+      expect(result.current.activeId).toBe(INBOX_SESSION_ID);
+      expect(mockRouterPush).toHaveBeenCalledWith(
+        SESSION_CHAT_URL(INBOX_SESSION_ID, result.current.isMobile),
+      );
+    });
+  });
+});

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

@@ -1,3 +1,5 @@
+import { message } from 'antd';
+import { t } from 'i18next';
 import useSWR, { SWRResponse, mutate } from 'swr';
 import { DeepPartial } from 'utility-types';
 import { StateCreator } from 'zustand/vanilla';
@@ -17,7 +19,9 @@ import {
 import { merge } from '@/utils/merge';
 import { setNamespace } from '@/utils/storeDebug';
 
+import { agentSelectors } from '../agent/selectors';
 import { initLobeSession } from './initialState';
+import { sessionSelectors } from './selectors';
 
 const n = setNamespace('session');
 
@@ -39,7 +43,7 @@ export interface SessionAction {
    * @returns sessionId
    */
   createSession: (agent?: DeepPartial<LobeAgentSettings>) => Promise<string>;
-
+  duplicateSession: (id: string) => Promise<void>;
   /**
    * Pins or unpins a session.
    *
@@ -48,20 +52,16 @@ export interface SessionAction {
    * @returns {Promise<void>} A promise that resolves when the session is successfully pinned or unpinned.
    */
   pinSession: (id: string, pinned?: boolean) => Promise<void>;
-
   /**
    * re-fetch the data
    */
   refreshSessions: () => Promise<void>;
-
   /**
    * remove session
    * @param id - sessionId
    */
   removeSession: (id: string) => void;
-
   switchBackToChat: () => void;
-
   /**
    * switch session url
    */
@@ -70,7 +70,6 @@ export interface SessionAction {
    * A custom hook that uses SWR to fetch sessions data.
    */
   useFetchSessions: () => SWRResponse<any>;
-
   useSearchSessions: (keyword?: string) => SWRResponse<any>;
 }
 
@@ -109,6 +108,27 @@ export const createSessionSlice: StateCreator<
     return id;
   },
 
+  duplicateSession: async (id) => {
+    const { switchSession, refreshSessions } = get();
+    const session = sessionSelectors.getSessionById(id)(get());
+
+    if (!session) return;
+    const title = agentSelectors.getTitle(session.meta);
+
+    const newTitle = t('duplicateTitle', { ns: 'chat', title: title });
+
+    const newId = await sessionService.duplicateSession(id, newTitle);
+
+    // duplicate Session Error
+    if (!newId) {
+      message.error('复制失败');
+      return;
+    }
+
+    await refreshSessions();
+    switchSession(newId);
+  },
+
   pinSession: async (sessionId, pinned) => {
     await sessionService.updateSessionGroup(sessionId, pinned ? 'pinned' : 'default');
 

package/src/types/topic.ts

@@ -2,6 +2,7 @@ import { BaseDataModel } from '@/types/meta';
 
 export interface ChatTopic extends Omit<BaseDataModel, 'meta'> {
   favorite?: boolean;
+  sessionId?: string;
   title: string;
 }
 

package/src/utils/fetch.test.ts

@@ -0,0 +1,131 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ErrorResponse, ErrorType } from '@/types/fetch';
+
+import { fetchAIFactory, fetchSSE, getMessageError } from './fetch';
+
+// 模拟 i18next
+vi.mock('i18next', () => ({
+  t: vi.fn((key) => `translated_${key}`),
+}));
+
+// 模拟 Response
+const createMockResponse = (body: any, ok: boolean, status: number = 200) => ({
+  ok,
+  status,
+  json: vi.fn(async () => body),
+  clone: vi.fn(function () {
+    // @ts-ignore
+    return this;
+  }),
+  text: vi.fn(async () => JSON.stringify(body)),
+  body: {
+    getReader: () => {
+      let done = false;
+      return {
+        read: () => {
+          if (!done) {
+            done = true;
+            return Promise.resolve({
+              value: new TextEncoder().encode(JSON.stringify(body)),
+              done: false,
+            });
+          } else {
+            return Promise.resolve({ done: true });
+          }
+        },
+      };
+    },
+  },
+});
+
+// 在每次测试后清理所有模拟
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('getMessageError', () => {
+  it('should handle business error correctly', async () => {
+    const mockErrorResponse: ErrorResponse = {
+      body: 'Error occurred',
+      errorType: 'InvalidAccessCode',
+    };
+    const mockResponse = createMockResponse(mockErrorResponse, false, 400);
+
+    const error = await getMessageError(mockResponse as any);
+
+    expect(error).toEqual({
+      body: mockErrorResponse.body,
+      message: 'translated_response.InvalidAccessCode',
+      type: mockErrorResponse.errorType,
+    });
+    expect(mockResponse.json).toHaveBeenCalled();
+  });
+
+  it('should handle regular error correctly', async () => {
+    const mockResponse = createMockResponse({}, false, 500);
+    mockResponse.json.mockImplementationOnce(() => {
+      throw new Error('Failed to parse');
+    });
+
+    const error = await getMessageError(mockResponse as any);
+
+    expect(error).toEqual({
+      message: 'translated_response.500',
+      type: 500,
+    });
+    expect(mockResponse.json).toHaveBeenCalled();
+  });
+});
+
+describe('fetchAIFactory', () => {
+  it('should handle successful response', async () => {
+    const fetcher = async (params: any, options: any) =>
+      new Response('AI response', { status: 200 });
+    const params = {
+      /* mock params */
+    };
+    const onMessageHandle = vi.fn();
+    const onFinish = vi.fn();
+    const onError = vi.fn();
+    const onLoadingChange = vi.fn();
+    const abortController = new AbortController();
+
+    const fetchAIFn = fetchAIFactory(fetcher);
+    const result = await fetchAIFn({
+      params,
+      onMessageHandle,
+      onFinish,
+      onError,
+      onLoadingChange,
+      abortController,
+    });
+
+    expect(result).toBe('AI response');
+    expect(onMessageHandle).toHaveBeenCalled();
+    expect(onFinish).toHaveBeenCalled();
+    expect(onError).not.toHaveBeenCalled();
+    expect(onLoadingChange).toHaveBeenCalledTimes(2);
+  });
+
+  it('should handle error response', async () => {
+    const fetcher = async (params: any, options: any) =>
+      new Response(null, { status: 404, statusText: 'Not Found' });
+    const params = {
+      /* mock params */
+    };
+    const onError = vi.fn();
+    const onLoadingChange = vi.fn();
+    const abortController = new AbortController();
+
+    const fetchAIFn = fetchAIFactory(fetcher);
+    await fetchAIFn({ params, onError, onLoadingChange, abortController });
+
+    expect(onError).toHaveBeenCalledWith(expect.any(Error), {
+      message: 'translated_response.404',
+      type: 404,
+    });
+    expect(onLoadingChange).toHaveBeenCalledTimes(3);
+    expect(onLoadingChange.mock.lastCall).toEqual([false]);
+  });
+});