@lobehub/chat 1.127.2 → 1.127.4

package/packages/model-runtime/src/utils/postProcessModelList.test.ts

@@ -0,0 +1,190 @@
+import type { AiModelType } from 'model-bank';
+import { describe, expect, it, vi } from 'vitest';
+
+import type { ChatModelCard } from '@/types/llm';
+
+import { IMAGE_GENERATION_MODEL_WHITELIST, postProcessModelList } from './postProcessModelList';
+
+// Mock model-bank
+vi.mock('model-bank', () => ({
+  CHAT_MODEL_IMAGE_GENERATION_PARAMS: {
+    max_tokens: 1000,
+    temperature: 0.7,
+  },
+}));
+
+describe('IMAGE_GENERATION_MODEL_WHITELIST', () => {
+  it('should contain expected whitelisted models', () => {
+    expect(IMAGE_GENERATION_MODEL_WHITELIST).toContain('gemini-2.5-flash-image-preview');
+    expect(IMAGE_GENERATION_MODEL_WHITELIST).toContain('gemini-2.5-flash-image-preview:free');
+  });
+});
+
+describe('postProcessModelList', () => {
+  const mockModels: ChatModelCard[] = [
+    {
+      id: 'gpt-3.5-turbo',
+      displayName: 'GPT-3.5 Turbo',
+      enabled: true,
+    },
+    {
+      id: 'gemini-2.5-flash-image-preview',
+      displayName: 'Gemini 2.5 Flash Image Preview',
+      enabled: true,
+    },
+    {
+      id: 'claude-3-opus',
+      displayName: 'Claude 3 Opus',
+      enabled: true,
+      type: 'chat' as AiModelType,
+    },
+  ];
+
+  it('should ensure all models have type field with default "chat"', async () => {
+    const result = await postProcessModelList(mockModels);
+
+    expect(result.length).toBeGreaterThanOrEqual(mockModels.length);
+    // Filter out generated image models for this test
+    const originalModels = result.filter((model) => !model.id.endsWith(':image'));
+    originalModels.forEach((model) => {
+      expect(model.type).toBeDefined();
+      if (!mockModels.find((m) => m.id === model.id)?.type) {
+        expect(model.type).toBe('chat');
+      }
+    });
+  });
+
+  it('should preserve existing type field', async () => {
+    const result = await postProcessModelList(mockModels);
+    const claudeModel = result.find((m) => m.id === 'claude-3-opus');
+
+    expect(claudeModel?.type).toBe('chat');
+  });
+
+  it('should use getModelTypeProperty when type is missing', async () => {
+    const modelsWithoutType: ChatModelCard[] = [
+      {
+        id: 'custom-model',
+        displayName: 'Custom Model',
+        enabled: true,
+      },
+    ];
+
+    const getModelTypeProperty = vi.fn().mockResolvedValue('embedding' as AiModelType);
+    const result = await postProcessModelList(modelsWithoutType, getModelTypeProperty);
+
+    expect(getModelTypeProperty).toHaveBeenCalledWith('custom-model');
+    expect(result[0].type).toBe('embedding');
+  });
+
+  it('should generate image models for whitelisted models', async () => {
+    const result = await postProcessModelList(mockModels);
+    const imageModel = result.find((m) => m.id === 'gemini-2.5-flash-image-preview:image');
+
+    expect(imageModel).toBeDefined();
+    expect(imageModel?.type).toBe('image');
+    expect(imageModel?.displayName).toBe('Gemini 2.5 Flash Image Preview');
+    expect(imageModel?.enabled).toBe(true);
+    expect(imageModel?.parameters).toEqual({
+      max_tokens: 1000,
+      temperature: 0.7,
+    });
+  });
+
+  it('should handle models that partially match whitelist patterns', async () => {
+    const modelsWithPartialMatch: ChatModelCard[] = [
+      {
+        id: 'custom-gemini-2.5-flash-image-preview',
+        displayName: 'Custom Gemini',
+        enabled: true,
+      },
+      {
+        id: 'gemini-2.5-flash-image-preview-custom',
+        displayName: 'Gemini Custom',
+        enabled: false,
+      },
+    ];
+
+    const result = await postProcessModelList(modelsWithPartialMatch);
+
+    // Should generate image model for the one that ends with whitelist pattern
+    const imageModel = result.find((m) => m.id === 'custom-gemini-2.5-flash-image-preview:image');
+    expect(imageModel).toBeDefined();
+    expect(imageModel?.enabled).toBe(true);
+
+    // Should not generate for the one that doesn't end with whitelist pattern
+    const noImageModel = result.find((m) => m.id === 'gemini-2.5-flash-image-preview-custom:image');
+    expect(noImageModel).toBeUndefined();
+  });
+
+  it('should handle empty model list', async () => {
+    const result = await postProcessModelList([]);
+    expect(result).toEqual([]);
+  });
+
+  it('should handle multiple whitelisted models', async () => {
+    const multipleWhitelistedModels: ChatModelCard[] = [
+      {
+        id: 'test-gemini-2.5-flash-image-preview',
+        displayName: 'Test Gemini',
+        enabled: true,
+      },
+      {
+        id: 'another-gemini-2.5-flash-image-preview:free',
+        displayName: 'Another Gemini Free',
+        enabled: false,
+      },
+    ];
+
+    const result = await postProcessModelList(multipleWhitelistedModels);
+
+    // Should have original models plus image versions
+    expect(result).toHaveLength(4);
+
+    const imageModel1 = result.find((m) => m.id === 'test-gemini-2.5-flash-image-preview:image');
+    const imageModel2 = result.find(
+      (m) => m.id === 'another-gemini-2.5-flash-image-preview:free:image',
+    );
+
+    expect(imageModel1).toBeDefined();
+    expect(imageModel2).toBeDefined();
+    expect(imageModel1?.type).toBe('image');
+    expect(imageModel2?.type).toBe('image');
+  });
+
+  it('should preserve all original model properties in image versions', async () => {
+    const modelWithManyProps: ChatModelCard[] = [
+      {
+        id: 'gemini-2.5-flash-image-preview',
+        displayName: 'Gemini Flash',
+        enabled: true,
+        contextWindowTokens: 4096,
+        description: 'A flash model',
+        functionCall: true,
+        vision: true,
+        reasoning: false,
+        maxOutput: 2048,
+      },
+    ];
+
+    const result = await postProcessModelList(modelWithManyProps);
+    const imageModel = result.find((m) => m.id === 'gemini-2.5-flash-image-preview:image');
+
+    expect(imageModel).toMatchObject({
+      id: 'gemini-2.5-flash-image-preview:image',
+      displayName: 'Gemini Flash',
+      enabled: true,
+      contextWindowTokens: 4096,
+      description: 'A flash model',
+      functionCall: true,
+      vision: true,
+      reasoning: false,
+      maxOutput: 2048,
+      type: 'image',
+      parameters: {
+        max_tokens: 1000,
+        temperature: 0.7,
+      },
+    });
+  });
+});

package/packages/model-runtime/src/utils/response.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+
+import { StreamingResponse } from './response';
+
+describe('StreamingResponse', () => {
+  it('should create Response with default headers', () => {
+    const mockStream = new ReadableStream();
+    const response = StreamingResponse(mockStream);
+
+    expect(response).toBeInstanceOf(Response);
+    expect(response.body).toBe(mockStream);
+    expect(response.headers.get('Cache-Control')).toBe('no-cache');
+    expect(response.headers.get('Content-Type')).toBe('text/event-stream');
+    expect(response.headers.get('X-Accel-Buffering')).toBe('no');
+  });
+
+  it('should create Response with custom headers', () => {
+    const mockStream = new ReadableStream();
+    const customHeaders = {
+      'Custom-Header': 'custom-value',
+      'Authorization': 'Bearer token',
+    };
+
+    const response = StreamingResponse(mockStream, { headers: customHeaders });
+
+    expect(response).toBeInstanceOf(Response);
+    expect(response.body).toBe(mockStream);
+
+    // Default headers should still be present
+    expect(response.headers.get('Cache-Control')).toBe('no-cache');
+    expect(response.headers.get('Content-Type')).toBe('text/event-stream');
+    expect(response.headers.get('X-Accel-Buffering')).toBe('no');
+
+    // Custom headers should be added
+    expect(response.headers.get('Custom-Header')).toBe('custom-value');
+    expect(response.headers.get('Authorization')).toBe('Bearer token');
+  });
+
+  it('should allow custom headers to override default headers', () => {
+    const mockStream = new ReadableStream();
+    const overrideHeaders = {
+      'Content-Type': 'application/json',
+      'Cache-Control': 'max-age=3600',
+    };
+
+    const response = StreamingResponse(mockStream, { headers: overrideHeaders });
+
+    expect(response.headers.get('Content-Type')).toBe('application/json');
+    expect(response.headers.get('Cache-Control')).toBe('max-age=3600');
+    expect(response.headers.get('X-Accel-Buffering')).toBe('no');
+  });
+
+  it('should handle empty options object', () => {
+    const mockStream = new ReadableStream();
+    const response = StreamingResponse(mockStream, {});
+
+    expect(response).toBeInstanceOf(Response);
+    expect(response.body).toBe(mockStream);
+    expect(response.headers.get('Cache-Control')).toBe('no-cache');
+    expect(response.headers.get('Content-Type')).toBe('text/event-stream');
+    expect(response.headers.get('X-Accel-Buffering')).toBe('no');
+  });
+
+  it('should handle options with empty headers', () => {
+    const mockStream = new ReadableStream();
+    const response = StreamingResponse(mockStream, { headers: {} });
+
+    expect(response).toBeInstanceOf(Response);
+    expect(response.body).toBe(mockStream);
+    expect(response.headers.get('Cache-Control')).toBe('no-cache');
+    expect(response.headers.get('Content-Type')).toBe('text/event-stream');
+    expect(response.headers.get('X-Accel-Buffering')).toBe('no');
+  });
+
+  it('should work with actual ReadableStream data', async () => {
+    const testData = 'data: {"test": "value"}\n\n';
+    const encoder = new TextEncoder();
+
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder.encode(testData));
+        controller.close();
+      },
+    });
+
+    const response = StreamingResponse(stream);
+    const responseText = await response.text();
+
+    expect(responseText).toBe(testData);
+  });
+});

package/packages/types/src/fetch.ts

@@ -1,5 +1,5 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix */
-import { ILobeAgentRuntimeErrorType } from '@/libs/model-runtime';
+import type { ILobeAgentRuntimeErrorType } from '@lobechat/model-runtime';
 
 export const ChatErrorType = {
   // ******* 业务错误语义 ******* //

package/packages/types/src/message/base.ts

@@ -1,6 +1,5 @@
-import { IPluginErrorType } from '@lobehub/chat-plugin-sdk';
-
-import { ILobeAgentRuntimeErrorType } from '@/libs/model-runtime';
+import type { ILobeAgentRuntimeErrorType } from '@lobechat/model-runtime';
+import type { IPluginErrorType } from '@lobehub/chat-plugin-sdk';
 
 import { ErrorType } from '../fetch';
 import { GroundingSearch } from '../search';

package/packages/types/src/user/settings/index.ts

@@ -1,5 +1,4 @@
-import type { LobeAgentSettings } from '@/types/session';
-
+import type { LobeAgentSettings } from '../../session';
 import { UserGeneralConfig } from './general';
 import { UserHotkeyConfig } from './hotkey';
 import { UserKeyVaults } from './keyVaults';

package/packages/types/src/user/settings/keyVaults.ts

@@ -47,6 +47,7 @@ export interface UserKeyVaults extends SearchEngineKeyVaults {
   azureai?: AzureOpenAIKeyVault;
   baichuan?: OpenAICompatibleKeyVault;
   bedrock?: AWSBedrockKeyVault;
+  bfl?: any;
   cloudflare?: CloudflareKeyVault;
   cohere?: OpenAICompatibleKeyVault;
   cometapi?: OpenAICompatibleKeyVault;

package/packages/types/src/user/settings/modelProvider.ts

@@ -1,6 +1,7 @@
-import { ModelProviderKey } from '@/libs/model-runtime';
-import { AiFullModelCard } from '../../../../model-bank/src/types/aiModel';
-import { ChatModelCard } from '@/types/llm';
+import type { ModelProviderKey } from '@lobechat/model-runtime';
+import { AiFullModelCard } from 'model-bank';
+
+import { ChatModelCard } from '../../llm';
 
 export interface ProviderConfig {
   /**

package/src/app/[variants]/(main)/settings/llm/ProviderList/HuggingFace/index.tsx

@@ -1,11 +1,11 @@
 'use client';
 
+import { GlobalLLMProviderKey } from '@lobechat/types';
 import { InputPassword, Markdown } from '@lobehub/ui';
 import { createStyles } from 'antd-style';
 import { useTranslation } from 'react-i18next';
 
 import { HuggingFaceProviderCard } from '@/config/modelProviders';
-import { GlobalLLMProviderKey } from '@/types/user/settings';
 
 import { KeyVaultsConfigKey, LLMProviderApiTokenKey } from '../../const';
 import { ProviderItem } from '../../type';

package/src/server/modules/ModelRuntime/index.test.ts

@@ -14,18 +14,16 @@ import {
   LobeOpenRouterAI,
   LobePerplexityAI,
   LobeQwenAI,
-  LobeRuntimeAI,
+  LobeStepfunAI,
   LobeTogetherAI,
   LobeZeroOneAI,
   LobeZhipuAI,
   ModelProvider,
+  ModelRuntime,
 } from '@lobechat/model-runtime';
-import { ModelRuntime } from '@lobechat/model-runtime';
 import { ClientSecretPayload } from '@lobechat/types';
 import { describe, expect, it, vi } from 'vitest';
 
-import { LobeStepfunAI } from '@/libs/model-runtime/stepfun';
-
 import { initModelRuntimeWithUserPayload } from './index';
 
 // 模拟依赖项

package/src/services/__tests__/chat.test.ts

@@ -17,8 +17,8 @@ import {
   LobeZeroOneAI,
   LobeZhipuAI,
   ModelProvider,
+  ModelRuntime,
 } from '@lobechat/model-runtime';
-import { ModelRuntime } from '@lobechat/model-runtime';
 import { ChatErrorType } from '@lobechat/types';
 import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 import { act } from '@testing-library/react';
@@ -67,9 +67,14 @@ vi.mock('@/utils/imageToBase64', () => ({
   imageUrlToBase64: vi.fn(),
 }));
 
-vi.mock('@/libs/model-runtime/utils/uriParser', () => ({
-  parseDataUri: vi.fn(),
-}));
+vi.mock('@lobechat/model-runtime', async (importOriginal) => {
+  const actual = await importOriginal();
+
+  return {
+    ...(actual as any),
+    parseDataUri: vi.fn(),
+  };
+});
 
 afterEach(() => {
   vi.restoreAllMocks();
@@ -92,7 +97,7 @@ beforeEach(async () => {
   // Set default mock return values for image processing utilities
   const { isLocalUrl } = await import('@/utils/url');
   const { imageUrlToBase64 } = await import('@/utils/imageToBase64');
-  const { parseDataUri } = await import('@/libs/model-runtime/utils/uriParser');
+  const { parseDataUri } = await import('@lobechat/model-runtime');
 
   vi.mocked(parseDataUri).mockReturnValue({ type: 'url', base64: null, mimeType: null });
   vi.mocked(isLocalUrl).mockReturnValue(false);
@@ -404,7 +409,7 @@ describe('ChatService', () => {
       it('should convert local image URLs to base64 and call processImageList', async () => {
         const { isLocalUrl } = await import('@/utils/url');
         const { imageUrlToBase64 } = await import('@/utils/imageToBase64');
-        const { parseDataUri } = await import('@/libs/model-runtime/utils/uriParser');
+        const { parseDataUri } = await import('@lobechat/model-runtime');
 
         // Mock for local URL
         vi.mocked(parseDataUri).mockReturnValue({ type: 'url', base64: null, mimeType: null });
@@ -490,7 +495,7 @@ describe('ChatService', () => {
       it('should not convert remote URLs to base64 and call processImageList', async () => {
         const { isLocalUrl } = await import('@/utils/url');
         const { imageUrlToBase64 } = await import('@/utils/imageToBase64');
-        const { parseDataUri } = await import('@/libs/model-runtime/utils/uriParser');
+        const { parseDataUri } = await import('@lobechat/model-runtime');
 
         // Mock for remote URL
         vi.mocked(parseDataUri).mockReturnValue({ type: 'url', base64: null, mimeType: null });
@@ -570,7 +575,7 @@ describe('ChatService', () => {
       it('should handle mixed local and remote URLs correctly', async () => {
         const { isLocalUrl } = await import('@/utils/url');
         const { imageUrlToBase64 } = await import('@/utils/imageToBase64');
-        const { parseDataUri } = await import('@/libs/model-runtime/utils/uriParser');
+        const { parseDataUri } = await import('@lobechat/model-runtime');
 
         // Mock parseDataUri to always return url type
         vi.mocked(parseDataUri).mockReturnValue({ type: 'url', base64: null, mimeType: null });

package/src/store/user/slices/settings/initialState.ts

@@ -1,8 +1,7 @@
+import { DEFAULT_SETTINGS } from '@lobechat/const';
+import { UserSettings } from '@lobechat/types';
 import type { PartialDeep } from 'type-fest';
 
-import { DEFAULT_SETTINGS } from '@/const/settings';
-import { UserSettings } from '@/types/user/settings';
-
 export interface UserSettingsState {
   defaultSettings: UserSettings;
   settings: PartialDeep<UserSettings>;

package/tsconfig.json

@@ -18,8 +18,6 @@
     "baseUrl": ".",
     "types": ["vitest/globals", "@serwist/next/typings"],
     "paths": {
-      "@/libs/model-runtime": ["./packages/model-runtime/src/index.ts"],
-      "@/libs/model-runtime/*": ["./packages/model-runtime/src/*"],
       "@/database/*": ["./packages/database/src/*", "./src/database/*"],
       "@/const/*": ["./packages/const/src/*", "./src/const/*"],
       "@/utils/*": ["./packages/utils/src/*", "./src/utils/*"],

package/vitest.config.mts

@@ -9,7 +9,6 @@ export default defineConfig({
   test: {
     alias: {
       /* eslint-disable sort-keys-fix/sort-keys-fix */
-      '@/libs/model-runtime': resolve(__dirname, './packages/model-runtime/src'),
       '@/database/_deprecated': resolve(__dirname, './src/database/_deprecated'),
       '@/database': resolve(__dirname, './packages/database/src'),
       '@/utils/client/switchLang': resolve(__dirname, './src/utils/client/switchLang'),

package/packages/model-runtime/src/RouterRuntime/baseRuntimeMap.ts

@@ -1,17 +0,0 @@
-import { LobeAnthropicAI } from '../anthropic';
-import { LobeAzureAI } from '../azureai';
-import { LobeCloudflareAI } from '../cloudflare';
-import { LobeFalAI } from '../fal';
-import { LobeGoogleAI } from '../google';
-import { LobeOpenAI } from '../openai';
-import { LobeXAI } from '../xai';
-
-export const baseRuntimeMap = {
-  anthropic: LobeAnthropicAI,
-  azure: LobeAzureAI,
-  cloudflare: LobeCloudflareAI,
-  fal: LobeFalAI,
-  google: LobeGoogleAI,
-  openai: LobeOpenAI,
-  xai: LobeXAI,
-};