@lobehub/chat 1.140.0 → 1.141.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.140.0",
+  "version": "1.141.0",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",
@@ -164,7 +164,7 @@
     "@lobehub/charts": "^2.1.2",
     "@lobehub/chat-plugin-sdk": "^1.32.4",
     "@lobehub/chat-plugins-gateway": "^1.9.0",
-    "@lobehub/editor": "^1.16.1",
+    "@lobehub/editor": "^1.20.2",
     "@lobehub/icons": "^2.42.0",
     "@lobehub/market-sdk": "^0.22.7",
     "@lobehub/tts": "^2.0.1",
@@ -174,6 +174,7 @@
     "@next/third-parties": "^15.5.4",
     "@opentelemetry/exporter-jaeger": "^2.1.0",
     "@opentelemetry/winston-transport": "^0.17.0",
+    "@react-pdf/renderer": "^4.3.0",
     "@react-spring/web": "^9.7.5",
     "@saintno/comfyui-sdk": "^0.2.48",
     "@serwist/next": "^9.2.1",
@@ -187,6 +188,7 @@
     "@vercel/edge-config": "^1.4.0",
     "@vercel/functions": "^3.1.3",
     "@vercel/speed-insights": "^1.2.0",
+    "@virtuoso.dev/masonry": "^1.3.5",
     "@xterm/xterm": "^5.5.0",
     "ahooks": "^3.9.5",
     "antd": "^5.27.4",
@@ -224,6 +226,7 @@
     "lucide-react": "^0.544.0",
     "mammoth": "^1.11.0",
     "markdown-to-txt": "^2.0.1",
+    "marked": "^16.3.0",
     "mdast-util-to-markdown": "^2.1.2",
     "model-bank": "workspace:*",
     "modern-screenshot": "^4.6.6",
@@ -244,6 +247,7 @@
     "path-browserify-esm": "^1.0.6",
     "pdf-parse": "^1.1.1",
     "pdfjs-dist": "4.8.69",
+    "pdfkit": "^0.17.2",
     "pg": "^8.16.3",
     "pino": "^9.13.1",
     "plaiceholder": "^3.0.0",
@@ -320,9 +324,11 @@
     "@types/json-schema": "^7.0.15",
     "@types/lodash": "^4.17.20",
     "@types/lodash-es": "^4.17.12",
+    "@types/marked": "^6.0.0",
     "@types/node": "^22.18.9",
     "@types/numeral": "^2.0.5",
     "@types/oidc-provider": "^9.5.0",
+    "@types/pdfkit": "^0.17.3",
     "@types/pg": "^8.15.5",
     "@types/react": "^19.2.2",
     "@types/react-dom": "^19.2.1",

package/packages/database/src/models/__tests__/message.test.ts

@@ -7,10 +7,10 @@ import { uuid } from '@/utils/uuid';
 
 import { getTestDB } from '../../models/__tests__/_util';
 import {
-  chunks,
-  embeddings,
   agents,
   chatGroups,
+  chunks,
+  embeddings,
   fileChunks,
   files,
   messagePlugins,
@@ -1290,6 +1290,204 @@ describe('MessageModel', () => {
     });
   });
 
+  describe('updateMetadata', () => {
+    it('should update metadata for an existing message', async () => {
+      // 创建测试数据
+      await serverDB.insert(messages).values({
+        id: 'msg-with-metadata',
+        userId,
+        role: 'user',
+        content: 'test message',
+        metadata: { existingKey: 'existingValue' },
+      });
+
+      // 调用 updateMetadata 方法
+      await messageModel.updateMetadata('msg-with-metadata', { newKey: 'newValue' });
+
+      // 断言结果
+      const result = await serverDB
+        .select()
+        .from(messages)
+        .where(eq(messages.id, 'msg-with-metadata'));
+
+      expect(result[0].metadata).toEqual({
+        existingKey: 'existingValue',
+        newKey: 'newValue',
+      });
+    });
+
+    it('should merge new metadata with existing metadata using lodash merge behavior', async () => {
+      // 创建测试数据
+      await serverDB.insert(messages).values({
+        id: 'msg-merge-metadata',
+        userId,
+        role: 'assistant',
+        content: 'test message',
+        metadata: {
+          level1: {
+            level2a: 'original',
+            level2b: { level3: 'deep' },
+          },
+          array: [1, 2, 3],
+        },
+      });
+
+      // 调用 updateMetadata 方法
+      await messageModel.updateMetadata('msg-merge-metadata', {
+        level1: {
+          level2a: 'updated',
+          level2c: 'new',
+        },
+        newTopLevel: 'value',
+      });
+
+      // 断言结果 - 应该使用 lodash merge 行为
+      const result = await serverDB
+        .select()
+        .from(messages)
+        .where(eq(messages.id, 'msg-merge-metadata'));
+
+      expect(result[0].metadata).toEqual({
+        level1: {
+          level2a: 'updated',
+          level2b: { level3: 'deep' },
+          level2c: 'new',
+        },
+        array: [1, 2, 3],
+        newTopLevel: 'value',
+      });
+    });
+
+    it('should handle non-existent message IDs', async () => {
+      // 调用 updateMetadata 方法，尝试更新不存在的消息
+      const result = await messageModel.updateMetadata('non-existent-id', { key: 'value' });
+
+      // 断言结果 - 应该返回 undefined
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle empty metadata updates', async () => {
+      // 创建测试数据
+      await serverDB.insert(messages).values({
+        id: 'msg-empty-metadata',
+        userId,
+        role: 'user',
+        content: 'test message',
+        metadata: { originalKey: 'originalValue' },
+      });
+
+      // 调用 updateMetadata 方法，传递空对象
+      await messageModel.updateMetadata('msg-empty-metadata', {});
+
+      // 断言结果 - 原始 metadata 应该保持不变
+      const result = await serverDB
+        .select()
+        .from(messages)
+        .where(eq(messages.id, 'msg-empty-metadata'));
+
+      expect(result[0].metadata).toEqual({ originalKey: 'originalValue' });
+    });
+
+    it('should handle message with null metadata', async () => {
+      // 创建测试数据
+      await serverDB.insert(messages).values({
+        id: 'msg-null-metadata',
+        userId,
+        role: 'user',
+        content: 'test message',
+        metadata: null,
+      });
+
+      // 调用 updateMetadata 方法
+      await messageModel.updateMetadata('msg-null-metadata', { key: 'value' });
+
+      // 断言结果 - 应该创建新的 metadata
+      const result = await serverDB
+        .select()
+        .from(messages)
+        .where(eq(messages.id, 'msg-null-metadata'));
+
+      expect(result[0].metadata).toEqual({ key: 'value' });
+    });
+
+    it('should only update messages belonging to the current user', async () => {
+      // 创建测试数据 - 其他用户的消息
+      await serverDB.insert(messages).values({
+        id: 'msg-other-user',
+        userId: '456',
+        role: 'user',
+        content: 'test message',
+        metadata: { originalKey: 'originalValue' },
+      });
+
+      // 调用 updateMetadata 方法
+      const result = await messageModel.updateMetadata('msg-other-user', {
+        hackedKey: 'hackedValue',
+      });
+
+      // 断言结果 - 应该返回 undefined
+      expect(result).toBeUndefined();
+
+      // 验证原始 metadata 未被修改
+      const dbResult = await serverDB
+        .select()
+        .from(messages)
+        .where(eq(messages.id, 'msg-other-user'));
+
+      expect(dbResult[0].metadata).toEqual({ originalKey: 'originalValue' });
+    });
+
+    it('should handle complex nested metadata updates', async () => {
+      // 创建测试数据
+      await serverDB.insert(messages).values({
+        id: 'msg-complex-metadata',
+        userId,
+        role: 'assistant',
+        content: 'test message',
+        metadata: {
+          config: {
+            settings: {
+              enabled: true,
+              options: ['a', 'b'],
+            },
+            version: 1,
+          },
+        },
+      });
+
+      // 调用 updateMetadata 方法
+      await messageModel.updateMetadata('msg-complex-metadata', {
+        config: {
+          settings: {
+            enabled: false,
+            timeout: 5000,
+          },
+          newField: 'value',
+        },
+        stats: { count: 10 },
+      });
+
+      // 断言结果
+      const result = await serverDB
+        .select()
+        .from(messages)
+        .where(eq(messages.id, 'msg-complex-metadata'));
+
+      expect(result[0].metadata).toEqual({
+        config: {
+          settings: {
+            enabled: false,
+            options: ['a', 'b'],
+            timeout: 5000,
+          },
+          version: 1,
+          newField: 'value',
+        },
+        stats: { count: 10 },
+      });
+    });
+  });
+
   describe('updateTranslate', () => {
     it('should insert a new record if message does not exist in messageTranslates table', async () => {
       // 创建测试数据

package/packages/database/src/models/message.ts

@@ -570,6 +570,19 @@ export class MessageModel {
     });
   };
 
+  updateMetadata = async (id: string, metadata: Record<string, any>) => {
+    const item = await this.db.query.messages.findFirst({
+      where: and(eq(messages.id, id), eq(messages.userId, this.userId)),
+    });
+
+    if (!item) return;
+
+    return this.db
+      .update(messages)
+      .set({ metadata: merge(item.metadata || {}, metadata) })
+      .where(and(eq(messages.userId, this.userId), eq(messages.id, id)));
+  };
+
   updatePluginState = async (id: string, state: Record<string, any>) => {
     const item = await this.db.query.messagePlugins.findFirst({
       where: eq(messagePlugins.id, id),

package/packages/model-runtime/src/core/openaiCompatibleFactory/index.test.ts

@@ -2048,6 +2048,319 @@ describe('LobeOpenAICompatibleFactory', () => {
       });
     });
 
+    describe('handleSchema option', () => {
+      let instanceWithSchemaHandler: any;
+      const mockSchemaHandler = vi.fn((schema: any) => {
+        const filtered: any = {};
+        for (const [key, value] of Object.entries(schema)) {
+          if (key !== 'maxLength' && key !== 'pattern') {
+            filtered[key] = value;
+          }
+        }
+        return filtered;
+      });
+
+      beforeEach(() => {
+        mockSchemaHandler.mockClear();
+        const RuntimeClass = createOpenAICompatibleRuntime({
+          baseURL: 'https://api.test.com',
+          generateObject: {
+            handleSchema: mockSchemaHandler,
+          },
+          provider: 'test-provider',
+        });
+
+        instanceWithSchemaHandler = new RuntimeClass({ apiKey: 'test-key' });
+      });
+
+      it('should apply schema transformation with Responses API', async () => {
+        const mockResponse = {
+          output_text: '{"name":"Alice","age":30}',
+        };
+
+        vi.spyOn(instanceWithSchemaHandler['client'].responses, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Extract person', role: 'user' as const }],
+          model: 'gpt-4o',
+          responseApi: true,
+          schema: {
+            name: 'person',
+            schema: {
+              maxLength: 100,
+              pattern: '^[a-z]+$',
+              properties: {
+                age: { type: 'number' },
+                name: { type: 'string' },
+              },
+              type: 'object' as const,
+            },
+          },
+        };
+
+        await instanceWithSchemaHandler.generateObject(payload);
+
+        expect(mockSchemaHandler).toHaveBeenCalledWith(payload.schema.schema);
+        expect(instanceWithSchemaHandler['client'].responses.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            text: expect.objectContaining({
+              format: expect.objectContaining({
+                schema: {
+                  properties: {
+                    age: { type: 'number' },
+                    name: { type: 'string' },
+                  },
+                  type: 'object',
+                },
+              }),
+            }),
+          }),
+          expect.any(Object),
+        );
+      });
+
+      it('should apply schema transformation with Chat Completions API', async () => {
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                content: '{"name":"Bob","age":25}',
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instanceWithSchemaHandler['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Extract person', role: 'user' as const }],
+          model: 'test-model',
+          schema: {
+            name: 'person',
+            schema: {
+              maxLength: 100,
+              pattern: '^[a-z]+$',
+              properties: {
+                age: { type: 'number' },
+                name: { type: 'string' },
+              },
+              type: 'object' as const,
+            },
+          },
+        };
+
+        await instanceWithSchemaHandler.generateObject(payload);
+
+        expect(mockSchemaHandler).toHaveBeenCalledWith(payload.schema.schema);
+        expect(instanceWithSchemaHandler['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            response_format: expect.objectContaining({
+              json_schema: expect.objectContaining({
+                schema: {
+                  properties: {
+                    age: { type: 'number' },
+                    name: { type: 'string' },
+                  },
+                  type: 'object',
+                },
+              }),
+            }),
+          }),
+          expect.any(Object),
+        );
+      });
+
+      it('should apply schema transformation with tool calling fallback', async () => {
+        const RuntimeClass = createOpenAICompatibleRuntime({
+          baseURL: 'https://api.test.com',
+          generateObject: {
+            handleSchema: mockSchemaHandler,
+            useToolsCalling: true,
+          },
+          provider: 'test-provider',
+        });
+
+        const instance = new RuntimeClass({ apiKey: 'test-key' });
+
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                tool_calls: [
+                  {
+                    function: {
+                      arguments: '{"name":"Charlie","age":35}',
+                      name: 'person',
+                    },
+                    type: 'function' as const,
+                  },
+                ],
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Extract person', role: 'user' as const }],
+          model: 'test-model',
+          schema: {
+            name: 'person',
+            schema: {
+              maxLength: 100,
+              pattern: '^[a-z]+$',
+              properties: {
+                age: { type: 'number' },
+                name: { type: 'string' },
+              },
+              type: 'object' as const,
+            },
+          },
+        };
+
+        await instance.generateObject(payload);
+
+        expect(mockSchemaHandler).toHaveBeenCalledWith(payload.schema.schema);
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            tools: [
+              expect.objectContaining({
+                function: expect.objectContaining({
+                  parameters: {
+                    properties: {
+                      age: { type: 'number' },
+                      name: { type: 'string' },
+                    },
+                    type: 'object',
+                  },
+                }),
+              }),
+            ],
+          }),
+          expect.any(Object),
+        );
+      });
+
+      it('should not apply schema transformation when handleSchema is not configured', async () => {
+        const RuntimeClass = createOpenAICompatibleRuntime({
+          baseURL: 'https://api.test.com',
+          provider: 'test-provider',
+        });
+
+        const instance = new RuntimeClass({ apiKey: 'test-key' });
+
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                content: '{"name":"Test"}',
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Extract data', role: 'user' as const }],
+          model: 'test-model',
+          schema: {
+            name: 'test',
+            schema: {
+              maxLength: 100,
+              properties: {
+                name: { type: 'string' },
+              },
+              type: 'object' as const,
+            },
+          },
+        };
+
+        await instance.generateObject(payload);
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            response_format: expect.objectContaining({
+              json_schema: expect.objectContaining({
+                schema: {
+                  maxLength: 100,
+                  properties: {
+                    name: { type: 'string' },
+                  },
+                  type: 'object',
+                },
+              }),
+            }),
+          }),
+          expect.any(Object),
+        );
+      });
+
+      it('should preserve original schema properties while filtering', async () => {
+        const mockResponse = {
+          output_text: '{"result":"success"}',
+        };
+
+        vi.spyOn(instanceWithSchemaHandler['client'].responses, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Test', role: 'user' as const }],
+          model: 'gpt-4o',
+          responseApi: true,
+          schema: {
+            description: 'Test schema',
+            name: 'test',
+            schema: {
+              description: 'Inner schema description',
+              maxLength: 100,
+              pattern: '^test$',
+              properties: {
+                result: { type: 'string' },
+              },
+              required: ['result'],
+              type: 'object' as const,
+            },
+            strict: true,
+          },
+        };
+
+        await instanceWithSchemaHandler.generateObject(payload);
+
+        expect(mockSchemaHandler).toHaveBeenCalledWith(payload.schema.schema);
+        expect(instanceWithSchemaHandler['client'].responses.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            text: expect.objectContaining({
+              format: expect.objectContaining({
+                description: 'Test schema',
+                name: 'test',
+                schema: {
+                  description: 'Inner schema description',
+                  properties: {
+                    result: { type: 'string' },
+                  },
+                  required: ['result'],
+                  type: 'object',
+                },
+                strict: true,
+              }),
+            }),
+          }),
+          expect.any(Object),
+        );
+      });
+    });
+
     describe('tool calling fallback', () => {
       let instanceWithToolCalling: any;
 

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

@@ -119,6 +119,10 @@ export interface OpenAICompatibleFactoryOptions<T extends Record<string, any> =
     invalidAPIKey: ILobeAgentRuntimeErrorType;
   };
   generateObject?: {
+    /**
+     * Transform schema before sending to the provider (e.g., filter unsupported properties)
+     */
+    handleSchema?: (schema: any) => any;
     /**
      * If true, route generateObject requests to Responses API path directly
      */
@@ -454,12 +458,19 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
       // Use tool calling fallback if configured
       if (generateObjectConfig?.useToolsCalling) {
         log('using tool calling fallback for structured output');
+
+        // Apply schema transformation if configured
+        const processedSchema = generateObjectConfig.handleSchema
+          ? { ...schema, schema: generateObjectConfig.handleSchema(schema.schema) }
+          : schema;
+
         const tool: ChatCompletionTool = {
           function: {
             description:
-              schema.description || 'Generate structured output according to the provided schema',
-            name: schema.name || 'structured_output',
-            parameters: schema.schema,
+              processedSchema.description ||
+              'Generate structured output according to the provided schema',
+            name: processedSchema.name || 'structured_output',
+            parameters: processedSchema.schema,
           },
           type: 'function',
         };
@@ -531,13 +542,18 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
         return false;
       })();
 
+      // Apply schema transformation if configured
+      const processedSchema = generateObjectConfig?.handleSchema
+        ? { ...schema, schema: generateObjectConfig.handleSchema(schema.schema) }
+        : schema;
+
       if (shouldUseResponses) {
         log('calling responses.create for structured output');
         const res = await this.client!.responses.create(
           {
             input: messages,
             model,
-            text: { format: { strict: true, type: 'json_schema', ...schema } },
+            text: { format: { strict: true, type: 'json_schema', ...processedSchema } },
             user: options?.user,
           },
           { headers: options?.headers, signal: options?.signal },
@@ -561,7 +577,7 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
         {
           messages,
           model,
-          response_format: { json_schema: schema, type: 'json_schema' },
+          response_format: { json_schema: processedSchema, type: 'json_schema' },
           user: options?.user,
         },
         { headers: options?.headers, signal: options?.signal },