@lobehub/chat 1.140.0 → 1.141.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.140.0",
+  "version": "1.141.1",
   "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/context-engine/src/__tests__/pipeline.test.ts

@@ -36,19 +36,9 @@ describe('ContextEngine', () => {
   });
 
   const createInitialContext = (): {
-    initialState: any;
-    maxTokens: number;
     messages: any[];
-    model: string;
   } => ({
-    initialState: {
-      messages: [],
-      model: 'test-model',
-      provider: 'test-provider',
-    },
-    maxTokens: 4000,
     messages: [{ content: 'test', role: 'user' }],
-    model: 'test-model',
   });
 
   describe('constructor', () => {
@@ -206,8 +196,7 @@ describe('ContextEngine', () => {
       const processor = createMockProcessor('p1');
       const engine = new ContextEngine({ pipeline: [processor] });
 
-      const input = { ...createInitialContext(), messages: undefined };
-      const result = await engine.process(input);
+      const result = await engine.process({ messages: [] });
 
       expect(result.messages).toEqual([]);
     });
@@ -216,19 +205,14 @@ describe('ContextEngine', () => {
       const processor: ContextProcessor = {
         name: 'test',
         process: vi.fn(async (context) => {
-          expect(context.metadata.maxTokens).toBe(4000);
-          expect(context.metadata.model).toBe('test-model');
-          expect(context.metadata.customKey).toBe('customValue');
+          expect(context.metadata).toBeDefined();
           return context;
         }),
       };
 
       const engine = new ContextEngine({ pipeline: [processor] });
 
-      await engine.process({
-        ...createInitialContext(),
-        metadata: { customKey: 'customValue' },
-      });
+      await engine.process(createInitialContext());
     });
 
     it('should track execution stats', async () => {
@@ -278,12 +262,7 @@ describe('ContextEngine', () => {
         pipeline: [processor1, processor2],
       });
 
-      const input = {
-        ...createInitialContext(),
-      };
-      input.initialState = { ...input.initialState, messages: [] };
-
-      const result = await engine.process(input);
+      const result = await engine.process(createInitialContext());
 
       expect(result.isAborted).toBe(true);
       expect(result.stats.processedCount).toBe(1);
@@ -333,16 +312,17 @@ describe('ContextEngine', () => {
     });
 
     it('should preserve initial state', async () => {
+      const testContext = createInitialContext();
       const processor: ContextProcessor = {
         name: 'test',
         process: vi.fn(async (context) => {
-          expect(context.initialState).toEqual(createInitialContext().initialState);
+          expect(context.initialState.messages).toEqual(testContext.messages);
           return context;
         }),
       };
 
       const engine = new ContextEngine({ pipeline: [processor] });
-      await engine.process(createInitialContext());
+      await engine.process(testContext);
     });
   });
 

package/packages/context-engine/src/pipeline.ts

@@ -1,12 +1,6 @@
 import debug from 'debug';
 
-import type {
-  AgentState,
-  ContextProcessor,
-  PipelineContext,
-  PipelineResult,
-  ProcessorOptions,
-} from './types';
+import type { ContextProcessor, PipelineContext, PipelineResult, ProcessorOptions } from './types';
 import { PipelineError } from './types';
 
 const log = debug('context-engine:ContextEngine');
@@ -70,26 +64,16 @@ export class ContextEngine {
   /**
    * Execute pipeline processing
    */
-  async process(input: {
-    initialState: AgentState;
-    maxTokens: number;
-    messages?: Array<any>;
-    metadata?: Record<string, any>;
-    model: string;
-  }): Promise<PipelineResult> {
+  async process(input: { messages: Array<any> }): Promise<PipelineResult> {
     const startTime = Date.now();
     const processorDurations: Record<string, number> = {};
 
     // Create initial pipeline context
     let context: PipelineContext = {
-      initialState: input.initialState,
+      initialState: { messages: input.messages },
       isAborted: false,
-      messages: Array.isArray(input.messages) ? [...input.messages] : [],
-      metadata: {
-        maxTokens: input.maxTokens,
-        model: input.model,
-        ...input.metadata,
-      },
+      messages: [...input.messages],
+      metadata: {},
     };
 
     log('Starting pipeline processing');

package/packages/context-engine/src/types.ts

@@ -60,9 +60,9 @@ export interface PipelineContext {
     /** 当前 token 估算值 */
     currentTokenCount?: number;
     /** 最大 token 限制 */
-    maxTokens: number;
+    maxTokens?: number;
     /** 模型标识 */
-    model: string;
+    model?: string;
   };
 }
 

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),