@lobehub/chat 1.106.8 → 1.107.1

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/libs/trpc/client/async.ts

@@ -9,7 +9,8 @@ export const asyncClient = createTRPCClient<AsyncRouter>({
   links: [
     httpBatchLink({
       fetch: isDesktop
-        ? (input, init) => fetchWithDesktopRemoteRPC(input as string, init)
+        ? // eslint-disable-next-line no-undef
+          (input, init) => fetchWithDesktopRemoteRPC(input as string, init as RequestInit)
         : undefined,
       maxURLLength: 2083,
       transformer: superjson,

package/src/libs/trpc/client/edge.ts

@@ -10,7 +10,8 @@ export const edgeClient = createTRPCClient<EdgeRouter>({
   links: [
     httpBatchLink({
       fetch: isDesktop
-        ? (input, init) => fetchWithDesktopRemoteRPC(input as string, init)
+        ? // eslint-disable-next-line no-undef
+          (input, init) => fetchWithDesktopRemoteRPC(input as string, init as RequestInit)
         : undefined,
       headers: async () => {
         // dynamic import to avoid circular dependency

package/src/libs/trpc/client/lambda.ts

@@ -17,12 +17,14 @@ const links = [
       if (isDesktop) {
         const { desktopRemoteRPCFetch } = await import('@/utils/electron/desktopRemoteRPCFetch');
 
-        const res = await desktopRemoteRPCFetch(input as string, init);
+        // eslint-disable-next-line no-undef
+        const res = await desktopRemoteRPCFetch(input as string, init as RequestInit);
 
         if (res) return res;
       }
 
-      const response = await fetch(input, init);
+      // eslint-disable-next-line no-undef
+      const response = await fetch(input, init as RequestInit);
 
       if (response.ok) return response;
 

package/src/libs/trpc/client/tools.ts

@@ -9,7 +9,8 @@ export const toolsClient = createTRPCClient<ToolsRouter>({
   links: [
     httpBatchLink({
       fetch: isDesktop
-        ? (input, init) => fetchWithDesktopRemoteRPC(input as string, init)
+        ? // eslint-disable-next-line no-undef
+          (input, init) => fetchWithDesktopRemoteRPC(input as string, init as RequestInit)
         : undefined,
       headers: async () => {
         // dynamic import to avoid circular dependency

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

package/src/server/modules/{AgentRuntime → ModelRuntime}/index.test.ts

@@ -23,10 +23,10 @@ import {
   LobeZhipuAI,
   ModelProvider,
 } from '@/libs/model-runtime';
-import { AgentRuntime } from '@/libs/model-runtime';
+import { ModelRuntime } from '@/libs/model-runtime';
 import { LobeStepfunAI } from '@/libs/model-runtime/stepfun';
 
-import { initAgentRuntimeWithUserPayload } from './index';
+import { initModelRuntimeWithUserPayload } from './index';
 
 // 模拟依赖项
 vi.mock('@/config/llm', () => ({
@@ -59,20 +59,17 @@ vi.mock('@/config/llm', () => ({
 }));
 
 /**
- * Test cases for function initAgentRuntimeWithUserPayload
- * this method will use AgentRuntime from `@/libs/model-runtime`
+ * Test cases for function initModelRuntimeWithUserPayload
+ * this method will use ModelRuntime from `@/libs/model-runtime`
  * and method `getLlmOptionsFromPayload` to initialize runtime
  * with user payload. Test case below will test both the methods
  */
-describe('initAgentRuntimeWithUserPayload method', () => {
+describe('initModelRuntimeWithUserPayload method', () => {
   describe('should initialize with options correctly', () => {
     it('OpenAI provider: with apikey and endpoint', async () => {
-      const jwtPayload: ClientSecretPayload = {
-        apiKey: 'user-openai-key',
-        baseURL: 'user-endpoint',
-      };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.OpenAI, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const jwtPayload: ClientSecretPayload = { apiKey: 'user-openai-key', baseURL: 'user-endpoint' };
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.OpenAI, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeOpenAI);
       expect(runtime['_runtime'].baseURL).toBe(jwtPayload.baseURL);
     });
@@ -83,37 +80,37 @@ describe('initAgentRuntimeWithUserPayload method', () => {
         baseURL: 'user-azure-endpoint',
         azureApiVersion: '2024-06-01',
       };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Azure, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Azure, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeAzureOpenAI);
       expect(runtime['_runtime'].baseURL).toBe(jwtPayload.baseURL);
     });
 
     it('ZhiPu AI provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'zhipu.user-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.ZhiPu, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.ZhiPu, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeZhipuAI);
     });
 
     it('Google provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-google-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Google, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Google, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeGoogleAI);
     });
 
     it('Moonshot AI provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-moonshot-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Moonshot, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Moonshot, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeMoonshotAI);
     });
 
     it('Qwen AI provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-qwen-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Qwen, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Qwen, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeQwenAI);
     });
 
@@ -124,86 +121,86 @@ describe('initAgentRuntimeWithUserPayload method', () => {
         awsSecretAccessKey: 'user-aws-secret',
         awsRegion: 'user-aws-region',
       };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Bedrock, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Bedrock, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeBedrockAI);
     });
 
     it('Ollama provider: with endpoint', async () => {
       const jwtPayload: ClientSecretPayload = { baseURL: 'http://user-ollama-url' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Ollama, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Ollama, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeOllamaAI);
       expect(runtime['_runtime']['baseURL']).toEqual(jwtPayload.baseURL);
     });
 
     it('Perplexity AI provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-perplexity-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Perplexity, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Perplexity, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobePerplexityAI);
     });
 
     it('Anthropic AI provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-anthropic-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Anthropic, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Anthropic, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeAnthropicAI);
     });
 
     it('Minimax AI provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-minimax-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Minimax, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Minimax, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeMinimaxAI);
     });
 
     it('Mistral AI provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-mistral-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Mistral, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Mistral, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeMistralAI);
     });
 
     it('OpenRouter AI provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-openrouter-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.OpenRouter, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.OpenRouter, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeOpenRouterAI);
     });
 
     it('DeepSeek AI provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-deepseek-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.DeepSeek, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.DeepSeek, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeDeepSeekAI);
     });
 
     it('Together AI provider: with apikey', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-togetherai-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.TogetherAI, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.TogetherAI, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeTogetherAI);
     });
 
     it('ZeroOne AI provider: with apikey', async () => {
       const jwtPayload = { apiKey: 'user-zeroone-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.ZeroOne, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.ZeroOne, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeZeroOneAI);
     });
 
     it('Groq AI provider: with apikey', async () => {
       const jwtPayload = { apiKey: 'user-zeroone-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Groq, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Groq, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeGroq);
     });
 
     it('Stepfun AI provider: with apikey', async () => {
       const jwtPayload = { apiKey: 'user-stepfun-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Stepfun, jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Stepfun, jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeStepfunAI);
     });
 
@@ -212,8 +209,8 @@ describe('initAgentRuntimeWithUserPayload method', () => {
         apiKey: 'user-unknown-key',
         baseURL: 'user-unknown-endpoint',
       };
-      const runtime = await initAgentRuntimeWithUserPayload('unknown', jwtPayload);
-      expect(runtime).toBeInstanceOf(AgentRuntime);
+      const runtime = await initModelRuntimeWithUserPayload('unknown', jwtPayload);
+      expect(runtime).toBeInstanceOf(ModelRuntime);
       expect(runtime['_runtime']).toBeInstanceOf(LobeOpenAI);
       expect(runtime['_runtime'].baseURL).toBe(jwtPayload.baseURL);
     });
@@ -222,7 +219,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
   describe('should initialize without some options', () => {
     it('OpenAI provider: without apikey', async () => {
       const jwtPayload: ClientSecretPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.OpenAI, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.OpenAI, jwtPayload);
       expect(runtime['_runtime']).toBeInstanceOf(LobeOpenAI);
     });
 
@@ -230,21 +227,21 @@ describe('initAgentRuntimeWithUserPayload method', () => {
       const jwtPayload: ClientSecretPayload = {
         azureApiVersion: 'test-azure-api-version',
       };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Azure, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Azure, jwtPayload);
 
       expect(runtime['_runtime']).toBeInstanceOf(LobeAzureOpenAI);
     });
 
     it('ZhiPu AI provider: without apikey', async () => {
       const jwtPayload: ClientSecretPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.ZhiPu, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.ZhiPu, jwtPayload);
 
       // 假设 LobeZhipuAI 是 ZhiPu 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeZhipuAI);
     });
 
     it('Google provider: without apikey', async () => {
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Google, {});
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Google, {});
 
       // 假设 LobeGoogleAI 是 Google 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeGoogleAI);
@@ -252,7 +249,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Moonshot AI provider: without apikey', async () => {
       const jwtPayload: ClientSecretPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Moonshot, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Moonshot, jwtPayload);
 
       // 假设 LobeMoonshotAI 是 Moonshot 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeMoonshotAI);
@@ -260,7 +257,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Qwen AI provider: without apikey', async () => {
       const jwtPayload: ClientSecretPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Qwen, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Qwen, jwtPayload);
 
       // 假设 LobeQwenAI 是 Qwen 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeQwenAI);
@@ -268,7 +265,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Qwen AI provider: without endpoint', async () => {
       const jwtPayload: ClientSecretPayload = { apiKey: 'user-qwen-key' };
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Qwen, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Qwen, jwtPayload);
 
       // 假设 LobeQwenAI 是 Qwen 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeQwenAI);
@@ -278,7 +275,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Bedrock AI provider: without apikey', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Bedrock, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Bedrock, jwtPayload);
 
       // 假设 LobeBedrockAI 是 Bedrock 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeBedrockAI);
@@ -286,7 +283,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Ollama provider: without endpoint', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Ollama, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Ollama, jwtPayload);
 
       // 假设 LobeOllamaAI 是 Ollama 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeOllamaAI);
@@ -294,7 +291,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Perplexity AI provider: without apikey', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Perplexity, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Perplexity, jwtPayload);
 
       // 假设 LobePerplexityAI 是 Perplexity 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobePerplexityAI);
@@ -302,7 +299,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Anthropic AI provider: without apikey', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Anthropic, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Anthropic, jwtPayload);
 
       // 假设 LobeAnthropicAI 是 Anthropic 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeAnthropicAI);
@@ -310,7 +307,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Minimax AI provider: without apikey', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Minimax, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Minimax, jwtPayload);
 
       // 假设 LobeMistralAI 是 Mistral 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeMinimaxAI);
@@ -318,7 +315,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Mistral AI provider: without apikey', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Mistral, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Mistral, jwtPayload);
 
       // 假设 LobeMistralAI 是 Mistral 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeMistralAI);
@@ -326,7 +323,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('OpenRouter AI provider: without apikey', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.OpenRouter, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.OpenRouter, jwtPayload);
 
       // 假设 LobeOpenRouterAI 是 OpenRouter 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeOpenRouterAI);
@@ -334,7 +331,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('DeepSeek AI provider: without apikey', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.DeepSeek, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.DeepSeek, jwtPayload);
 
       // 假设 LobeDeepSeekAI 是 DeepSeek 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeDeepSeekAI);
@@ -342,7 +339,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Stepfun AI provider: without apikey', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Stepfun, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Stepfun, jwtPayload);
 
       // 假设 LobeDeepSeekAI 是 DeepSeek 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeStepfunAI);
@@ -350,7 +347,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Together AI provider: without apikey', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.TogetherAI, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.TogetherAI, jwtPayload);
 
       // 假设 LobeTogetherAI 是 TogetherAI 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeTogetherAI);
@@ -360,7 +357,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
       process.env.OPENAI_PROXY_URL = 'https://proxy.example.com/v1';
 
       const jwtPayload: ClientSecretPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.OpenAI, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.OpenAI, jwtPayload);
       expect(runtime['_runtime']).toBeInstanceOf(LobeOpenAI);
       // 应返回 OPENAI_PROXY_URL
       expect(runtime['_runtime'].baseURL).toBe('https://proxy.example.com/v1');
@@ -370,7 +367,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
       process.env.OPENAI_PROXY_URL = 'https://proxy.example.com/v1';
 
       const jwtPayload: ClientSecretPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Qwen, jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload(ModelProvider.Qwen, jwtPayload);
 
       // 假设 LobeQwenAI 是 Qwen 提供者的实现类
       expect(runtime['_runtime']).toBeInstanceOf(LobeQwenAI);
@@ -380,7 +377,7 @@ describe('initAgentRuntimeWithUserPayload method', () => {
 
     it('Unknown Provider', async () => {
       const jwtPayload = {};
-      const runtime = await initAgentRuntimeWithUserPayload('unknown', jwtPayload);
+      const runtime = await initModelRuntimeWithUserPayload('unknown', jwtPayload);
 
       // 根据实际实现，你可能需要检查是否返回了默认的 runtime 实例，或者是否抛出了异常
       // 例如，如果默认使用 OpenAI:

package/src/server/modules/{AgentRuntime → ModelRuntime}/index.ts

@@ -1,6 +1,6 @@
 import { getLLMConfig } from '@/config/llm';
 import { ClientSecretPayload } from '@/const/auth';
-import { AgentRuntime, ModelProvider } from '@/libs/model-runtime';
+import { ModelProvider, ModelRuntime } from '@/libs/model-runtime';
 
 import apiKeyManager from './apiKeyManager';
 
@@ -113,12 +113,12 @@ const getParamsFromPayload = (provider: string, payload: ClientSecretPayload) =>
  * @param params
  * @returns A promise that resolves when the agent runtime is initialized.
  */
-export const initAgentRuntimeWithUserPayload = (
+export const initModelRuntimeWithUserPayload = (
   provider: string,
   payload: ClientSecretPayload,
   params: any = {},
 ) => {
-  return AgentRuntime.initializeWithProvider(provider, {
+  return ModelRuntime.initializeWithProvider(provider, {
     ...getParamsFromPayload(provider, payload),
     ...params,
   });

package/src/server/routers/async/file.ts

@@ -13,7 +13,7 @@ import { FileModel } from '@/database/models/file';
 import { NewChunkItem, NewEmbeddingsItem } from '@/database/schemas';
 import { asyncAuthedProcedure, asyncRouter as router } from '@/libs/trpc/async';
 import { getServerDefaultFilesConfig } from '@/server/globalConfig';
-import { initAgentRuntimeWithUserPayload } from '@/server/modules/AgentRuntime';
+import { initModelRuntimeWithUserPayload } from '@/server/modules/ModelRuntime';
 import { ChunkService } from '@/server/services/chunk';
 import { FileService } from '@/server/services/file';
 import {
@@ -91,7 +91,7 @@ export const fileRouter = router({
             await pMap(
               requestArray,
               async (chunks, index) => {
-                const agentRuntime = await initAgentRuntimeWithUserPayload(
+                const agentRuntime = await initModelRuntimeWithUserPayload(
                   provider,
                   ctx.jwtPayload,
                 );