@lobehub/chat 1.85.0 → 1.85.1

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+### [Version 1.85.1](https://github.com/lobehub/lobe-chat/compare/v1.85.0...v1.85.1)
+
+<sup>Released on **2025-05-10**</sup>
+
+#### 💄 Styles
+
+- **misc**: Add Qwen3 models for infiniai.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Add Qwen3 models for infiniai, closes [#7657](https://github.com/lobehub/lobe-chat/issues/7657) ([edd1732](https://github.com/lobehub/lobe-chat/commit/edd1732))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 1.85.0](https://github.com/lobehub/lobe-chat/compare/v1.84.27...v1.85.0)
 
 <sup>Released on **2025-05-09**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Add Qwen3 models for infiniai."
+      ]
+    },
+    "date": "2025-05-10",
+    "version": "1.85.1"
+  },
   {
     "children": {
       "features": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.85.0",
+  "version": "1.85.1",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",
@@ -353,7 +353,7 @@
     "vitest": "^3.1.1",
     "vitest-canvas-mock": "^0.3.3"
   },
-  "packageManager": "pnpm@9.15.9",
+  "packageManager": "pnpm@10.10.0",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"

package/src/config/aiModels/infiniai.ts

@@ -37,12 +37,16 @@ const infiniaiChatModels: AIChatModelCard[] = [
     type: 'chat',
   },
   {
-    contextWindowTokens: 65_536,
+    abilities: {
+      functionCall: true,
+      reasoning: true,
+    },
+    contextWindowTokens: 128_000,
     description:
-      'QwQ 是 Qwen 系列的推理模型，相比传统指令调优模型，QwQ 具备思考和推理能力，在下游任务尤其是难题上能取得显著性能提升。QwQ-32B 是一款中等规模的推理模型，其性能可与最先进的推理模型相媲美，例如 DeepSeek-R1 和 o1-mini。',
-    displayName: 'QwQ 32B',
+      'Qwen3-235B-A22B 是 Qwen 系列第三代的大型语言模型，采用混合专家（MoE）架构，总计 2350 亿参数，每 token 激活 220 亿参数。支持无缝切换思考模式（复杂推理）和非思考模式（通用对话），在数学、编码、常识推理及多语言指令执行中表现出色。',
+    displayName: 'Qwen3 235B A22B',
     enabled: true,
-    id: 'qwq-32b',
+    id: 'qwen3-235b-a22b',
     pricing: {
       currency: 'CNY',
       input: 0,
@@ -51,11 +55,70 @@ const infiniaiChatModels: AIChatModelCard[] = [
     type: 'chat',
   },
   {
-    contextWindowTokens: 32_768,
+    abilities: {
+      functionCall: true,
+      reasoning: true,
+    },
+    contextWindowTokens: 128_000,
     description:
-      'DeepSeek-R1-Distill-Qwen-32B 是基于 DeepSeek-R1 蒸馏而来的模型，在 Qwen2.5-32B 的基础上使用 DeepSeek-R1 生成的样本进行微调。该模型在各种基准测试中表现出色，保持了强大的推理能力。',
-    displayName: 'DeepSeek R1 Distill Qwen 32B',
-    id: 'deepseek-r1-distill-qwen-32b',
+      'Qwen3-30B-A3B 是 Qwen 系列第三代的大型语言模型，采用混合专家（MoE）架构，总计 305 亿参数，每 token 激活 33 亿参数。支持无缝切换思维模式（复杂推理）和非思维模式（通用对话），在数学、编码、常识推理及多语言指令执行中表现出色。',
+    displayName: 'Qwen3 30B A3B',
+    enabled: true,
+    id: 'qwen3-30b-a3b',
+    pricing: {
+      currency: 'CNY',
+      input: 0,
+      output: 0,
+    },
+    type: 'chat',
+  },
+  {
+    abilities: {
+      functionCall: true,
+      reasoning: true,
+    },
+    contextWindowTokens: 128_000,
+    description:
+      'Qwen3-32B 是 Qwen 系列第三代的大型语言模型，拥有 328 亿参数，专为高效推理和多语言任务设计。支持无缝切换思考模式（复杂推理）和非思考模式（通用对话），在数学、编码、常识推理及多语言指令执行中表现出色。',
+    displayName: 'Qwen3 32B',
+    enabled: true,
+    id: 'qwen3-32b',
+    pricing: {
+      currency: 'CNY',
+      input: 0,
+      output: 0,
+    },
+    type: 'chat',
+  },
+  {
+    abilities: {
+      functionCall: true,
+      reasoning: true,
+    },
+    contextWindowTokens: 128_000,
+    description:
+      'Qwen3-14B 是 Qwen 系列第三代的大型语言模型，拥有 148 亿参数，专为高效推理和多语言任务设计。支持无缝切换思维模式（复杂推理）和非思维模式（通用对话），在数学、编码、常识推理及多语言指令执行中表现出色。',
+    displayName: 'Qwen3 14B',
+    enabled: false,
+    id: 'qwen3-14b',
+    pricing: {
+      currency: 'CNY',
+      input: 0,
+      output: 0,
+    },
+    type: 'chat',
+  },
+  {
+    abilities: {
+      functionCall: true,
+      reasoning: true,
+    },
+    contextWindowTokens: 128_000,
+    description:
+      'Qwen3-8B 是 Qwen 系列第三代的大型语言模型，拥有 82 亿参数，专为高效推理和多语言任务设计。支持无缝切换思考模式（复杂推理）和非思考模式（通用对话），在数学、编码、常识推理及多语言指令执行中表现出色。',
+    displayName: 'Qwen3 8B',
+    enabled: false,
+    id: 'qwen3-8b',
     pricing: {
       currency: 'CNY',
       input: 0,
@@ -114,6 +177,9 @@ const infiniaiChatModels: AIChatModelCard[] = [
     type: 'chat',
   },
   {
+    abilities: {
+      functionCall: true,
+    },
     contextWindowTokens: 32_768,
     description:
       'Qwen2.5 是 Qwen 大型语言模型系列的最新成果。Qwen2.5 发布了从 0.5 到 720 亿参数不等的基础语言模型及指令调优语言模型。Qwen2.5 相比 Qwen2 带来了以下改进：\n显著增加知识量，在编程与数学领域的能力得到极大提升。\n在遵循指令、生成长文本、理解结构化数据 (例如，表格) 以及生成结构化输出特别是 JSON 方面有显著提升。对系统提示的多样性更具韧性，增强了聊天机器人中的角色扮演实现和条件设定。\n支持长上下文处理。\n支持超过 29 种语言的多语言功能，包括中文、英语、法语、西班牙语、葡萄牙语、德语、意大利语、俄语、日语、韩语、越南语、泰语、阿拉伯语等。',
@@ -128,6 +194,9 @@ const infiniaiChatModels: AIChatModelCard[] = [
     type: 'chat',
   },
   {
+    abilities: {
+      functionCall: true,
+    },
     contextWindowTokens: 32_768,
     description:
       'Qwen2.5 是 Qwen 大型语言模型系列的最新成果。Qwen2.5 发布了从 0.5 到 720 亿参数不等的基础语言模型及指令调优语言模型。Qwen2.5 相比 Qwen2 带来了以下改进：\n显著增加知识量，在编程与数学领域的能力得到极大提升。\n在遵循指令、生成长文本、理解结构化数据 (例如，表格) 以及生成结构化输出特别是 JSON 方面有显著提升。对系统提示的多样性更具韧性，增强了聊天机器人中的角色扮演实现和条件设定。\n支持长上下文处理。\n支持超过 29 种语言的多语言功能，包括中文、英语、法语、西班牙语、葡萄牙语、德语、意大利语、俄语、日语、韩语、越南语、泰语、阿拉伯语等。',
@@ -168,6 +237,9 @@ const infiniaiChatModels: AIChatModelCard[] = [
     type: 'chat',
   },
   {
+    abilities: {
+      functionCall: true,
+    },
     contextWindowTokens: 32_768,
     description:
       'Qwen2.5 是 Qwen 大型语言模型系列的最新成果。Qwen2.5 发布了从 0.5 到 720 亿参数不等的基础语言模型及指令调优语言模型。Qwen2.5 相比 Qwen2 带来了以下改进：\n显著增加知识量，在编程与数学领域的能力得到极大提升。\n在遵循指令、生成长文本、理解结构化数据 (例如，表格) 以及生成结构化输出特别是 JSON 方面有显著提升。对系统提示的多样性更具韧性，增强了聊天机器人中的角色扮演实现和条件设定。\n支持长上下文处理。\n支持超过 29 种语言的多语言功能，包括中文、英语、法语、西班牙语、葡萄牙语、德语、意大利语、俄语、日语、韩语、越南语、泰语、阿拉伯语等。',
@@ -180,12 +252,44 @@ const infiniaiChatModels: AIChatModelCard[] = [
     },
     type: 'chat',
   },
+  {
+    abilities: {
+      functionCall: true,
+      reasoning: true,
+    },
+    contextWindowTokens: 65_536,
+    description:
+      'QwQ 是 Qwen 系列的推理模型，相比传统指令调优模型，QwQ 具备思考和推理能力，在下游任务尤其是难题上能取得显著性能提升。QwQ-32B 是一款中等规模的推理模型，其性能可与最先进的推理模型相媲美，例如 DeepSeek-R1 和 o1-mini。',
+    displayName: 'QwQ 32B',
+    enabled: false,
+    id: 'qwq-32b',
+    pricing: {
+      currency: 'CNY',
+      input: 0,
+      output: 0,
+    },
+    type: 'chat',
+  },
+  {
+    contextWindowTokens: 32_768,
+    description:
+      'DeepSeek-R1-Distill-Qwen-32B 是基于 DeepSeek-R1 蒸馏而来的模型，在 Qwen2.5-32B 的基础上使用 DeepSeek-R1 生成的样本进行微调。该模型在各种基准测试中表现出色，保持了强大的推理能力。',
+    displayName: 'DeepSeek R1 Distill Qwen 32B',
+    enabled: false,
+    id: 'deepseek-r1-distill-qwen-32b',
+    pricing: {
+      currency: 'CNY',
+      input: 0,
+      output: 0,
+    },
+    type: 'chat',
+  },
   {
     contextWindowTokens: 8192,
     description:
       'Meta 发布的 LLaMA 3.3 多语言大规模语言模型（LLMs）是一个经过预训练和指令微调的生成模型，提供 70B 规模（文本输入/文本输出）。该模型使用超过 15T 的数据进行训练，支持英语、德语、法语、意大利语、葡萄牙语、印地语、西班牙语和泰语，知识更新截止于 2023 年 12 月。',
     displayName: 'LLaMA 3.3 70B',
-    enabled: true,
+    enabled: false,
     id: 'llama-3.3-70b-instruct',
     pricing: {
       currency: 'CNY',

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

@@ -44,7 +44,7 @@ export const LobeInfiniAI = LobeOpenAICompatibleFactory({
   models: async ({ client }) => {
     const { LOBE_DEFAULT_MODEL_LIST } = await import('@/config/aiModels');
 
-    const reasoningKeywords = ['deepseek-r1', 'qwq'];
+    const reasoningKeywords = ['deepseek-r1', 'qwq', 'qwen3'];
     const visionKeywords = ['qwen2.5-vl'];
 
     const modelsPage = (await client.models.list()) as any;

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

@@ -0,0 +1,213 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { MessageModel } from '@/database/models/message';
+import { FileService } from '@/server/services/file';
+import { ChatMessage, CreateMessageParams } from '@/types/message';
+
+vi.mock('@/database/models/message', () => ({
+  MessageModel: vi.fn(),
+}));
+
+vi.mock('@/server/services/file', () => ({
+  FileService: vi.fn(),
+}));
+
+vi.mock('@/database/server', () => ({
+  getServerDB: vi.fn(),
+}));
+
+describe('messageRouter', () => {
+  it('should handle batchCreateMessages', async () => {
+    const mockBatchCreate = vi.fn().mockResolvedValue({ rowCount: 2 });
+    vi.mocked(MessageModel).mockImplementation(
+      () =>
+        ({
+          batchCreate: mockBatchCreate,
+        }) as any,
+    );
+
+    const input = [
+      {
+        id: '1',
+        role: 'user',
+        content: 'test',
+        sessionId: 'session1',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        agentId: 'agent1',
+        clientId: 'client1',
+        parentId: null,
+        quotaId: null,
+        model: null,
+        provider: null,
+        topicId: null,
+        error: null,
+        favorite: false,
+        observationId: null,
+        reasoning: null,
+        pluginState: null,
+        translate: null,
+        tts: null,
+        search: null,
+        threadId: null,
+        tools: null,
+        traceId: null,
+        userId: 'user1',
+      } as any,
+    ];
+
+    const ctx = {
+      messageModel: new MessageModel({} as any, 'user1'),
+    };
+
+    const result = await ctx.messageModel.batchCreate(input);
+
+    expect(mockBatchCreate).toHaveBeenCalledWith(input);
+    expect(result.rowCount).toBe(2);
+  });
+
+  it('should handle count', async () => {
+    const mockCount = vi.fn().mockResolvedValue(5);
+    vi.mocked(MessageModel).mockImplementation(
+      () =>
+        ({
+          count: mockCount,
+        }) as any,
+    );
+
+    const input = { startDate: '2024-01-01' };
+    const ctx = {
+      messageModel: new MessageModel({} as any, 'user1'),
+    };
+
+    const result = await ctx.messageModel.count(input);
+
+    expect(mockCount).toHaveBeenCalledWith(input);
+    expect(result).toBe(5);
+  });
+
+  it('should handle createMessage', async () => {
+    const mockCreate = vi.fn().mockResolvedValue({ id: 'msg1' });
+    vi.mocked(MessageModel).mockImplementation(
+      () =>
+        ({
+          create: mockCreate,
+        }) as any,
+    );
+
+    const input: CreateMessageParams = {
+      content: 'test',
+      role: 'user',
+      sessionId: 'session1',
+    };
+
+    const ctx = {
+      messageModel: new MessageModel({} as any, 'user1'),
+    };
+
+    const result = await ctx.messageModel.create(input);
+
+    expect(mockCreate).toHaveBeenCalledWith(input);
+    expect(result.id).toBe('msg1');
+  });
+
+  it('should handle getMessages', async () => {
+    const mockQuery = vi.fn().mockResolvedValue([{ id: 'msg1' }]);
+    const mockGetFullFileUrl = vi
+      .fn()
+      .mockImplementation((path: string | null, file: { fileType: string }) => {
+        return Promise.resolve('url');
+      });
+
+    vi.mocked(MessageModel).mockImplementation(
+      () =>
+        ({
+          query: mockQuery,
+        }) as any,
+    );
+
+    vi.mocked(FileService).mockImplementation(
+      () =>
+        ({
+          getFullFileUrl: mockGetFullFileUrl,
+        }) as any,
+    );
+
+    const input = { sessionId: 'session1' };
+    const ctx = {
+      messageModel: new MessageModel({} as any, 'user1'),
+      fileService: new FileService({} as any, 'user1'),
+      userId: 'user1',
+    };
+
+    const result = await ctx.messageModel.query(input, {
+      postProcessUrl: mockGetFullFileUrl,
+    });
+
+    expect(mockQuery).toHaveBeenCalledWith(input, expect.any(Object));
+    expect(result).toEqual([{ id: 'msg1' }]);
+  });
+
+  it('should handle getAllMessages', async () => {
+    const mockQueryAll = vi.fn().mockResolvedValue([
+      {
+        id: 'msg1',
+        meta: {},
+      } as ChatMessage,
+    ]);
+    vi.mocked(MessageModel).mockImplementation(
+      () =>
+        ({
+          queryAll: mockQueryAll,
+        }) as any,
+    );
+
+    const ctx = {
+      messageModel: new MessageModel({} as any, 'user1'),
+    };
+
+    const result = await ctx.messageModel.queryAll();
+
+    expect(mockQueryAll).toHaveBeenCalled();
+    expect(result).toEqual([{ id: 'msg1', meta: {} }]);
+  });
+
+  it('should handle removeMessage', async () => {
+    const mockDelete = vi.fn().mockResolvedValue(undefined);
+    vi.mocked(MessageModel).mockImplementation(
+      () =>
+        ({
+          deleteMessage: mockDelete,
+        }) as any,
+    );
+
+    const input = { id: 'msg1' };
+    const ctx = {
+      messageModel: new MessageModel({} as any, 'user1'),
+    };
+
+    await ctx.messageModel.deleteMessage(input.id);
+
+    expect(mockDelete).toHaveBeenCalledWith(input.id);
+  });
+
+  it('should handle updateMessage', async () => {
+    const mockUpdate = vi.fn().mockResolvedValue({ success: true });
+    vi.mocked(MessageModel).mockImplementation(
+      () =>
+        ({
+          update: mockUpdate,
+        }) as any,
+    );
+
+    const input = { id: 'msg1', value: { content: 'updated' } };
+    const ctx = {
+      messageModel: new MessageModel({} as any, 'user1'),
+    };
+
+    const result = await ctx.messageModel.update(input.id, input.value);
+
+    expect(mockUpdate).toHaveBeenCalledWith(input.id, input.value);
+    expect(result).toEqual({ success: true });
+  });
+});

package/src/server/services/file/__tests__/index.test.ts

@@ -0,0 +1,115 @@
+import { TRPCError } from '@trpc/server';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { FileModel } from '@/database/models/file';
+import { TempFileManager } from '@/server/utils/tempFileManager';
+
+import { FileService } from '../index';
+
+vi.mock('@/config/db', () => ({
+  serverDBEnv: {
+    REMOVE_GLOBAL_FILE: false,
+  },
+}));
+
+vi.mock('../impls', () => ({
+  createFileServiceModule: () => ({
+    deleteFile: vi.fn(),
+    deleteFiles: vi.fn(),
+    getFileContent: vi.fn(),
+    getFileByteArray: vi.fn(),
+    createPreSignedUrl: vi.fn(),
+    createPreSignedUrlForPreview: vi.fn(),
+    uploadContent: vi.fn(),
+    getFullFileUrl: vi.fn(),
+  }),
+}));
+
+vi.mock('@/database/models/file');
+
+vi.mock('@/server/utils/tempFileManager');
+
+vi.mock('@/utils/uuid', () => ({
+  nanoid: () => 'test-id',
+}));
+
+describe('FileService', () => {
+  let service: FileService;
+  const mockDb = {} as any;
+  const mockUserId = 'test-user';
+  let mockFileModel: any;
+  let mockTempManager: any;
+
+  beforeEach(() => {
+    mockFileModel = {
+      findById: vi.fn(),
+      delete: vi.fn(),
+    };
+    mockTempManager = {
+      writeTempFile: vi.fn(),
+      cleanup: vi.fn(),
+    };
+    vi.mocked(FileModel).mockImplementation(() => mockFileModel);
+    vi.mocked(TempFileManager).mockImplementation(() => mockTempManager);
+    service = new FileService(mockDb, mockUserId);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('downloadFileToLocal', () => {
+    const mockFile = {
+      id: 'test-file-id',
+      name: 'test.txt',
+      url: 'test-url',
+    };
+
+    it('should throw error if file not found', async () => {
+      mockFileModel.findById.mockResolvedValue(undefined);
+
+      await expect(service.downloadFileToLocal('test-file-id')).rejects.toThrow(
+        new TRPCError({ code: 'BAD_REQUEST', message: 'File not found' }),
+      );
+    });
+
+    it('should throw error if file content is empty', async () => {
+      mockFileModel.findById.mockResolvedValue(mockFile);
+      vi.mocked(service['impl'].getFileByteArray).mockResolvedValue(undefined as any);
+
+      await expect(service.downloadFileToLocal('test-file-id')).rejects.toThrow(
+        new TRPCError({ code: 'BAD_REQUEST', message: 'File content is empty' }),
+      );
+    });
+
+    it('should delete file from db and throw error if file not found in storage', async () => {
+      mockFileModel.findById.mockResolvedValue(mockFile);
+      vi.mocked(service['impl'].getFileByteArray).mockRejectedValue({ Code: 'NoSuchKey' });
+
+      await expect(service.downloadFileToLocal('test-file-id')).rejects.toThrow(
+        new TRPCError({ code: 'BAD_REQUEST', message: 'File not found' }),
+      );
+
+      expect(mockFileModel.delete).toHaveBeenCalledWith('test-file-id', false);
+    });
+
+    it('should successfully download file to local', async () => {
+      const mockContent = new Uint8Array([1, 2, 3]);
+      const mockFilePath = '/tmp/test.txt';
+
+      mockFileModel.findById.mockResolvedValue(mockFile);
+      vi.mocked(service['impl'].getFileByteArray).mockResolvedValue(mockContent);
+      mockTempManager.writeTempFile.mockResolvedValue(mockFilePath);
+
+      const result = await service.downloadFileToLocal('test-file-id');
+
+      expect(result).toEqual({
+        cleanup: expect.any(Function),
+        file: mockFile,
+        filePath: mockFilePath,
+      });
+
+      expect(mockTempManager.writeTempFile).toHaveBeenCalledWith(mockContent, mockFile.name);
+    });
+  });
+});

package/src/server/utils/__tests__/tempFileManager.test.ts

@@ -0,0 +1,94 @@
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+
+import { TempFileManager } from '../tempFileManager';
+
+// Mock node modules
+vi.mock('node:fs');
+vi.mock('node:os');
+vi.mock('node:path', () => ({
+  join: (...args: string[]) => args.join('/'),
+  default: {
+    join: (...args: string[]) => args.join('/'),
+  },
+}));
+
+describe('TempFileManager', () => {
+  const mockTmpDir = '/tmp';
+  const mockDirname = 'test-';
+  const mockFullTmpDir = '/tmp/test-xyz';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(tmpdir).mockReturnValue(mockTmpDir);
+    vi.mocked(mkdtempSync).mockReturnValue(mockFullTmpDir);
+    vi.mocked(existsSync).mockReturnValue(true);
+  });
+
+  it('should create temp directory on initialization', () => {
+    new TempFileManager(mockDirname);
+
+    expect(tmpdir).toHaveBeenCalled();
+    expect(mkdtempSync).toHaveBeenCalledWith(`${mockTmpDir}/${mockDirname}`);
+  });
+
+  it('should write temp file successfully', async () => {
+    const manager = new TempFileManager(mockDirname);
+    const testData = new Uint8Array([1, 2, 3]);
+    const fileName = 'test.txt';
+
+    const filePath = await manager.writeTempFile(testData, fileName);
+
+    expect(writeFileSync).toHaveBeenCalledWith(`${mockFullTmpDir}/${fileName}`, testData);
+    expect(filePath).toBe(`${mockFullTmpDir}/${fileName}`);
+  });
+
+  it('should cleanup on write failure', async () => {
+    const manager = new TempFileManager(mockDirname);
+    const testData = new Uint8Array([1, 2, 3]);
+    const fileName = 'test.txt';
+
+    vi.mocked(writeFileSync).mockImplementation(() => {
+      throw new Error('Write failed');
+    });
+
+    await expect(manager.writeTempFile(testData, fileName)).rejects.toThrow(
+      'Failed to write temp file: Write failed',
+    );
+
+    expect(existsSync).toHaveBeenCalledWith(mockFullTmpDir);
+    expect(rmSync).toHaveBeenCalledWith(mockFullTmpDir, { force: true, recursive: true });
+  });
+
+  it('should cleanup temp directory', () => {
+    const manager = new TempFileManager(mockDirname);
+    vi.mocked(existsSync).mockReturnValue(true);
+
+    manager.cleanup();
+
+    expect(existsSync).toHaveBeenCalledWith(mockFullTmpDir);
+    expect(rmSync).toHaveBeenCalledWith(mockFullTmpDir, { force: true, recursive: true });
+  });
+
+  it('should skip cleanup if directory does not exist', () => {
+    const manager = new TempFileManager(mockDirname);
+    vi.mocked(existsSync).mockReturnValue(false);
+
+    manager.cleanup();
+
+    expect(existsSync).toHaveBeenCalledWith(mockFullTmpDir);
+    expect(rmSync).not.toHaveBeenCalled();
+  });
+
+  it('should register cleanup hooks on process events', () => {
+    const processOnSpy = vi.spyOn(process, 'on');
+    new TempFileManager(mockDirname);
+
+    expect(processOnSpy).toHaveBeenCalledWith('exit', expect.any(Function));
+    expect(processOnSpy).toHaveBeenCalledWith('uncaughtException', expect.any(Function));
+    expect(processOnSpy).toHaveBeenCalledWith('SIGINT', expect.any(Function));
+    expect(processOnSpy).toHaveBeenCalledWith('SIGTERM', expect.any(Function));
+  });
+});