@lobehub/chat 1.77.15 → 1.77.17

package/src/libs/agent-runtime/openrouter/index.test.ts

@@ -4,6 +4,7 @@ import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
 import { testProvider } from '@/libs/agent-runtime/providerTestUtils';
 
+import frontendModels from './fixtures/frontendModels.json';
 import models from './fixtures/models.json';
 import { LobeOpenRouterAI } from './index';
 
@@ -137,12 +138,66 @@ describe('LobeOpenRouterAI', () => {
   });
 
   describe('models', () => {
-    it('should get models', async () => {
+    it('should get models with frontend models data', async () => {
       // mock the models.list method
       (instance['client'].models.list as Mock).mockResolvedValue({ data: models });
 
+      // 模拟成功的 fetch 响应
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: vi.fn().mockResolvedValue(frontendModels),
+        }),
+      );
+
+      const list = await instance.models();
+
+      // 验证 fetch 被正确调用
+      expect(fetch).toHaveBeenCalledWith('https://openrouter.ai/api/frontend/models');
+
+      // 验证模型列表中包含了从前端 API 获取的额外信息
+      const reflectionModel = list.find((model) => model.id === 'mattshumer/reflection-70b:free');
+      expect(reflectionModel).toBeDefined();
+      expect(reflectionModel?.reasoning).toBe(true);
+      expect(reflectionModel?.functionCall).toBe(true);
+
+      expect(list).toMatchSnapshot();
+    });
+
+    it('should handle fetch failure gracefully', async () => {
+      // mock the models.list method
+      (instance['client'].models.list as Mock).mockResolvedValue({ data: models });
+
+      // 模拟失败的 fetch 响应
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: false,
+        }),
+      );
+
+      const list = await instance.models();
+
+      // 验证即使 fetch 失败，方法仍然能返回有效的模型列表
+      expect(fetch).toHaveBeenCalledWith('https://openrouter.ai/api/frontend/models');
+      expect(list.length).toBeGreaterThan(0); // 确保返回了模型列表
+      expect(list).toMatchSnapshot();
+    });
+
+    it('should handle fetch error gracefully', async () => {
+      // mock the models.list method
+      (instance['client'].models.list as Mock).mockResolvedValue({ data: models });
+
+      // 在测试环境中，需要先修改 fetch 的实现，确保错误被捕获
+      vi.spyOn(global, 'fetch').mockImplementation(() => {
+        throw new Error('Network error');
+      });
+
       const list = await instance.models();
 
+      // 验证即使 fetch 出错，方法仍然能返回有效的模型列表
+      expect(list.length).toBeGreaterThan(0); // 确保返回了模型列表
       expect(list).toMatchSnapshot();
     });
   });

package/src/libs/agent-runtime/openrouter/index.ts

@@ -54,11 +54,16 @@ export const LobeOpenRouterAI = LobeOpenAICompatibleFactory({
     const modelsPage = (await client.models.list()) as any;
     const modelList: OpenRouterModelCard[] = modelsPage.data;
 
-    const response = await fetch('https://openrouter.ai/api/frontend/models');
     const modelsExtraInfo: OpenRouterModelExtraInfo[] = [];
-    if (response.ok) {
-      const data = await response.json();
-      modelsExtraInfo.push(...data['data']);
+    try {
+      const response = await fetch('https://openrouter.ai/api/frontend/models');
+      if (response.ok) {
+        const data = await response.json();
+        modelsExtraInfo.push(...data['data']);
+      }
+    } catch (error) {
+      // 忽略 fetch 错误，使用空的 modelsExtraInfo 数组继续处理
+      console.error('Failed to fetch OpenRouter frontend models:', error);
     }
 
     return modelList

package/src/libs/agent-runtime/types/index.ts

@@ -1,5 +1,6 @@
 export * from './chat';
 export * from './embeddings';
+export * from './model';
 export * from './textToImage';
 export * from './tts';
 export * from './type';

package/src/libs/agent-runtime/types/model.ts

@@ -0,0 +1,44 @@
+export interface ModelDetail {
+  details?: {
+    families?: string[];
+    family?: string;
+    format?: string;
+    parameter_size?: string;
+    quantization_level?: string;
+  };
+  digest?: string;
+  id: string;
+  modified_at?: Date;
+  name?: string;
+  size?: number;
+}
+
+export interface ModelProgressResponse {
+  completed?: number;
+  digest?: string;
+  model?: string;
+  status: string;
+  total?: number;
+}
+
+export interface ModelsParams {
+  name?: string;
+}
+
+export interface PullModelParams {
+  insecure?: boolean;
+  model: string;
+  stream?: boolean;
+}
+
+export interface ModelDetailParams {
+  model: string;
+}
+
+export interface DeleteModelParams {
+  model: string;
+}
+
+export interface ModelRequestOptions {
+  signal?: AbortSignal;
+}

package/src/libs/agent-runtime/utils/streams/index.ts

@@ -1,6 +1,7 @@
 export * from './anthropic';
 export * from './bedrock';
 export * from './google-ai';
+export * from './model';
 export * from './ollama';
 export * from './openai';
 export * from './protocol';

package/src/libs/agent-runtime/utils/streams/model.ts

@@ -0,0 +1,110 @@
+/**
+ * 将异步迭代器转换为 JSON 格式的 ReadableStream
+ */
+export const createModelPullStream = <
+  T extends { completed?: number; digest?: string; status: string; total?: number },
+>(
+  iterable: AsyncIterable<T>,
+  model: string,
+  {
+    onCancel, // 新增：取消时调用的回调函数
+  }: {
+    onCancel?: (reason?: any) => void; // 回调函数签名
+  } = {},
+): ReadableStream => {
+  let iterator: AsyncIterator<T>; // 在外部跟踪迭代器以便取消时可以调用 return
+
+  return new ReadableStream({
+    // 实现 cancel 方法
+    cancel(reason) {
+      // 调用传入的 onCancel 回调，执行外部的清理逻辑（如 client.abort()）
+      if (onCancel) {
+        onCancel(reason);
+      }
+
+      // 尝试优雅地终止迭代器
+      // 注意：这依赖于 AsyncIterable 的实现是否支持 return/throw
+      if (iterator && typeof iterator.return === 'function') {
+        // 不需要 await，让它在后台执行清理
+        iterator.return().catch();
+      }
+    },
+    async start(controller) {
+      iterator = iterable[Symbol.asyncIterator](); // 获取迭代器
+
+      const encoder = new TextEncoder();
+
+      try {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+          // 等待下一个数据块或迭代完成
+          const { value: progress, done } = await iterator.next();
+
+          // 如果迭代完成，跳出循环
+          if (done) {
+            break;
+          }
+
+          // 忽略 'pulling manifest' 状态，因为它不包含进度
+          if (progress.status === 'pulling manifest') continue;
+
+          // 格式化为标准格式并写入流
+          const progressData =
+            JSON.stringify({
+              completed: progress.completed,
+              digest: progress.digest,
+              model,
+              status: progress.status,
+              total: progress.total,
+            }) + '\n';
+
+          controller.enqueue(encoder.encode(progressData));
+        }
+
+        // 正常完成
+        controller.close();
+      } catch (error) {
+        // 处理错误
+
+        // 如果错误是由于中止操作引起的，则静默处理或记录日志，然后尝试关闭流
+        if (error instanceof DOMException && error.name === 'AbortError') {
+          // 不需要再 enqueue 错误信息，因为连接可能已断开
+          // 尝试正常关闭，如果已经取消，controller 可能已关闭或出错
+          try {
+            controller.enqueue(new TextEncoder().encode(JSON.stringify({ status: 'cancelled' })));
+            controller.close();
+          } catch {
+            // 忽略关闭错误，可能流已经被取消机制处理了
+          }
+        } else {
+          console.error('[createModelPullStream] model download stream error:', error);
+          // 对于其他错误，尝试将错误信息发送给客户端
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          const errorData =
+            JSON.stringify({
+              error: errorMessage,
+              model,
+              status: 'error',
+            }) + '\n';
+
+          try {
+            // 只有在流还期望数据时才尝试 enqueue
+            if (controller.desiredSize !== null && controller.desiredSize > 0) {
+              controller.enqueue(encoder.encode(errorData));
+            }
+          } catch (enqueueError) {
+            console.error('[createModelPullStream] Error enqueueing error message:', enqueueError);
+            // 如果这里也失败，很可能连接已断开
+          }
+
+          // 尝试关闭流或标记为错误状态
+          try {
+            controller.close(); // 尝试正常关闭
+          } catch {
+            controller.error(error); // 如果关闭失败，则将流置于错误状态
+          }
+        }
+      }
+    },
+  });
+};

package/src/locales/default/components.ts

@@ -93,6 +93,10 @@ export default {
     provider: '服务商',
   },
   OllamaSetupGuide: {
+    action: {
+      close: '关闭提示',
+      start: '已安装并运行，开始对话',
+    },
     cors: {
       description: '因浏览器安全限制，你需要为 Ollama 进行跨域配置后方可正常使用。',
       linux: {

package/src/locales/default/modelProvider.ts

@@ -166,6 +166,7 @@ export default {
     },
     download: {
       desc: 'Ollama 正在下载该模型，请尽量不要关闭本页面。重新下载时将会中断处继续',
+      failed: '模型下载失败，请检查网络或者 Ollama 设置后重试',
       remainingTime: '剩余时间',
       speed: '下载速度',
       title: '正在下载模型 {{model}} ',

package/src/server/routers/async/file.ts

@@ -14,8 +14,8 @@ import { NewChunkItem, NewEmbeddingsItem } from '@/database/schemas';
 import { asyncAuthedProcedure, asyncRouter as router } from '@/libs/trpc/async';
 import { getServerDefaultFilesConfig } from '@/server/globalConfig';
 import { initAgentRuntimeWithUserPayload } from '@/server/modules/AgentRuntime';
-import { S3 } from '@/server/modules/S3';
 import { ChunkService } from '@/server/services/chunk';
+import { FileService } from '@/server/services/file';
 import {
   AsyncTaskError,
   AsyncTaskErrorType,
@@ -35,6 +35,7 @@ const fileProcedure = asyncAuthedProcedure.use(async (opts) => {
       chunkService: new ChunkService(ctx.userId),
       embeddingModel: new EmbeddingModel(ctx.serverDB, ctx.userId),
       fileModel: new FileModel(ctx.serverDB, ctx.userId),
+      fileService: new FileService(),
     },
   });
 });
@@ -162,11 +163,9 @@ export const fileRouter = router({
         throw new TRPCError({ code: 'BAD_REQUEST', message: 'File not found' });
       }
 
-      const s3 = new S3();
-
       let content: Uint8Array | undefined;
       try {
-        content = await s3.getFileByteArray(file.url);
+        content = await ctx.fileService.getFileByteArray(file.url);
       } catch (e) {
         console.error(e);
         // if file not found, delete it from db

package/src/server/routers/lambda/file.ts

@@ -7,8 +7,7 @@ import { ChunkModel } from '@/database/models/chunk';
 import { FileModel } from '@/database/models/file';
 import { authedProcedure, router } from '@/libs/trpc';
 import { serverDatabase } from '@/libs/trpc/lambda';
-import { S3 } from '@/server/modules/S3';
-import { getFullFileUrl } from '@/server/utils/files';
+import { FileService } from '@/server/services/file';
 import { AsyncTaskStatus, AsyncTaskType } from '@/types/asyncTask';
 import { FileListItem, QueryFileListSchema, UploadFileSchema } from '@/types/files';
 
@@ -20,6 +19,7 @@ const fileProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
       asyncTaskModel: new AsyncTaskModel(ctx.serverDB, ctx.userId),
       chunkModel: new ChunkModel(ctx.serverDB, ctx.userId),
       fileModel: new FileModel(ctx.serverDB, ctx.userId),
+      fileService: new FileService(),
     },
   });
 });
@@ -50,7 +50,7 @@ export const fileRouter = router({
         !isExist,
       );
 
-      return { id, url: await getFullFileUrl(input.url) };
+      return { id, url: await ctx.fileService.getFullFileUrl(input.url) };
     }),
   findById: fileProcedure
     .input(
@@ -62,7 +62,7 @@ export const fileRouter = router({
       const item = await ctx.fileModel.findById(input.id);
       if (!item) throw new TRPCError({ code: 'BAD_REQUEST', message: 'File not found' });
 
-      return { ...item, url: await getFullFileUrl(item?.url) };
+      return { ...item, url: await ctx.fileService.getFullFileUrl(item?.url) };
     }),
 
   getFileItemById: fileProcedure
@@ -95,7 +95,7 @@ export const fileRouter = router({
         embeddingError: embeddingTask?.error,
         embeddingStatus: embeddingTask?.status as AsyncTaskStatus,
         finishEmbedding: embeddingTask?.status === AsyncTaskStatus.Success,
-        url: await getFullFileUrl(item.url!),
+        url: await ctx.fileService.getFullFileUrl(item.url!),
       };
     }),
 
@@ -132,7 +132,7 @@ export const fileRouter = router({
         embeddingError: embeddingTask?.error ?? null,
         embeddingStatus: embeddingTask?.status as AsyncTaskStatus,
         finishEmbedding: embeddingTask?.status === AsyncTaskStatus.Success,
-        url: await getFullFileUrl(item.url!),
+        url: await ctx.fileService.getFullFileUrl(item.url!),
       } as FileListItem;
       resultFiles.push(fileItem);
     }
@@ -150,8 +150,7 @@ export const fileRouter = router({
     if (!file) return;
 
     // delele the file from remove from S3 if it is not used by other files
-    const s3Client = new S3();
-    await s3Client.deleteFile(file.url!);
+    await ctx.fileService.deleteFile(file.url!);
   }),
 
   removeFileAsyncTask: fileProcedure
@@ -184,9 +183,7 @@ export const fileRouter = router({
       if (!needToRemoveFileList || needToRemoveFileList.length === 0) return;
 
       // remove from S3
-      const s3Client = new S3();
-
-      await s3Client.deleteFiles(needToRemoveFileList.map((file) => file.url!));
+      await ctx.fileService.deleteFiles(needToRemoveFileList.map((file) => file.url!));
     }),
 });
 

package/src/server/routers/lambda/importer.ts

@@ -4,7 +4,7 @@ import { z } from 'zod';
 import { DataImporterRepos } from '@/database/repositories/dataImporter';
 import { authedProcedure, router } from '@/libs/trpc';
 import { serverDatabase } from '@/libs/trpc/lambda';
-import { S3 } from '@/server/modules/S3';
+import { FileService } from '@/server/services/file';
 import { ImportPgDataStructure } from '@/types/export';
 import { ImportResultData, ImporterEntryData } from '@/types/importer';
 
@@ -13,7 +13,7 @@ const importProcedure = authedProcedure.use(serverDatabase).use(async (opts) =>
   const dataImporterService = new DataImporterRepos(ctx.serverDB, ctx.userId);
 
   return opts.next({
-    ctx: { dataImporterService },
+    ctx: { dataImporterService, fileService: new FileService() },
   });
 });
 
@@ -24,8 +24,7 @@ export const importerRouter = router({
       let data: ImporterEntryData | undefined;
 
       try {
-        const s3 = new S3();
-        const dataStr = await s3.getFileContent(input.pathname);
+        const dataStr = await ctx.fileService.getFileContent(input.pathname);
         data = JSON.parse(dataStr);
       } catch {
         data = undefined;

package/src/server/routers/lambda/message.ts

@@ -5,7 +5,7 @@ import { updateMessagePluginSchema } from '@/database/schemas';
 import { getServerDB } from '@/database/server';
 import { authedProcedure, publicProcedure, router } from '@/libs/trpc';
 import { serverDatabase } from '@/libs/trpc/lambda';
-import { getFullFileUrl } from '@/server/utils/files';
+import { FileService } from '@/server/services/file';
 import { ChatMessage } from '@/types/message';
 import { BatchTaskResult } from '@/types/service';
 
@@ -15,7 +15,10 @@ const messageProcedure = authedProcedure.use(serverDatabase).use(async (opts) =>
   const { ctx } = opts;
 
   return opts.next({
-    ctx: { messageModel: new MessageModel(ctx.serverDB, ctx.userId) },
+    ctx: {
+      fileService: new FileService(),
+      messageModel: new MessageModel(ctx.serverDB, ctx.userId),
+    },
   });
 });
 
@@ -99,8 +102,11 @@ export const messageRouter = router({
       const serverDB = await getServerDB();
 
       const messageModel = new MessageModel(serverDB, ctx.userId);
+      const fileService = new FileService();
 
-      return messageModel.query(input, { postProcessUrl: (path) => getFullFileUrl(path) });
+      return messageModel.query(input, {
+        postProcessUrl: (path) => fileService.getFullFileUrl(path),
+      });
     }),
 
   rankModels: messageProcedure.query(async ({ ctx }) => {

package/src/server/routers/lambda/ragEval.ts

@@ -16,9 +16,8 @@ import {
 import { authedProcedure, router } from '@/libs/trpc';
 import { serverDatabase } from '@/libs/trpc/lambda';
 import { keyVaults } from '@/libs/trpc/middleware/keyVaults';
-import { S3 } from '@/server/modules/S3';
 import { createAsyncServerClient } from '@/server/routers/async';
-import { getFullFileUrl } from '@/server/utils/files';
+import { FileService } from '@/server/services/file';
 import {
   EvalDatasetRecord,
   EvalEvaluationStatus,
@@ -42,7 +41,7 @@ const ragEvalProcedure = authedProcedure
         datasetRecordModel: new EvalDatasetRecordModel(ctx.userId),
         evaluationModel: new EvalEvaluationModel(ctx.userId),
         evaluationRecordModel: new EvaluationRecordModel(ctx.userId),
-        s3: new S3(),
+        fileService: new FileService(),
       },
     });
   });
@@ -144,7 +143,7 @@ export const ragEvalRouter = router({
       }),
     )
     .mutation(async ({ input, ctx }) => {
-      const dataStr = await ctx.s3.getFileContent(input.pathname);
+      const dataStr = await ctx.fileService.getFileContent(input.pathname);
       const items = JSONL.parse<InsertEvalDatasetRecord>(dataStr);
 
       insertEvalDatasetRecordSchema.array().parse(items);
@@ -262,12 +261,12 @@ export const ragEvalRouter = router({
         const filename = `${date}-eval_${evaluation.id}-${evaluation.name}.jsonl`;
         const path = `rag_eval_records/${filename}`;
 
-        await ctx.s3.uploadContent(path, JSONL.stringify(evalRecords));
+        await ctx.fileService.uploadContent(path, JSONL.stringify(evalRecords));
 
         // 保存数据
         await ctx.evaluationModel.update(input.id, {
           status: EvalEvaluationStatus.Success,
-          evalRecordsUrl: await getFullFileUrl(path),
+          evalRecordsUrl: await ctx.fileService.getFullFileUrl(path),
         });
       }
 

package/src/server/services/file/impls/index.ts

@@ -0,0 +1,12 @@
+import { S3StaticFileImpl } from './s3';
+import { FileServiceImpl } from './type';
+
+/**
+ * 创建文件服务模块
+ */
+export const createFileServiceModule = (): FileServiceImpl => {
+  // 默认使用 S3 实现
+  return new S3StaticFileImpl();
+};
+
+export type { FileServiceImpl } from './type';

package/src/server/services/file/impls/s3.test.ts

@@ -0,0 +1,110 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { S3StaticFileImpl } from './s3';
+
+const config = {
+  S3_ENABLE_PATH_STYLE: false,
+  S3_PUBLIC_DOMAIN: 'https://example.com',
+  S3_BUCKET: 'my-bucket',
+  S3_SET_ACL: true,
+};
+
+// 模拟 fileEnv
+vi.mock('@/config/file', () => ({
+  get fileEnv() {
+    return config;
+  },
+}));
+
+// 模拟 S3 类
+vi.mock('@/server/modules/S3', () => ({
+  S3: vi.fn().mockImplementation(() => ({
+    createPreSignedUrlForPreview: vi
+      .fn()
+      .mockResolvedValue('https://presigned.example.com/test.jpg'),
+    getFileContent: vi.fn().mockResolvedValue('file content'),
+    getFileByteArray: vi.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
+    deleteFile: vi.fn().mockResolvedValue({}),
+    deleteFiles: vi.fn().mockResolvedValue({}),
+    createPreSignedUrl: vi.fn().mockResolvedValue('https://upload.example.com/test.jpg'),
+    uploadContent: vi.fn().mockResolvedValue({}),
+  })),
+}));
+
+describe('S3StaticFileImpl', () => {
+  let fileService: S3StaticFileImpl;
+
+  beforeEach(() => {
+    fileService = new S3StaticFileImpl();
+  });
+
+  describe('getFullFileUrl', () => {
+    it('should return empty string for null or undefined input', async () => {
+      expect(await fileService.getFullFileUrl(null)).toBe('');
+      expect(await fileService.getFullFileUrl(undefined)).toBe('');
+    });
+
+    it('当S3_SET_ACL为false时应返回预签名URL', async () => {
+      config.S3_SET_ACL = false;
+      const url = 'path/to/file.jpg';
+      expect(await fileService.getFullFileUrl(url)).toBe('https://presigned.example.com/test.jpg');
+      config.S3_SET_ACL = true;
+    });
+
+    it('should return correct URL when S3_ENABLE_PATH_STYLE is false', async () => {
+      const url = 'path/to/file.jpg';
+      expect(await fileService.getFullFileUrl(url)).toBe('https://example.com/path/to/file.jpg');
+    });
+
+    it('should return correct URL when S3_ENABLE_PATH_STYLE is true', async () => {
+      config.S3_ENABLE_PATH_STYLE = true;
+      const url = 'path/to/file.jpg';
+      expect(await fileService.getFullFileUrl(url)).toBe(
+        'https://example.com/my-bucket/path/to/file.jpg',
+      );
+      config.S3_ENABLE_PATH_STYLE = false;
+    });
+  });
+
+  describe('getFileContent', () => {
+    it('应该返回文件内容', async () => {
+      expect(await fileService.getFileContent('test.txt')).toBe('file content');
+    });
+  });
+
+  describe('getFileByteArray', () => {
+    it('应该返回文件字节数组', async () => {
+      const result = await fileService.getFileByteArray('test.jpg');
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(result.length).toBe(3);
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('应该调用S3的deleteFile方法', async () => {
+      await fileService.deleteFile('test.jpg');
+      expect(fileService['s3'].deleteFile).toHaveBeenCalledWith('test.jpg');
+    });
+  });
+
+  describe('deleteFiles', () => {
+    it('应该调用S3的deleteFiles方法', async () => {
+      await fileService.deleteFiles(['test1.jpg', 'test2.jpg']);
+      expect(fileService['s3'].deleteFiles).toHaveBeenCalledWith(['test1.jpg', 'test2.jpg']);
+    });
+  });
+
+  describe('createPreSignedUrl', () => {
+    it('应该调用S3的createPreSignedUrl方法', async () => {
+      const result = await fileService.createPreSignedUrl('test.jpg');
+      expect(result).toBe('https://upload.example.com/test.jpg');
+    });
+  });
+
+  describe('uploadContent', () => {
+    it('应该调用S3的uploadContent方法', async () => {
+      await fileService.uploadContent('test.jpg', 'content');
+      expect(fileService['s3'].uploadContent).toHaveBeenCalledWith('test.jpg', 'content');
+    });
+  });
+});