@lobehub/chat 1.11.9 → 1.12.1

package/src/services/upload.ts

@@ -1,99 +1,104 @@
 import { fileEnv } from '@/config/file';
-import { DB_File } from '@/database/client/schemas/files';
+import { FileModel } from '@/database/client/models/file';
 import { edgeClient } from '@/libs/trpc/client';
-import { API_ENDPOINTS } from '@/services/_url';
-import { serverConfigSelectors } from '@/store/serverConfig/selectors';
-import compressImage from '@/utils/compressImage';
+import { FileMetadata, UploadFileParams } from '@/types/files';
+import { FileUploadState, FileUploadStatus } from '@/types/files/upload';
 import { uuid } from '@/utils/uuid';
 
 class UploadService {
-  async uploadFile(file: DB_File) {
-    if (this.enableServer) {
-      const { data, ...params } = file;
-      const filename = `${uuid()}.${file.name.split('.').at(-1)}`;
-
-      // 精确到以 h 为单位的 path
-      const date = (Date.now() / 1000 / 60 / 60).toFixed(0);
-      const dirname = `${fileEnv.NEXT_PUBLIC_S3_FILE_PATH}/${date}`;
-      const pathname = `${dirname}/${filename}`;
-
-      const url = await edgeClient.upload.createS3PreSignedUrl.mutate({ pathname });
-
-      const res = await fetch(url, {
-        body: data,
-        headers: { 'Content-Type': file.fileType },
-        method: 'PUT',
+  uploadWithProgress = async (
+    file: File,
+    onProgress: (status: FileUploadStatus, state: FileUploadState) => void,
+  ): Promise<FileMetadata> => {
+    const xhr = new XMLHttpRequest();
+
+    const { preSignUrl, ...result } = await this.getSignedUploadUrl(file);
+
+    let startTime = Date.now();
+    xhr.upload.addEventListener('progress', (event) => {
+      if (event.lengthComputable) {
+        const progress = Number(((event.loaded / event.total) * 100).toFixed(1));
+
+        const speedInByte = event.loaded / ((Date.now() - startTime) / 1000);
+
+        onProgress?.('uploading', {
+          // if the progress is 100, it means the file is uploaded
+          // but the server is still processing it
+          // so make it as 99.9 and let users think it's still uploading
+          progress: progress === 100 ? 99.9 : progress,
+          restTime: (event.total - event.loaded) / speedInByte,
+          speed: speedInByte / 1024,
+        });
+      }
+    });
+
+    xhr.open('PUT', preSignUrl);
+    xhr.setRequestHeader('Content-Type', file.type);
+    const data = await file.arrayBuffer();
+
+    await new Promise((resolve, reject) => {
+      xhr.addEventListener('load', () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          onProgress('success', {
+            progress: 100,
+            restTime: 0,
+            speed: file.size / ((Date.now() - startTime) / 1000),
+          });
+          resolve(xhr.response);
+        } else {
+          reject(xhr.statusText);
+        }
       });
+      xhr.addEventListener('error', () => reject(xhr.statusText));
+      xhr.send(data);
+    });
 
-      if (res.ok) {
-        return {
-          ...params,
-          metadata: { date, dirname: dirname, filename: filename, path: pathname },
-          name: file.name,
-          saveMode: 'url',
-          url: pathname,
-        } as DB_File;
-      } else {
-        throw new Error('Upload Error');
-      }
-    }
+    return result;
+  };
 
-    // 跳过图片上传测试
-    const isTestData = file.size === 1;
-    if (this.isImage(file.fileType) && !isTestData) {
-      return this.uploadImageFile(file);
-    }
+  uploadToClientDB = async (params: UploadFileParams, file: File) => {
+    const fileArrayBuffer = await file.arrayBuffer();
 
     // save to local storage
     // we may want to save to a remote server later
-    return file;
-  }
-
-  async uploadImageByUrl(url: string, file: Pick<DB_File, 'name' | 'metadata'>) {
-    const res = await fetch(API_ENDPOINTS.proxy, { body: url, method: 'POST' });
-    const data = await res.arrayBuffer();
-    const fileType = res.headers.get('content-type') || 'image/webp';
-
-    return this.uploadFile({
-      data,
-      fileType,
-      metadata: file.metadata,
-      name: file.name,
-      saveMode: 'local',
-      size: data.byteLength,
+    const res = await FileModel.create({
+      createdAt: Date.now(),
+      ...params,
+      data: fileArrayBuffer,
     });
-  }
-
-  private isImage(fileType: string) {
-    const imageRegex = /^image\//;
-    return imageRegex.test(fileType);
-  }
-
-  private async uploadImageFile(file: DB_File) {
-    // 加载图片
-    const url = file.url || URL.createObjectURL(new Blob([file.data!]));
-
-    const img = new Image();
-    img.src = url;
-    await (() =>
-      new Promise((resolve) => {
-        img.addEventListener('load', resolve);
-      }))();
-
-    // 压缩图片
-    const base64String = compressImage({ img, type: file.fileType });
-    const binaryString = atob(base64String.split('base64,')[1]);
-    const uint8Array = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
-    file.data = uint8Array.buffer;
-
-    return file;
-  }
-
-  private get enableServer() {
-    return serverConfigSelectors.enableUploadFileToServer(
-      window.global_serverConfigStore.getState(),
-    );
-  }
+    // arrayBuffer to url
+    const base64 = Buffer.from(fileArrayBuffer).toString('base64');
+
+    return {
+      id: res.id,
+      url: `data:${params.fileType};base64,${base64}`,
+    };
+  };
+
+  private getSignedUploadUrl = async (
+    file: File,
+  ): Promise<
+    FileMetadata & {
+      preSignUrl: string;
+    }
+  > => {
+    const filename = `${uuid()}.${file.name.split('.').at(-1)}`;
+
+    // 精确到以 h 为单位的 path
+    const date = (Date.now() / 1000 / 60 / 60).toFixed(0);
+    const dirname = `${fileEnv.NEXT_PUBLIC_S3_FILE_PATH}/${date}`;
+    const pathname = `${dirname}/${filename}`;
+
+    const preSignUrl = await edgeClient.upload.createS3PreSignedUrl.mutate({ pathname });
+
+    return {
+      date,
+      dirname,
+      filename,
+      path: pathname,
+      preSignUrl,
+    };
+  };
 }
 
 export const uploadService = new UploadService();

package/src/services/upload_legacy.ts

@@ -0,0 +1,104 @@
+import { fileEnv } from '@/config/file';
+import { DB_File } from '@/database/client/schemas/files';
+import { edgeClient } from '@/libs/trpc/client';
+import { API_ENDPOINTS } from '@/services/_url';
+import { serverConfigSelectors } from '@/store/serverConfig/selectors';
+import compressImage from '@/utils/compressImage';
+import { uuid } from '@/utils/uuid';
+
+class UploadService {
+  async uploadFile(file: DB_File) {
+    if (this.enableServer) {
+      const { data, ...params } = file;
+      const filename = `${uuid()}.${file.name.split('.').at(-1)}`;
+
+      // 精确到以 h 为单位的 path
+      const date = (Date.now() / 1000 / 60 / 60).toFixed(0);
+      const dirname = `${fileEnv.NEXT_PUBLIC_S3_FILE_PATH}/${date}`;
+      const pathname = `${dirname}/${filename}`;
+
+      const url = await edgeClient.upload.createS3PreSignedUrl.mutate({ pathname });
+
+      const res = await fetch(url, {
+        body: data,
+        headers: { 'Content-Type': file.fileType },
+        method: 'PUT',
+      });
+
+      if (res.ok) {
+        return {
+          ...params,
+          metadata: { date, dirname: dirname, filename: filename, path: pathname },
+          name: file.name,
+          saveMode: 'url',
+          url: pathname,
+        } as DB_File;
+      } else {
+        throw new Error('Upload Error');
+      }
+    }
+
+    // 跳过图片上传测试
+    const isTestData = file.size === 1;
+    if (this.isImage(file.fileType) && !isTestData) {
+      return this.uploadImageFile(file);
+    }
+
+    // save to local storage
+    // we may want to save to a remote server later
+    return file;
+  }
+
+  /**
+   * @deprecated
+   * @param url
+   * @param file
+   */
+  async uploadImageByUrl(url: string, file: Pick<DB_File, 'name' | 'metadata'>) {
+    const res = await fetch(API_ENDPOINTS.proxy, { body: url, method: 'POST' });
+    const data = await res.arrayBuffer();
+    const fileType = res.headers.get('content-type') || 'image/webp';
+
+    return this.uploadFile({
+      data,
+      fileType,
+      metadata: file.metadata,
+      name: file.name,
+      saveMode: 'local',
+      size: data.byteLength,
+    });
+  }
+
+  private isImage(fileType: string) {
+    const imageRegex = /^image\//;
+    return imageRegex.test(fileType);
+  }
+
+  private async uploadImageFile(file: DB_File) {
+    // 加载图片
+    const url = file.url || URL.createObjectURL(new Blob([file.data!]));
+
+    const img = new Image();
+    img.src = url;
+    await (() =>
+      new Promise((resolve) => {
+        img.addEventListener('load', resolve);
+      }))();
+
+    // 压缩图片
+    const base64String = compressImage({ img, type: file.fileType });
+    const binaryString = atob(base64String.split('base64,')[1]);
+    const uint8Array = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
+    file.data = uint8Array.buffer;
+
+    return file;
+  }
+
+  private get enableServer() {
+    return serverConfigSelectors.enableUploadFileToServer(
+      window.global_serverConfigStore.getState(),
+    );
+  }
+}
+
+export const legacyUploadService = new UploadService();

package/src/services/user/client.ts

@@ -3,7 +3,7 @@ import { DeepPartial } from 'utility-types';
 import { MessageModel } from '@/database/client/models/message';
 import { SessionModel } from '@/database/client/models/session';
 import { UserModel } from '@/database/client/models/user';
-import { UserInitializationState, UserPreference } from '@/types/user';
+import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
 import { UserSettings } from '@/types/user/settings';
 import { AsyncLocalStorage } from '@/utils/localStorage';
 
@@ -46,7 +46,12 @@ export class ClientService implements IUserService {
     return UserModel.updateAvatar(avatar);
   }
 
-  async updatePreference(preference: UserPreference) {
+  async updatePreference(preference: Partial<UserPreference>) {
     await this.preferenceStorage.saveToLocalStorage(preference);
   }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async updateGuide(guide: Partial<UserGuide>) {
+    throw new Error('Method not implemented.');
+  }
 }

package/src/services/user/server.ts

@@ -2,7 +2,7 @@ import { DeepPartial } from 'utility-types';
 
 import { lambdaClient } from '@/libs/trpc/client';
 import { IUserService } from '@/services/user/type';
-import { UserInitializationState, UserPreference } from '@/types/user';
+import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
 import { UserSettings } from '@/types/user/settings';
 
 export class ServerService implements IUserService {
@@ -14,10 +14,14 @@ export class ServerService implements IUserService {
     return lambdaClient.user.makeUserOnboarded.mutate();
   }
 
-  async updatePreference(preference: UserPreference) {
+  async updatePreference(preference: Partial<UserPreference>) {
     return lambdaClient.user.updatePreference.mutate(preference);
   }
 
+  async updateGuide(guide: Partial<UserGuide>) {
+    return lambdaClient.user.updateGuide.mutate(guide);
+  }
+
   updateUserSettings = async (value: DeepPartial<UserSettings>, signal?: AbortSignal) => {
     return lambdaClient.user.updateSettings.mutate(value, { signal });
   };

package/src/services/user/type.ts

@@ -1,11 +1,12 @@
 import { DeepPartial } from 'utility-types';
 
-import { UserInitializationState, UserPreference } from '@/types/user';
+import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
 import { UserSettings } from '@/types/user/settings';
 
 export interface IUserService {
   getUserState: () => Promise<UserInitializationState>;
   resetUserSettings: () => Promise<any>;
-  updatePreference: (preference: UserPreference) => Promise<any>;
+  updateGuide: (guide: Partial<UserGuide>) => Promise<any>;
+  updatePreference: (preference: Partial<UserPreference>) => Promise<any>;
   updateUserSettings: (patch: DeepPartial<UserSettings>) => Promise<any>;
 }

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

@@ -8,10 +8,12 @@ import { MESSAGE_CANCEL_FLAT } from '@/const/message';
 import { INBOX_SESSION_ID } from '@/const/session';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { useClientDataSWR, useOnlyFetchOnceSWR } from '@/libs/swr';
+import { agentService } from '@/services/agent';
 import { sessionService } from '@/services/session';
 import { AgentState } from '@/store/agent/slices/chat/initialState';
 import { useSessionStore } from '@/store/session';
 import { LobeAgentChatConfig, LobeAgentConfig } from '@/types/agent';
+import { KnowledgeItem } from '@/types/knowledgeBase';
 import { merge } from '@/utils/merge';
 
 import { AgentStore } from '../../store';
@@ -21,35 +23,42 @@ import { agentSelectors } from './selectors';
  * 助手接口
  */
 export interface AgentChatAction {
+  addFilesToAgent: (fileIds: string[], boolean?: boolean) => Promise<void>;
+  addKnowledgeBaseToAgent: (knowledgeBaseId: string) => Promise<void>;
+  internal_createAbortController: (key: keyof AgentState) => AbortController;
+
+  internal_dispatchAgentMap: (
+    id: string,
+    config: DeepPartial<LobeAgentConfig>,
+    actions?: string,
+  ) => void;
+  internal_refreshAgentConfig: (id: string) => Promise<void>;
+  internal_refreshAgentKnowledge: () => Promise<void>;
+  internal_updateAgentConfig: (
+    id: string,
+    data: DeepPartial<LobeAgentConfig>,
+    signal?: AbortSignal,
+  ) => Promise<void>;
+  removeFileFromAgent: (fileId: string) => Promise<void>;
+  removeKnowledgeBaseFromAgent: (knowledgeBaseId: string) => Promise<void>;
+
   removePlugin: (id: string) => void;
+  toggleFile: (id: string, open?: boolean) => Promise<void>;
+  toggleKnowledgeBase: (id: string, open?: boolean) => Promise<void>;
+
   togglePlugin: (id: string, open?: boolean) => Promise<void>;
   updateAgentChatConfig: (config: Partial<LobeAgentChatConfig>) => Promise<void>;
   updateAgentConfig: (config: DeepPartial<LobeAgentConfig>) => Promise<void>;
-
   useFetchAgentConfig: (id: string) => SWRResponse<LobeAgentConfig>;
+  useFetchFilesAndKnowledgeBases: () => SWRResponse<KnowledgeItem[]>;
   useInitAgentStore: (
     isLogin: boolean | undefined,
     defaultAgentConfig?: DeepPartial<LobeAgentConfig>,
   ) => SWRResponse<DeepPartial<LobeAgentConfig>>;
-
-  /* eslint-disable typescript-sort-keys/interface */
-
-  internal_updateAgentConfig: (
-    id: string,
-    data: DeepPartial<LobeAgentConfig>,
-    signal?: AbortSignal,
-  ) => Promise<void>;
-  internal_refreshAgentConfig: (id: string) => Promise<void>;
-  internal_dispatchAgentMap: (
-    id: string,
-    config: DeepPartial<LobeAgentConfig>,
-    actions?: string,
-  ) => void;
-  internal_createAbortController: (key: keyof AgentState) => AbortController;
-  /* eslint-enable */
 }
 
 const FETCH_AGENT_CONFIG_KEY = 'FETCH_AGENT_CONFIG';
+const FETCH_AGENT_KNOWLEDGE_KEY = 'FETCH_AGENT_KNOWLEDGE';
 
 export const createChatSlice: StateCreator<
   AgentStore,
@@ -57,10 +66,59 @@ export const createChatSlice: StateCreator<
   [],
   AgentChatAction
 > = (set, get) => ({
+  addFilesToAgent: async (fileIds, enabled) => {
+    const { activeAgentId, internal_refreshAgentConfig, internal_refreshAgentKnowledge } = get();
+    if (!activeAgentId) return;
+    if (fileIds.length === 0) return;
+
+    await agentService.createAgentFiles(activeAgentId, fileIds, enabled);
+    await internal_refreshAgentConfig(get().activeId);
+    await internal_refreshAgentKnowledge();
+  },
+  addKnowledgeBaseToAgent: async (knowledgeBaseId) => {
+    const { activeAgentId, internal_refreshAgentConfig, internal_refreshAgentKnowledge } = get();
+    if (!activeAgentId) return;
+
+    await agentService.createAgentKnowledgeBase(activeAgentId, knowledgeBaseId, true);
+    await internal_refreshAgentConfig(get().activeId);
+    await internal_refreshAgentKnowledge();
+  },
+  removeFileFromAgent: async (fileId) => {
+    const { activeAgentId, internal_refreshAgentConfig, internal_refreshAgentKnowledge } = get();
+    if (!activeAgentId) return;
+
+    await agentService.deleteAgentFile(activeAgentId, fileId);
+    await internal_refreshAgentConfig(get().activeId);
+    await internal_refreshAgentKnowledge();
+  },
+  removeKnowledgeBaseFromAgent: async (knowledgeBaseId) => {
+    const { activeAgentId, internal_refreshAgentConfig, internal_refreshAgentKnowledge } = get();
+    if (!activeAgentId) return;
+
+    await agentService.deleteAgentKnowledgeBase(activeAgentId, knowledgeBaseId);
+    await internal_refreshAgentConfig(get().activeId);
+    await internal_refreshAgentKnowledge();
+  },
+
   removePlugin: async (id) => {
     await get().togglePlugin(id, false);
   },
+  toggleFile: async (id, open) => {
+    const { activeAgentId, internal_refreshAgentConfig } = get();
+    if (!activeAgentId) return;
 
+    await agentService.toggleFile(activeAgentId, id, open);
+
+    await internal_refreshAgentConfig(get().activeId);
+  },
+  toggleKnowledgeBase: async (id, open) => {
+    const { activeAgentId, internal_refreshAgentConfig } = get();
+    if (!activeAgentId) return;
+
+    await agentService.toggleKnowledgeBase(activeAgentId, id, open);
+
+    await internal_refreshAgentConfig(get().activeId);
+  },
   togglePlugin: async (id, open) => {
     const originConfig = agentSelectors.currentAgentConfig(get());
 
@@ -109,10 +167,22 @@ export const createChatSlice: StateCreator<
         fallbackData: DEFAULT_AGENT_CONFIG,
         onSuccess: (data) => {
           get().internal_dispatchAgentMap(sessionId, data, 'fetch');
+          set({ activeAgentId: data.id }, false, 'updateActiveAgentId');
         },
         suspense: true,
       },
     ),
+  useFetchFilesAndKnowledgeBases: () => {
+    return useClientDataSWR<KnowledgeItem[]>(
+      [FETCH_AGENT_KNOWLEDGE_KEY, get().activeAgentId],
+      ([, id]: string[]) => agentService.getFilesAndKnowledgeBases(id),
+      {
+        fallbackData: [],
+        suspense: true,
+      },
+    );
+  },
+
   useInitAgentStore: (isLogin, defaultAgentConfig) =>
     useOnlyFetchOnceSWR<DeepPartial<LobeAgentConfig>>(
       !!isLogin ? 'fetchInboxAgentConfig' : null,
@@ -134,7 +204,6 @@ export const createChatSlice: StateCreator<
         },
       },
     ),
-
   /* eslint-disable sort-keys-fix/sort-keys-fix */
 
   internal_dispatchAgentMap: (id, config, actions) => {
@@ -167,6 +236,9 @@ export const createChatSlice: StateCreator<
     await mutate([FETCH_AGENT_CONFIG_KEY, id]);
   },
 
+  internal_refreshAgentKnowledge: async () => {
+    await mutate([FETCH_AGENT_KNOWLEDGE_KEY, get().activeAgentId]);
+  },
   internal_createAbortController: (key) => {
     const abortController = get()[key] as AbortController;
     if (abortController) abortController.abort(MESSAGE_CANCEL_FLAT);

package/src/store/agent/slices/chat/initialState.ts

@@ -5,6 +5,7 @@ import { AgentSettingsInstance } from '@/features/AgentSetting';
 import { LobeAgentConfig } from '@/types/agent';
 
 export interface AgentState {
+  activeAgentId?: string;
   activeId: string;
   agentMap: Record<string, DeepPartial<LobeAgentConfig>>;
   agentSettingInstance?: AgentSettingsInstance | null;

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

@@ -9,6 +9,7 @@ import {
 } from '@/const/settings';
 import { AgentStore } from '@/store/agent';
 import { LobeAgentChatConfig, LobeAgentConfig, LobeAgentTTSConfig } from '@/types/agent';
+import { KnowledgeItem, KnowledgeType } from '@/types/knowledgeBase';
 import { merge } from '@/utils/merge';
 
 const isInboxSession = (s: AgentStore) => s.activeId === INBOX_SESSION_ID;
@@ -47,6 +48,18 @@ const currentAgentPlugins = (s: AgentStore) => {
   return config?.plugins || [];
 };
 
+const currentAgentKnowledgeBases = (s: AgentStore) => {
+  const config = currentAgentConfig(s);
+
+  return config?.knowledgeBases || [];
+};
+
+const currentAgentFiles = (s: AgentStore) => {
+  const config = currentAgentConfig(s);
+
+  return config?.files || [];
+};
+
 const currentAgentTTS = (s: AgentStore): LobeAgentTTSConfig => {
   const config = currentAgentConfig(s);
 
@@ -76,21 +89,66 @@ const currentAgentTTSVoice =
     return currentVoice || 'alloy';
   };
 
+const currentEnabledKnowledge = (s: AgentStore) => {
+  const knowledgeBases = currentAgentKnowledgeBases(s);
+  const files = currentAgentFiles(s);
+
+  return [
+    ...files
+      .filter((f) => f.enabled)
+      .map((f) => ({ fileType: f.type, id: f.id, name: f.name, type: KnowledgeType.File })),
+    ...knowledgeBases
+      .filter((k) => k.enabled)
+      .map((k) => ({ id: k.id, name: k.name, type: KnowledgeType.KnowledgeBase })),
+  ] as KnowledgeItem[];
+};
+
 const hasSystemRole = (s: AgentStore) => {
   const config = currentAgentConfig(s);
 
   return !!config.systemRole;
 };
 
+const hasKnowledgeBases = (s: AgentStore) => {
+  const knowledgeBases = currentAgentKnowledgeBases(s);
+
+  return knowledgeBases.length > 0;
+};
+
+const hasFiles = (s: AgentStore) => {
+  const files = currentAgentFiles(s);
+
+  return files.length > 0;
+};
+
+const hasKnowledge = (s: AgentStore) => hasKnowledgeBases(s) || hasFiles(s);
+const hasEnabledKnowledge = (s: AgentStore) => currentEnabledKnowledge(s).length > 0;
+const currentKnowledgeIds = (s: AgentStore) => {
+  return {
+    fileIds: currentAgentFiles(s)
+      .filter((item) => item.enabled)
+      .map((f) => f.id),
+    knowledgeBaseIds: currentAgentKnowledgeBases(s)
+      .filter((item) => item.enabled)
+      .map((k) => k.id),
+  };
+};
+
 export const agentSelectors = {
   currentAgentChatConfig,
   currentAgentConfig,
+  currentAgentFiles,
+  currentAgentKnowledgeBases,
   currentAgentModel,
   currentAgentModelProvider,
   currentAgentPlugins,
   currentAgentSystemRole,
   currentAgentTTS,
   currentAgentTTSVoice,
+  currentEnabledKnowledge,
+  currentKnowledgeIds,
+  hasEnabledKnowledge,
+  hasKnowledge,
   hasSystemRole,
   inboxAgentConfig,
   inboxAgentModel,

package/src/store/chat/slices/builtinTool/action.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, it, vi } from 'vitest';
 
 import { fileService } from '@/services/file';
 import { imageGenerationService } from '@/services/textToImage';
-import { uploadService } from '@/services/upload';
+import { legacyUploadService as uploadService } from '@/services/upload_legacy';
 import { chatSelectors } from '@/store/chat/selectors';
 import { ChatMessage } from '@/types/message';
 import { DallEImageItem } from '@/types/tool/dalle';
@@ -37,7 +37,7 @@ describe('chatToolSlice', () => {
 
       vi.spyOn(imageGenerationService, 'generateImage').mockResolvedValue(mockUrl);
       vi.spyOn(uploadService, 'uploadImageByUrl').mockResolvedValue({} as any);
-      vi.spyOn(fileService, 'createFile').mockResolvedValue({ id: mockId });
+      vi.spyOn(fileService, 'createFile').mockResolvedValue({ id: mockId, url: '' });
       vi.spyOn(result.current, 'toggleDallEImageLoading');
 
       await act(async () => {

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

@@ -4,7 +4,7 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { fileService } from '@/services/file';
 import { imageGenerationService } from '@/services/textToImage';
-import { uploadService } from '@/services/upload';
+import { legacyUploadService } from '@/services/upload_legacy';
 import { chatSelectors } from '@/store/chat/selectors';
 import { ChatStore } from '@/store/chat/store';
 import { DallEImageItem } from '@/types/tool/dalle';
@@ -61,7 +61,7 @@ export const chatToolSlice: StateCreator<
 
       toggleDallEImageLoading(messageId + params.prompt, false);
 
-      uploadService
+      legacyUploadService
         .uploadImageByUrl(url, {
           metadata: { ...params, originPrompt: originPrompt },
           name: `${originPrompt || params.prompt}_${index}.png`,