@lobehub/chat 1.98.1 → 1.99.0

package/src/store/image/slices/generationTopic/selectors.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+
+import { ImageStore } from '@/store/image';
+import { initialState } from '@/store/image/initialState';
+import { ImageGenerationTopic } from '@/types/generation';
+import { merge } from '@/utils/merge';
+
+import { generationTopicSelectors } from './selectors';
+
+const initialStore = initialState as ImageStore;
+
+const mockGenerationTopics: ImageGenerationTopic[] = [
+  {
+    id: 'gt_aBc123xYz456',
+    title: 'Generation Topic 1',
+    coverUrl: 'https://example.com/cover1.jpg',
+    createdAt: new Date('2023-01-01'),
+    updatedAt: new Date('2023-01-01'),
+  },
+  {
+    id: 'gt_dEf789uVw012',
+    title: 'Generation Topic 2',
+    coverUrl: null,
+    createdAt: new Date('2023-01-02'),
+    updatedAt: new Date('2023-01-02'),
+  },
+];
+
+describe('generationTopicSelectors', () => {
+  describe('activeGenerationTopicId', () => {
+    it('should return null when no active topic is set', () => {
+      const activeId = generationTopicSelectors.activeGenerationTopicId(initialStore);
+      expect(activeId).toBeNull();
+    });
+
+    it('should return the active generation topic id', () => {
+      const state = merge(initialStore, { activeGenerationTopicId: 'gt_aBc123xYz456' });
+      const activeId = generationTopicSelectors.activeGenerationTopicId(state);
+      expect(activeId).toBe('gt_aBc123xYz456');
+    });
+  });
+
+  describe('generationTopics', () => {
+    it('should return empty array when no topics exist', () => {
+      const topics = generationTopicSelectors.generationTopics(initialStore);
+      expect(topics).toEqual([]);
+    });
+
+    it('should return all generation topics from the store', () => {
+      const state = merge(initialStore, { generationTopics: mockGenerationTopics });
+      const topics = generationTopicSelectors.generationTopics(state);
+      expect(topics).toEqual(mockGenerationTopics);
+    });
+  });
+
+  describe('getGenerationTopicById', () => {
+    it('should return undefined when topic is not found', () => {
+      const state = merge(initialStore, { generationTopics: mockGenerationTopics });
+      const topic = generationTopicSelectors.getGenerationTopicById('nonexistent')(state);
+      expect(topic).toBeUndefined();
+    });
+
+    it('should return the topic with the given id', () => {
+      const state = merge(initialStore, { generationTopics: mockGenerationTopics });
+      const topic = generationTopicSelectors.getGenerationTopicById('gt_aBc123xYz456')(state);
+      expect(topic).toEqual(mockGenerationTopics[0]);
+    });
+
+    it('should return the correct topic when multiple topics exist', () => {
+      const state = merge(initialStore, { generationTopics: mockGenerationTopics });
+      const topic = generationTopicSelectors.getGenerationTopicById('gt_dEf789uVw012')(state);
+      expect(topic).toEqual(mockGenerationTopics[1]);
+    });
+  });
+
+  describe('isLoadingGenerationTopic', () => {
+    it('should return false when no topics are loading', () => {
+      const isLoading =
+        generationTopicSelectors.isLoadingGenerationTopic('gt_aBc123xYz456')(initialStore);
+      expect(isLoading).toBe(false);
+    });
+
+    it('should return false when topic is not in loading list', () => {
+      const state = merge(initialStore, { loadingGenerationTopicIds: ['gt_dEf789uVw012'] });
+      const isLoading = generationTopicSelectors.isLoadingGenerationTopic('gt_aBc123xYz456')(state);
+      expect(isLoading).toBe(false);
+    });
+
+    it('should return true when topic is in loading list', () => {
+      const state = merge(initialStore, {
+        loadingGenerationTopicIds: ['gt_aBc123xYz456', 'gt_dEf789uVw012'],
+      });
+      const isLoading = generationTopicSelectors.isLoadingGenerationTopic('gt_aBc123xYz456')(state);
+      expect(isLoading).toBe(true);
+    });
+
+    it('should return true when topic is the only one in loading list', () => {
+      const state = merge(initialStore, { loadingGenerationTopicIds: ['gt_aBc123xYz456'] });
+      const isLoading = generationTopicSelectors.isLoadingGenerationTopic('gt_aBc123xYz456')(state);
+      expect(isLoading).toBe(true);
+    });
+  });
+});

package/src/store/image/slices/generationTopic/selectors.ts

@@ -0,0 +1,15 @@
+import { ImageStoreState } from '../../initialState';
+
+const activeGenerationTopicId = (s: ImageStoreState) => s.activeGenerationTopicId;
+const generationTopics = (s: ImageStoreState) => s.generationTopics;
+const getGenerationTopicById = (id: string) => (s: ImageStoreState) =>
+  s.generationTopics.find((topic) => topic.id === id);
+const isLoadingGenerationTopic = (id: string) => (s: ImageStoreState) =>
+  s.loadingGenerationTopicIds.includes(id);
+
+export const generationTopicSelectors = {
+  activeGenerationTopicId,
+  generationTopics,
+  getGenerationTopicById,
+  isLoadingGenerationTopic,
+};

package/src/store/image/store.ts

@@ -0,0 +1,42 @@
+import { subscribeWithSelector } from 'zustand/middleware';
+import { shallow } from 'zustand/shallow';
+import { createWithEqualityFn } from 'zustand/traditional';
+import { StateCreator } from 'zustand/vanilla';
+
+import { createDevtools } from '../middleware/createDevtools';
+import { ImageStoreState, initialState } from './initialState';
+import { CreateImageAction, createCreateImageSlice } from './slices/createImage/action';
+import { GenerationBatchAction, createGenerationBatchSlice } from './slices/generationBatch/action';
+import {
+  GenerationConfigAction,
+  createGenerationConfigSlice,
+} from './slices/generationConfig/action';
+import { GenerationTopicAction, createGenerationTopicSlice } from './slices/generationTopic/action';
+
+//  ===============  aggregate createStoreFn ============ //
+
+export interface ImageStore
+  extends GenerationConfigAction,
+    GenerationTopicAction,
+    GenerationBatchAction,
+    CreateImageAction,
+    ImageStoreState {}
+
+const createStore: StateCreator<ImageStore, [['zustand/devtools', never]]> = (...parameters) => ({
+  ...initialState,
+  ...createGenerationConfigSlice(...parameters),
+  ...createGenerationTopicSlice(...parameters),
+  ...createGenerationBatchSlice(...parameters),
+  ...createCreateImageSlice(...parameters),
+});
+
+//  ===============  implement useStore ============ //
+
+const devtools = createDevtools('image');
+
+export const useImageStore = createWithEqualityFn<ImageStore>()(
+  subscribeWithSelector(devtools(createStore)),
+  shallow,
+);
+
+export const getImageStoreState = () => useImageStore.getState();

package/src/store/image/utils/size.ts

@@ -0,0 +1,51 @@
+/**
+ * 解析比例字符串，例如 "16:9" -> 1.777
+ * @param ratio - 格式为 "width:height" 的比例字符串
+ * @returns 比例数值，出现错误时返回 1:1 比例
+ */
+export function parseRatio(ratio: string): number {
+  if (!ratio || typeof ratio !== 'string') return 1;
+
+  const parts = ratio.split(':');
+  if (parts.length !== 2) return 1;
+
+  const [widthStr, heightStr] = parts;
+  const width = Number(widthStr);
+  const height = Number(heightStr);
+
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return 1;
+  }
+
+  return width / height;
+}
+
+/**
+ * 根据目标比例和默认尺寸，计算最合适的尺寸
+ * @param ratio - 目标宽高比例
+ * @param defaultWidth - 默认宽度
+ * @param defaultHeight - 默认高度
+ * @returns 计算出的尺寸对象
+ */
+export function adaptSizeToRatio(ratio: number, defaultWidth: number, defaultHeight: number) {
+  // 验证输入参数
+  if (!Number.isFinite(ratio) || ratio <= 0) {
+    throw new Error('Invalid ratio: must be a positive finite number');
+  }
+  if (!Number.isFinite(defaultWidth) || defaultWidth <= 0) {
+    throw new Error('Invalid defaultWidth: must be a positive finite number');
+  }
+  if (!Number.isFinite(defaultHeight) || defaultHeight <= 0) {
+    throw new Error('Invalid defaultHeight: must be a positive finite number');
+  }
+
+  const currentRatio = defaultWidth / defaultHeight;
+
+  if (ratio > currentRatio) {
+    // 目标比例更宽，保持宽度，调整高度
+    return { width: defaultWidth, height: Math.round(defaultWidth / ratio) };
+  } else {
+    // 目标比例更高，保持高度，调整宽度
+    return { width: Math.round(defaultHeight * ratio), height: defaultHeight };
+  }
+}

package/src/store/tool/slices/customPlugin/action.ts

@@ -51,7 +51,16 @@ export const createCustomPluginSlice: StateCreator<
         const url = plugin.customParams?.mcp?.url;
         if (!url) return;
 
-        manifest = await mcpService.getStreamableMcpServerManifest(plugin.identifier, url);
+        manifest = await mcpService.getStreamableMcpServerManifest({
+          auth: plugin.customParams.mcp.auth,
+          headers: plugin.customParams.mcp.headers,
+          identifier: plugin.identifier,
+          metadata: {
+            avatar: plugin.customParams.avatar,
+            description: plugin.customParams.description,
+          },
+          url,
+        });
       } else {
         manifest = await toolService.getToolManifest(
           plugin.customParams?.manifestUrl,

package/src/store/tool/slices/mcpStore/action.ts

@@ -229,11 +229,13 @@ export const createMCPPluginStoreSlice: StateCreator<
       }
       if (connection?.type === 'http') {
         manifest = await mcpService.getStreamableMcpServerManifest(
-          identifier,
-          connection.url!,
           {
-            avatar: plugin.icon,
-            description: plugin.description,
+            identifier,
+            metadata: {
+              avatar: plugin.icon,
+              description: plugin.description,
+            },
+            url: connection.url!,
           },
           abortController.signal,
         );

package/src/store/user/slices/settings/selectors/__snapshots__/settings.test.ts.snap

@@ -55,6 +55,10 @@ exports[`settingsSelectors > currentSystemAgent > should merge DEFAULT_SYSTEM_AG
     "provider": "openai",
   },
   "enableAutoReply": true,
+  "generationTopic": {
+    "model": "gpt-4.1-mini",
+    "provider": "openai",
+  },
   "historyCompress": {
     "model": "gpt-4.1-mini",
     "provider": "openai",

package/src/store/user/slices/settings/selectors/systemAgent.ts

@@ -13,9 +13,11 @@ const thread = (s: UserStore) => currentSystemAgent(s).thread;
 const agentMeta = (s: UserStore) => currentSystemAgent(s).agentMeta;
 const queryRewrite = (s: UserStore) => currentSystemAgent(s).queryRewrite;
 const historyCompress = (s: UserStore) => currentSystemAgent(s).historyCompress;
+const generationTopic = (s: UserStore) => currentSystemAgent(s).generationTopic;
 
 export const systemAgentSelectors = {
   agentMeta,
+  generationTopic,
   historyCompress,
   queryRewrite,
   thread,

package/src/types/aiModel.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 
+import { ModelParamsSchema } from '@/libs/standard-parameters';
+
 export type ModelPriceCurrency = 'CNY' | 'USD';
 
 export const AiModelSourceEnum = {
@@ -186,15 +188,16 @@ export interface AIEmbeddingModelCard extends AIBaseModelCard {
   type: 'embedding';
 }
 
-export interface AIText2ImageModelCard extends AIBaseModelCard {
+export interface AIImageModelCard extends AIBaseModelCard {
+  parameters?: ModelParamsSchema;
   pricing?: {
     /**
      * the currency of the pricing
      * @default USD
      */
     currency?: ModelPriceCurrency;
-  } & Record<string, number>; // [resolution: string]: number;
-  resolutions: string[];
+  } & Record<string, number>;
+  resolutions?: string[];
   type: 'image';
 }
 
@@ -299,6 +302,7 @@ export interface AiProviderModelListItem {
   displayName?: string;
   enabled: boolean;
   id: string;
+  parameters?: Record<string, any>;
   pricing?: ChatModelPricing;
   releasedAt?: string;
   settings?: AiModelSettings;
@@ -350,6 +354,7 @@ export interface EnabledAiModel {
   displayName?: string;
   enabled?: boolean;
   id: string;
+  parameters?: Record<string, any>;
   providerId: string;
   settings?: AiModelSettings;
   sort?: number;

package/src/types/aiProvider.ts

@@ -255,5 +255,6 @@ export interface AiProviderRuntimeConfig {
 export interface AiProviderRuntimeState {
   enabledAiModels: EnabledAiModel[];
   enabledAiProviders: EnabledProvider[];
+  enabledImageAiProviders: EnabledProvider[];
   runtimeConfig: Record<string, AiProviderRuntimeConfig>;
 }

package/src/types/asyncTask.ts

@@ -1,6 +1,7 @@
 export enum AsyncTaskType {
   Chunking = 'chunk',
   Embedding = 'embedding',
+  ImageGeneration = 'image_generation',
 }
 
 export enum AsyncTaskStatus {
@@ -12,6 +13,7 @@ export enum AsyncTaskStatus {
 
 export enum AsyncTaskErrorType {
   EmbeddingError = 'EmbeddingError',
+  InvalidProviderAPIKey = 'InvalidProviderAPIKey',
   /**
    * the chunk parse result it empty
    */

package/src/types/files/index.ts

@@ -7,12 +7,17 @@ export enum FilesTabs {
   Websites = 'websites',
 }
 
+export enum FileSource {
+  ImageGeneration = 'image_generation',
+}
+
 export interface FileItem {
   createdAt: Date;
   enabled?: boolean;
   id: string;
   name: string;
   size: number;
+  source?: FileSource | null;
   type: string;
   updatedAt: Date;
   url: string;

package/src/types/generation/index.ts

@@ -0,0 +1,80 @@
+import { AsyncTaskError, AsyncTaskStatus } from '../asyncTask';
+
+export interface ImageGenerationTopic {
+  id: string;
+  title?: string | null;
+  coverUrl?: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface BaseGenerationAsset {
+  type: string;
+}
+
+export interface ImageGenerationAsset extends BaseGenerationAsset {
+  /**
+   * api provider 家的 cdn url，一般很快就会失效
+   */
+  originalUrl?: string;
+  /**
+   * 存到自己 oss 的 url, 只存了 key， 完整的 url 需要使用 FileService.getFullFileUrl 获取
+   */
+  url?: string;
+  /**
+   * 缩略图，图片那就是尺寸裁剪过的，视频那就是封面的缩略图
+   */
+  thumbnailUrl?: string;
+  /**
+   * 图片/视频的宽度
+   */
+  width?: number;
+  /**
+   * 图片/视频的高度
+   */
+  height?: number;
+}
+
+export type GenerationAsset = ImageGenerationAsset;
+
+export interface GenerationConfig {
+  prompt: string;
+  imageUrls?: string[];
+  width?: number;
+  height?: number;
+  aspectRatio?: string;
+  size?: string;
+  steps?: number;
+  cfg?: number;
+}
+
+export interface GenerationAsyncTask {
+  id: string;
+  status: AsyncTaskStatus;
+  error?: AsyncTaskError;
+}
+
+export interface Generation {
+  id: string;
+  /**
+   * The asset associated with the generation, containing image URLs and dimensions.
+   */
+  asset?: GenerationAsset | null;
+  seed?: number | null;
+  createdAt: Date;
+  asyncTaskId: string | null;
+
+  task: GenerationAsyncTask;
+}
+
+export interface GenerationBatch {
+  id: string;
+  provider: string;
+  model: string;
+  prompt: string;
+  width?: number | null;
+  height?: number | null;
+  config?: GenerationConfig;
+  createdAt: Date;
+  generations: Generation[];
+}

package/src/types/hotkey.ts

@@ -84,6 +84,8 @@ export const HotkeyScopeEnum = {
   // 默认全局注册的快捷键 scope
   // https://react-hotkeys-hook.vercel.app/docs/documentation/hotkeys-provider
   Global: 'global',
+
+  Image: 'image',
 } as const;
 
 export type HotkeyId = (typeof HotkeyEnum)[keyof typeof HotkeyEnum];

package/src/types/plugins/mcp.ts

@@ -1,5 +1,6 @@
 import { PluginQueryParams, SystemDependency } from '@lobehub/market-sdk';
 
+import { MCPErrorType } from '@/libs/mcp';
 import { MCPInstallStep } from '@/store/tool/slices/mcpStore';
 
 export interface CheckMcpInstallParams {
@@ -147,12 +148,7 @@ export interface MCPErrorInfo {
   /**
    * 错误类型
    */
-  type:
-    | 'CONNECTION_FAILED'
-    | 'PROCESS_SPAWN_ERROR'
-    | 'INITIALIZATION_TIMEOUT'
-    | 'VALIDATION_ERROR'
-    | 'UNKNOWN_ERROR';
+  type: MCPErrorType;
 }
 
 export interface MCPInstallProgress {

package/src/types/tool/plugin.ts

@@ -27,6 +27,14 @@ export interface CustomPluginParams {
     command?: string;
     type: 'http' | 'stdio';
     url?: string;
+    // 新增认证配置支持
+    auth?: {
+      type: 'none' | 'bearer' | 'oauth2';
+      token?: string; // Bearer Token
+      accessToken?: string; // OAuth2 Access Token
+    };
+    // 新增 headers 配置支持
+    headers?: Record<string, string>;
   };
   avatar?: string;
   description?: string;

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

@@ -3,6 +3,10 @@ export interface OpenAICompatibleKeyVault {
   baseURL?: string;
 }
 
+export interface FalKeyVault {
+  apiKey?: string;
+}
+
 export interface AzureOpenAIKeyVault {
   apiKey?: string;
   apiVersion?: string;
@@ -43,6 +47,7 @@ export interface UserKeyVaults extends SearchEngineKeyVaults {
   cloudflare?: CloudflareKeyVault;
   cohere?: OpenAICompatibleKeyVault;
   deepseek?: OpenAICompatibleKeyVault;
+  fal?: FalKeyVault;
   fireworksai?: OpenAICompatibleKeyVault;
   giteeai?: OpenAICompatibleKeyVault;
   github?: OpenAICompatibleKeyVault;

package/src/types/user/settings/systemAgent.ts

@@ -11,6 +11,7 @@ export interface QueryRewriteSystemAgent extends Omit<SystemAgentItem, 'enabled'
 
 export interface UserSystemAgentConfig {
   agentMeta: SystemAgentItem;
+  generationTopic: SystemAgentItem;
   historyCompress: SystemAgentItem;
   queryRewrite: QueryRewriteSystemAgent;
   thread: SystemAgentItem;

package/src/utils/client/downloadFile.ts

@@ -1,19 +1,48 @@
-export const downloadFile = async (url: string, fileName: string) => {
+export const downloadFile = async (
+  url: string,
+  fileName: string,
+  fallbackToOpen: boolean = true,
+) => {
   try {
-    const res = await fetch(url);
-    const blob = await res.blob();
+    // Use better CORS handling similar to download-image.ts
+    const response = await fetch(url, {
+      // Avoid image disk cache which can cause incorrect CORS headers
+      cache: 'no-store',
 
+      credentials: 'omit',
+
+      mode: 'cors',
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
+    }
+
+    const blob = await response.blob();
+
+    // Create download link
     const blobUrl = window.URL.createObjectURL(blob);
     const link = document.createElement('a');
     link.href = blobUrl;
     link.download = fileName;
     link.style.display = 'none';
+
+    // Trigger download
     document.body.append(link);
     link.click();
+
+    // Cleanup
     link.remove();
     window.URL.revokeObjectURL(blobUrl);
   } catch (error) {
     console.log('Download failed:', error);
-    window.open(url);
+
+    // Fallback: open in new tab if enabled
+    if (fallbackToOpen) {
+      window.open(url);
+    } else {
+      // Re-throw the error if fallback is disabled
+      throw error;
+    }
   }
 };

package/src/utils/number.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { MAX_SEED, generateUniqueSeeds } from './number';
+
+describe('number utilities', () => {
+  describe('MAX_SEED constant', () => {
+    it('should be 2^31 - 1', () => {
+      expect(MAX_SEED).toBe(2147483647);
+      expect(MAX_SEED).toBe(2 ** 31 - 1);
+    });
+  });
+
+  describe('generateUniqueSeeds', () => {
+    it('should generate the correct number of seeds', () => {
+      const seedCount = 5;
+      const seeds = generateUniqueSeeds(seedCount);
+
+      expect(seeds).toHaveLength(seedCount);
+    });
+
+    it('should generate unique seeds', () => {
+      const seedCount = 10;
+      const seeds = generateUniqueSeeds(seedCount);
+
+      // Convert to Set to check uniqueness
+      const uniqueSeeds = new Set(seeds);
+      expect(uniqueSeeds.size).toBe(seedCount);
+    });
+
+    it('should generate seeds within valid range', () => {
+      const seedCount = 20;
+      const seeds = generateUniqueSeeds(seedCount);
+
+      seeds.forEach((seed) => {
+        expect(seed).toBeGreaterThanOrEqual(0);
+        expect(seed).toBeLessThanOrEqual(MAX_SEED);
+        expect(Number.isInteger(seed)).toBe(true);
+      });
+    });
+
+    it('should handle edge case of 0 seeds', () => {
+      const seeds = generateUniqueSeeds(0);
+
+      expect(seeds).toHaveLength(0);
+      expect(Array.isArray(seeds)).toBe(true);
+    });
+
+    it('should handle edge case of 1 seed', () => {
+      const seeds = generateUniqueSeeds(1);
+
+      expect(seeds).toHaveLength(1);
+      expect(seeds[0]).toBeGreaterThanOrEqual(0);
+      expect(seeds[0]).toBeLessThanOrEqual(MAX_SEED);
+    });
+
+    it('should generate different results on different calls', () => {
+      const seedCount = 5;
+
+      // Generate seeds at different times to ensure different timestamps
+      const seeds1 = generateUniqueSeeds(seedCount);
+
+      // Add a small delay to ensure different timestamp
+      vi.useFakeTimers();
+      vi.advanceTimersByTime(1);
+      const seeds2 = generateUniqueSeeds(seedCount);
+      vi.useRealTimers();
+
+      // The arrays should not be identical (very low probability of collision)
+      expect(seeds1).not.toEqual(seeds2);
+    });
+
+    it('should handle larger seed counts', () => {
+      const seedCount = 100;
+      const seeds = generateUniqueSeeds(seedCount);
+
+      expect(seeds).toHaveLength(seedCount);
+
+      // Verify uniqueness
+      const uniqueSeeds = new Set(seeds);
+      expect(uniqueSeeds.size).toBe(seedCount);
+
+      // Verify all are in valid range
+      seeds.forEach((seed) => {
+        expect(seed).toBeGreaterThanOrEqual(0);
+        expect(seed).toBeLessThanOrEqual(MAX_SEED);
+      });
+    });
+
+    it('should use current timestamp as initial seed', () => {
+      const mockTimestamp = 1234567890123;
+      vi.useFakeTimers();
+      vi.setSystemTime(mockTimestamp);
+
+      // Mock Date.now to verify it's being used
+      const dateSpy = vi.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+
+      generateUniqueSeeds(3);
+
+      expect(dateSpy).toHaveBeenCalled();
+
+      dateSpy.mockRestore();
+      vi.useRealTimers();
+    });
+  });
+});