@lobehub/chat 1.119.1 → 1.120.0

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());
     });
   });

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

@@ -1,4 +1,5 @@
 import type { ChatModelCard } from '@lobechat/types';
+import { AIBaseModelCard } from 'model-bank';
 
 import type { ModelProviderKey } from '../types';
 
@@ -25,16 +26,16 @@ export const MODEL_LIST_CONFIGS = {
     reasoningKeywords: ['thinking', '-2.5-'],
     visionKeywords: ['gemini', 'learnlm'],
   },
+  llama: {
+    functionCallKeywords: ['llama-3.2', 'llama-3.3', 'llama-4'],
+    reasoningKeywords: [],
+    visionKeywords: ['llava'],
+  },
   moonshot: {
     functionCallKeywords: ['moonshot', 'kimi'],
     reasoningKeywords: ['thinking'],
     visionKeywords: ['vision', 'kimi-latest', 'kimi-thinking-preview'],
   },
-  ollama: {
-    functionCallKeywords: ['llama-3.2', 'llama-3.3', 'llama-4'],
-    reasoningKeywords: [],
-    visionKeywords: ['llava'],
-  },
   openai: {
     excludeKeywords: ['audio'],
     functionCallKeywords: ['4o', '4.1', 'o3', 'o4', 'oss'],
@@ -81,13 +82,13 @@ export const MODEL_LIST_CONFIGS = {
   },
 } as const;
 
-// 模型提供商关键词配置
-export const PROVIDER_DETECTION_CONFIG = {
+// 模型所有者 (提供商) 关键词配置
+export const MODEL_OWNER_DETECTION_CONFIG = {
   anthropic: ['claude'],
   deepseek: ['deepseek'],
   google: ['gemini', 'imagen'],
+  llama: ['llama', 'llava'],
   moonshot: ['moonshot', 'kimi'],
-  ollama: ['llama', 'llava'],
   openai: ['o1', 'o3', 'o4', 'gpt-'],
   qwen: ['qwen', 'qwq', 'qvq'],
   v0: ['v0'],
@@ -175,7 +176,12 @@ const findKnownModelByProvider = async (
     // 尝试动态导入对应的配置文件
     const modules = await import('model-bank');
 
-    const providerModels = modules[provider];
+    // 如果提供商配置文件不存在，跳过
+    if (!(provider in modules)) {
+      return null;
+    }
+
+    const providerModels = modules[provider as keyof typeof modules] as AIBaseModelCard[];
 
     // 如果导入成功且有数据，进行查找
     if (Array.isArray(providerModels)) {
@@ -197,7 +203,7 @@ const findKnownModelByProvider = async (
 export const detectModelProvider = (modelId: string): keyof typeof MODEL_LIST_CONFIGS => {
   const lowerModelId = modelId.toLowerCase();
 
-  for (const [provider, keywords] of Object.entries(PROVIDER_DETECTION_CONFIG)) {
+  for (const [provider, keywords] of Object.entries(MODEL_OWNER_DETECTION_CONFIG)) {
     const hasKeyword = isKeywordListMatch(lowerModelId, keywords);
 
     if (hasKeyword && provider in MODEL_LIST_CONFIGS) {

package/packages/model-runtime/src/utils/openaiCompatibleFactory/createImage.ts

@@ -1,9 +1,9 @@
-import { imageUrlToBase64 } from '@lobechat/utils';
 import createDebug from 'debug';
 import { RuntimeImageGenParamsValue } from 'model-bank';
 import OpenAI from 'openai';
 
 import { CreateImagePayload, CreateImageResponse } from '../../types/image';
+import { imageUrlToBase64 } from '../imageToBase64';
 import { convertImageUrlToFile } from '../openaiHelpers';
 import { parseDataUri } from '../uriParser';
 

package/packages/model-runtime/src/utils/openaiCompatibleFactory/index.ts

@@ -1,15 +1,13 @@
-import { getModelPropertyWithFallback } from '@lobechat/utils';
 import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc';
 import { LOBE_DEFAULT_MODEL_LIST } from 'model-bank';
+import type { AiModelType } from 'model-bank';
 import OpenAI, { ClientOptions } from 'openai';
 import { Stream } from 'openai/streaming';
 
-import type { AiModelType } from '@/types/aiModel';
 import type { ChatModelCard } from '@/types/llm';
 
 import { LobeRuntimeAI } from '../../BaseAI';
-import { AgentRuntimeErrorType, ILobeAgentRuntimeErrorType } from '../../error';
 import {
   ChatCompletionErrorPayload,
   ChatCompletionTool,
@@ -24,10 +22,12 @@ import {
   TextToSpeechOptions,
   TextToSpeechPayload,
 } from '../../types';
+import { AgentRuntimeErrorType, ILobeAgentRuntimeErrorType } from '../../types/error';
 import { CreateImagePayload, CreateImageResponse } from '../../types/image';
 import { AgentRuntimeError } from '../createError';
 import { debugResponse, debugStream } from '../debugStream';
 import { desensitizeUrl } from '../desensitizeUrl';
+import { getModelPropertyWithFallback } from '../getFallbackModelProperty';
 import { handleOpenAIError } from '../handleOpenAIError';
 import { convertOpenAIMessages, convertOpenAIResponseInputs } from '../openaiHelpers';
 import { postProcessModelList } from '../postProcessModelList';

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

@@ -1,7 +1,7 @@
-import { imageUrlToBase64 } from '@lobechat/utils';
 import OpenAI from 'openai';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { imageUrlToBase64 } from './imageToBase64';
 import {
   convertImageUrlToFile,
   convertMessageContent,
@@ -11,7 +11,7 @@ import {
 import { parseDataUri } from './uriParser';
 
 // 模拟依赖
-vi.mock('@lobechat/utils');
+vi.mock('./imageToBase64');
 vi.mock('./uriParser');
 
 describe('convertMessageContent', () => {

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

@@ -1,9 +1,8 @@
-import { imageUrlToBase64 } from '@lobechat/utils';
 import OpenAI, { toFile } from 'openai';
 
-import { disableStreamModels, systemToUserModels } from '@/const/models';
-import { ChatStreamPayload, OpenAIChatMessage } from '@/libs/model-runtime';
-
+import { disableStreamModels, systemToUserModels } from '../const/models';
+import { ChatStreamPayload, OpenAIChatMessage } from '../types';
+import { imageUrlToBase64 } from './imageToBase64';
 import { parseDataUri } from './uriParser';
 
 export const convertMessageContent = async (

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

@@ -1,5 +1,5 @@
-import { CHAT_MODEL_IMAGE_GENERATION_PARAMS } from '@/const/image';
-import type { AiModelType } from '@/types/aiModel';
+import { AiModelType, CHAT_MODEL_IMAGE_GENERATION_PARAMS } from 'model-bank';
+
 import type { ChatModelCard } from '@/types/llm';
 
 // Whitelist for automatic image model generation

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

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+
+import { safeParseJSON } from './safeParseJSON';
+
+describe('safeParseJSON', () => {
+  it('should parse a valid JSON string', () => {
+    const validJSON = '{"name": "John", "age": 30}';
+    const result = safeParseJSON(validJSON);
+    expect(result).toEqual({ name: 'John', age: 30 });
+  });
+
+  it('should return undefined for invalid JSON', () => {
+    const invalidJSON = '{name: John}';
+    const result = safeParseJSON(invalidJSON);
+    expect(result).toBeUndefined();
+  });
+
+  it('should parse an empty object', () => {
+    const emptyObject = '{}';
+    const result = safeParseJSON(emptyObject);
+    expect(result).toEqual({});
+  });
+
+  it('should parse an array', () => {
+    const arrayJSON = '[1, 2, 3]';
+    const result = safeParseJSON(arrayJSON);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it('should parse nested objects', () => {
+    const nestedJSON = '{"user": {"name": "John", "age": 30}}';
+    const result = safeParseJSON(nestedJSON);
+    expect(result).toEqual({ user: { name: 'John', age: 30 } });
+  });
+
+  it('should return undefined for an empty string', () => {
+    const result = safeParseJSON('');
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined for non-string input', () => {
+    // @ts-expect-error: Testing with invalid input type
+    const result = safeParseJSON(123);
+    expect(result).toBeUndefined();
+  });
+
+  it('should parse JSON with special characters', () => {
+    const specialJSON = '{"message": "Hello, \\"world\\"!"}';
+    const result = safeParseJSON(specialJSON);
+    expect(result).toEqual({ message: 'Hello, "world"!' });
+  });
+
+  it('should parse large JSON without throwing an error', () => {
+    const largeJSON = JSON.stringify({ data: Array(1000).fill('test') });
+    const result = safeParseJSON(largeJSON);
+    expect(result).toHaveProperty('data');
+    expect(Array.isArray(result!.data)).toBe(true);
+    expect(result!.data).toHaveLength(1000);
+  });
+
+  it('should handle JSON with different data types', () => {
+    const mixedJSON = '{"string": "text", "number": 42, "boolean": true, "null": null}';
+    const result = safeParseJSON(mixedJSON);
+    expect(result).toEqual({
+      string: 'text',
+      number: 42,
+      boolean: true,
+      null: null,
+    });
+  });
+});

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

@@ -0,0 +1,12 @@
+export const safeParseJSON = <T = Record<string, any>>(text?: string) => {
+  if (typeof text !== 'string') return undefined;
+
+  let json: T;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    return undefined;
+  }
+
+  return json;
+};

package/packages/model-runtime/src/utils/streams/bedrock/claude.ts

@@ -1,7 +1,7 @@
 import { InvokeModelWithResponseStreamResponse } from '@aws-sdk/client-bedrock-runtime';
-import { nanoid } from '@lobechat/utils';
 
 import { ChatStreamCallbacks } from '../../../types';
+import { nanoid } from '../../uuid';
 import { transformAnthropicStream } from '../anthropic';
 import {
   StreamContext,

package/packages/model-runtime/src/utils/streams/bedrock/llama.test.ts

@@ -1,8 +1,7 @@
 import { InvokeModelWithResponseStreamResponse } from '@aws-sdk/client-bedrock-runtime';
-import * as uuidModule from '@lobechat/utils';
-import { Readable } from 'stream';
 import { describe, expect, it, vi } from 'vitest';
 
+import * as uuidModule from '../../uuid';
 import { AWSBedrockLlamaStream } from './llama';
 
 describe('AWSBedrockLlamaStream', () => {

package/packages/model-runtime/src/utils/streams/bedrock/llama.ts

@@ -1,7 +1,7 @@
 import { InvokeModelWithResponseStreamResponse } from '@aws-sdk/client-bedrock-runtime';
-import { nanoid } from '@lobechat/utils';
 
 import { ChatStreamCallbacks } from '../../../types';
+import { nanoid } from '../../uuid';
 import {
   StreamContext,
   StreamProtocolChunk,

package/packages/model-runtime/src/utils/streams/google-ai.test.ts

@@ -1,7 +1,7 @@
 import { GenerateContentResponse } from '@google/genai';
-import * as uuidModule from '@lobechat/utils';
 import { describe, expect, it, vi } from 'vitest';
 
+import * as uuidModule from '../uuid';
 import { GoogleGenerativeAIStream } from './google-ai';
 
 describe('GoogleGenerativeAIStream', () => {

package/packages/model-runtime/src/utils/streams/google-ai.ts

@@ -1,11 +1,11 @@
 import { GenerateContentResponse } from '@google/genai';
-import { nanoid } from '@lobechat/utils';
 
 import errorLocale from '@/locales/default/error';
 import { ModelTokensUsage } from '@/types/message';
 import { GroundingSearch } from '@/types/search';
 
 import { ChatStreamCallbacks } from '../../types';
+import { nanoid } from '../uuid';
 import {
   StreamContext,
   StreamProtocolChunk,