@lobehub/chat 0.146.2 → 0.147.1

package/src/libs/agent-runtime/openrouter/fixtures/models.json

@@ -0,0 +1,62 @@
+[
+  {
+    "id": "haotian-liu/llava-13b",
+    "name": "Llava 13B",
+    "description": "LLaVA is a large multimodal model that combines a vision encoder and Vicuna for general-purpose visual and language understanding, achieving impressive chat capabilities mimicking [GPT-4](/models/openai/gpt-4-vision-preview) and setting a new state-of-the-art accuracy on Science QA\n\n#multimodal",
+    "pricing": { "prompt": "0.000005", "completion": "0.000005", "image": "0", "request": "0" },
+    "context_length": 2048,
+    "architecture": { "modality": "multimodal", "tokenizer": "Llama2", "instruct_type": null },
+    "top_provider": { "max_completion_tokens": null, "is_moderated": false },
+    "per_request_limits": { "prompt_tokens": "891204", "completion_tokens": "891204" }
+  },
+  {
+    "id": "nousresearch/nous-hermes-2-vision-7b",
+    "name": "Nous: Hermes 2 Vision 7B (alpha)",
+    "description": "This vision-language model builds on innovations from the popular [OpenHermes-2.5](/models/teknium/openhermes-2.5-mistral-7b) model, by Teknium. It adds vision support, and is trained on a custom dataset enriched with function calling\n\nThis project is led by [qnguyen3](https://twitter.com/stablequan) and [teknium](https://twitter.com/Teknium1).\n\n#multimodal",
+    "pricing": { "prompt": "0.000005", "completion": "0.000005", "image": "0", "request": "0" },
+    "context_length": 4096,
+    "architecture": { "modality": "multimodal", "tokenizer": "Mistral", "instruct_type": null },
+    "top_provider": { "max_completion_tokens": null, "is_moderated": false },
+    "per_request_limits": { "prompt_tokens": "891204", "completion_tokens": "891204" }
+  },
+  {
+    "id": "openai/gpt-3.5-turbo",
+    "name": "OpenAI: GPT-3.5 Turbo",
+    "description": "GPT-3.5 Turbo is OpenAI's fastest model. It can understand and generate natural language or code, and is optimized for chat and traditional completion tasks.\n\nUpdated by OpenAI to point to the [latest version of GPT-3.5](/models?q=openai/gpt-3.5). Training data up to Sep 2021.",
+    "pricing": { "prompt": "0.0000005", "completion": "0.0000015", "image": "0", "request": "0" },
+    "context_length": 16385,
+    "architecture": { "modality": "text", "tokenizer": "GPT", "instruct_type": null },
+    "top_provider": { "max_completion_tokens": 4096, "is_moderated": true },
+    "per_request_limits": { "prompt_tokens": "8912044", "completion_tokens": "2970681" }
+  },
+  {
+    "id": "openai/gpt-4-vision-preview",
+    "name": "OpenAI: GPT-4 Vision",
+    "description": "Ability to understand images, in addition to all other [GPT-4 Turbo capabilties](/models/openai/gpt-4-turbo). Training data: up to Apr 2023.\n\n**Note:** heavily rate limited by OpenAI while in preview.\n\n#multimodal",
+    "pricing": { "prompt": "0.00001", "completion": "0.00003", "image": "0.01445", "request": "0" },
+    "context_length": 128000,
+    "architecture": { "modality": "multimodal", "tokenizer": "GPT", "instruct_type": null },
+    "top_provider": { "max_completion_tokens": 4096, "is_moderated": true },
+    "per_request_limits": { "prompt_tokens": "445602", "completion_tokens": "148534" }
+  },
+  {
+    "id": "google/gemma-7b-it",
+    "name": "Google: Gemma 7B",
+    "description": "Gemma by Google is an advanced, open-source language model family, leveraging the latest in decoder-only, text-to-text technology. It offers English language capabilities across text generation tasks like question answering, summarization, and reasoning. The Gemma 7B variant is comparable in performance to leading open source models.\n\nUsage of Gemma is subject to Google's [Gemma Terms of Use](https://ai.google.dev/gemma/terms).",
+    "pricing": { "prompt": "0.00000013", "completion": "0.00000013", "image": "0", "request": "0" },
+    "context_length": 8192,
+    "architecture": { "modality": "text", "tokenizer": "Llama2", "instruct_type": "gemma" },
+    "top_provider": { "max_completion_tokens": null, "is_moderated": false },
+    "per_request_limits": { "prompt_tokens": "34277093", "completion_tokens": "34277093" }
+  },
+  {
+    "id": "gryphe/mythomax-l2-13b:nitro",
+    "name": "MythoMax 13B (nitro)",
+    "description": "One of the highest performing and most popular fine-tunes of Llama 2 13B, with rich descriptions and roleplay. #merge\n\nNote: this is a higher-throughput version of [this model](/models/gryphe/mythomax-l2-13b), and may have higher prices and slightly different outputs.",
+    "pricing": { "prompt": "0.0000002", "completion": "0.0000002", "image": "0", "request": "0" },
+    "context_length": 4096,
+    "architecture": { "modality": "text", "tokenizer": "Llama2", "instruct_type": "alpaca" },
+    "top_provider": { "max_completion_tokens": null, "is_moderated": false },
+    "per_request_limits": { "prompt_tokens": "22280110", "completion_tokens": "22280110" }
+  }
+]

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

@@ -2,9 +2,10 @@
 import OpenAI from 'openai';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { ChatStreamCallbacks } from '@/libs/agent-runtime';
+import { ChatStreamCallbacks, LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
 
 import * as debugStreamModule from '../utils/debugStream';
+import models from './fixtures/models.json';
 import { LobeOpenRouterAI } from './index';
 
 const provider = 'openrouter';
@@ -15,7 +16,7 @@ const invalidErrorType = 'InvalidOpenRouterAPIKey';
 // Mock the console.error to avoid polluting test output
 vi.spyOn(console, 'error').mockImplementation(() => {});
 
-let instance: LobeOpenRouterAI;
+let instance: LobeOpenAICompatibleRuntime;
 
 beforeEach(() => {
   instance = new LobeOpenRouterAI({ apiKey: 'test' });
@@ -24,6 +25,7 @@ beforeEach(() => {
   vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
     new ReadableStream() as any,
   );
+  vi.spyOn(instance['client'].models, 'list').mockResolvedValue({ data: [] } as any);
 });
 
 afterEach(() => {
@@ -75,13 +77,16 @@ describe('LobeOpenRouterAI', () => {
       });
 
       // Assert
-      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith({
-        max_tokens: 1024,
-        messages: [{ content: 'Hello', role: 'user' }],
-        model: 'mistralai/mistral-7b-instruct:free',
-        temperature: 0.7,
-        top_p: 1,
-      })
+      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+        {
+          max_tokens: 1024,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'mistralai/mistral-7b-instruct:free',
+          temperature: 0.7,
+          top_p: 1,
+        },
+        { headers: { Accept: '*/*' } },
+      );
       expect(result).toBeInstanceOf(Response);
     });
 
@@ -344,4 +349,15 @@ describe('LobeOpenRouterAI', () => {
       });
     });
   });
+
+  describe('models', () => {
+    it('should get models', async () => {
+      // mock the models.list method
+      (instance['client'].models.list as Mock).mockResolvedValue({ data: models });
+
+      const list = await instance.models();
+
+      expect(list).toMatchSnapshot();
+    });
+  });
 });

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

@@ -1,86 +1,44 @@
-import { OpenAIStream, StreamingTextResponse } from 'ai';
-import OpenAI, { ClientOptions } from 'openai';
+import { LOBE_DEFAULT_MODEL_LIST } from '@/config/modelProviders';
 
-import { LobeRuntimeAI } from '../BaseAI';
 import { AgentRuntimeErrorType } from '../error';
-import { ChatCompetitionOptions, ChatStreamPayload, ModelProvider } from '../types';
-import { AgentRuntimeError } from '../utils/createError';
-import { debugStream } from '../utils/debugStream';
-import { desensitizeUrl } from '../utils/desensitizeUrl';
-import { handleOpenAIError } from '../utils/handleOpenAIError';
-
-const DEFAULT_BASE_URL = 'https://openrouter.ai/api/v1';
-
-export class LobeOpenRouterAI implements LobeRuntimeAI {
-  private client: OpenAI;
-
-  baseURL: string;
-
-  constructor({ apiKey, baseURL = DEFAULT_BASE_URL, ...res }: ClientOptions) {
-    if (!apiKey) throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidOpenRouterAPIKey);
-    
-    this.client = new OpenAI({
-      apiKey,
-      baseURL,
-      defaultHeaders: {
-        "HTTP-Referer": "https://chat-preview.lobehub.com",
-        "X-Title": "Lobe Chat"
-      },
-      ...res
-    });
-    this.baseURL = this.client.baseURL;
-  }
-
-  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
-    try {
-      const response = await this.client.chat.completions.create(
-        payload as unknown as OpenAI.ChatCompletionCreateParamsStreaming
-      );
-      const [prod, debug] = response.tee();
-
-      if (process.env.DEBUG_OPENROUTER_CHAT_COMPLETION === '1') {
-        debugStream(debug.toReadableStream()).catch(console.error);
-      }
-
-      return new StreamingTextResponse(OpenAIStream(prod, options?.callback), {
-        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.InvalidOpenRouterAPIKey,
-              provider: ModelProvider.OpenRouter,
-            });
-          }
-
-          default: {
-            break;
-          }
-        }
-      }
-
-      const { errorResult, RuntimeError } = handleOpenAIError(error);
-
-      const errorType = RuntimeError || AgentRuntimeErrorType.OpenRouterBizError;
-
-      throw AgentRuntimeError.chat({
-        endpoint: desensitizedEndpoint,
-        error: errorResult,
-        errorType,
-        provider: ModelProvider.OpenRouter,
-      });
-    }
-  }
-}
-
-export default LobeOpenRouterAI;
+import { ModelProvider } from '../types';
+import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
+import { OpenRouterModelCard } from './type';
+
+export const LobeOpenRouterAI = LobeOpenAICompatibleFactory({
+  baseURL: 'https://openrouter.ai/api/v1',
+  constructorOptions: {
+    defaultHeaders: {
+      'HTTP-Referer': 'https://chat-preview.lobehub.com',
+      'X-Title': 'Lobe Chat',
+    },
+  },
+  debug: {
+    chatCompletion: () => process.env.DEBUG_OPENROUTER_CHAT_COMPLETION === '1',
+  },
+
+  errorType: {
+    bizError: AgentRuntimeErrorType.OpenRouterBizError,
+    invalidAPIKey: AgentRuntimeErrorType.InvalidOpenRouterAPIKey,
+  },
+  models: {
+    transformModel: (m) => {
+      const model = m as unknown as OpenRouterModelCard;
+
+      return {
+        description: model.description,
+        displayName: model.name,
+        enabled: LOBE_DEFAULT_MODEL_LIST.find((m) => model.id.endsWith(m.id))?.enabled || false,
+        functionCall: model.description.includes('function calling'),
+        id: model.id,
+        maxTokens:
+          typeof model.top_provider.max_completion_tokens === 'number'
+            ? model.top_provider.max_completion_tokens
+            : undefined,
+        tokens: model.context_length,
+        vision: model.description.includes('vision') || model.id.includes('vision'),
+      };
+    },
+  },
+  provider: ModelProvider.OpenRouter,
+});

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

@@ -0,0 +1,28 @@
+interface ModelPricing {
+  completion: string;
+  image: string;
+  prompt: string;
+  request: string;
+}
+
+interface ModelArchitecture {
+  instruct_type: string | null;
+  modality: string;
+  tokenizer: string;
+}
+
+interface ModelTopProvider {
+  is_moderated: boolean;
+  max_completion_tokens: number | null;
+}
+
+export interface OpenRouterModelCard {
+  architecture: ModelArchitecture;
+  context_length: number;
+  description: string;
+  id: string;
+  name: string;
+  per_request_limits: any | null;
+  pricing: ModelPricing;
+  top_provider: ModelTopProvider;
+}

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

@@ -2,7 +2,7 @@
 import OpenAI from 'openai';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { ChatStreamCallbacks } from '@/libs/agent-runtime';
+import { ChatStreamCallbacks, LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
 
 import * as debugStreamModule from '../utils/debugStream';
 import { LobeTogetherAI } from './index';
@@ -15,7 +15,7 @@ const invalidErrorType = 'InvalidTogetherAIAPIKey';
 // Mock the console.error to avoid polluting test output
 vi.spyOn(console, 'error').mockImplementation(() => {});
 
-let instance: LobeTogetherAI;
+let instance: LobeOpenAICompatibleRuntime;
 
 beforeEach(() => {
   instance = new LobeTogetherAI({ apiKey: 'test' });
@@ -75,13 +75,16 @@ describe('LobeTogetherAI', () => {
       });
 
       // Assert
-      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith({
-        max_tokens: 1024,
-        messages: [{ content: 'Hello', role: 'user' }],
-        model: 'mistralai/mistral-7b-instruct:free',
-        temperature: 0.7,
-        top_p: 1,
-      });
+      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+        {
+          max_tokens: 1024,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'mistralai/mistral-7b-instruct:free',
+          temperature: 0.7,
+          top_p: 1,
+        },
+        { headers: { Accept: '*/*' } },
+      );
       expect(result).toBeInstanceOf(Response);
     });
 

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

@@ -1,86 +1,21 @@
-import { OpenAIStream, StreamingTextResponse } from 'ai';
-import OpenAI, { ClientOptions } from 'openai';
-
-import { LobeRuntimeAI } from '../BaseAI';
 import { AgentRuntimeErrorType } from '../error';
-import { ChatCompetitionOptions, ChatStreamPayload, ModelProvider } from '../types';
-import { AgentRuntimeError } from '../utils/createError';
-import { debugStream } from '../utils/debugStream';
-import { desensitizeUrl } from '../utils/desensitizeUrl';
-import { handleOpenAIError } from '../utils/handleOpenAIError';
-
-const DEFAULT_BASE_URL = 'https://api.together.xyz/v1';
-
-export class LobeTogetherAI implements LobeRuntimeAI {
-  private client: OpenAI;
-
-  baseURL: string;
-
-  constructor({ apiKey, baseURL = DEFAULT_BASE_URL, ...res }: ClientOptions) {
-    if (!apiKey) throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidTogetherAIAPIKey);
-
-    this.client = new OpenAI({
-      apiKey,
-      baseURL,
-      defaultHeaders: {
-        'HTTP-Referer': 'https://chat-preview.lobehub.com',
-        'X-Title': 'Lobe Chat',
-      },
-      ...res,
-    });
-    this.baseURL = this.client.baseURL;
-  }
-
-  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
-    try {
-      const response = await this.client.chat.completions.create(
-        payload as unknown as OpenAI.ChatCompletionCreateParamsStreaming,
-      );
-      const [prod, debug] = response.tee();
-
-      if (process.env.DEBUG_TOGETHERAI_CHAT_COMPLETION === '1') {
-        debugStream(debug.toReadableStream()).catch(console.error);
-      }
-
-      return new StreamingTextResponse(OpenAIStream(prod, options?.callback), {
-        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.InvalidTogetherAIAPIKey,
-              provider: ModelProvider.TogetherAI,
-            });
-          }
-
-          default: {
-            break;
-          }
-        }
-      }
-
-      const { errorResult, RuntimeError } = handleOpenAIError(error);
-
-      const errorType = RuntimeError || AgentRuntimeErrorType.TogetherAIBizError;
-
-      throw AgentRuntimeError.chat({
-        endpoint: desensitizedEndpoint,
-        error: errorResult,
-        errorType,
-        provider: ModelProvider.TogetherAI,
-      });
-    }
-  }
-}
-
-export default LobeTogetherAI;
+import { ModelProvider } from '../types';
+import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
+
+export const LobeTogetherAI = LobeOpenAICompatibleFactory({
+  baseURL: 'https://api.together.xyz/v1',
+  constructorOptions: {
+    defaultHeaders: {
+      'HTTP-Referer': 'https://chat-preview.lobehub.com',
+      'X-Title': 'Lobe Chat',
+    },
+  },
+  debug: {
+    chatCompletion: () => process.env.DEBUG_TOGETHERAI_CHAT_COMPLETION === '1',
+  },
+  errorType: {
+    bizError: AgentRuntimeErrorType.TogetherAIBizError,
+    invalidAPIKey: AgentRuntimeErrorType.InvalidTogetherAIAPIKey,
+  },
+  provider: ModelProvider.TogetherAI,
+});

package/src/libs/agent-runtime/utils/anthropicHelpers.test.ts

@@ -1,18 +1,10 @@
 import { describe, expect, it } from 'vitest';
 
-import {
-  buildAnthropicMessage,
-  buildAnthropicBlock,
-} from './anthropicHelpers';
-
+import { OpenAIChatMessage, UserMessageContentPart } from '../types/chat';
+import { buildAnthropicBlock, buildAnthropicMessage } from './anthropicHelpers';
 import { parseDataUri } from './uriParser';
-import {
-  OpenAIChatMessage,
-  UserMessageContentPart,
-} from '../types/chat';
 
 describe('anthropicHelpers', () => {
-
   // Mock the parseDataUri function since it's an implementation detail
   vi.mock('./uriParser', () => ({
     parseDataUri: vi.fn().mockReturnValue({
@@ -23,15 +15,16 @@ describe('anthropicHelpers', () => {
 
   describe('buildAnthropicBlock', () => {
     it('should return the content as is for text type', () => {
-      const content: UserMessageContentPart =
-        { type: 'text', text: 'Hello!' };
+      const content: UserMessageContentPart = { type: 'text', text: 'Hello!' };
       const result = buildAnthropicBlock(content);
       expect(result).toEqual(content);
     });
-  
+
     it('should transform an image URL into an Anthropic.ImageBlockParam', () => {
-      const content: UserMessageContentPart =
-        { type: 'image_url', image_url: { url: 'data:image/jpeg;base64,base64EncodedString' } };
+      const content: UserMessageContentPart = {
+        type: 'image_url',
+        image_url: { url: 'data:image/jpeg;base64,base64EncodedString' },
+      };
       const result = buildAnthropicBlock(content);
       expect(parseDataUri).toHaveBeenCalledWith(content.image_url.url);
       expect(result).toEqual({
@@ -47,13 +40,12 @@ describe('anthropicHelpers', () => {
 
   describe('buildAnthropicMessage', () => {
     it('should correctly convert system message to assistant message', () => {
-      const message: OpenAIChatMessage = 
-        { content: [{ type: 'text', text: 'Hello!' }], role: 'system' };
+      const message: OpenAIChatMessage = {
+        content: [{ type: 'text', text: 'Hello!' }],
+        role: 'system',
+      };
       const result = buildAnthropicMessage(message);
-      expect(result).toEqual(
-        { content: [{ type: 'text', text: 'Hello!' }], role: 'assistant' }
-      );
+      expect(result).toEqual({ content: [{ type: 'text', text: 'Hello!' }], role: 'assistant' });
     });
   });
-
-});
+});

package/src/libs/agent-runtime/utils/anthropicHelpers.ts

@@ -1,10 +1,6 @@
 import Anthropic from '@anthropic-ai/sdk';
 
-import {
-  OpenAIChatMessage,
-  UserMessageContentPart,
-} from '../types';
-
+import { OpenAIChatMessage, UserMessageContentPart } from '../types';
 import { parseDataUri } from './uriParser';
 
 export const buildAnthropicBlock = (
@@ -28,20 +24,18 @@ export const buildAnthropicBlock = (
       };
     }
   }
-}
+};
 
 export const buildAnthropicMessage = (
   message: OpenAIChatMessage,
 ): Anthropic.Messages.MessageParam => {
   const content = message.content as string | UserMessageContentPart[];
   return {
-    content:
-      typeof content === 'string' ? content : content.map((c) => buildAnthropicBlock(c)),
+    content: typeof content === 'string' ? content : content.map((c) => buildAnthropicBlock(c)),
     role: message.role === 'function' || message.role === 'system' ? 'assistant' : message.role,
   };
 };
 
 export const buildAnthropicMessages = (
   messages: OpenAIChatMessage[],
-): Anthropic.Messages.MessageParam[] =>
-  messages.map((message) => buildAnthropicMessage(message));
+): Anthropic.Messages.MessageParam[] => messages.map((message) => buildAnthropicMessage(message));