@lobehub/chat 1.119.1 → 1.119.2

package/packages/model-runtime/src/openai/index.ts

@@ -1,5 +1,4 @@
-import { responsesAPIModels } from '@/const/models';
-
+import { responsesAPIModels } from '../const/models';
 import { ChatStreamPayload, ModelProvider } from '../types';
 import { processMultiProviderModelList } from '../utils/modelParse';
 import { createOpenAICompatibleRuntime } from '../utils/openaiCompatibleFactory';
@@ -19,7 +18,7 @@ const supportsFlexTier = (model: string) => {
   if (model.startsWith('o3-mini')) {
     return false;
   }
-  return flexSupportedModels.some(supportedModel => model.startsWith(supportedModel));
+  return flexSupportedModels.some((supportedModel) => model.startsWith(supportedModel));
 };
 
 export const LobeOpenAI = createOpenAICompatibleRuntime({
@@ -54,7 +53,12 @@ export const LobeOpenAI = createOpenAICompatibleRuntime({
         } as any;
       }
 
-      return { ...rest, model, ...(enableServiceTierFlex && supportsFlexTier(model) && { service_tier: 'flex' }), stream: payload.stream ?? true };
+      return {
+        ...rest,
+        model,
+        ...(enableServiceTierFlex && supportsFlexTier(model) && { service_tier: 'flex' }),
+        stream: payload.stream ?? true,
+      };
     },
   },
   debug: {
@@ -97,13 +101,17 @@ export const LobeOpenAI = createOpenAICompatibleRuntime({
           tools: openaiTools as any,
           // computer-use series must set truncation as auto
           ...(model.startsWith('computer-use') && { truncation: 'auto' }),
-          text: verbosity
-            ? { verbosity }
-            : undefined,
+          text: verbosity ? { verbosity } : undefined,
         }) as any;
       }
 
-      return { ...rest, model, ...(enableServiceTierFlex && supportsFlexTier(model) && { service_tier: 'flex' }), stream: payload.stream ?? true, tools: openaiTools } as any;
+      return {
+        ...rest,
+        model,
+        ...(enableServiceTierFlex && supportsFlexTier(model) && { service_tier: 'flex' }),
+        stream: payload.stream ?? true,
+        tools: openaiTools,
+      } as any;
     },
   },
 });

package/packages/model-runtime/src/providerTestUtils.ts

@@ -1,8 +1,7 @@
 import OpenAI from 'openai';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { LobeOpenAICompatibleRuntime } from '@/libs/model-runtime';
-
+import { LobeOpenAICompatibleRuntime } from './BaseAI';
 import * as debugStreamModule from './utils/debugStream';
 
 interface TesstProviderParams {

package/packages/model-runtime/src/qiniu/index.test.ts

@@ -1,7 +1,6 @@
 // @vitest-environment node
-import { ModelProvider } from '@/libs/model-runtime';
-import { testProvider } from '@/libs/model-runtime/providerTestUtils';
-
+import { testProvider } from '../providerTestUtils';
+import { ModelProvider } from '../types';
 import { LobeQiniuAI } from './index';
 
 const provider = ModelProvider.Qiniu;

package/packages/model-runtime/src/siliconcloud/index.ts

@@ -1,5 +1,5 @@
-import { AgentRuntimeErrorType } from '../error';
 import { ChatCompletionErrorPayload, ModelProvider } from '../types';
+import { AgentRuntimeErrorType } from '../types/error';
 import { processMultiProviderModelList } from '../utils/modelParse';
 import { createOpenAICompatibleRuntime } from '../utils/openaiCompatibleFactory';
 

package/packages/model-runtime/src/types/chat.ts

@@ -1,25 +1,5 @@
-import type { PartialDeep } from 'type-fest';
-
-import { ModelTokensUsage, ToolFunction } from '@/types/message';
-
-export interface MessageToolCall {
-  /**
-   * The function that the model called.
-   */
-  function: ToolFunction;
-
-  /**
-   * The ID of the tool call.
-   */
-  id: string;
-
-  /**
-   * The type of the tool. Currently, only `function` is supported.
-   */
-  type: 'function' | string;
-}
-
-export type MessageToolCallChunk = PartialDeep<MessageToolCall> & { index: number };
+import { MessageToolCall, MessageToolCallChunk } from './toolsCalling';
+import { ModelTokensUsage } from './usage';
 
 export type LLMRoleType = 'user' | 'system' | 'assistant' | 'function' | 'tool';
 

package/packages/model-runtime/src/{error.ts → types/error.ts}

@@ -37,3 +37,32 @@ export const AGENT_RUNTIME_ERROR_SET = new Set<string>(Object.values(AgentRuntim
 
 export type ILobeAgentRuntimeErrorType =
   (typeof AgentRuntimeErrorType)[keyof typeof AgentRuntimeErrorType];
+
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+export const StandardErrorType = {
+  // ******* Client Error ******* //
+  BadRequest: 400,
+  Unauthorized: 401,
+  Forbidden: 403,
+  ContentNotFound: 404,
+  MethodNotAllowed: 405,
+  TooManyRequests: 429,
+
+  // ******* Server Error ******* //
+  InternalServerError: 500,
+  BadGateway: 502,
+  ServiceUnavailable: 503,
+  GatewayTimeout: 504,
+} as const;
+/* eslint-enable */
+
+export type ErrorType = (typeof StandardErrorType)[keyof typeof StandardErrorType];
+
+/**
+ * 聊天消息错误对象
+ */
+export interface ChatMessageError {
+  body?: any;
+  message: string;
+  type: ErrorType | ILobeAgentRuntimeErrorType;
+}

package/packages/model-runtime/src/types/index.ts

@@ -1,6 +1,10 @@
 export * from './chat';
 export * from './embeddings';
+export * from './error';
+export * from './image';
 export * from './model';
 export * from './textToImage';
+export * from './toolsCalling';
 export * from './tts';
 export * from './type';
+export * from './usage';

package/packages/model-runtime/src/types/toolsCalling.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PartialDeep } from 'type-fest';
+
+/**
+ * The function that the model called.
+ */
+export interface ToolFunction {
+  /**
+   * The arguments to call the function with, as generated by the model in JSON
+   * format. Note that the model does not always generate valid JSON, and may
+   * hallucinate parameters not defined by your function schema. Validate the
+   * arguments in your code before calling your function.
+   */
+  arguments: string;
+
+  /**
+   * The name of the function to call.
+   */
+  name: string;
+}
+
+export interface MessageToolCall {
+  /**
+   * The function that the model called.
+   */
+  function: ToolFunction;
+
+  /**
+   * The ID of the tool call.
+   */
+  id: string;
+
+  /**
+   * The type of the tool. Currently, only `function` is supported.
+   */
+  type: 'function' | string;
+}
+
+export const MessageToolCallSchema = z.object({
+  function: z.object({
+    arguments: z.string(),
+    name: z.string(),
+  }),
+  id: z.string(),
+  type: z.string(),
+});
+
+export type MessageToolCallChunk = PartialDeep<MessageToolCall> & { index: number };

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

@@ -1,7 +1,7 @@
 import OpenAI from 'openai';
 
-import { ILobeAgentRuntimeErrorType } from '../error';
 import { ChatStreamPayload } from './chat';
+import { ILobeAgentRuntimeErrorType } from './error';
 
 export interface AgentInitErrorPayload {
   error: object;

package/packages/model-runtime/src/types/usage.ts

@@ -0,0 +1,27 @@
+export interface ModelTokensUsage {
+  acceptedPredictionTokens?: number;
+  inputAudioTokens?: number;
+  inputCacheMissTokens?: number;
+  inputCachedTokens?: number;
+  /**
+   * currently only pplx has citation_tokens
+   */
+  inputCitationTokens?: number;
+  /**
+   * user prompt image
+   */
+  inputImageTokens?: number;
+  /**
+   * user prompt input
+   */
+  inputTextTokens?: number;
+  inputWriteCacheTokens?: number;
+  outputAudioTokens?: number;
+  outputImageTokens?: number;
+  outputReasoningTokens?: number;
+  outputTextTokens?: number;
+  rejectedPredictionTokens?: number;
+  totalInputTokens?: number;
+  totalOutputTokens?: number;
+  totalTokens?: number;
+}

package/packages/model-runtime/src/utils/anthropicHelpers.test.ts

@@ -1,8 +1,8 @@
-import { imageUrlToBase64 } from '@lobechat/utils';
 import { OpenAI } from 'openai';
 import { describe, expect, it, vi } from 'vitest';
 
 import { OpenAIChatMessage, UserMessageContentPart } from '../types/chat';
+import { imageUrlToBase64 } from '../utils/imageToBase64';
 import {
   buildAnthropicBlock,
   buildAnthropicMessage,
@@ -19,7 +19,7 @@ vi.mock('./uriParser', () => ({
     type: 'base64',
   }),
 }));
-vi.mock('@lobechat/utils');
+vi.mock('../utils/imageToBase64');
 
 describe('anthropicHelpers', () => {
   describe('buildAnthropicBlock', () => {

package/packages/model-runtime/src/utils/anthropicHelpers.ts

@@ -1,8 +1,8 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { imageUrlToBase64 } from '@lobechat/utils';
 import OpenAI from 'openai';
 
 import { OpenAIChatMessage, UserMessageContentPart } from '../types';
+import { imageUrlToBase64 } from '../utils/imageToBase64';
 import { parseDataUri } from './uriParser';
 
 export const buildAnthropicBlock = async (

package/packages/model-runtime/src/utils/createError.ts

@@ -1,9 +1,9 @@
-import { ILobeAgentRuntimeErrorType } from '../error';
 import {
   AgentInitErrorPayload,
   ChatCompletionErrorPayload,
   CreateImageErrorPayload,
 } from '../types';
+import { ILobeAgentRuntimeErrorType } from '../types/error';
 
 export const AgentRuntimeError = {
   chat: (error: ChatCompletionErrorPayload): ChatCompletionErrorPayload => error,

package/packages/model-runtime/src/utils/errorResponse.test.ts

@@ -0,0 +1,110 @@
+import { AgentRuntimeErrorType } from '@lobechat/model-runtime';
+import { ChatErrorType } from '@lobechat/types';
+import { describe, expect, it, vi } from 'vitest';
+
+import { createErrorResponse } from './errorResponse';
+
+describe('createErrorResponse', () => {
+  // 测试包含Invalid的错误类型
+  it('returns a 401 status for Invalid error type', () => {
+    const errorType = 'InvalidTestError';
+    const response = createErrorResponse(errorType as any);
+    expect(response.status).toBe(401);
+  });
+
+  it('returns a 403 status for LocationNotSupportError error type', () => {
+    const errorType = AgentRuntimeErrorType.LocationNotSupportError;
+    const response = createErrorResponse(errorType);
+    expect(response.status).toBe(403);
+  });
+
+  it('returns a 404 status for ModelNotFound error type', () => {
+    const errorType = AgentRuntimeErrorType.ModelNotFound;
+    const response = createErrorResponse(errorType);
+    expect(response.status).toBe(404);
+  });
+
+  it('returns a 429 status for InsufficientQuota error type', () => {
+    const errorType = AgentRuntimeErrorType.InsufficientQuota;
+    const response = createErrorResponse(errorType);
+    expect(response.status).toBe(429);
+  });
+
+  it('returns a 429 status for QuotaLimitReached error type', () => {
+    const errorType = AgentRuntimeErrorType.QuotaLimitReached;
+    const response = createErrorResponse(errorType);
+    expect(response.status).toBe(429);
+  });
+
+  it('returns a 400 status for ExceededContextWindow error type', () => {
+    const errorType = AgentRuntimeErrorType.ExceededContextWindow;
+    const response = createErrorResponse(errorType);
+    expect(response.status).toBe(400);
+  });
+
+  describe('Provider Biz Error', () => {
+    it('returns a 471 status for ProviderBizError error type', () => {
+      const errorType = AgentRuntimeErrorType.ProviderBizError;
+      const response = createErrorResponse(errorType);
+      expect(response.status).toBe(471);
+    });
+
+    it('returns a 470 status for AgentRuntimeError error type', () => {
+      const errorType = AgentRuntimeErrorType.AgentRuntimeError;
+      const response = createErrorResponse(errorType);
+      expect(response.status).toBe(470);
+    });
+
+    it('returns a 472 status for OllamaBizError error type', () => {
+      const errorType = AgentRuntimeErrorType.OllamaBizError;
+      const response = createErrorResponse(errorType);
+      expect(response.status).toBe(472);
+    });
+
+    it('returns a 472 status for OllamaServiceUnavailable error type', () => {
+      const errorType = ChatErrorType.OllamaServiceUnavailable;
+      const response = createErrorResponse(errorType);
+      expect(response.status).toBe(472);
+    });
+  });
+
+  // 测试状态码不在200-599范围内的情况
+  it('logs an error when the status code is not a number or not in the range of 200-599', () => {
+    const errorType = 'Unknown Error';
+    const consoleSpy = vi.spyOn(console, 'error');
+    try {
+      createErrorResponse(errorType as any);
+    } catch (e) {}
+    expect(consoleSpy).toHaveBeenCalled();
+    consoleSpy.mockRestore();
+  });
+
+  // 测试默认情况
+  it('returns the same error type as status for unknown error types', () => {
+    const errorType = 500; // 假设500是一个未知的错误类型
+    const response = createErrorResponse(errorType as any);
+    expect(response.status).toBe(errorType);
+  });
+
+  // 测试返回的Response对象是否包含正确的body和errorType
+  it('returns a Response object with the correct body and errorType', () => {
+    const errorType = ChatErrorType.NoOpenAIAPIKey;
+    const body = { message: 'No API key provided' };
+    const response = createErrorResponse(errorType, body);
+    return response.json().then((data) => {
+      expect(data).toEqual({
+        body,
+        errorType,
+      });
+    });
+  });
+
+  // 测试没有提供body时，返回的Response对象的body是否为undefined
+  it('returns a Response object with an undefined body when no body is provided', () => {
+    const errorType = ChatErrorType.NoOpenAIAPIKey;
+    const response = createErrorResponse(errorType);
+    return response.json().then((data) => {
+      expect(data.body).toBeUndefined();
+    });
+  });
+});

package/packages/model-runtime/src/utils/errorResponse.ts

@@ -0,0 +1,64 @@
+import { ChatErrorType, ErrorResponse, ErrorType } from '@lobechat/types';
+
+import { AgentRuntimeErrorType, ILobeAgentRuntimeErrorType } from '../types';
+
+const getStatus = (errorType: ILobeAgentRuntimeErrorType | ErrorType) => {
+  // InvalidAccessCode / InvalidAzureAPIKey / InvalidOpenAIAPIKey / InvalidZhipuAPIKey ....
+  if (errorType.toString().includes('Invalid')) return 401;
+
+  switch (errorType) {
+    case AgentRuntimeErrorType.InvalidProviderAPIKey: {
+      return 401;
+    }
+
+    case AgentRuntimeErrorType.ExceededContextWindow: {
+      return 400;
+    }
+
+    case AgentRuntimeErrorType.LocationNotSupportError: {
+      return 403;
+    }
+
+    case AgentRuntimeErrorType.ModelNotFound: {
+      return 404;
+    }
+
+    case AgentRuntimeErrorType.InsufficientQuota:
+    case AgentRuntimeErrorType.QuotaLimitReached: {
+      return 429;
+    }
+
+    // define the 471~480 as provider error
+    case AgentRuntimeErrorType.AgentRuntimeError: {
+      return 470;
+    }
+
+    case AgentRuntimeErrorType.ProviderBizError: {
+      return 471;
+    }
+
+    // all local provider connection error
+    case AgentRuntimeErrorType.OllamaServiceUnavailable:
+    case ChatErrorType.OllamaServiceUnavailable:
+    case AgentRuntimeErrorType.OllamaBizError: {
+      return 472;
+    }
+  }
+
+  return errorType as number;
+};
+
+export const createErrorResponse = (errorType: ILobeAgentRuntimeErrorType, body?: any) => {
+  const statusCode = getStatus(errorType);
+
+  const data: ErrorResponse = { body, errorType };
+
+  if (typeof statusCode !== 'number' || statusCode < 200 || statusCode > 599) {
+    console.error(
+      `current StatusCode: \`${statusCode}\` .`,
+      'Please go to `./utils/errorResponse.ts` to defined the statusCode.',
+    );
+  }
+
+  return new Response(JSON.stringify(data), { status: statusCode });
+};

package/packages/{utils/src → model-runtime/src/utils}/getFallbackModelProperty.ts

@@ -1,4 +1,4 @@
-import { AiFullModelCard } from '@/types/aiModel';
+import type { AiFullModelCard } from 'model-bank';
 
 /**
  * Get the model property value, first from the specified provider, and then from other providers as a fallback.

package/packages/model-runtime/src/utils/googleErrorParser.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { AgentRuntimeErrorType } from '../error';
+import { AgentRuntimeErrorType } from '../types/error';
 import {
   cleanErrorMessage,
   extractStatusCodeFromError,

package/packages/model-runtime/src/utils/googleErrorParser.ts

@@ -1,4 +1,4 @@
-import { AgentRuntimeErrorType, ILobeAgentRuntimeErrorType } from '../error';
+import { AgentRuntimeErrorType, ILobeAgentRuntimeErrorType } from '../types/error';
 
 export interface ParsedError {
   error: any;

package/packages/model-runtime/src/utils/handleOpenAIError.ts

@@ -1,6 +1,6 @@
 import OpenAI from 'openai';
 
-import { AgentRuntimeErrorType } from '../error';
+import { AgentRuntimeErrorType } from '../types/error';
 
 export const handleOpenAIError = (
   error: any,

package/packages/model-runtime/src/utils/imageToBase64.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { imageToBase64, imageUrlToBase64 } from './imageToBase64';
+
+describe('imageToBase64', () => {
+  let mockImage: HTMLImageElement;
+  let mockCanvas: HTMLCanvasElement;
+  let mockContext: CanvasRenderingContext2D;
+
+  beforeEach(() => {
+    mockImage = {
+      width: 200,
+      height: 100,
+    } as HTMLImageElement;
+
+    mockContext = {
+      drawImage: vi.fn(),
+    } as unknown as CanvasRenderingContext2D;
+
+    mockCanvas = {
+      width: 0,
+      height: 0,
+      getContext: vi.fn().mockReturnValue(mockContext),
+      toDataURL: vi.fn().mockReturnValue('data:image/webp;base64,mockBase64Data'),
+    } as unknown as HTMLCanvasElement;
+
+    vi.spyOn(document, 'createElement').mockReturnValue(mockCanvas);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should convert image to base64 with correct size and type', () => {
+    const result = imageToBase64({ img: mockImage, size: 100, type: 'image/jpeg' });
+
+    expect(document.createElement).toHaveBeenCalledWith('canvas');
+    expect(mockCanvas.width).toBe(100);
+    expect(mockCanvas.height).toBe(100);
+    expect(mockCanvas.getContext).toHaveBeenCalledWith('2d');
+    expect(mockContext.drawImage).toHaveBeenCalledWith(mockImage, 50, 0, 100, 100, 0, 0, 100, 100);
+    expect(mockCanvas.toDataURL).toHaveBeenCalledWith('image/jpeg');
+    expect(result).toBe('data:image/webp;base64,mockBase64Data');
+  });
+
+  it('should use default type when not specified', () => {
+    imageToBase64({ img: mockImage, size: 100 });
+    expect(mockCanvas.toDataURL).toHaveBeenCalledWith('image/webp');
+  });
+
+  it('should handle taller images correctly', () => {
+    mockImage.width = 100;
+    mockImage.height = 200;
+    imageToBase64({ img: mockImage, size: 100 });
+    expect(mockContext.drawImage).toHaveBeenCalledWith(mockImage, 0, 50, 100, 100, 0, 0, 100, 100);
+  });
+});
+
+describe('imageUrlToBase64', () => {
+  const mockFetch = vi.fn();
+  const mockArrayBuffer = new ArrayBuffer(8);
+
+  beforeEach(() => {
+    global.fetch = mockFetch;
+    global.btoa = vi.fn().mockReturnValue('mockBase64String');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should convert image URL to base64 string', async () => {
+    mockFetch.mockResolvedValue({
+      arrayBuffer: () => Promise.resolve(mockArrayBuffer),
+      blob: () => Promise.resolve(new Blob([mockArrayBuffer], { type: 'image/jpg' })),
+    });
+
+    const result = await imageUrlToBase64('https://example.com/image.jpg');
+
+    expect(mockFetch).toHaveBeenCalledWith('https://example.com/image.jpg');
+    expect(global.btoa).toHaveBeenCalled();
+    expect(result).toEqual({ base64: 'mockBase64String', mimeType: 'image/jpg' });
+  });
+
+  it('should throw an error when fetch fails', async () => {
+    const mockError = new Error('Fetch failed');
+    mockFetch.mockRejectedValue(mockError);
+
+    await expect(imageUrlToBase64('https://example.com/image.jpg')).rejects.toThrow('Fetch failed');
+  });
+});

package/packages/model-runtime/src/utils/imageToBase64.ts

@@ -0,0 +1,62 @@
+export const imageToBase64 = ({
+  size,
+  img,
+  type = 'image/webp',
+}: {
+  img: HTMLImageElement;
+  size: number;
+  type?: string;
+}) => {
+  const canvas = document.createElement('canvas');
+  const ctx = canvas.getContext('2d') as CanvasRenderingContext2D;
+  let startX = 0;
+  let startY = 0;
+
+  if (img.width > img.height) {
+    startX = (img.width - img.height) / 2;
+  } else {
+    startY = (img.height - img.width) / 2;
+  }
+
+  canvas.width = size;
+  canvas.height = size;
+
+  ctx.drawImage(
+    img,
+    startX,
+    startY,
+    Math.min(img.width, img.height),
+    Math.min(img.width, img.height),
+    0,
+    0,
+    size,
+    size,
+  );
+
+  return canvas.toDataURL(type);
+};
+
+export const imageUrlToBase64 = async (
+  imageUrl: string,
+): Promise<{ base64: string; mimeType: string }> => {
+  try {
+    const res = await fetch(imageUrl);
+    const blob = await res.blob();
+    const arrayBuffer = await blob.arrayBuffer();
+
+    const base64 =
+      typeof btoa === 'function'
+        ? btoa(
+            new Uint8Array(arrayBuffer).reduce(
+              (data, byte) => data + String.fromCharCode(byte),
+              '',
+            ),
+          )
+        : Buffer.from(arrayBuffer).toString('base64');
+
+    return { base64, mimeType: blob.type };
+  } catch (error) {
+    console.error('Error converting image to base64:', error);
+    throw error;
+  }
+};

package/packages/model-runtime/src/utils/modelParse.test.ts

@@ -4,7 +4,7 @@ import type { ChatModelCard } from '@/types/llm';
 
 import {
   MODEL_LIST_CONFIGS,
-  PROVIDER_DETECTION_CONFIG,
+  MODEL_OWNER_DETECTION_CONFIG,
   detectModelProvider,
   processModelList,
   processMultiProviderModelList,
@@ -754,7 +754,7 @@ describe('modelParse', () => {
   describe('MODEL_LIST_CONFIGS and PROVIDER_DETECTION_CONFIG', () => {
     it('should have matching keys in both configuration objects', () => {
       const modelConfigKeys = Object.keys(MODEL_LIST_CONFIGS);
-      const providerDetectionKeys = Object.keys(PROVIDER_DETECTION_CONFIG);
+      const providerDetectionKeys = Object.keys(MODEL_OWNER_DETECTION_CONFIG);
       expect(modelConfigKeys.sort()).toEqual(providerDetectionKeys.sort());
     });
   });