@lobehub/chat 1.16.2 → 1.16.4

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

@@ -0,0 +1,40 @@
+import OpenAI from 'openai';
+
+import { imageUrlToBase64 } from '@/utils/imageToBase64';
+
+import { parseDataUri } from './uriParser';
+
+export const convertMessageContent = async (
+  content: OpenAI.ChatCompletionContentPart,
+): Promise<OpenAI.ChatCompletionContentPart> => {
+  if (content.type === 'image_url') {
+    const { type } = parseDataUri(content.image_url.url);
+
+    if (type === 'url' && process.env.LLM_VISION_IMAGE_USE_BASE64 === '1') {
+      const { base64, mimeType } = await imageUrlToBase64(content.image_url.url);
+
+      return {
+        ...content,
+        image_url: { ...content.image_url, url: `data:${mimeType};base64,${base64}` },
+      };
+    }
+  }
+
+  return content;
+};
+
+export const convertOpenAIMessages = async (messages: OpenAI.ChatCompletionMessageParam[]) => {
+  return (await Promise.all(
+    messages.map(async (message) => ({
+      ...message,
+      content:
+        typeof message.content === 'string'
+          ? message.content
+          : await Promise.all(
+              (message.content || []).map((c) =>
+                convertMessageContent(c as OpenAI.ChatCompletionContentPart),
+              ),
+            ),
+    })),
+  )) as OpenAI.ChatCompletionMessageParam[];
+};

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

@@ -2,19 +2,14 @@ import OpenAI, { ClientOptions } from 'openai';
 
 import { LobeRuntimeAI } from '../BaseAI';
 import { AgentRuntimeErrorType } from '../error';
-import {
-  ChatCompetitionOptions,
-  ChatStreamPayload,
-  ModelProvider,
-  OpenAIChatMessage,
-} from '../types';
+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';
+import { convertOpenAIMessages } from '../utils/openaiHelpers';
 import { StreamingResponse } from '../utils/response';
 import { OpenAIStream } from '../utils/streams';
-import { parseDataUri } from '../utils/uriParser';
 import { generateApiToken } from './authToken';
 
 const DEFAULT_BASE_URL = 'https://open.bigmodel.cn/api/paas/v4';
@@ -52,7 +47,7 @@ export class LobeZhipuAI implements LobeRuntimeAI {
 
   async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
     try {
-      const params = this.buildCompletionsParams(payload);
+      const params = await this.buildCompletionsParams(payload);
 
       const response = await this.client.chat.completions.create(
         params as unknown as OpenAI.ChatCompletionCreateParamsStreaming,
@@ -85,11 +80,11 @@ export class LobeZhipuAI implements LobeRuntimeAI {
     }
   }
 
-  private buildCompletionsParams(payload: ChatStreamPayload) {
+  private async buildCompletionsParams(payload: ChatStreamPayload) {
     const { messages, temperature, top_p, ...params } = payload;
 
     return {
-      messages: messages.map((m) => this.transformMessage(m)) as any,
+      messages: await convertOpenAIMessages(messages as any),
       ...params,
       do_sample: temperature === 0,
       stream: true,
@@ -99,32 +94,6 @@ export class LobeZhipuAI implements LobeRuntimeAI {
       top_p: top_p === 1 ? 0.99 : top_p,
     };
   }
-
-  // TODO: 临时处理，后续需要移除
-  private transformMessage = (message: OpenAIChatMessage): OpenAIChatMessage => {
-    return {
-      ...message,
-      content:
-        typeof message.content === 'string'
-          ? message.content
-          : message.content.map((c) => {
-              switch (c.type) {
-                default:
-                case 'text': {
-                  return c;
-                }
-
-                case 'image_url': {
-                  const { base64 } = parseDataUri(c.image_url.url);
-                  return {
-                    image_url: { ...c.image_url, url: base64 || c.image_url.url },
-                    type: 'image_url',
-                  };
-                }
-              }
-            }),
-    };
-  };
 }
 
 export default LobeZhipuAI;

package/src/locales/default/common.ts

@@ -10,7 +10,7 @@ export default {
       title: '{{name}} 开始公测',
     },
   },
-  appInitializing: '应用启动中，请耐心等待...',
+  appInitializing: '应用启动中...',
   autoGenerate: '自动补全',
   autoGenerateTooltip: '基于提示词自动补全助手描述',
   autoGenerateTooltipDisabled: '请填写提示词后使用自动补全功能',

package/src/locales/default/error.ts

@@ -16,7 +16,8 @@ export default {
   fetchErrorDetail: '错误详情',
   notFound: {
     backHome: '返回首页',
-    desc: '我们找不到你正在寻找的页面，请检查链接是否正确',
+    check: '请检查你的 URL 是否正确',
+    desc: '我们找不到你寻找的页面',
     title: '进入了未知领域？',
   },
   pluginSettings: {

package/src/locales/default/file.ts

@@ -21,6 +21,7 @@ export default {
       embeddingStatus: '向量化',
     },
   },
+  empty: '暂无已上传文件/文件夹',
   header: {
     actions: {
       newFolder: '新建文件夹',
@@ -38,6 +39,7 @@ export default {
     new: '新建知识库',
     title: '知识库',
   },
+  networkError: '获取知识库失败，请检测网络连接后重试',
   notSupportGuide: {
     desc: '当前部署实例为客户端数据库模式，无法使用文件管理功能。请切换到<1>服务端数据库部署模式</1>，或直接使用 <3>LobeChat Cloud</3>',
     features: {

package/src/utils/imageToBase64.test.ts

@@ -72,13 +72,14 @@ describe('imageUrlToBase64', () => {
   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).toBe('mockBase64String');
+    expect(result).toEqual({ base64: 'mockBase64String', mimeType: 'image/jpg' });
   });
 
   it('should throw an error when fetch fails', async () => {

package/src/utils/imageToBase64.ts

@@ -36,16 +36,25 @@ export const imageToBase64 = ({
   return canvas.toDataURL(type);
 };
 
-export const imageUrlToBase64 = async (imageUrl: string): Promise<string> => {
+export const imageUrlToBase64 = async (
+  imageUrl: string,
+): Promise<{ base64: string; mimeType: string }> => {
   try {
     const res = await fetch(imageUrl);
-    const arrayBuffer = await res.arrayBuffer();
+    const blob = await res.blob();
+    const arrayBuffer = await blob.arrayBuffer();
 
-    return typeof btoa === 'function'
-      ? btoa(
-          new Uint8Array(arrayBuffer).reduce((data, byte) => data + String.fromCharCode(byte), ''),
-        )
-      : Buffer.from(arrayBuffer).toString('base64');
+    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;