@lobehub/chat 1.128.0 → 1.128.1

package/packages/context-engine/src/processors/ToolMessageReorder.ts

@@ -0,0 +1,113 @@
+import debug from 'debug';
+
+import { BaseProcessor } from '../base/BaseProcessor';
+import type { PipelineContext, ProcessorOptions } from '../types';
+
+const log = debug('context-engine:processor:ToolMessageReorder');
+
+/**
+ * Reorder tool messages to ensure that tool messages are displayed in the correct order.
+ * see https://github.com/lobehub/lobe-chat/pull/3155
+ */
+export class ToolMessageReorder extends BaseProcessor {
+  readonly name = 'ToolMessageReorder';
+
+  constructor(options: ProcessorOptions = {}) {
+    super(options);
+  }
+
+  protected async doProcess(context: PipelineContext): Promise<PipelineContext> {
+    const clonedContext = this.cloneContext(context);
+
+    // 重新排序消息
+    const reorderedMessages = this.reorderToolMessages(clonedContext.messages);
+
+    const originalCount = clonedContext.messages.length;
+    const reorderedCount = reorderedMessages.length;
+
+    clonedContext.messages = reorderedMessages;
+
+    // 更新元数据
+    clonedContext.metadata.toolMessageReorder = {
+      originalCount,
+      removedInvalidTools: originalCount - reorderedCount,
+      reorderedCount,
+    };
+
+    if (originalCount !== reorderedCount) {
+      log(
+        'Tool message reordering completed, removed',
+        originalCount - reorderedCount,
+        'invalid tool messages',
+      );
+    } else {
+      log('Tool message reordering completed, message order optimized');
+    }
+
+    return this.markAsExecuted(clonedContext);
+  }
+
+  /**
+   * 重新排序工具消息
+   */
+  private reorderToolMessages(messages: any[]): any[] {
+    // 1. 先收集所有 assistant 消息中的有效 tool_call_id
+    const validToolCallIds = new Set<string>();
+    messages.forEach((message) => {
+      if (message.role === 'assistant' && message.tool_calls) {
+        message.tool_calls.forEach((toolCall: any) => {
+          validToolCallIds.add(toolCall.id);
+        });
+      }
+    });
+
+    // 2. 收集所有有效的 tool 消息
+    const toolMessages: Record<string, any> = {};
+    messages.forEach((message) => {
+      if (
+        message.role === 'tool' &&
+        message.tool_call_id &&
+        validToolCallIds.has(message.tool_call_id)
+      ) {
+        toolMessages[message.tool_call_id] = message;
+      }
+    });
+
+    // 3. 重新排序消息
+    const reorderedMessages: any[] = [];
+    messages.forEach((message) => {
+      // 跳过无效的 tool 消息
+      if (
+        message.role === 'tool' &&
+        (!message.tool_call_id || !validToolCallIds.has(message.tool_call_id))
+      ) {
+        log('Skipping invalid tool message:', message.id);
+        return;
+      }
+
+      // 检查是否已经添加过该 tool 消息
+      const hasPushed = reorderedMessages.some(
+        (m) => !!message.tool_call_id && m.tool_call_id === message.tool_call_id,
+      );
+
+      if (hasPushed) return;
+
+      reorderedMessages.push(message);
+
+      // 如果是 assistant 消息且有 tool_calls，添加对应的 tool 消息
+      if (message.role === 'assistant' && message.tool_calls) {
+        message.tool_calls.forEach((toolCall: any) => {
+          const correspondingToolMessage = toolMessages[toolCall.id];
+          if (correspondingToolMessage) {
+            reorderedMessages.push(correspondingToolMessage);
+            delete toolMessages[toolCall.id];
+          }
+        });
+      }
+    });
+
+    return reorderedMessages;
+  }
+
+  // 简化：移除验证/统计等辅助方法
+}

package/packages/context-engine/src/processors/__tests__/HistoryTruncate.test.ts

@@ -0,0 +1,175 @@
+import { describe, expect, it } from 'vitest';
+
+import { HistoryTruncateProcessor, getSlicedMessages } from '../HistoryTruncate';
+
+describe('HistoryTruncateProcessor', () => {
+  describe('getSlicedMessages', () => {
+    const messages = [
+      { id: '1', content: 'First', role: 'user' },
+      { id: '2', content: 'Second', role: 'assistant' },
+      { id: '3', content: 'Third', role: 'user' },
+      { id: '4', content: 'Fourth', role: 'assistant' },
+      { id: '5', content: 'Fifth', role: 'user' },
+    ];
+
+    it('should return all messages when history count is disabled', () => {
+      const result = getSlicedMessages(messages, { enableHistoryCount: false });
+      expect(result).toEqual(messages);
+    });
+
+    it('should return all messages when historyCount is undefined', () => {
+      const result = getSlicedMessages(messages, {
+        enableHistoryCount: true,
+        historyCount: undefined,
+      });
+      expect(result).toEqual(messages);
+    });
+
+    it('should return last N messages based on historyCount', () => {
+      const result = getSlicedMessages(messages, {
+        enableHistoryCount: true,
+        historyCount: 2,
+      });
+      expect(result).toEqual([
+        { id: '4', content: 'Fourth', role: 'assistant' },
+        { id: '5', content: 'Fifth', role: 'user' },
+      ]);
+    });
+
+    it('should include new user message in count when includeNewUserMessage is true', () => {
+      const result = getSlicedMessages(messages, {
+        enableHistoryCount: true,
+        historyCount: 3,
+      });
+
+      expect(result).toEqual([
+        { id: '3', content: 'Third', role: 'user' },
+        { id: '4', content: 'Fourth', role: 'assistant' },
+        { id: '5', content: 'Fifth', role: 'user' },
+      ]);
+    });
+
+    it('should return empty array when historyCount is 0', () => {
+      const result = getSlicedMessages(messages, {
+        enableHistoryCount: true,
+        historyCount: 0,
+      });
+      expect(result).toEqual([]);
+    });
+
+    it('should return empty array when historyCount is negative', () => {
+      const result = getSlicedMessages(messages, {
+        enableHistoryCount: true,
+        historyCount: -1,
+      });
+      expect(result).toEqual([]);
+    });
+
+    it('should return all messages when historyCount exceeds array length', () => {
+      const result = getSlicedMessages(messages, {
+        enableHistoryCount: true,
+        historyCount: 10,
+      });
+      expect(result).toEqual(messages);
+    });
+
+    it('should handle empty message array', () => {
+      const result = getSlicedMessages([], {
+        enableHistoryCount: true,
+        historyCount: 2,
+      });
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('HistoryTruncateProcessor', () => {
+    it('should truncate messages based on configuration', async () => {
+      const processor = new HistoryTruncateProcessor({
+        enableHistoryCount: true,
+        historyCount: 3,
+      });
+
+      const context = {
+        initialState: {
+          messages: [],
+          model: 'gpt-4',
+          provider: 'openai',
+          systemRole: '',
+          tools: [],
+        },
+        messages: [
+          { id: '1', content: 'First', role: 'user', createdAt: Date.now(), updatedAt: Date.now() },
+          {
+            id: '2',
+            content: 'Second',
+            role: 'assistant',
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+          },
+          { id: '3', content: 'Third', role: 'user', createdAt: Date.now(), updatedAt: Date.now() },
+          {
+            id: '4',
+            content: 'Fourth',
+            role: 'assistant',
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+          },
+          { id: '5', content: 'Fifth', role: 'user', createdAt: Date.now(), updatedAt: Date.now() },
+        ],
+        metadata: {
+          model: 'gpt-4',
+          maxTokens: 4096,
+        },
+        isAborted: false,
+      };
+
+      const result = await processor.process(context);
+
+      expect(result.messages).toHaveLength(3); // 2 + 1 for new user message
+      expect(result.messages).toEqual([
+        expect.objectContaining({ content: 'Third' }),
+        expect.objectContaining({ content: 'Fourth' }),
+        expect.objectContaining({ content: 'Fifth' }),
+      ]);
+      expect(result.metadata.historyTruncated).toBe(2);
+      expect(result.metadata.finalMessageCount).toBe(3);
+    });
+
+    it('should not truncate when history count is disabled', async () => {
+      const processor = new HistoryTruncateProcessor({
+        enableHistoryCount: false,
+      });
+
+      const context = {
+        initialState: {
+          messages: [],
+          model: 'gpt-4',
+          provider: 'openai',
+          systemRole: '',
+          tools: [],
+        },
+        messages: [
+          { id: '1', content: 'First', role: 'user', createdAt: Date.now(), updatedAt: Date.now() },
+          {
+            id: '2',
+            content: 'Second',
+            role: 'assistant',
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+          },
+        ],
+        metadata: {
+          model: 'gpt-4',
+          maxTokens: 4096,
+        },
+        isAborted: false,
+      };
+
+      const result = await processor.process(context);
+
+      expect(result.messages).toHaveLength(2);
+      expect(result.metadata.historyTruncated).toBe(0);
+      expect(result.metadata.finalMessageCount).toBe(2);
+    });
+  });
+});

package/packages/context-engine/src/processors/__tests__/InputTemplate.test.ts

@@ -0,0 +1,243 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { InputTemplateProcessor } from '../InputTemplate';
+
+describe('InputTemplateProcessor', () => {
+  it('should apply template to user messages', async () => {
+    const processor = new InputTemplateProcessor({
+      inputTemplate: 'Template: {{text}} - End',
+    });
+
+    const context = {
+      initialState: {
+        messages: [],
+        model: 'gpt-4',
+        provider: 'openai',
+        systemRole: '',
+        tools: [],
+      },
+      messages: [
+        {
+          id: '1',
+          role: 'user',
+          content: 'Original user message',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+        {
+          id: '2',
+          role: 'assistant',
+          content: 'Assistant response',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+      ],
+      metadata: {
+        model: 'gpt-4',
+        maxTokens: 4096,
+      },
+      isAborted: false,
+    };
+
+    const result = await processor.process(context);
+
+    expect(result.messages[0].content).toBe('Template: Original user message - End');
+    expect(result.messages[1].content).toBe('Assistant response'); // Assistant message unchanged
+    expect(result.metadata.inputTemplateProcessed).toBe(1);
+  });
+
+  it('should skip processing when no template is configured', async () => {
+    const processor = new InputTemplateProcessor({});
+
+    const context = {
+      initialState: {
+        messages: [],
+        model: 'gpt-4',
+        provider: 'openai',
+        systemRole: '',
+        tools: [],
+      },
+      messages: [
+        {
+          id: '1',
+          role: 'user',
+          content: 'User message',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+      ],
+      metadata: {
+        model: 'gpt-4',
+        maxTokens: 4096,
+      },
+      isAborted: false,
+    };
+
+    const result = await processor.process(context);
+
+    expect(result.messages[0].content).toBe('User message'); // Unchanged
+    expect(result.metadata.inputTemplateProcessed).toBeUndefined();
+  });
+
+  it('should handle template without {{text}} placeholder', async () => {
+    const processor = new InputTemplateProcessor({
+      inputTemplate: 'Static template content',
+    });
+
+    const context = {
+      initialState: {
+        messages: [],
+        model: 'gpt-4',
+        provider: 'openai',
+        systemRole: '',
+        tools: [],
+      },
+      messages: [
+        {
+          id: '1',
+          role: 'user',
+          content: 'Original message',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+      ],
+      metadata: {
+        model: 'gpt-4',
+        maxTokens: 4096,
+      },
+      isAborted: false,
+    };
+
+    const result = await processor.process(context);
+
+    expect(result.messages[0].content).toBe('Static template content');
+    expect(result.metadata.inputTemplateProcessed).toBe(1);
+  });
+
+  it('should handle template compilation errors gracefully', async () => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const processor = new InputTemplateProcessor({
+      inputTemplate: '<%- invalid javascript code %>',
+    });
+
+    const context = {
+      initialState: {
+        messages: [],
+        model: 'gpt-4',
+        provider: 'openai',
+        systemRole: '',
+        tools: [],
+      },
+      messages: [
+        {
+          id: '1',
+          role: 'user',
+          content: 'User message',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+      ],
+      metadata: {
+        model: 'gpt-4',
+        maxTokens: 4096,
+      },
+      isAborted: false,
+    };
+
+    const result = await processor.process(context);
+
+    // Should skip processing due to compilation error
+    expect(result.messages[0].content).toBe('User message'); // Original content preserved
+    expect(result.metadata.inputTemplateProcessed).toBe(0);
+
+    consoleSpy.mockRestore();
+  });
+
+  it('should handle template application errors gracefully', async () => {
+    const processor = new InputTemplateProcessor({
+      inputTemplate: '{{text}} <%- throw new Error("Application error") %>',
+    });
+
+    const context = {
+      initialState: {
+        messages: [],
+        model: 'gpt-4',
+        provider: 'openai',
+        systemRole: '',
+        tools: [],
+      },
+      messages: [
+        {
+          id: '1',
+          role: 'user',
+          content: 'User message',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+      ],
+      metadata: {
+        model: 'gpt-4',
+        maxTokens: 4096,
+      },
+      isAborted: false,
+    };
+
+    const result = await processor.process(context);
+
+    // Should keep original message when template application fails
+    expect(result.messages[0].content).toBe('User message');
+    expect(result.metadata.inputTemplateProcessed).toBe(0);
+  });
+
+  it('should only process user messages, not assistant messages', async () => {
+    const processor = new InputTemplateProcessor({
+      inputTemplate: 'Processed: {{text}}',
+    });
+
+    const context = {
+      initialState: {
+        messages: [],
+        model: 'gpt-4',
+        provider: 'openai',
+        systemRole: '',
+        tools: [],
+      },
+      messages: [
+        {
+          id: '1',
+          role: 'user',
+          content: 'User message',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+        {
+          id: '2',
+          role: 'assistant',
+          content: 'Assistant message',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+        {
+          id: '3',
+          role: 'system',
+          content: 'System message',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+      ],
+      metadata: {
+        model: 'gpt-4',
+        maxTokens: 4096,
+      },
+      isAborted: false,
+    };
+
+    const result = await processor.process(context);
+
+    expect(result.messages[0].content).toBe('Processed: User message');
+    expect(result.messages[1].content).toBe('Assistant message'); // Unchanged
+    expect(result.messages[2].content).toBe('System message'); // Unchanged
+    expect(result.metadata.inputTemplateProcessed).toBe(1);
+  });
+});