@lobehub/chat 1.42.1 → 1.42.2

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

@@ -131,7 +131,7 @@ describe('getProviderAuthPayload', () => {
     expect(payload).toEqual({
       apiKey: mockAzureConfig.apiKey,
       azureApiVersion: mockAzureConfig.apiVersion,
-      endpoint: mockAzureConfig.endpoint,
+      baseURL: mockAzureConfig.endpoint,
     });
   });
 
@@ -144,7 +144,7 @@ describe('getProviderAuthPayload', () => {
 
     const payload = getProviderAuthPayload(ModelProvider.Ollama);
     expect(payload).toEqual({
-      endpoint: mockOllamaProxyUrl,
+      baseURL: mockOllamaProxyUrl,
     });
   });
 
@@ -152,8 +152,7 @@ describe('getProviderAuthPayload', () => {
     // 假设的 OpenAI 配置
     const mockOpenAIConfig = {
       apiKey: 'openai-api-key',
-      baseURL: 'openai-baseURL',
-      endpoint: 'openai-endpoint',
+      baseURL: 'openai-endpoint',
       useAzure: true,
       azureApiVersion: 'openai-azure-api-version',
     };
@@ -164,7 +163,7 @@ describe('getProviderAuthPayload', () => {
     const payload = getProviderAuthPayload(ModelProvider.OpenAI);
     expect(payload).toEqual({
       apiKey: mockOpenAIConfig.apiKey,
-      endpoint: mockOpenAIConfig.baseURL,
+      baseURL: mockOpenAIConfig.baseURL,
     });
   });
 
@@ -181,7 +180,7 @@ describe('getProviderAuthPayload', () => {
     const payload = getProviderAuthPayload(ModelProvider.Stepfun);
     expect(payload).toEqual({
       apiKey: mockOpenAIConfig.apiKey,
-      endpoint: mockOpenAIConfig.baseURL,
+      baseURL: mockOpenAIConfig.baseURL,
     });
   });
 

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

@@ -939,6 +939,7 @@ describe('AgentRuntimeOnClient', () => {
             },
           },
         } as UserSettingsState) as unknown as UserStore;
+
         const runtime = await initializeWithClientStore(ModelProvider.Azure, {});
         expect(runtime).toBeInstanceOf(AgentRuntime);
         expect(runtime['_runtime']).toBeInstanceOf(LobeAzureOpenAI);

package/src/services/_auth.ts

@@ -45,14 +45,14 @@ export const getProviderAuthPayload = (provider: string) => {
       return {
         apiKey: azure.apiKey,
         azureApiVersion: azure.apiVersion,
-        endpoint: azure.endpoint,
+        baseURL: azure.endpoint,
       };
     }
 
     case ModelProvider.Ollama: {
       const config = keyVaultsConfigSelectors.ollamaConfig(useUserStore.getState());
 
-      return { endpoint: config?.baseURL };
+      return { baseURL: config?.baseURL };
     }
 
     case ModelProvider.Cloudflare: {
@@ -69,7 +69,7 @@ export const getProviderAuthPayload = (provider: string) => {
         useUserStore.getState(),
       );
 
-      return { apiKey: config?.apiKey, endpoint: config?.baseURL };
+      return { apiKey: config?.apiKey, baseURL: config?.baseURL };
     }
   }
 };

package/src/services/chat.ts

@@ -94,21 +94,20 @@ export function initializeWithClientStore(provider: string, payload: any) {
     default:
     case ModelProvider.OpenAI: {
       providerOptions = {
-        baseURL: providerAuthPayload?.endpoint,
+        baseURL: providerAuthPayload?.baseURL,
       };
       break;
     }
     case ModelProvider.Azure: {
       providerOptions = {
+        apiKey: providerAuthPayload?.apiKey,
         apiVersion: providerAuthPayload?.azureApiVersion,
-        // That's a wired properity, but just remapped it
-        apikey: providerAuthPayload?.apiKey,
       };
       break;
     }
     case ModelProvider.Google: {
       providerOptions = {
-        baseURL: providerAuthPayload?.endpoint,
+        baseURL: providerAuthPayload?.baseURL,
       };
       break;
     }
@@ -125,27 +124,27 @@ export function initializeWithClientStore(provider: string, payload: any) {
     }
     case ModelProvider.Ollama: {
       providerOptions = {
-        baseURL: providerAuthPayload?.endpoint,
+        baseURL: providerAuthPayload?.baseURL,
       };
       break;
     }
     case ModelProvider.Perplexity: {
       providerOptions = {
         apikey: providerAuthPayload?.apiKey,
-        baseURL: providerAuthPayload?.endpoint,
+        baseURL: providerAuthPayload?.baseURL,
       };
       break;
     }
     case ModelProvider.Anthropic: {
       providerOptions = {
-        baseURL: providerAuthPayload?.endpoint,
+        baseURL: providerAuthPayload?.baseURL,
       };
       break;
     }
     case ModelProvider.Groq: {
       providerOptions = {
         apikey: providerAuthPayload?.apiKey,
-        baseURL: providerAuthPayload?.endpoint,
+        baseURL: providerAuthPayload?.baseURL,
       };
       break;
     }

package/src/store/user/slices/modelList/selectors/modelProvider.test.ts

@@ -51,6 +51,7 @@ describe('modelProviderSelectors', () => {
       const result = modelProviderSelectors.getDefaultEnabledModelsById('openai')(s);
       expect(result).toEqual([
         'o1-mini',
+        'o1-2024-12-17',
         'o1-preview',
         'gpt-4o-mini',
         'gpt-4o-2024-11-20',

package/src/types/aiModel.ts

@@ -0,0 +1,275 @@
+import { z } from 'zod';
+
+export type ModelPriceCurrency = 'CNY' | 'USD';
+
+export const AiModelSourceEnum = {
+  Builtin: 'builtin',
+  Custom: 'custom',
+  Remote: 'remote',
+} as const;
+export type AiModelSourceType = (typeof AiModelSourceEnum)[keyof typeof AiModelSourceEnum];
+
+export type AiModelType =
+  | 'chat'
+  | 'embedding'
+  | 'tts'
+  | 'stt'
+  | 'image'
+  | 'text2video'
+  | 'text2music';
+
+export interface ModelAbilities {
+  /**
+   * whether model supports file upload
+   */
+  files?: boolean;
+  /**
+   * whether model supports function call
+   */
+  functionCall?: boolean;
+  /**
+   *  whether model supports vision
+   */
+  vision?: boolean;
+}
+
+const AiModelAbilitiesSchema = z.object({
+  // files: z.boolean().optional(),
+  functionCall: z.boolean().optional(),
+  vision: z.boolean().optional(),
+});
+
+// 语言模型的设置参数
+export interface LLMParams {
+  /**
+   * 控制生成文本中的惩罚系数，用于减少重复性
+   * @default 0
+   */
+  frequency_penalty?: number;
+  /**
+   * 生成文本的最大长度
+   */
+  max_tokens?: number;
+  /**
+   * 控制生成文本中的惩罚系数，用于减少主题的变化
+   * @default 0
+   */
+  presence_penalty?: number;
+  /**
+   * 生成文本的随机度量，用于控制文本的创造性和多样性
+   * @default 1
+   */
+  temperature?: number;
+  /**
+   * 控制生成文本中最高概率的单个 token
+   * @default 1
+   */
+  top_p?: number;
+}
+
+export interface BasicModelPricing {
+  /**
+   * the currency of the pricing
+   * @default USD
+   */
+  currency?: ModelPriceCurrency;
+  /**
+   * the input pricing, e.g. $1 / 1M tokens
+   */
+  input?: number;
+}
+
+export interface ChatModelPricing extends BasicModelPricing {
+  audioInput?: number;
+  audioOutput?: number;
+  cachedAudioInput?: number;
+  cachedInput?: number;
+  /**
+   * the output pricing, e.g. $2 / 1M tokens
+   */
+  output?: number;
+  writeCacheInput?: number;
+}
+
+interface AIBaseModelCard {
+  /**
+   * the context window (or input + output tokens limit)
+   */
+  contextWindowTokens?: number;
+  description?: string;
+  /**
+   * the name show for end user
+   */
+  displayName?: string;
+  enabled?: boolean;
+  id: string;
+  /**
+   * whether model is legacy (deprecated but not removed yet)
+   */
+  legacy?: boolean;
+  /**
+   * who create this model
+   */
+  organization?: string;
+
+  releasedAt?: string;
+}
+
+export interface AIChatModelCard extends AIBaseModelCard {
+  abilities?: {
+    /**
+     * whether model supports file upload
+     */
+    files?: boolean;
+    /**
+     * whether model supports function call
+     */
+    functionCall?: boolean;
+    /**
+     *  whether model supports vision
+     */
+    vision?: boolean;
+  };
+  /**
+   * used in azure and doubao
+   */
+  deploymentName?: string;
+  maxOutput?: number;
+  pricing?: ChatModelPricing;
+  type: 'chat';
+}
+
+export interface AIEmbeddingModelCard extends AIBaseModelCard {
+  maxDimension: number;
+  pricing?: {
+    /**
+     * the currency of the pricing
+     * @default USD
+     */
+    currency?: ModelPriceCurrency;
+    /**
+     * the input pricing, e.g. $1 / 1M tokens
+     */
+    input?: number;
+  };
+  type: 'embedding';
+}
+
+export interface AIText2ImageModelCard extends AIBaseModelCard {
+  pricing?: {
+    /**
+     * the currency of the pricing
+     * @default USD
+     */
+    currency?: ModelPriceCurrency;
+  } & Record<string, number>; // [resolution: string]: number;
+  resolutions: string[];
+  type: 'image';
+}
+
+export interface AITTSModelCard extends AIBaseModelCard {
+  pricing?: {
+    /**
+     * the currency of the pricing
+     * @default USD
+     */
+    currency?: ModelPriceCurrency;
+    /**
+     * the input pricing, e.g. $1 / 1M tokens
+     */
+    input?: number;
+  };
+  type: 'tts';
+}
+
+export interface AISTTModelCard extends AIBaseModelCard {
+  pricing?: {
+    /**
+     * the currency of the pricing
+     * @default USD
+     */
+    currency?: ModelPriceCurrency;
+    /**
+     * the input pricing, e.g. $1 / 1M tokens
+     */
+    input?: number;
+  };
+  type: 'stt';
+}
+
+export interface AIRealtimeModelCard extends AIBaseModelCard {
+  abilities?: {
+    /**
+     * whether model supports file upload
+     */
+    files?: boolean;
+    /**
+     * whether model supports function call
+     */
+    functionCall?: boolean;
+    /**
+     *  whether model supports vision
+     */
+    vision?: boolean;
+  };
+  /**
+   * used in azure and doubao
+   */
+  deploymentName?: string;
+  maxOutput?: number;
+  pricing?: ChatModelPricing;
+  type: 'realtime';
+}
+
+// create
+export const CreateAiModelSchema = z.object({
+  abilities: AiModelAbilitiesSchema.optional(),
+  contextWindowTokens: z.number().optional(),
+  displayName: z.string().optional(),
+  id: z.string(),
+  providerId: z.string(),
+  releasedAt: z.string().optional(),
+
+  // checkModel: z.string().optional(),
+  // homeUrl: z.string().optional(),
+  // modelsUrl: z.string().optional(),
+});
+
+export type CreateAiModelParams = z.infer<typeof CreateAiModelSchema>;
+
+// List Query
+
+export interface AiProviderModelListItem {
+  abilities?: ModelAbilities;
+  contextWindowTokens?: number;
+  displayName?: string;
+  enabled: boolean;
+  id: string;
+  pricing?: ChatModelPricing;
+  releasedAt?: string;
+  source?: AiModelSourceType;
+  type: AiModelType;
+}
+
+// Update
+export const UpdateAiModelSchema = z.object({
+  abilities: AiModelAbilitiesSchema.optional(),
+  contextWindowTokens: z.number().optional(),
+  displayName: z.string().optional(),
+});
+
+export type UpdateAiModelParams = z.infer<typeof UpdateAiModelSchema>;
+
+export interface AiModelSortMap {
+  id: string;
+  sort: number;
+}
+
+export const ToggleAiModelEnableSchema = z.object({
+  enabled: z.boolean(),
+  id: z.string(),
+  providerId: z.string(),
+  source: z.enum(['builtin', 'custom', 'remote']).optional(),
+});
+
+export type ToggleAiModelEnableParams = z.infer<typeof ToggleAiModelEnableSchema>;

package/src/types/aiProvider.ts

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+
+import { SmoothingParams } from '@/types/llm';
+
+// create
+export const CreateAiProviderSchema = z.object({
+  config: z.object({}).passthrough().optional(),
+  description: z.string().optional(),
+  id: z.string(),
+  keyVaults: z.any().optional(),
+  logo: z.string().optional(),
+  name: z.string(),
+  sdkType: z.enum(['openai', 'anthropic']).optional(),
+  // checkModel: z.string().optional(),
+  // homeUrl: z.string().optional(),
+  // modelsUrl: z.string().optional(),
+});
+
+export type CreateAiProviderParams = z.infer<typeof CreateAiProviderSchema>;
+
+// List Query
+
+export interface AiProviderListItem {
+  description?: string;
+  enabled: boolean;
+  id: string;
+  logo?: string;
+  name?: string;
+  sort?: number;
+  source: 'builtin' | 'custom';
+}
+
+// Detail Query
+
+interface AiProviderConfig {
+  /**
+   * whether provider show browser request option by default
+   *
+   * @default false
+   */
+  defaultShowBrowserRequest?: boolean;
+  /**
+   * some provider server like stepfun and aliyun don't support browser request,
+   * So we should disable it
+   *
+   * @default false
+   */
+  disableBrowserRequest?: boolean;
+  proxyUrl?:
+    | {
+        desc?: string;
+        placeholder: string;
+        title?: string;
+      }
+    | false;
+
+  /**
+   * whether show api key in the provider config
+   * so provider like ollama don't need api key field
+   */
+  showApiKey?: boolean;
+
+  /**
+   * whether show checker in the provider config
+   */
+  showChecker?: boolean;
+  showDeployName?: boolean;
+  showModelFetcher?: boolean;
+  /**
+   * whether to smoothing the output
+   */
+  smoothing?: SmoothingParams;
+}
+
+export interface AiProviderItem {
+  /**
+   * the default model that used for connection check
+   */
+  checkModel?: string;
+  config: AiProviderConfig;
+  description?: string;
+  enabled: boolean;
+  enabledChatModels: string[];
+  /**
+   * provider's website url
+   */
+  homeUrl?: string;
+  id: string;
+  logo?: string;
+  /**
+   * the url show the all models in the provider
+   */
+  modelsUrl?: string;
+  /**
+   * the name show for end user
+   */
+  name: string;
+  /**
+   * default openai
+   */
+  sdkType?: 'openai' | 'anthropic';
+  source: 'builtin' | 'custom';
+}
+
+export interface AiProviderDetailItem {
+  /**
+   * the default model that used for connection check
+   */
+  checkModel?: string;
+  config: AiProviderConfig;
+  description?: string;
+  enabled: boolean;
+  fetchOnClient?: boolean;
+  /**
+   * provider's website url
+   */
+  homeUrl?: string;
+  id: string;
+  keyVaults?: Record<string, any>;
+  logo?: string;
+  /**
+   * the url show the all models in the provider
+   */
+  modelsUrl?: string;
+  /**
+   * the name show for end user
+   */
+  name: string;
+  /**
+   * default openai
+   */
+  sdkType?: 'openai' | 'anthropic';
+  source: 'builtin' | 'custom';
+}
+
+// Update
+export const UpdateAiProviderConfigSchema = z.object({
+  checkModel: z.string().optional(),
+  fetchOnClient: z.boolean().optional(),
+  keyVaults: z.object({}).passthrough().optional(),
+});
+
+export type UpdateAiProviderConfigParams = z.infer<typeof UpdateAiProviderConfigSchema>;
+
+export interface AiProviderSortMap {
+  id: string;
+  sort: number;
+}

package/src/types/llm.ts

@@ -1,5 +1,7 @@
 import { ReactNode } from 'react';
 
+import { ChatModelPricing } from '@/types/aiModel';
+
 export type ModelPriceCurrency = 'CNY' | 'USD';
 
 export interface ChatModelCard {
@@ -38,23 +40,7 @@ export interface ChatModelCard {
    */
   legacy?: boolean;
   maxOutput?: number;
-  pricing?: {
-    cachedInput?: number;
-    /**
-     * the currency of the pricing
-     * @default USD
-     */
-    currency?: ModelPriceCurrency;
-    /**
-     * the input pricing, e.g. $1 / 1M tokens
-     */
-    input?: number;
-    /**
-     * the output pricing, e.g. $2 / 1M tokens
-     */
-    output?: number;
-    writeCacheInput?: number;
-  };
+  pricing?: ChatModelPricing;
   releasedAt?: string;
 
   /**

package/src/utils/merge.test.ts

@@ -0,0 +1,48 @@
+import { expect } from 'vitest';
+
+import { AIChatModelCard } from '@/types/aiModel';
+
+import { mergeArrayById } from './merge';
+
+describe('mergeArrayById', () => {
+  it('should merge data', () => {
+    const data = mergeArrayById(
+      [
+        {
+          contextWindowTokens: 128_000,
+          description:
+            'o1-mini是一款针对编程、数学和科学应用场景而设计的快速、经济高效的推理模型。该模型具有128K上下文和2023年10月的知识截止日期。',
+          displayName: 'OpenAI o1-mini',
+          enabled: true,
+          id: 'o1-mini',
+          maxOutput: 65_536,
+          pricing: {
+            input: 3,
+            output: 12,
+          },
+          releasedAt: '2024-09-12',
+          type: 'chat',
+        },
+      ],
+      [{ id: 'o1-mini', displayName: 'OpenAI o1-mini ABC', type: 'chat' }],
+    );
+
+    expect(data).toEqual([
+      {
+        contextWindowTokens: 128_000,
+        description:
+          'o1-mini是一款针对编程、数学和科学应用场景而设计的快速、经济高效的推理模型。该模型具有128K上下文和2023年10月的知识截止日期。',
+        displayName: 'OpenAI o1-mini ABC',
+        enabled: true,
+        id: 'o1-mini',
+        maxOutput: 65_536,
+        pricing: {
+          input: 3,
+          output: 12,
+        },
+        releasedAt: '2024-09-12',
+        type: 'chat',
+      },
+    ]);
+  });
+});

package/src/utils/merge.ts

@@ -9,3 +9,42 @@ export const merge: typeof _merge = <T = object>(target: T, source: T) =>
   mergeWith({}, target, source, (obj, src) => {
     if (Array.isArray(obj)) return src;
   });
+
+type MergeableItem = {
+  [key: string]: any;
+  id: string;
+};
+
+/**
+ * Merge two arrays based on id, preserving metadata from default items
+ * @param defaultItems Items with default configuration and metadata
+ * @param userItems User-defined items with higher priority
+ */
+export const mergeArrayById = <T extends MergeableItem>(defaultItems: T[], userItems: T[]): T[] => {
+  // Create a map of default items for faster lookup
+  const defaultItemsMap = new Map(defaultItems.map((item) => [item.id, item]));
+
+  // Process user items with default metadata
+  const mergedItems = userItems.map((userItem) => {
+    const defaultItem = defaultItemsMap.get(userItem.id);
+    if (!defaultItem) return userItem;
+
+    // Merge strategy: use default value when user value is null or undefined
+    const mergedItem: T = { ...defaultItem };
+    Object.entries(userItem).forEach(([key, value]) => {
+      // Only use user value if it's not null and not undefined
+      if (value !== null && value !== undefined) {
+        // @ts-expect-error
+        mergedItem[key] = value;
+      }
+    });
+
+    return mergedItem;
+  });
+
+  // Add items that only exist in default configuration
+  const userItemIds = new Set(userItems.map((item) => item.id));
+  const onlyInDefaultItems = defaultItems.filter((item) => !userItemIds.has(item.id));
+
+  return [...mergedItems, ...onlyInDefaultItems];
+};