@lobehub/chat 1.106.8 → 1.107.0

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/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',
       },