@lobehub/chat 0.109.0 → 0.110.0

package/src/store/session/slices/agent/selectors.test.ts

@@ -0,0 +1,228 @@
+import { describe, expect, it } from 'vitest';
+
+import { DEFAULT_AVATAR } from '@/const/meta';
+import { DEFAULT_AGENT_CONFIG, DEFAUTT_AGENT_TTS_CONFIG } from '@/const/settings';
+import { SessionStore } from '@/store/session';
+import { MetaData } from '@/types/meta';
+import { LobeAgentSession, LobeSessionType } from '@/types/session';
+
+import { agentSelectors } from '../agent';
+
+vi.mock('i18next', () => ({
+  t: vi.fn((key) => key), // Simplified mock return value
+}));
+
+const mockSessionStore = {
+  activeId: '1',
+  sessions: [
+    {
+      id: '1',
+      config: DEFAULT_AGENT_CONFIG,
+      meta: {
+        title: 'title1',
+        description: 'description1',
+      },
+      type: LobeSessionType.Agent,
+    } as LobeAgentSession,
+    {
+      id: '2',
+      meta: {
+        title: 'title2',
+        description: 'description2',
+      },
+      config: DEFAULT_AGENT_CONFIG,
+      type: LobeSessionType.Agent,
+    } as LobeAgentSession,
+  ],
+} as unknown as SessionStore;
+
+describe('agentSelectors', () => {
+  describe('currentAgentConfig', () => {
+    it('should return the merged default and session-specific agent config', () => {
+      const config = agentSelectors.currentAgentConfig(mockSessionStore);
+      expect(config).toEqual(expect.objectContaining(mockSessionStore.sessions[0].config));
+    });
+  });
+
+  describe('currentAgentModel', () => {
+    it('should return the model from the agent config', () => {
+      const model = agentSelectors.currentAgentModel(mockSessionStore);
+      expect(model).toBe(mockSessionStore.sessions[0].config.model);
+    });
+  });
+
+  describe('currentAgentMeta', () => {
+    it('should return the merged default and session-specific meta data', () => {
+      const meta = agentSelectors.currentAgentMeta(mockSessionStore);
+      expect(meta).toEqual(expect.objectContaining(mockSessionStore.sessions[0].meta));
+    });
+
+    it('should return inbox defaults if it is an inbox session', () => {
+      // Assume sessionSelectors.isInboxSession() is mocked to return true for this test
+      const meta = agentSelectors.currentAgentMeta(mockSessionStore);
+      expect(meta.avatar).toBe(DEFAULT_AVATAR);
+    });
+  });
+
+  describe('currentAgentTitle', () => {
+    it('should return the title from the session meta data', () => {
+      const title = agentSelectors.currentAgentTitle(mockSessionStore);
+      expect(title).toBe(mockSessionStore.sessions[0].meta.title);
+    });
+  });
+
+  describe('currentAgentDescription', () => {
+    it('should return the description from the session meta data', () => {
+      const description = agentSelectors.currentAgentDescription(mockSessionStore);
+      expect(description).toBe(mockSessionStore.sessions[0].meta.description);
+    });
+  });
+
+  // ... More tests for other selectors
+
+  describe('hasSystemRole', () => {
+    it('should return true if the system role is defined in the agent config', () => {
+      const hasRole = agentSelectors.hasSystemRole(mockSessionStore);
+      expect(hasRole).toBe(false);
+    });
+
+    it('should return false if the system role is not defined in the agent config', () => {
+      const modifiedSessionStore = {
+        ...mockSessionStore,
+        sessions: [
+          {
+            ...mockSessionStore.sessions[0],
+            config: {
+              ...mockSessionStore.sessions[0].config,
+              systemRole: 'test',
+            },
+          },
+        ],
+      };
+      const hasRole = agentSelectors.hasSystemRole(modifiedSessionStore);
+      expect(hasRole).toBe(true);
+    });
+  });
+
+  describe('currentAgentTTS', () => {
+    it('should return the TTS config from the agent config', () => {
+      const ttsConfig = agentSelectors.currentAgentTTS(mockSessionStore);
+      expect(ttsConfig).toEqual(mockSessionStore.sessions[0].config.tts);
+    });
+
+    it('should return the default TTS config if none is defined in the agent config', () => {
+      const modifiedSessionStore = {
+        ...mockSessionStore,
+        sessions: [
+          {
+            ...mockSessionStore.sessions[0],
+            config: {
+              ...mockSessionStore.sessions[0].config,
+              tts: DEFAUTT_AGENT_TTS_CONFIG,
+            },
+          },
+        ],
+      };
+      const ttsConfig = agentSelectors.currentAgentTTS(modifiedSessionStore);
+      expect(ttsConfig).toEqual(DEFAUTT_AGENT_TTS_CONFIG);
+    });
+  });
+
+  describe('currentAgentTTSVoice', () => {
+    it('should return the appropriate TTS voice based on the service and language', () => {
+      const lang = 'en';
+      const ttsVoice = agentSelectors.currentAgentTTSVoice(lang)(mockSessionStore);
+      expect(ttsVoice).toBe(mockSessionStore.sessions[0].config.tts.voice.openai);
+    });
+  });
+
+  describe('getAvatar', () => {
+    it('should return the avatar from the meta data', () => {
+      const meta: MetaData = { avatar: 'custom-avatar.png' };
+      const avatar = agentSelectors.getAvatar(meta);
+      expect(avatar).toBe(meta.avatar);
+    });
+
+    it('should return the default avatar if none is defined in the meta data', () => {
+      const meta: MetaData = {};
+      const avatar = agentSelectors.getAvatar(meta);
+      expect(avatar).toBe(DEFAULT_AVATAR);
+    });
+  });
+
+  describe('getTitle', () => {
+    it('should return the title from the meta data', () => {
+      const meta: MetaData = { title: 'Custom Title' };
+      const title = agentSelectors.getTitle(meta);
+      expect(title).toBe(meta.title);
+    });
+
+    it('should return the default title if none is defined in the meta data', () => {
+      const meta: MetaData = {};
+      const title = agentSelectors.getTitle(meta);
+      expect(title).toBe('defaultSession'); // Assuming translation returns this key
+    });
+  });
+
+  describe('getDescription', () => {
+    it('should return the description from the meta data', () => {
+      const meta: MetaData = { description: 'Custom Description' };
+      const description = agentSelectors.getDescription(meta);
+      expect(description).toBe(meta.description);
+    });
+
+    it('should return the default description if none is defined in the meta data', () => {
+      const meta: MetaData = {};
+      const description = agentSelectors.getDescription(meta);
+      expect(description).toBe('noDescription'); // Assuming translation returns this key
+    });
+  });
+
+  describe('showTokenTag', () => {
+    it('should return true if the model is in the list of models that show tokens', () => {
+      const show = agentSelectors.showTokenTag(mockSessionStore);
+      expect(show).toBe(true);
+    });
+
+    it('should return false if the model is not in the list of models that show tokens', () => {
+      const modifiedSessionStore = {
+        ...mockSessionStore,
+        sessions: [
+          {
+            ...mockSessionStore.sessions[0],
+            config: {
+              ...mockSessionStore.sessions[0].config,
+              model: 'some-other-model',
+            },
+          },
+        ],
+      };
+      const show = agentSelectors.showTokenTag(modifiedSessionStore);
+      expect(show).toBe(false);
+    });
+  });
+
+  describe('modelHasVisionAbility', () => {
+    it('should return true if the model has vision ability', () => {
+      const hasAbility = agentSelectors.modelHasVisionAbility(mockSessionStore);
+      expect(hasAbility).toBe(false);
+    });
+
+    it('should return false if the model does not have vision ability', () => {
+      const modifiedSessionStore = {
+        ...mockSessionStore,
+        sessions: [
+          {
+            ...mockSessionStore.sessions[0],
+            config: {
+              ...mockSessionStore.sessions[0].config,
+              model: 'some-other-model',
+            },
+          },
+        ],
+      };
+      const hasAbility = agentSelectors.modelHasVisionAbility(modifiedSessionStore);
+      expect(hasAbility).toBe(false);
+    });
+  });
+});

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

@@ -1,3 +1,4 @@
+import { VoiceList } from '@lobehub/tts';
 import { t } from 'i18next';
 
 import { DEFAULT_OPENAI_MODEL_LIST, VISION_MODEL_WHITE_LIST } from '@/const/llm';
@@ -46,6 +47,29 @@ const currentAgentTTS = (s: SessionStore): LobeAgentTTSConfig => {
   return config?.tts || DEFAUTT_AGENT_TTS_CONFIG;
 };
 
+const currentAgentTTSVoice =
+  (lang: string) =>
+  (s: SessionStore): string => {
+    const { voice, ttsService } = currentAgentTTS(s);
+    const voiceList = new VoiceList(lang);
+    let currentVoice;
+    switch (ttsService) {
+      case 'openai': {
+        currentVoice = voice.openai || (VoiceList.openaiVoiceOptions?.[0].value as string);
+        break;
+      }
+      case 'edge': {
+        currentVoice = voice.edge || (voiceList.edgeVoiceOptions?.[0].value as string);
+        break;
+      }
+      case 'microsoft': {
+        currentVoice = voice.microsoft || (voiceList.microsoftVoiceOptions?.[0].value as string);
+        break;
+      }
+    }
+    return currentVoice || 'alloy';
+  };
+
 // ==========   Meta   ============== //
 const currentAgentMeta = (s: SessionStore): MetaData => {
   const isInbox = sessionSelectors.isInboxSession(s);
@@ -97,6 +121,7 @@ export const agentSelectors = {
   currentAgentPlugins,
   currentAgentSystemRole,
   currentAgentTTS,
+  currentAgentTTSVoice,
   currentAgentTitle,
   getAvatar,
   getDescription,

package/src/store/tool/helpers.ts

@@ -7,7 +7,7 @@ const getPluginFormList = (pluginList: LobeChatPluginMeta[], id: string) =>
 
 const getPluginTitle = (meta?: LobeChatPluginMeta['meta']) => meta?.title;
 const getPluginDesc = (meta?: LobeChatPluginMeta['meta']) => meta?.description;
-const getPluginAvatar = (meta?: LobeChatPluginMeta['meta']) => meta?.avatar;
+const getPluginAvatar = (meta?: LobeChatPluginMeta['meta']) => meta?.avatar || '🧩';
 
 const isCustomPlugin = (id: string, pluginList: CustomPlugin[]) =>
   pluginList.some((i) => i.identifier === id);

package/src/types/chatMessage.ts

@@ -18,7 +18,9 @@ export interface ChatTranslate extends Translate {
 }
 
 export interface ChatTTS {
-  init?: boolean;
+  contentMd5?: string;
+  file?: string;
+  voice?: string;
 }
 
 export interface ChatPluginPayload {

package/vitest.config.ts

@@ -2,6 +2,10 @@ import { resolve } from 'node:path';
 import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
+  optimizeDeps: {
+    exclude: ['crypto', 'util', 'tty'],
+    include: ['@lobehub/tts'],
+  },
   test: {
     alias: {
       '@': resolve(__dirname, './src'),

package/src/app/chat/features/Conversation/ChatList/Extras/TTS.tsx

@@ -1,122 +0,0 @@
-import { AudioPlayer } from '@lobehub/tts/react';
-import { ActionIcon, Alert, Highlighter } from '@lobehub/ui';
-import { Button } from 'antd';
-import { TrashIcon } from 'lucide-react';
-import { memo, useCallback, useEffect, useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import { Flexbox } from 'react-layout-kit';
-
-import { useTTS } from '@/hooks/useTTS';
-import { useChatStore } from '@/store/chat';
-import { ChatMessageError, ChatTTS } from '@/types/chatMessage';
-import { getMessageError } from '@/utils/fetch';
-
-interface TTSProps extends ChatTTS {
-  content: string;
-  id: string;
-  loading?: boolean;
-}
-
-const TTS = memo<TTSProps>(({ id, init, content }) => {
-  const [isStart, setIsStart] = useState(false);
-  const [error, setError] = useState<ChatMessageError>();
-  const { t } = useTranslation('chat');
-
-  const [ttsMessage, clearTTS] = useChatStore((s) => [s.ttsMessage, s.clearTTS]);
-
-  const setDefaultError = useCallback(
-    (err?: any) => {
-      setError({ body: err, message: t('tts.responseError', { ns: 'error' }), type: 500 });
-    },
-    [t],
-  );
-
-  const { isGlobalLoading, audio, start, stop, response } = useTTS(content, {
-    onError: (err) => {
-      stop();
-      setDefaultError(err);
-    },
-    onErrorRetry: (err) => {
-      stop();
-      setDefaultError(err);
-    },
-    onSuccess: async () => {
-      if (!response) return;
-      if (response.status === 200) return ttsMessage(id, true);
-      const message = await getMessageError(response);
-      if (message) {
-        setError(message);
-      } else {
-        setDefaultError();
-      }
-      stop();
-    },
-  });
-
-  const handleInitStart = useCallback(() => {
-    if (isStart) return;
-    start();
-    setIsStart(true);
-  }, [isStart]);
-
-  const handleDelete = useCallback(() => {
-    stop();
-    clearTTS(id);
-  }, [stop, id]);
-
-  const handleRetry = useCallback(() => {
-    setError(undefined);
-    start();
-  }, [start]);
-
-  useEffect(() => {
-    if (init) return;
-    handleInitStart();
-  }, [init]);
-
-  return (
-    <Flexbox align={'center'} horizontal style={{ minWidth: 160, width: '100%' }}>
-      {error ? (
-        <Alert
-          action={
-            <Button onClick={handleRetry} size={'small'} type={'primary'}>
-              {t('retry', { ns: 'common' })}
-            </Button>
-          }
-          closable
-          extra={
-            error.body && (
-              <Highlighter copyButtonSize={'small'} language={'json'} type={'pure'}>
-                {JSON.stringify(error.body, null, 2)}
-              </Highlighter>
-            )
-          }
-          message={error.message}
-          onClose={handleDelete}
-          style={{ alignItems: 'center', width: '100%' }}
-          type="error"
-        />
-      ) : (
-        <>
-          <AudioPlayer
-            audio={audio}
-            buttonSize={'small'}
-            isLoading={isGlobalLoading}
-            onInitPlay={handleInitStart}
-            onLoadingStop={stop}
-            timeRender={'tag'}
-            timeStyle={{ margin: 0 }}
-          />
-          <ActionIcon
-            icon={TrashIcon}
-            onClick={handleDelete}
-            size={'small'}
-            title={t('tts.clear')}
-          />
-        </>
-      )}
-    </Flexbox>
-  );
-});
-
-export default TTS;