@lobehub/chat 1.69.0 → 1.69.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.69.0",
+  "version": "1.69.2",
   "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",
@@ -133,7 +133,7 @@
     "@lobehub/chat-plugins-gateway": "^1.9.0",
     "@lobehub/icons": "^1.73.1",
     "@lobehub/tts": "^1.28.0",
-    "@lobehub/ui": "^1.165.2",
+    "@lobehub/ui": "^1.165.5",
     "@neondatabase/serverless": "^0.10.4",
     "@next/third-parties": "^15.2.0",
     "@react-spring/web": "^9.7.5",

package/src/config/aiModels/google.ts

@@ -118,7 +118,6 @@ const googleChatModels: AIChatModelCard[] = [
     description:
       'Gemini 2.0 Flash Thinking Exp 是 Google 的实验性多模态推理AI模型，能对复杂问题进行推理，拥有新的思维能力。',
     displayName: 'Gemini 2.0 Flash Thinking Experimental',
-    enabled: true,
     id: 'gemini-2.0-flash-thinking-exp',
     maxOutput: 65_536,
     pricing: {

package/src/config/aiModels/groq.ts

@@ -4,6 +4,20 @@ import { AIChatModelCard } from '@/types/aiModel';
 // https://console.groq.com/docs/models
 
 const groqChatModels: AIChatModelCard[] = [
+  {
+    abilities: {
+      functionCall: true,
+      reasoning: true,
+    },
+    contextWindowTokens: 131_072,
+    displayName: 'Qwen QwQ 32B',
+    id: 'qwen-qwq-32b',
+    pricing: {
+      input: 0.29,
+      output: 0.39,
+    },
+    type: 'chat',
+  },
   {
     abilities: {
       functionCall: true,

package/src/config/aiModels/novita.ts

@@ -150,6 +150,29 @@ const novitaChatModels: AIChatModelCard[] = [
     },
     type: 'chat',
   },
+  {
+    contextWindowTokens: 64_000,
+    displayName: 'Deepseek V3 Turbo',
+    id: 'deepseek/deepseek-v3-turbo',
+    pricing: {
+      input: 0.4,
+      output: 1.3,
+    },
+    type: 'chat',
+  },
+  {
+    abilities: {
+      reasoning: true,
+    },
+    contextWindowTokens: 64_000,
+    displayName: 'Deepseek R1 Turbo',
+    id: 'deepseek/deepseek-r1-turbo',
+    pricing: {
+      input: 0.7,
+      output: 2.5,
+    },
+    type: 'chat',
+  },
   {
     abilities: {
       reasoning: true,
@@ -378,6 +401,19 @@ const novitaChatModels: AIChatModelCard[] = [
     },
     type: 'chat',
   },
+  {
+    abilities: {
+      reasoning: true,
+    },
+    contextWindowTokens: 32_768,
+    displayName: 'QwQ 32B',
+    id: 'qwen/qwq-32b',
+    pricing: {
+      input: 0.18,
+      output: 0.2,
+    },
+    type: 'chat',
+  },
 ];
 
 export const allModels = [...novitaChatModels];

package/src/config/aiModels/siliconcloud.ts

@@ -226,9 +226,25 @@ const siliconcloudChatModels: AIChatModelCard[] = [
     },
     contextWindowTokens: 32_768,
     description:
-      'QwQ-32B-Preview是Qwen 最新的实验性研究模型，专注于提升AI推理能力。通过探索语言混合、递归推理等复杂机制，主要优势包括强大的推理分析能力、数学和编程能力。与此同时，也存在语言切换问题、推理循环、安全性考虑、其他能力方面的差异。',
-    displayName: 'QwQ 32B Preview',
+      'QwQ 是 Qwen 系列的推理模型。与传统的指令调优模型相比，QwQ 具备思考和推理能力，能够在下游任务中实现显著增强的性能，尤其是在解决困难问题方面。QwQ-32B 是中型推理模型，能够在与最先进的推理模型（如 DeepSeek-R1、o1-mini）的对比中取得有竞争力的性能。该模型采用 RoPE、SwiGLU、RMSNorm 和 Attention QKV bias 等技术，具有 64 层网络结构和 40 个 Q 注意力头（GQA 架构中 KV 为 8 个）。',
+    displayName: 'QwQ 32B',
     enabled: true,
+    id: 'Qwen/QwQ-32B',
+    pricing: {
+      currency: 'CNY',
+      input: 1,
+      output: 4,
+    },
+    type: 'chat',
+  },
+  {
+    abilities: {
+      reasoning: true,
+    },
+    contextWindowTokens: 32_768,
+    description:
+      'QwQ-32B-Preview 是 Qwen 最新的实验性研究模型，专注于提升AI推理能力。通过探索语言混合、递归推理等复杂机制，主要优势包括强大的推理分析能力、数学和编程能力。与此同时，也存在语言切换问题、推理循环、安全性考虑、其他能力方面的差异。',
+    displayName: 'QwQ 32B Preview',
     id: 'Qwen/QwQ-32B-Preview',
     pricing: {
       currency: 'CNY',

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

@@ -0,0 +1,114 @@
+import { LobeRuntimeAI } from '../BaseAI';
+import { LobeOpenAI } from '../openai';
+import { providerRuntimeMap } from '../runtimeMap';
+import {
+  ChatCompetitionOptions,
+  type ChatCompletionErrorPayload,
+  ChatStreamPayload,
+  EmbeddingsOptions,
+  EmbeddingsPayload,
+  TextToImagePayload,
+  TextToSpeechPayload,
+} from '../types';
+
+export interface RuntimeItem {
+  id: string;
+  models?: string[];
+  runtime: LobeRuntimeAI;
+}
+
+interface ProviderInitParams extends Record<string, any> {
+  accessKeyId?: string;
+  accessKeySecret?: string;
+  apiKey?: string;
+  apiVersion?: string;
+  baseURL?: string;
+  baseURLOrAccountID?: string;
+  dangerouslyAllowBrowser?: boolean;
+  region?: string;
+  sessionToken?: string;
+}
+
+interface ProviderInstance {
+  apiType: keyof typeof providerRuntimeMap;
+  models?: string[];
+  params: ProviderInitParams;
+  runtime?: typeof LobeOpenAI;
+}
+
+interface UniformRuntimeOptions {
+  chat?: {
+    handleError?: (error: any) => Omit<ChatCompletionErrorPayload, 'provider'> | undefined;
+  };
+}
+
+class UniformRuntime {
+  private _runtimes: RuntimeItem[];
+  private _options: UniformRuntimeOptions;
+
+  constructor(id: string, providers: ProviderInstance[], options: UniformRuntimeOptions) {
+    if (providers.length === 0) {
+      throw new Error('empty providers');
+    }
+
+    this._runtimes = providers.map((options) => {
+      const providerAI = options.runtime ?? providerRuntimeMap[options.apiType] ?? LobeOpenAI;
+      const runtime: LobeRuntimeAI = new providerAI({ ...options.params, id });
+
+      return { id: options.apiType, models: options.models, runtime };
+    });
+
+    this._options = options;
+  }
+
+  // 检查下是否能匹配到特定模型，否则默认使用第一个 runtime
+  getRuntimeByModel(model: string) {
+    const runtimeItem =
+      this._runtimes.find((runtime) => runtime.models && runtime.models.includes(model)) ||
+      this._runtimes[0];
+
+    return runtimeItem.runtime;
+  }
+
+  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
+    try {
+      const runtime = this.getRuntimeByModel(payload.model);
+
+      return await runtime.chat(payload, options);
+    } catch (e) {
+      if (this._options.chat?.handleError) {
+        const error = this._options.chat.handleError(e);
+
+        if (error) {
+          throw error;
+        }
+      }
+
+      throw e;
+    }
+  }
+
+  async textToImage(payload: TextToImagePayload) {
+    const runtime = this.getRuntimeByModel(payload.model);
+
+    return runtime.textToImage?.(payload);
+  }
+
+  async models() {
+    return this._runtimes[0].runtime.models?.();
+  }
+
+  async embeddings(payload: EmbeddingsPayload, options?: EmbeddingsOptions) {
+    const runtime = this.getRuntimeByModel(payload.model);
+
+    return runtime.embeddings?.(payload, options);
+  }
+
+  async textToSpeech(payload: TextToSpeechPayload, options?: EmbeddingsOptions) {
+    const runtime = this.getRuntimeByModel(payload.model);
+
+    return runtime.textToSpeech?.(payload, options);
+  }
+}
+
+export default UniformRuntime;

package/src/libs/agent-runtime/anthropic/handleAnthropicError.ts

@@ -0,0 +1,15 @@
+export const handleAnthropicError = (error: any) => {
+  let errorResult: any = error;
+
+  if (error.error) {
+    errorResult = error.error;
+
+    if ('error' in errorResult) {
+      errorResult = errorResult.error;
+    }
+  } else {
+    errorResult = { headers: error.headers, stack: error.stack, status: error.status };
+  }
+
+  return { errorResult };
+};

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

@@ -44,6 +44,15 @@ describe('LobeAnthropicAI', () => {
       expect(instance).toBeInstanceOf(LobeAnthropicAI);
       expect(instance.baseURL).toBe('https://api.anthropic.proxy');
     });
+
+    it('should correctly initialize with different id', async () => {
+      const instance = new LobeAnthropicAI({
+        apiKey: 'test_api_key',
+        id: 'abc',
+      });
+      expect(instance).toBeInstanceOf(LobeAnthropicAI);
+      expect(instance['id']).toBe('abc');
+    });
   });
 
   describe('chat', () => {
@@ -347,7 +356,7 @@ describe('LobeAnthropicAI', () => {
           // Assert
           expect(e).toEqual({
             endpoint: 'https://api.anthropic.com',
-            error: apiError,
+            error: apiError.error.error,
             errorType: bizErrorType,
             provider,
           });

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

@@ -2,18 +2,23 @@
 import '@anthropic-ai/sdk/shims/web';
 import Anthropic from '@anthropic-ai/sdk';
 import { ClientOptions } from 'openai';
+import type { ChatModelCard } from '@/types/llm';
 
 import { LobeRuntimeAI } from '../BaseAI';
 import { AgentRuntimeErrorType } from '../error';
-import { ChatCompetitionOptions, ChatStreamPayload, ModelProvider } from '../types';
+import {
+  ChatCompetitionOptions,
+  type ChatCompletionErrorPayload,
+  ChatStreamPayload,
+  ModelProvider,
+} from '../types';
 import { AgentRuntimeError } from '../utils/createError';
 import { debugStream } from '../utils/debugStream';
 import { desensitizeUrl } from '../utils/desensitizeUrl';
 import { buildAnthropicMessages, buildAnthropicTools } from '../utils/anthropicHelpers';
 import { StreamingResponse } from '../utils/response';
 import { AnthropicStream } from '../utils/streams';
-
-import type { ChatModelCard } from '@/types/llm';
+import { handleAnthropicError } from './handleAnthropicError';
 
 export interface AnthropicModelCard {
   display_name: string;
@@ -22,18 +27,24 @@ export interface AnthropicModelCard {
 
 const DEFAULT_BASE_URL = 'https://api.anthropic.com';
 
+interface AnthropicAIParams extends ClientOptions {
+  id?: string;
+}
+
 export class LobeAnthropicAI implements LobeRuntimeAI {
   private client: Anthropic;
 
   baseURL: string;
   apiKey?: string;
+  private id: string;
 
-  constructor({ apiKey, baseURL = DEFAULT_BASE_URL, ...res }: ClientOptions = {}) {
+  constructor({ apiKey, baseURL = DEFAULT_BASE_URL, id, ...res }: AnthropicAIParams = {}) {
     if (!apiKey) throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey);
 
     this.client = new Anthropic({ apiKey, baseURL, ...res });
     this.baseURL = this.client.baseURL;
     this.apiKey = apiKey;
+    this.id = id || ModelProvider.Anthropic;
   }
 
   async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
@@ -57,42 +68,7 @@ export class LobeAnthropicAI implements LobeRuntimeAI {
         headers: options?.headers,
       });
     } catch (error) {
-      let desensitizedEndpoint = this.baseURL;
-
-      if (this.baseURL !== DEFAULT_BASE_URL) {
-        desensitizedEndpoint = desensitizeUrl(this.baseURL);
-      }
-
-      if ('status' in (error as any)) {
-        switch ((error as Response).status) {
-          case 401: {
-            throw AgentRuntimeError.chat({
-              endpoint: desensitizedEndpoint,
-              error: error as any,
-              errorType: AgentRuntimeErrorType.InvalidProviderAPIKey,
-              provider: ModelProvider.Anthropic,
-            });
-          }
-
-          case 403: {
-            throw AgentRuntimeError.chat({
-              endpoint: desensitizedEndpoint,
-              error: error as any,
-              errorType: AgentRuntimeErrorType.LocationNotSupportError,
-              provider: ModelProvider.Anthropic,
-            });
-          }
-          default: {
-            break;
-          }
-        }
-      }
-      throw AgentRuntimeError.chat({
-        endpoint: desensitizedEndpoint,
-        error: error as any,
-        errorType: AgentRuntimeErrorType.ProviderBizError,
-        provider: ModelProvider.Anthropic,
-      });
+      throw this.handleError(error);
     }
   }
 
@@ -191,6 +167,48 @@ export class LobeAnthropicAI implements LobeRuntimeAI {
       })
       .filter(Boolean) as ChatModelCard[];
   }
+
+  private handleError(error: any): ChatCompletionErrorPayload {
+    let desensitizedEndpoint = this.baseURL;
+
+    if (this.baseURL !== DEFAULT_BASE_URL) {
+      desensitizedEndpoint = desensitizeUrl(this.baseURL);
+    }
+
+    if ('status' in (error as any)) {
+      switch ((error as Response).status) {
+        case 401: {
+          throw AgentRuntimeError.chat({
+            endpoint: desensitizedEndpoint,
+            error: error as any,
+            errorType: AgentRuntimeErrorType.InvalidProviderAPIKey,
+            provider: this.id,
+          });
+        }
+
+        case 403: {
+          throw AgentRuntimeError.chat({
+            endpoint: desensitizedEndpoint,
+            error: error as any,
+            errorType: AgentRuntimeErrorType.LocationNotSupportError,
+            provider: this.id,
+          });
+        }
+        default: {
+          break;
+        }
+      }
+    }
+
+    const { errorResult } = handleAnthropicError(error);
+
+    throw AgentRuntimeError.chat({
+      endpoint: desensitizedEndpoint,
+      error: errorResult,
+      errorType: AgentRuntimeErrorType.ProviderBizError,
+      provider: this.id,
+    });
+  }
 }
 
 export default LobeAnthropicAI;

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

@@ -13,10 +13,16 @@ import { transformResponseToStream } from '../utils/openaiCompatibleFactory';
 import { StreamingResponse } from '../utils/response';
 import { OpenAIStream, createSSEDataExtractor } from '../utils/streams';
 
+interface AzureAIParams {
+  apiKey?: string;
+  apiVersion?: string;
+  baseURL?: string;
+}
+
 export class LobeAzureAI implements LobeRuntimeAI {
   client: ModelClient;
 
-  constructor(params?: { apiKey?: string; apiVersion?: string; baseURL?: string }) {
+  constructor(params?: AzureAIParams) {
     if (!params?.apiKey || !params?.baseURL)
       throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey);
 

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

@@ -1,9 +1,9 @@
+import type { ChatModelCard } from '@/types/llm';
+
 import { AgentRuntimeErrorType } from '../error';
-import { pruneReasoningPayload } from '../openai';
 import { ModelProvider } from '../types';
 import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
-
-import type { ChatModelCard } from '@/types/llm';
+import { pruneReasoningPayload } from '../utils/openaiHelpers';
 
 export interface GithubModelCard {
   description: string;
@@ -39,27 +39,20 @@ export const LobeGithubAI = LobeOpenAICompatibleFactory({
   models: async ({ client }) => {
     const { LOBE_DEFAULT_MODEL_LIST } = await import('@/config/aiModels');
 
-    const functionCallKeywords = [
-      'function',
-      'tool',
-    ];
+    const functionCallKeywords = ['function', 'tool'];
 
-    const visionKeywords = [
-      'vision',
-    ];
+    const visionKeywords = ['vision'];
 
-    const reasoningKeywords = [
-      'deepseek-r1',
-      'o1',
-      'o3',
-    ];
+    const reasoningKeywords = ['deepseek-r1', 'o1', 'o3'];
 
     const modelsPage = (await client.models.list()) as any;
     const modelList: GithubModelCard[] = modelsPage.body;
 
     return modelList
       .map((model) => {
-        const knownModel = LOBE_DEFAULT_MODEL_LIST.find((m) => model.name.toLowerCase() === m.id.toLowerCase());
+        const knownModel = LOBE_DEFAULT_MODEL_LIST.find(
+          (m) => model.name.toLowerCase() === m.id.toLowerCase(),
+        );
 
         return {
           contextWindowTokens: knownModel?.contextWindowTokens ?? undefined,
@@ -67,18 +60,20 @@ export const LobeGithubAI = LobeOpenAICompatibleFactory({
           displayName: model.friendly_name,
           enabled: knownModel?.enabled || false,
           functionCall:
-            functionCallKeywords.some(keyword => model.description.toLowerCase().includes(keyword))
-            || knownModel?.abilities?.functionCall
-            || false,
+            functionCallKeywords.some((keyword) =>
+              model.description.toLowerCase().includes(keyword),
+            ) ||
+            knownModel?.abilities?.functionCall ||
+            false,
           id: model.name,
           reasoning:
-            reasoningKeywords.some(keyword => model.name.toLowerCase().includes(keyword))
-            || knownModel?.abilities?.reasoning
-            || false,
+            reasoningKeywords.some((keyword) => model.name.toLowerCase().includes(keyword)) ||
+            knownModel?.abilities?.reasoning ||
+            false,
           vision:
-            visionKeywords.some(keyword => model.description.toLowerCase().includes(keyword))
-            || knownModel?.abilities?.vision
-            || false,
+            visionKeywords.some((keyword) => model.description.toLowerCase().includes(keyword)) ||
+            knownModel?.abilities?.vision ||
+            false,
         };
       })
       .filter(Boolean) as ChatModelCard[];

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

@@ -19,6 +19,8 @@ export { LobeQwenAI } from './qwen';
 export { LobeTogetherAI } from './togetherai';
 export * from './types';
 export { AgentRuntimeError } from './utils/createError';
+export { LobeOpenAICompatibleFactory } from './utils/openaiCompatibleFactory';
+export { pruneReasoningPayload } from './utils/openaiHelpers';
 export { LobeVolcengineAI } from './volcengine';
 export { LobeZeroOneAI } from './zeroone';
 export { LobeZhipuAI } from './zhipu';

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

@@ -1,33 +1,13 @@
-import { disableStreamModels, systemToUserModels } from '@/const/models';
 import type { ChatModelCard } from '@/types/llm';
 
-import { ChatStreamPayload, ModelProvider, OpenAIChatMessage } from '../types';
+import { ModelProvider } from '../types';
 import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
+import { pruneReasoningPayload } from '../utils/openaiHelpers';
 
 export interface OpenAIModelCard {
   id: string;
 }
 
-export const pruneReasoningPayload = (payload: ChatStreamPayload) => {
-  return {
-    ...payload,
-    frequency_penalty: 0,
-    messages: payload.messages.map((message: OpenAIChatMessage) => ({
-      ...message,
-      role:
-        message.role === 'system'
-          ? systemToUserModels.has(payload.model)
-            ? 'user'
-            : 'developer'
-          : message.role,
-    })),
-    presence_penalty: 0,
-    stream: !disableStreamModels.has(payload.model),
-    temperature: 1,
-    top_p: 1,
-  };
-};
-
 export const LobeOpenAI = LobeOpenAICompatibleFactory({
   baseURL: 'https://api.openai.com/v1',
   chatCompletion: {

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

@@ -13,7 +13,7 @@ export interface ChatCompletionErrorPayload {
   endpoint?: string;
   error: object;
   errorType: ILobeAgentRuntimeErrorType;
-  provider: ModelProvider;
+  provider: string;
 }
 
 export interface CreateChatCompletionOptions {

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

@@ -168,6 +168,8 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
   return class LobeOpenAICompatibleAI implements LobeRuntimeAI {
     client!: OpenAI;
 
+    private id: string;
+
     baseURL!: string;
     protected _options: ConstructorOptions<T>;
 
@@ -192,6 +194,8 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
       }
 
       this.baseURL = baseURL || this.client.baseURL;
+
+      this.id = options.id || provider;
     }
 
     async chat({ responseMode, ...payload }: ChatStreamPayload, options?: ChatCompetitionOptions) {
@@ -210,7 +214,7 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
         const streamOptions: OpenAIStreamOptions = {
           bizErrorTypeTransformer: chatCompletion?.handleStreamBizErrorType,
           callbacks: options?.callback,
-          provider,
+          provider: this.id,
         };
 
         if (customClient?.createChatCompletionStream) {
@@ -368,7 +372,7 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
         if (errorResult)
           return AgentRuntimeError.chat({
             ...errorResult,
-            provider,
+            provider: this.id,
           } as ChatCompletionErrorPayload);
       }
 
@@ -379,7 +383,7 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
               endpoint: desensitizedEndpoint,
               error: error as any,
               errorType: ErrorType.invalidAPIKey,
-              provider: provider as ModelProvider,
+              provider: this.id as ModelProvider,
             });
           }
 
@@ -397,7 +401,7 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
             endpoint: desensitizedEndpoint,
             error: errorResult,
             errorType: AgentRuntimeErrorType.InsufficientQuota,
-            provider: provider as ModelProvider,
+            provider: this.id as ModelProvider,
           });
         }
 
@@ -406,7 +410,7 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
             endpoint: desensitizedEndpoint,
             error: errorResult,
             errorType: AgentRuntimeErrorType.ModelNotFound,
-            provider: provider as ModelProvider,
+            provider: this.id as ModelProvider,
           });
         }
 
@@ -417,7 +421,7 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
             endpoint: desensitizedEndpoint,
             error: errorResult,
             errorType: AgentRuntimeErrorType.ExceededContextWindow,
-            provider: provider as ModelProvider,
+            provider: this.id as ModelProvider,
           });
         }
       }
@@ -426,7 +430,7 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
         endpoint: desensitizedEndpoint,
         error: errorResult,
         errorType: RuntimeError || ErrorType.bizError,
-        provider: provider as ModelProvider,
+        provider: this.id as ModelProvider,
       });
     }
   };