@lobehub/chat 1.106.7 → 1.107.0

package/src/config/modelProviders/index.ts

@@ -2,6 +2,7 @@ import { ChatModelCard, ModelProviderCard } from '@/types/llm';
 
 import Ai21Provider from './ai21';
 import Ai360Provider from './ai360';
+import AiHubMixProvider from './aihubmix';
 import AnthropicProvider from './anthropic';
 import AzureProvider from './azure';
 import AzureAIProvider from './azureai';
@@ -94,6 +95,7 @@ export const LOBE_DEFAULT_MODEL_LIST: ChatModelCard[] = [
   TaichuProvider.chatModels,
   CloudflareProvider.chatModels,
   Ai360Provider.chatModels,
+  AiHubMixProvider.chatModels,
   SiliconCloudProvider.chatModels,
   GiteeAIProvider.chatModels,
   UpstageProvider.chatModels,
@@ -163,6 +165,7 @@ export const DEFAULT_MODEL_PROVIDER_LIST = [
   GiteeAIProvider,
   TaichuProvider,
   Ai360Provider,
+  AiHubMixProvider,
   Search1APIProvider,
   InfiniAIProvider,
   QiniuProvider,
@@ -179,6 +182,7 @@ export const isProviderDisableBrowserRequest = (id: string) => {
 
 export { default as Ai21ProviderCard } from './ai21';
 export { default as Ai360ProviderCard } from './ai360';
+export { default as AiHubMixProviderCard } from './aihubmix';
 export { default as AnthropicProviderCard } from './anthropic';
 export { default as AzureProviderCard } from './azure';
 export { default as AzureAIProviderCard } from './azureai';

package/src/libs/model-runtime/ModelRuntime.test.ts

@@ -6,10 +6,10 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import * as langfuseCfg from '@/config/langfuse';
 import { ClientSecretPayload } from '@/const/auth';
 import { TraceNameMap } from '@/const/trace';
-import { AgentRuntime, ChatStreamPayload, LobeOpenAI, ModelProvider } from '@/libs/model-runtime';
+import { ChatStreamPayload, LobeOpenAI, ModelProvider, ModelRuntime } from '@/libs/model-runtime';
 import { providerRuntimeMap } from '@/libs/model-runtime/runtimeMap';
 import { CreateImagePayload } from '@/libs/model-runtime/types/image';
-import { createTraceOptions } from '@/server/modules/AgentRuntime';
+import { createTraceOptions } from '@/server/modules/ModelRuntime';
 
 import { AgentChatOptions } from './ModelRuntime';
 
@@ -52,7 +52,7 @@ const testRuntime = (providerId: string, payload?: any) => {
   describe(`${providerId} provider runtime`, () => {
     it('should initialize correctly', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-key', ...payload };
-      const runtime = await AgentRuntime.initializeWithProvider(providerId, jwtPayload);
+      const runtime = await ModelRuntime.initializeWithProvider(providerId, jwtPayload);
 
       // @ts-ignore
       expect(runtime['_runtime']).toBeInstanceOf(providerRuntimeMap[providerId]);
@@ -64,16 +64,15 @@ const testRuntime = (providerId: string, payload?: any) => {
   });
 };
 
-let mockModelRuntime: AgentRuntime;
+let mockModelRuntime: ModelRuntime;
 beforeEach(async () => {
   const jwtPayload: ClientSecretPayload = { apiKey: 'user-openai-key', baseURL: 'user-endpoint' };
-  mockModelRuntime = await AgentRuntime.initializeWithProvider(ModelProvider.OpenAI, jwtPayload);
+  mockModelRuntime = await ModelRuntime.initializeWithProvider(ModelProvider.OpenAI, jwtPayload);
 });
 
-describe('AgentRuntime', () => {
+describe('ModelRuntime', () => {
   describe('should initialize with various providers', () => {
     const providers = Object.values(ModelProvider).filter((i) => i !== 'lobehub');
-
     const specialProviderIds = [ModelProvider.VertexAI, ...specialProviders.map((p) => p.id)];
 
     const generalTestProviders = providers.filter(
@@ -87,7 +86,7 @@ describe('AgentRuntime', () => {
     specialProviders.forEach(({ id, payload }) => testRuntime(id, payload));
   });
 
-  describe('AgentRuntime chat method', () => {
+  describe('ModelRuntime chat method', () => {
     it('should run correctly', async () => {
       const payload: ChatStreamPayload = {
         messages: [{ role: 'user', content: 'Hello, world!' }],
@@ -243,7 +242,7 @@ describe('AgentRuntime', () => {
     });
   });
 
-  describe('AgentRuntime createImage method', () => {
+  describe('ModelRuntime createImage method', () => {
     it('should run correctly', async () => {
       const payload: CreateImagePayload = {
         model: 'dall-e-3',
@@ -292,7 +291,7 @@ describe('AgentRuntime', () => {
     });
   });
 
-  describe('AgentRuntime models method', () => {
+  describe('ModelRuntime models method', () => {
     it('should run correctly', async () => {
       const mockModels = [
         { id: 'gpt-4', name: 'GPT-4' },

package/src/libs/model-runtime/ModelRuntime.ts

@@ -25,7 +25,7 @@ export interface AgentChatOptions {
   trace?: TracePayload;
 }
 
-class ModelRuntime {
+export class ModelRuntime {
   private _runtime: LobeRuntimeAI;
 
   constructor(runtime: LobeRuntimeAI) {
@@ -113,10 +113,9 @@ class ModelRuntime {
   ) {
     // @ts-expect-error runtime map not include vertex so it will be undefined
     const providerAI = providerRuntimeMap[provider] ?? LobeOpenAI;
+
     const runtimeModel: LobeRuntimeAI = new providerAI(params);
 
     return new ModelRuntime(runtimeModel);
   }
 }
-
-export default ModelRuntime;

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

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

package/src/libs/model-runtime/RouterRuntime/createRuntime.ts

@@ -0,0 +1,193 @@
+/**
+ * @see https://github.com/lobehub/lobe-chat/discussions/6563
+ */
+import OpenAI, { ClientOptions } from 'openai';
+import { Stream } from 'openai/streaming';
+
+import { ILobeAgentRuntimeErrorType } from '@/libs/model-runtime';
+import { CreateImagePayload, CreateImageResponse } from '@/libs/model-runtime/types/image';
+import {
+  CreateImageOptions,
+  CustomClientOptions,
+} from '@/libs/model-runtime/utils/openaiCompatibleFactory';
+import type { ChatModelCard } from '@/types/llm';
+
+import { LobeRuntimeAI } from '../BaseAI';
+import { LobeOpenAI } from '../openai';
+import {
+  type ChatCompletionErrorPayload,
+  ChatMethodOptions,
+  ChatStreamCallbacks,
+  ChatStreamPayload,
+  EmbeddingsOptions,
+  EmbeddingsPayload,
+  TextToImagePayload,
+  TextToSpeechPayload,
+} from '../types';
+import { baseRuntimeMap } from './baseRuntimeMap';
+
+export interface RuntimeItem {
+  id: string;
+  models?: string[];
+  runtime: LobeRuntimeAI;
+}
+
+interface ProviderIniOptions extends Record<string, any> {
+  accessKeyId?: string;
+  accessKeySecret?: string;
+  apiKey?: string;
+  apiVersion?: string;
+  baseURL?: string;
+  baseURLOrAccountID?: string;
+  dangerouslyAllowBrowser?: boolean;
+  region?: string;
+  sessionToken?: string;
+}
+
+interface RouterInstance {
+  apiType: keyof typeof baseRuntimeMap;
+  models?: string[];
+  options: ProviderIniOptions;
+  runtime?: typeof LobeOpenAI;
+}
+
+type ConstructorOptions<T extends Record<string, any> = any> = ClientOptions & T;
+
+interface CreateRouterRuntimeOptions<T extends Record<string, any> = any> {
+  apiKey?: string;
+  chatCompletion?: {
+    excludeUsage?: boolean;
+    handleError?: (
+      error: any,
+      options: ConstructorOptions<T>,
+    ) => Omit<ChatCompletionErrorPayload, 'provider'> | undefined;
+    handlePayload?: (
+      payload: ChatStreamPayload,
+      options: ConstructorOptions<T>,
+    ) => OpenAI.ChatCompletionCreateParamsStreaming;
+    handleStream?: (
+      stream: Stream<OpenAI.ChatCompletionChunk> | ReadableStream,
+      { callbacks, inputStartAt }: { callbacks?: ChatStreamCallbacks; inputStartAt?: number },
+    ) => ReadableStream;
+    handleStreamBizErrorType?: (error: {
+      message: string;
+      name: string;
+    }) => ILobeAgentRuntimeErrorType | undefined;
+    handleTransformResponseToStream?: (
+      data: OpenAI.ChatCompletion,
+    ) => ReadableStream<OpenAI.ChatCompletionChunk>;
+    noUserId?: boolean;
+  };
+  constructorOptions?: ConstructorOptions<T>;
+  createImage?: (
+    payload: CreateImagePayload,
+    options: CreateImageOptions,
+  ) => Promise<CreateImageResponse>;
+  customClient?: CustomClientOptions<T>;
+  debug?: {
+    chatCompletion: () => boolean;
+    responses?: () => boolean;
+  };
+  errorType?: {
+    bizError: ILobeAgentRuntimeErrorType;
+    invalidAPIKey: ILobeAgentRuntimeErrorType;
+  };
+  id: string;
+  models?:
+    | ((params: { client: OpenAI }) => Promise<ChatModelCard[]>)
+    | {
+        transformModel?: (model: OpenAI.Model) => ChatModelCard;
+      };
+  responses?: {
+    handlePayload?: (
+      payload: ChatStreamPayload,
+      options: ConstructorOptions<T>,
+    ) => ChatStreamPayload;
+  };
+  routers: RouterInstance[];
+}
+
+export const createRouterRuntime = ({
+  id,
+  routers,
+  apiKey: DEFAULT_API_LEY,
+  ...params
+}: CreateRouterRuntimeOptions) => {
+  return class UniformRuntime implements LobeRuntimeAI {
+    private _runtimes: RuntimeItem[];
+    private _options: ClientOptions & Record<string, any>;
+
+    constructor(options: ClientOptions & Record<string, any> = {}) {
+      const _options = {
+        ...options,
+        apiKey: options.apiKey?.trim() || DEFAULT_API_LEY,
+        baseURL: options.baseURL?.trim(),
+      };
+
+      if (routers.length === 0) {
+        throw new Error('empty providers');
+      }
+
+      this._runtimes = routers.map((router) => {
+        const providerAI = router.runtime ?? baseRuntimeMap[router.apiType] ?? LobeOpenAI;
+
+        const finalOptions = { ...router.options, ...options };
+        // @ts-ignore
+        const runtime: LobeRuntimeAI = new providerAI({ ...params, ...finalOptions, id });
+
+        return { id: router.apiType, models: router.models, runtime };
+      });
+
+      this._options = _options;
+    }
+
+    // 检查下是否能匹配到特定模型，否则默认使用最后一个 runtime
+    getRuntimeByModel(model: string) {
+      const runtimeItem =
+        this._runtimes.find((runtime) => runtime.models && runtime.models.includes(model)) ||
+        this._runtimes.at(-1)!;
+
+      return runtimeItem.runtime;
+    }
+
+    async chat(payload: ChatStreamPayload, options?: ChatMethodOptions) {
+      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);
+    }
+  };
+};

package/src/libs/model-runtime/RouterRuntime/index.ts

@@ -0,0 +1,9 @@
+import { LobeRuntimeAI } from '../BaseAI';
+
+export interface RuntimeItem {
+  id: string;
+  models?: string[];
+  runtime: LobeRuntimeAI;
+}
+
+export { createRouterRuntime } from './createRuntime';

package/src/libs/model-runtime/aihubmix/index.ts

@@ -0,0 +1,118 @@
+import urlJoin from 'url-join';
+
+import { LOBE_DEFAULT_MODEL_LIST } from '@/config/aiModels';
+import AiHubMixModels from '@/config/aiModels/aihubmix';
+import type { ChatModelCard } from '@/types/llm';
+
+import { createRouterRuntime } from '../RouterRuntime';
+import { ModelProvider } from '../types';
+
+export interface AiHubMixModelCard {
+  created: number;
+  id: string;
+  object: string;
+  owned_by: string;
+}
+
+const baseURL = 'https://aihubmix.com';
+
+export const LobeAiHubMixAI = createRouterRuntime({
+  constructorOptions: {
+    defaultHeaders: {
+      'APP-Code': 'LobeHub',
+    },
+  },
+  debug: {
+    chatCompletion: () => process.env.DEBUG_AIHUBMIX_CHAT_COMPLETION === '1',
+  },
+  id: ModelProvider.AiHubMix,
+  models: async ({ client }) => {
+    const functionCallKeywords = [
+      'gpt-4',
+      'gpt-3.5',
+      'claude',
+      'gemini',
+      'qwen',
+      'deepseek',
+      'llama',
+    ];
+
+    const visionKeywords = [
+      'gpt-4o',
+      'gpt-4-vision',
+      'claude-3',
+      'claude-4',
+      'gemini-pro-vision',
+      'qwen-vl',
+      'llava',
+    ];
+
+    const reasoningKeywords = [
+      'o1',
+      'deepseek-r1',
+      'qwq',
+      'claude-opus-4',
+      'claude-sonnet-4',
+      'claude-3-5-sonnet',
+      'claude-3-5-haiku',
+    ];
+
+    try {
+      const modelsPage = (await client.models.list()) as any;
+      const modelList: AiHubMixModelCard[] = modelsPage.data || [];
+
+      return modelList
+        .map((model) => {
+          const knownModel = AiHubMixModels.find(
+            (m) => model.id.toLowerCase() === m.id.toLowerCase(),
+          );
+
+          const modelId = model.id.toLowerCase();
+
+          return {
+            contextWindowTokens: knownModel?.contextWindowTokens ?? undefined,
+            displayName: knownModel?.displayName ?? model.id,
+            enabled: knownModel?.enabled || false,
+            functionCall:
+              functionCallKeywords.some((keyword) => modelId.includes(keyword)) ||
+              knownModel?.abilities?.functionCall ||
+              false,
+            id: model.id,
+            reasoning:
+              reasoningKeywords.some((keyword) => modelId.includes(keyword)) ||
+              knownModel?.abilities?.reasoning ||
+              false,
+            vision:
+              visionKeywords.some((keyword) => modelId.includes(keyword)) ||
+              knownModel?.abilities?.vision ||
+              false,
+          };
+        })
+        .filter(Boolean) as ChatModelCard[];
+    } catch (error) {
+      console.warn(
+        'Failed to fetch AiHubMix models. Please ensure your AiHubMix API key is valid:',
+        error,
+      );
+      return [];
+    }
+  },
+  routers: [
+    {
+      apiType: 'anthropic',
+      models: LOBE_DEFAULT_MODEL_LIST.map((m) => m.id).filter(
+        (id) => id.startsWith('claude') || id.startsWith('kimi-k2'),
+      ),
+      options: { baseURL },
+    },
+    {
+      apiType: 'google',
+      models: LOBE_DEFAULT_MODEL_LIST.map((m) => m.id).filter((id) => id.startsWith('gemini')),
+      options: { baseURL: urlJoin(baseURL, '/gemini') },
+    },
+    {
+      apiType: 'openai',
+      options: { baseURL: urlJoin(baseURL, '/v1') },
+    },
+  ],
+});

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

@@ -10,7 +10,7 @@ export { LobeGroq } from './groq';
 export * from './helpers';
 export { LobeMinimaxAI } from './minimax';
 export { LobeMistralAI } from './mistral';
-export { default as AgentRuntime } from './ModelRuntime';
+export { ModelRuntime } from './ModelRuntime';
 export { LobeMoonshotAI } from './moonshot';
 export { LobeOllamaAI } from './ollama';
 export { LobeOpenAI } from './openai';

package/src/libs/model-runtime/openrouter/index.ts

@@ -49,8 +49,8 @@ export const LobeOpenRouterAI = createOpenAICompatibleRuntime({
   },
   constructorOptions: {
     defaultHeaders: {
-      'HTTP-Referer': 'https://chat-preview.lobehub.com',
-      'X-Title': 'Lobe Chat',
+      'HTTP-Referer': 'https://lobehub.com',
+      'X-Title': 'LobeHub',
     },
   },
   debug: {

package/src/libs/model-runtime/runtimeMap.ts

@@ -1,5 +1,6 @@
 import { LobeAi21AI } from './ai21';
 import { LobeAi360AI } from './ai360';
+import { LobeAiHubMixAI } from './aihubmix';
 import { LobeAnthropicAI } from './anthropic';
 import { LobeAzureOpenAI } from './azureOpenai';
 import { LobeAzureAI } from './azureai';
@@ -56,6 +57,7 @@ import { LobeZhipuAI } from './zhipu';
 export const providerRuntimeMap = {
   ai21: LobeAi21AI,
   ai360: LobeAi360AI,
+  aihubmix: LobeAiHubMixAI,
   anthropic: LobeAnthropicAI,
   azure: LobeAzureOpenAI,
   azureai: LobeAzureAI,

package/src/libs/model-runtime/sensenova/index.ts

@@ -12,7 +12,7 @@ export const LobeSenseNovaAI = createOpenAICompatibleRuntime({
   baseURL: 'https://api.sensenova.cn/compatible-mode/v1',
   chatCompletion: {
     handlePayload: (payload) => {
-      const { frequency_penalty, max_tokens, messages, model, temperature, top_p, ...rest } =
+      const { frequency_penalty, max_tokens, messages, model, temperature, thinking, top_p, ...rest } =
         payload;
 
       return {
@@ -33,6 +33,9 @@ export const LobeSenseNovaAI = createOpenAICompatibleRuntime({
           temperature !== undefined && temperature > 0 && temperature <= 2
             ? temperature
             : undefined,
+        thinking: thinking 
+          ? (model && model.includes('-V6-5-') && thinking.type === 'enabled' ? { enabled: true } : { enabled: false })
+          : undefined,
         top_p: top_p !== undefined && top_p > 0 && top_p < 1 ? top_p : undefined,
       } as any;
     },

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

@@ -30,6 +30,7 @@ export interface CreateChatCompletionOptions {
 export enum ModelProvider {
   Ai21 = 'ai21',
   Ai360 = 'ai360',
+  AiHubMix = 'aihubmix',
   Anthropic = 'anthropic',
   Azure = 'azure',
   AzureAI = 'azureai',

package/src/locales/default/modelProvider.ts

@@ -192,6 +192,7 @@ export default {
       aesGcm: '您的秘钥与代理地址等将使用 <1>AES-GCM</1> 加密算法进行加密',
       apiKey: {
         desc: '请填写你的 {{name}} API Key',
+        descWithUrl: '请填写你的 {{name}} API Key，<3>点此获取</3>',
         placeholder: '{{name}} API Key',
         title: 'API Key',
       },