@lobehub/chat 0.105.2 → 0.107.0

package/src/database/models/topic.ts

@@ -0,0 +1,196 @@
+import { BaseModel } from '@/database/core';
+import { DB_Topic, DB_TopicSchema } from '@/database/schemas/topic';
+import { ChatTopic } from '@/types/topic';
+import { nanoid } from '@/utils/uuid';
+
+export interface CreateTopicParams {
+  favorite?: boolean;
+  sessionId: string;
+  title: string;
+}
+
+export interface QueryTopicParams {
+  current?: number;
+  pageSize?: number;
+  sessionId: string;
+}
+
+class _TopicModel extends BaseModel {
+  constructor() {
+    super('topics', DB_TopicSchema);
+  }
+
+  async create({ title, favorite, sessionId }: CreateTopicParams, id = nanoid()) {
+    return this._add({ favorite: favorite ? 1 : 0, sessionId, title: title }, id);
+  }
+
+  async batchCreate(topics: CreateTopicParams[]) {
+    return this._batchAdd(topics.map((t) => ({ ...t, favorite: t.favorite ? 1 : 0 })));
+  }
+
+  async query({ pageSize = 9999, current = 0, sessionId }: QueryTopicParams): Promise<ChatTopic[]> {
+    const offset = current * pageSize;
+
+    // get all topics
+    const allTopics = await this.table.where('sessionId').equals(sessionId).toArray();
+
+    // 将所有主题按星标消息优先，时间倒序进行排序
+    const sortedTopics = allTopics.sort((a, b) => {
+      if (a.favorite && !b.favorite) return -1; // a是星标，b不是，a排前面
+      if (!a.favorite && b.favorite) return 1; // b是星标，a不是，b排前面
+
+      // 如果星标状态相同，则按时间倒序排序
+      return b.createdAt - a.createdAt;
+    });
+
+    // handle pageSize
+    const pagedTopics = sortedTopics.slice(offset, offset + pageSize);
+
+    return pagedTopics.map((i) => ({ ...i, favorite: !!i.favorite }));
+  }
+
+  async findBySessionId(sessionId: string) {
+    return this.table.where({ sessionId }).toArray();
+  }
+
+  async findById(id: string) {
+    return this.table.get(id);
+  }
+
+  /**
+   * Deletes a topic and all messages associated with it.
+   */
+  async delete(id: string) {
+    return this.db.transaction('rw', [this.table, this.db.messages], async () => {
+      // Delete all messages associated with the topic
+      const messages = await this.db.messages.where('topicId').equals(id).toArray();
+
+      if (messages.length > 0) {
+        const messageIds = messages.map((msg) => msg.id);
+        await this.db.messages.bulkDelete(messageIds);
+      }
+
+      await this.table.delete(id);
+    });
+  }
+
+  /**
+   * Deletes multiple topic based on the sessionId.
+   *
+   * @param {string} sessionId - The identifier of the assistant associated with the messages.
+   * @returns {Promise<void>}
+   */
+  async batchDeleteBySessionId(sessionId: string): Promise<void> {
+    // use sessionId as the filter criteria in the query.
+    const query = this.table.where('sessionId').equals(sessionId);
+
+    // Retrieve a collection of message IDs that satisfy the criteria
+    const topicIds = await query.primaryKeys();
+
+    // Use the bulkDelete method to delete all selected messages in bulk
+    return this.table.bulkDelete(topicIds);
+  }
+
+  async clearTable() {
+    return this.table.clear();
+  }
+
+  async update(id: string, data: Partial<DB_Topic>) {
+    return super._update(id, { ...data, updatedAt: Date.now() });
+  }
+
+  async toggleFavorite(id: string, newState?: boolean) {
+    const topic = await this.findById(id);
+    if (!topic) {
+      throw new Error(`Topic with id ${id} not found`);
+    }
+
+    // Toggle the 'favorite' status
+    const nextState = typeof newState !== 'undefined' ? newState : !topic.favorite;
+
+    await this.update(id, { favorite: nextState ? 1 : 0 });
+
+    return nextState;
+  }
+
+  /**
+   * Deletes multiple topics and all messages associated with them in a transaction.
+   */
+  async batchDelete(topicIds: string[]) {
+    return this.db.transaction('rw', [this.table, this.db.messages], async () => {
+      // Iterate over each topicId and delete related messages, then delete the topic itself
+      for (const topicId of topicIds) {
+        // Delete all messages associated with the topic
+        const messages = await this.db.messages.where('topicId').equals(topicId).toArray();
+        if (messages.length > 0) {
+          const messageIds = messages.map((msg) => msg.id);
+          await this.db.messages.bulkDelete(messageIds);
+        }
+
+        // Delete the topic
+        await this.table.delete(topicId);
+      }
+    });
+  }
+
+  queryAll() {
+    return this.table.orderBy('updatedAt').toArray();
+  }
+
+  /**
+   * Query topics by keyword in title, message content, or translated content
+   * @param keyword The keyword to search for
+   */
+  async queryByKeyword(keyword: string): Promise<ChatTopic[]> {
+    if (!keyword) return [];
+
+    console.time('queryTopicsByKeyword');
+    const keywordLowerCase = keyword.toLowerCase();
+
+    // Find topics with matching title
+    const matchingTopicsPromise = this.table
+      .filter((topic) => topic.title.toLowerCase().includes(keywordLowerCase))
+      .toArray();
+
+    // Find messages with matching content or translate.content
+    const matchingMessagesPromise = this.db.messages
+      .filter((message) => {
+        // check content
+        if (message.content.toLowerCase().includes(keywordLowerCase)) return true;
+
+        // check translate content
+        if (message.translate && message.translate.content) {
+          return message.translate.content.toLowerCase().includes(keywordLowerCase);
+        }
+
+        return false;
+      })
+      .toArray();
+
+    // Resolve both promises
+    const [matchingTopics, matchingMessages] = await Promise.all([
+      matchingTopicsPromise,
+      matchingMessagesPromise,
+    ]);
+
+    // Extract topic IDs from messages
+    const topicIdsFromMessages = matchingMessages.map((message) => message.topicId);
+
+    // Combine topic IDs from both sources
+    const combinedTopicIds = new Set([
+      ...topicIdsFromMessages,
+      ...matchingTopics.map((topic) => topic.id),
+    ]);
+
+    // Retrieve unique topics by IDs
+    const uniqueTopics = await this.table
+      .where('id')
+      .anyOf([...combinedTopicIds])
+      .toArray();
+
+    console.timeEnd('queryTopicsByKeyword');
+    return uniqueTopics.map((i) => ({ ...i, favorite: !!i.favorite }));
+  }
+}
+
+export const TopicModel = new _TopicModel();

package/src/{types/database → database/schemas}/files.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
-export const LocalFileSchema = z.object({
+export const DB_FileSchema = z.object({
   /**
    * create Time
    */
@@ -35,4 +35,4 @@ export const LocalFileSchema = z.object({
   url: z.string().url().optional(),
 });
 
-export type LocalFile = z.infer<typeof LocalFileSchema>;
+export type DB_File = z.infer<typeof DB_FileSchema>;

package/src/database/schemas/message.ts

@@ -0,0 +1,37 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix  */
+import { z } from 'zod';
+
+const TranslateSchema = z.object({
+  from: z.string().optional(),
+  to: z.string(),
+  content: z.string().optional(),
+});
+
+const PluginSchema = z.object({
+  identifier: z.string(),
+  arguments: z.string(),
+  apiName: z.string(),
+  type: z.enum(['default', 'standalone']).default('default'),
+});
+
+export const DB_MessageSchema = z.object({
+  role: z.enum(['user', 'system', 'assistant', 'function']),
+  content: z.string(),
+  files: z.array(z.string()).optional(),
+  favorite: z.number().int().min(0).max(1).optional(),
+  error: z.any().optional(),
+
+  plugin: PluginSchema.optional(),
+  pluginState: z.any().optional(),
+  fromModel: z.string().optional(),
+  translate: TranslateSchema.optional().or(z.null()),
+  tts: z.any().optional(),
+
+  // foreign keys
+  parentId: z.string().optional(),
+  quotaId: z.string().optional(),
+  sessionId: z.string(),
+  topicId: z.string().optional(),
+});
+
+export type DB_Message = z.infer<typeof DB_MessageSchema>;

package/src/database/schemas/session.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+
+import { LobeMetaDataSchema } from '@/types/meta';
+
+const fewShotsSchema = z.array(
+  z.object({
+    content: z.string(),
+    role: z.string(),
+  }),
+);
+
+const ttsSchema = z.object({
+  showAllLocaleVoice: z.boolean().optional(),
+  sttLocale: z.string().default('auto'),
+  ttsService: z.string().default('openai'),
+  voice: z
+    .object({
+      edge: z.string().optional(),
+      microsoft: z.string().optional(),
+      openai: z.string().default(''),
+    })
+    .optional(),
+});
+
+export const AgentSchema = z.object({
+  autoCreateTopicThreshold: z.number().default(2),
+  compressThreshold: z.number().optional(),
+  displayMode: z.enum(['chat', 'docs']).optional(),
+  enableAutoCreateTopic: z.boolean().default(true),
+  enableCompressThreshold: z.boolean().optional(),
+  enableHistoryCount: z.boolean().optional(),
+  enableMaxTokens: z.boolean().optional(),
+  fewShots: fewShotsSchema.optional(),
+  historyCount: z.number().default(8).optional(),
+  inputTemplate: z.string().optional(),
+  model: z.string().default('gpt-3.5-turbo'),
+  params: z.object({
+    frequency_penalty: z.number().default(0).optional(),
+    max_tokens: z.number().optional(),
+    presence_penalty: z.number().default(0).optional(),
+    temperature: z.number().default(0.6).optional(),
+    top_p: z.number().default(1).optional(),
+  }),
+  plugins: z.array(z.string()).optional(),
+  systemRole: z.string().default(''),
+  tts: ttsSchema.optional(),
+});
+
+export const DB_SessionSchema = z.object({
+  config: AgentSchema,
+  group: z.string().default('default'),
+  meta: LobeMetaDataSchema,
+  type: z.enum(['agent', 'group']).default('agent'),
+});
+
+export type DB_Session = z.infer<typeof DB_SessionSchema>;

package/src/database/schemas/topic.ts

@@ -0,0 +1,12 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix  */
+import { z } from 'zod';
+
+export const DB_TopicSchema = z.object({
+  title: z.string(),
+  favorite: z.number().int().default(0),
+
+  // foreign keys
+  sessionId: z.string().optional(),
+});
+
+export type DB_Topic = z.infer<typeof DB_TopicSchema>;

package/src/features/AgentSetting/AgentConfig/index.tsx

@@ -114,7 +114,14 @@ const AgentConfig = memo(() => {
   const model: ItemGroup = {
     children: [
       {
-        children: <Select options={modelList.map((value) => ({ label: value, value }))} />,
+        children: (
+          <Select
+            options={modelList.map(({ name, displayName }) => ({
+              label: displayName,
+              value: name,
+            }))}
+          />
+        ),
         desc: t('settingModel.model.desc'),
         label: t('settingModel.model.title'),
         name: 'model',

package/src/features/AgentSetting/AgentTTS/SelectWithTTSPreview.tsx

@@ -7,8 +7,8 @@ import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
 import { useTTS } from '@/hooks/useTTS';
+import { TTSServer } from '@/types/agent';
 import { ChatMessageError } from '@/types/chatMessage';
-import { TTSServer } from '@/types/session';
 import { getMessageError } from '@/utils/fetch';
 
 interface SelectWithTTSPreviewProps extends SelectProps {

package/src/features/AgentSetting/store/action.ts

@@ -5,8 +5,8 @@ import { chainSummaryAgentName } from '@/chains/summaryAgentName';
 import { chainSummaryDescription } from '@/chains/summaryDescription';
 import { chainSummaryTags } from '@/chains/summaryTags';
 import { chatService } from '@/services/chat';
+import { LobeAgentConfig } from '@/types/agent';
 import { MetaData } from '@/types/meta';
-import { LobeAgentConfig } from '@/types/session';
 import { setNamespace } from '@/utils/storeDebug';
 
 import { SessionLoadingState } from '../store/initialState';

package/src/features/AgentSetting/store/initialState.ts

@@ -1,7 +1,7 @@
 import { DEFAULT_AGENT_META } from '@/const/meta';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { MetaData } from '@/types/meta';
-import { LobeAgentConfig } from '@/types/session';
+import { LobeAgentConfig } from '@/types/agent';
 
 export interface State {
   autocompleteLoading: SessionLoadingState;

package/src/features/AgentSetting/store/reducers/config.ts

@@ -1,7 +1,7 @@
 import { produce } from 'immer';
 
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
-import { LobeAgentConfig } from '@/types/session';
+import { LobeAgentConfig } from '@/types/agent';
 import { merge } from '@/utils/merge';
 
 export type ConfigDispatch =

package/src/features/DataImporter/index.tsx

@@ -0,0 +1,240 @@
+import { Icon } from '@lobehub/ui';
+import { Button, Result, Table, Upload } from 'antd';
+import { createStyles } from 'antd-style';
+import { BadgeCheck, ImportIcon } from 'lucide-react';
+import React, { ReactNode, memo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Center, Flexbox } from 'react-layout-kit';
+
+import DataStyleModal from '@/components/DataStyleModal';
+import { useImportConfig } from '@/hooks/useImportConfig';
+import { ImportResult, ImportResults } from '@/services/config';
+
+const useStyles = createStyles(({ css, token }) => {
+  const size = 28;
+
+  return {
+    loader: css`
+      transform: translateX(-${size * 2}px);
+
+      aspect-ratio: 1;
+      width: 6px;
+
+      color: ${token.colorPrimary};
+
+      border-radius: 50%;
+      box-shadow:
+        ${size}px -${size}px 0 0,
+        ${size * 2}px -${size}px 0 0,
+        ${size * 3}px -${size}px 0 0,
+        ${size}px 0 0 5px,
+        ${size * 2}px 0 0 5px,
+        ${size * 3}px 0 0 5px,
+        ${size}px ${size}px 0 0,
+        ${size * 2}px ${size}px 0 0,
+        ${size * 3}px ${size}px 0 0;
+
+      animation: loading 2s infinite linear;
+
+      @keyframes loading {
+        12.5% {
+          box-shadow:
+            ${size}px -${size}px 0 0,
+            ${size * 2}px -${size}px 0 0,
+            ${size * 3}px -${size}px 0 5px,
+            ${size}px 0 0 5px,
+            ${size * 2}px 0 0 0,
+            ${size * 3}px 0 0 5px,
+            ${size}px ${size}px 0 0,
+            ${size * 2}px ${size}px 0 0,
+            ${size * 3}px ${size}px 0 0;
+        }
+
+        25% {
+          box-shadow:
+            ${size}px -${size}px 0 5px,
+            ${size * 2}px -${size}px 0 0,
+            ${size * 3}px -${size}px 0 5px,
+            ${size}px 0 0 0,
+            ${size * 2}px 0 0 0,
+            ${size * 3}px 0 0 0,
+            ${size}px ${size}px 0 0,
+            ${size * 2}px ${size}px 0 5px,
+            ${size * 3}px ${size}px 0 0;
+        }
+
+        50% {
+          box-shadow:
+            ${size}px -${size}px 0 5px,
+            ${size * 2}px -${size}px 0 5px,
+            ${size * 3}px -${size}px 0 0,
+            ${size}px 0 0 0,
+            ${size * 2}px 0 0 0,
+            ${size * 3}px 0 0 0,
+            ${size}px ${size}px 0 0,
+            ${size * 2}px ${size}px 0 0,
+            ${size * 3}px ${size}px 0 5px;
+        }
+
+        62.5% {
+          box-shadow:
+            ${size}px -${size}px 0 0,
+            ${size * 2}px -${size}px 0 0,
+            ${size * 3}px -${size}px 0 0,
+            ${size}px 0 0 5px,
+            ${size * 2}px 0 0 0,
+            ${size * 3}px 0 0 0,
+            ${size}px ${size}px 0 0,
+            ${size * 2}px ${size}px 0 5px,
+            ${size * 3}px ${size}px 0 5px;
+        }
+
+        75% {
+          box-shadow:
+            ${size}px -${size}px 0 0,
+            ${size * 2}px -${size}px 0 5px,
+            ${size * 3}px -${size}px 0 0,
+            ${size}px 0 0 0,
+            ${size * 2}px 0 0 0,
+            ${size * 3}px 0 0 5px,
+            ${size}px ${size}px 0 0,
+            ${size * 2}px ${size}px 0 0,
+            ${size * 3}px ${size}px 0 5px;
+        }
+
+        87.5% {
+          box-shadow:
+            ${size}px -${size}px 0 0,
+            ${size * 2}px -${size}px 0 5px,
+            ${size * 3}px -${size}px 0 0,
+            ${size}px 0 0 0,
+            ${size * 2}px 0 0 5px,
+            ${size * 3}px 0 0 0,
+            ${size}px ${size}px 0 5px,
+            ${size * 2}px ${size}px 0 0,
+            ${size * 3}px ${size}px 0 0;
+        }
+      }
+    `,
+  };
+});
+
+enum ImportState {
+  Start,
+  Loading,
+  Finished,
+  Close,
+}
+
+interface DataImporterProps {
+  children?: ReactNode;
+  onFinishImport?: () => void;
+}
+const DataImporter = memo<DataImporterProps>(({ children, onFinishImport }) => {
+  const { t } = useTranslation('common');
+  const { importConfig } = useImportConfig();
+  const [duration, setDuration] = useState(0);
+  const [importState, setImportState] = useState(ImportState.Start);
+  const [importData, setImportData] = useState<ImportResults | undefined>();
+  const { styles } = useStyles();
+
+  return (
+    <>
+      <DataStyleModal
+        icon={ImportIcon}
+        open={importState === ImportState.Loading || importState === ImportState.Finished}
+        title={t('importModal.title')}
+        width={importState === ImportState.Finished ? 500 : 400}
+      >
+        <Center
+          gap={24}
+          padding={40}
+          style={{
+            paddingBlock: importState === ImportState.Finished ? 0 : undefined,
+          }}
+        >
+          {importState === ImportState.Finished ? (
+            // TODO: 在这里加个撒花效果
+            <Result
+              extra={
+                <Button
+                  onClick={() => {
+                    setImportState(ImportState.Close);
+
+                    onFinishImport?.();
+                  }}
+                  size={'large'}
+                  type={'primary'}
+                >
+                  {t('importModal.finish.start')}
+                </Button>
+              }
+              icon={<Icon icon={BadgeCheck} />}
+              status={'success'}
+              style={{ paddingBlock: 24 }}
+              subTitle={
+                // if there is no importData, means it's only import the settings
+                !importData ? (
+                  t('importModal.finish.onlySettings')
+                ) : (
+                  <Flexbox gap={16} width={400}>
+                    {t('importModal.finish.subTitle', { duration: (duration / 1000).toFixed(2) })}
+                    <Table
+                      bordered
+                      columns={[
+                        { dataIndex: 'title', title: t('importModal.result.type') },
+                        { dataIndex: 'added', title: t('importModal.result.added') },
+                        { dataIndex: 'skips', title: t('importModal.result.skips') },
+                        { dataIndex: 'error', title: t('importModal.result.errors') },
+                      ]}
+                      dataSource={Object.entries(importData).map(
+                        ([item, value]: [string, ImportResult]) => ({
+                          added: value.added,
+                          error: value.errors,
+                          skips: value.skips,
+                          title: t(`importModal.result.${item as keyof ImportResults}`),
+                        }),
+                      )}
+                      pagination={false}
+                      size={'small'}
+                    />
+                  </Flexbox>
+                )
+              }
+              title={t('importModal.finish.title')}
+            />
+          ) : (
+            <>
+              <Center style={{ height: 80 }}>
+                <div className={styles.loader} />
+              </Center>
+              <p>{t('importModal.loading')}</p>
+            </>
+          )}
+        </Center>
+      </DataStyleModal>
+      <Upload
+        beforeUpload={async (file) => {
+          setImportState(ImportState.Loading);
+          const time = Date.now();
+          const data = await importConfig(file);
+
+          if (data) {
+            setImportData(data);
+          }
+
+          setDuration(Date.now() - time);
+          setImportState(ImportState.Finished);
+
+          return false;
+        }}
+        maxCount={1}
+        showUploadList={false}
+      >
+        {children}
+      </Upload>
+    </>
+  );
+});
+
+export default DataImporter;

package/src/features/DebugUI/index.tsx

@@ -0,0 +1,34 @@
+import { Icon } from '@lobehub/ui';
+import { App, FloatButton, Spin } from 'antd';
+import { DatabaseIcon, Loader2 } from 'lucide-react';
+import { memo, useState } from 'react';
+
+import { debugService } from '@/services/debug';
+
+const DebugUI = memo(() => {
+  const [loading, setLoading] = useState(false);
+  const { message } = App.useApp();
+  return (
+    <>
+      {loading && <Spin fullscreen />}
+      <FloatButton
+        icon={<Icon icon={loading ? Loader2 : DatabaseIcon} spin={loading} />}
+        onClick={async () => {
+          setLoading(true);
+
+          const startTime = Date.now();
+
+          await debugService.insertLargeDataToDB();
+
+          const duration = Date.now() - startTime;
+
+          setLoading(false);
+          message.success(`插入成功，耗时：${(duration / 1000).toFixed(1)} s`);
+        }}
+        tooltip={'性能压测，插入100w数据'}
+      />
+    </>
+  );
+});
+
+export default DebugUI;