@lobehub/chat 1.68.6 → 1.68.8

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

@@ -2,7 +2,12 @@ import type { ChatModelCard } from '@/types/llm';
 
 import { ModelProvider } from '../types';
 import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
-import { OpenRouterModelCard } from './type';
+import { OpenRouterModelCard, OpenRouterModelExtraInfo } from './type';
+
+const formatPrice = (price: string) => {
+  if (price === '-1') return undefined;
+  return Number((Number(price) * 1e6).toPrecision(5));
+};
 
 export const LobeOpenRouterAI = LobeOpenAICompatibleFactory({
   baseURL: 'https://openrouter.ai/api/v1',
@@ -28,8 +33,6 @@ export const LobeOpenRouterAI = LobeOpenAICompatibleFactory({
   models: async ({ client }) => {
     const { LOBE_DEFAULT_MODEL_LIST } = await import('@/config/aiModels');
 
-    const visionKeywords = ['qwen/qvq', 'vision'];
-
     const reasoningKeywords = [
       'deepseek/deepseek-r1',
       'openai/o1',
@@ -42,11 +45,21 @@ export const LobeOpenRouterAI = LobeOpenAICompatibleFactory({
     const modelsPage = (await client.models.list()) as any;
     const modelList: OpenRouterModelCard[] = modelsPage.data;
 
+    const response = await fetch('https://openrouter.ai/api/frontend/models');
+    const modelsExtraInfo: OpenRouterModelExtraInfo[] = [];
+    if (response.ok) {
+      const data = await response.json();
+      modelsExtraInfo.push(...data['data']);
+    }
+
     return modelList
       .map((model) => {
         const knownModel = LOBE_DEFAULT_MODEL_LIST.find(
           (m) => model.id.toLowerCase() === m.id.toLowerCase(),
         );
+        const extraInfo = modelsExtraInfo.find(
+          (m) => m.slug.toLowerCase() === model.id.toLowerCase(),
+        );
 
         return {
           contextWindowTokens: model.context_length,
@@ -56,6 +69,7 @@ export const LobeOpenRouterAI = LobeOpenAICompatibleFactory({
           functionCall:
             model.description.includes('function calling') ||
             model.description.includes('tools') ||
+            extraInfo?.endpoint?.supports_tool_parameters ||
             knownModel?.abilities?.functionCall ||
             false,
           id: model.id,
@@ -63,16 +77,18 @@ export const LobeOpenRouterAI = LobeOpenAICompatibleFactory({
             typeof model.top_provider.max_completion_tokens === 'number'
               ? model.top_provider.max_completion_tokens
               : undefined,
+          pricing: {
+            input: formatPrice(model.pricing.prompt),
+            output: formatPrice(model.pricing.completion),
+          },
           reasoning:
             reasoningKeywords.some((keyword) => model.id.toLowerCase().includes(keyword)) ||
+            extraInfo?.endpoint?.supports_reasoning ||
             knownModel?.abilities?.reasoning ||
             false,
+          releasedAt: new Date(model.created * 1000).toISOString().split('T')[0],
           vision:
-            model.description.includes('vision') ||
-            model.description.includes('multimodal') ||
-            visionKeywords.some((keyword) => model.id.toLowerCase().includes(keyword)) ||
-            knownModel?.abilities?.vision ||
-            false,
+            model.architecture.modality.includes('image') || knownModel?.abilities?.vision || false,
         };
       })
       .filter(Boolean) as ChatModelCard[];

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

@@ -19,6 +19,7 @@ interface ModelTopProvider {
 export interface OpenRouterModelCard {
   architecture: ModelArchitecture;
   context_length: number;
+  created: number;
   description: string;
   id: string;
   name: string;
@@ -26,3 +27,13 @@ export interface OpenRouterModelCard {
   pricing: ModelPricing;
   top_provider: ModelTopProvider;
 }
+
+interface OpenRouterModelEndpoint {
+  supports_reasoning?: boolean;
+  supports_tool_parameters?: boolean;
+}
+
+export interface OpenRouterModelExtraInfo {
+  endpoint?: OpenRouterModelEndpoint;
+  slug: string;
+}

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

@@ -0,0 +1,97 @@
+import { LobeAi21AI } from './ai21';
+import { LobeAi360AI } from './ai360';
+import LobeAnthropicAI from './anthropic';
+import { LobeAzureOpenAI } from './azureOpenai';
+import { LobeAzureAI } from './azureai';
+import { LobeBaichuanAI } from './baichuan';
+import LobeBedrockAI from './bedrock';
+import { LobeCloudflareAI } from './cloudflare';
+import { LobeDeepSeekAI } from './deepseek';
+import { LobeFireworksAI } from './fireworksai';
+import { LobeGiteeAI } from './giteeai';
+import { LobeGithubAI } from './github';
+import LobeGoogleAI from './google';
+import { LobeGroq } from './groq';
+import { LobeHigressAI } from './higress';
+import { LobeHuggingFaceAI } from './huggingface';
+import { LobeHunyuanAI } from './hunyuan';
+import { LobeInternLMAI } from './internlm';
+import { LobeJinaAI } from './jina';
+import { LobeLMStudioAI } from './lmstudio';
+import { LobeMinimaxAI } from './minimax';
+import { LobeMistralAI } from './mistral';
+import { LobeMoonshotAI } from './moonshot';
+import { LobeNovitaAI } from './novita';
+import { LobeNvidiaAI } from './nvidia';
+import LobeOllamaAI from './ollama';
+import { LobeOpenAI } from './openai';
+import { LobeOpenRouterAI } from './openrouter';
+import { LobePerplexityAI } from './perplexity';
+import { LobePPIOAI } from './ppio';
+import { LobeQwenAI } from './qwen';
+import { LobeSambaNovaAI } from './sambanova';
+import { LobeSenseNovaAI } from './sensenova';
+import { LobeSiliconCloudAI } from './siliconcloud';
+import { LobeSparkAI } from './spark';
+import { LobeStepfunAI } from './stepfun';
+import { LobeTaichuAI } from './taichu';
+import { LobeTencentCloudAI } from './tencentcloud';
+import { LobeTogetherAI } from './togetherai';
+import { ModelProvider } from './types';
+import { LobeUpstageAI } from './upstage';
+import { LobeVLLMAI } from './vllm';
+import { LobeVolcengineAI } from './volcengine';
+import { LobeWenxinAI } from './wenxin';
+import { LobeXAI } from './xai';
+import { LobeZeroOneAI } from './zeroone';
+import { LobeZhipuAI } from './zhipu';
+
+export const providerRuntimeMap = {
+  [ModelProvider.OpenAI]: LobeOpenAI,
+  [ModelProvider.Azure]: LobeAzureOpenAI,
+  [ModelProvider.AzureAI]: LobeAzureAI,
+  [ModelProvider.ZhiPu]: LobeZhipuAI,
+  [ModelProvider.Google]: LobeGoogleAI,
+  [ModelProvider.Moonshot]: LobeMoonshotAI,
+  [ModelProvider.Bedrock]: LobeBedrockAI,
+  [ModelProvider.LMStudio]: LobeLMStudioAI,
+  [ModelProvider.Ollama]: LobeOllamaAI,
+  [ModelProvider.VLLM]: LobeVLLMAI,
+  [ModelProvider.Perplexity]: LobePerplexityAI,
+  [ModelProvider.Anthropic]: LobeAnthropicAI,
+  [ModelProvider.DeepSeek]: LobeDeepSeekAI,
+  [ModelProvider.HuggingFace]: LobeHuggingFaceAI,
+  [ModelProvider.Minimax]: LobeMinimaxAI,
+  [ModelProvider.Mistral]: LobeMistralAI,
+  [ModelProvider.Groq]: LobeGroq,
+  [ModelProvider.Github]: LobeGithubAI,
+  [ModelProvider.OpenRouter]: LobeOpenRouterAI,
+  [ModelProvider.TogetherAI]: LobeTogetherAI,
+  [ModelProvider.FireworksAI]: LobeFireworksAI,
+  [ModelProvider.ZeroOne]: LobeZeroOneAI,
+  [ModelProvider.Stepfun]: LobeStepfunAI,
+  [ModelProvider.Qwen]: LobeQwenAI,
+  [ModelProvider.Novita]: LobeNovitaAI,
+  [ModelProvider.Nvidia]: LobeNvidiaAI,
+  [ModelProvider.Taichu]: LobeTaichuAI,
+  [ModelProvider.Baichuan]: LobeBaichuanAI,
+  [ModelProvider.Ai360]: LobeAi360AI,
+  [ModelProvider.SiliconCloud]: LobeSiliconCloudAI,
+  [ModelProvider.GiteeAI]: LobeGiteeAI,
+  [ModelProvider.Upstage]: LobeUpstageAI,
+  [ModelProvider.Spark]: LobeSparkAI,
+  [ModelProvider.Ai21]: LobeAi21AI,
+  [ModelProvider.Hunyuan]: LobeHunyuanAI,
+  [ModelProvider.SenseNova]: LobeSenseNovaAI,
+  [ModelProvider.XAI]: LobeXAI,
+  [ModelProvider.Jina]: LobeJinaAI,
+  [ModelProvider.SambaNova]: LobeSambaNovaAI,
+  [ModelProvider.Cloudflare]: LobeCloudflareAI,
+  [ModelProvider.InternLM]: LobeInternLMAI,
+  [ModelProvider.Higress]: LobeHigressAI,
+  [ModelProvider.TencentCloud]: LobeTencentCloudAI,
+  [ModelProvider.Volcengine]: LobeVolcengineAI,
+  [ModelProvider.PPIO]: LobePPIOAI,
+  [ModelProvider.Doubao]: LobeVolcengineAI,
+  [ModelProvider.Wenxin]: LobeWenxinAI,
+};

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

@@ -1,6 +1,8 @@
 import { VertexAI, VertexInit } from '@google-cloud/vertexai';
 
-import { AgentRuntimeError, AgentRuntimeErrorType, LobeGoogleAI } from '@/libs/agent-runtime';
+import { AgentRuntimeErrorType } from '../error';
+import { LobeGoogleAI } from '../google';
+import { AgentRuntimeError } from '../utils/createError';
 
 export class LobeVertexAI extends LobeGoogleAI {
   static initFromVertexAI(params?: VertexInit) {

package/src/server/modules/AgentRuntime/index.ts

@@ -130,8 +130,9 @@ export const initAgentRuntimeWithUserPayload = (
   payload: JWTPayload,
   params: any = {},
 ) => {
-  return AgentRuntime.initializeWithProviderOptions(provider, {
-    [provider]: { ...getLlmOptionsFromPayload(provider, payload), ...params },
+  return AgentRuntime.initializeWithProvider(provider, {
+    ...getLlmOptionsFromPayload(provider, payload),
+    ...params,
   });
 };
 

package/src/services/chat.ts

@@ -147,12 +147,10 @@ export function initializeWithClientStore(provider: string, payload: any) {
    * Configuration override order:
    * payload -> providerAuthPayload -> commonOptions
    */
-  return AgentRuntime.initializeWithProviderOptions(provider, {
-    [provider]: {
-      ...commonOptions,
-      ...providerAuthPayload,
-      ...payload,
-    },
+  return AgentRuntime.initializeWithProvider(provider, {
+    ...commonOptions,
+    ...providerAuthPayload,
+    ...payload,
   });
 }
 

package/src/types/llm.ts

@@ -49,7 +49,7 @@ export interface ChatModelCard {
   reasoning?: boolean;
 
   /**
-   * whether model is legacy (deprecated but not removed yet)
+   * the date when model is released
    */
   releasedAt?: string;