@lobehub/chat 1.128.0 → 1.128.1

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

@@ -0,0 +1,219 @@
+import debug from 'debug';
+
+import type {
+  AgentState,
+  ContextProcessor,
+  PipelineContext,
+  PipelineResult,
+  ProcessorOptions,
+} from './types';
+import { PipelineError } from './types';
+
+const log = debug('context-engine:ContextEngine');
+
+/**
+ * Context Engine Configuration
+ */
+export interface ContextEngineConfig extends ProcessorOptions {
+  /** Processor pipeline */
+  pipeline: ContextProcessor[];
+}
+
+/**
+ * Context Engine - Core orchestrator that executes processors sequentially
+ */
+export class ContextEngine {
+  private processors: ContextProcessor[] = [];
+  private options: ProcessorOptions;
+
+  constructor(config: ContextEngineConfig) {
+    const { pipeline, ...options } = config;
+    this.processors = [...pipeline];
+    this.options = {
+      debug: false,
+      logger: console.log,
+      ...options,
+    };
+  }
+
+  /**
+   * Add processor to pipeline
+   */
+  addProcessor(processor: ContextProcessor): this {
+    this.processors.push(processor);
+    return this;
+  }
+
+  /**
+   * Remove processor
+   */
+  removeProcessor(name: string): this {
+    this.processors = this.processors.filter((p) => p.name !== name);
+    return this;
+  }
+
+  /**
+   * Get processor list
+   */
+  getProcessors(): ContextProcessor[] {
+    return [...this.processors];
+  }
+
+  /**
+   * Clear all processors
+   */
+  clear(): this {
+    this.processors = [];
+    return this;
+  }
+
+  /**
+   * Execute pipeline processing
+   */
+  async process(input: {
+    initialState: AgentState;
+    maxTokens: number;
+    messages?: Array<any>;
+    metadata?: Record<string, any>;
+    model: string;
+  }): Promise<PipelineResult> {
+    const startTime = Date.now();
+    const processorDurations: Record<string, number> = {};
+
+    // Create initial pipeline context
+    let context: PipelineContext = {
+      initialState: input.initialState,
+      isAborted: false,
+      messages: Array.isArray(input.messages) ? [...input.messages] : [],
+      metadata: {
+        maxTokens: input.maxTokens,
+        model: input.model,
+        ...input.metadata,
+      },
+    };
+
+    log('Starting pipeline processing');
+    log('Number of processors:', this.processors.length);
+
+    let processedCount = 0;
+
+    try {
+      // Execute each processor in sequence
+      for (const processor of this.processors) {
+        if (context.isAborted) {
+          log('Pipeline aborted before processor', processor.name, 'reason:', context.abortReason);
+          break;
+        }
+
+        const processorStartTime = Date.now();
+        log('Executing processor:', processor.name);
+
+        try {
+          context = await processor.process(context);
+          processedCount++;
+
+          const duration = Date.now() - processorStartTime;
+          processorDurations[processor.name] = duration;
+
+          log('Processor', processor.name, 'completed in', duration + 'ms');
+
+          if (context.isAborted) {
+            log('Pipeline aborted by processor', processor.name, 'reason:', context.abortReason);
+            break;
+          }
+        } catch (error) {
+          const duration = Date.now() - processorStartTime;
+          processorDurations[processor.name] = duration;
+
+          log('Processor', processor.name, 'execution failed:', error);
+          throw new PipelineError(
+            `Processor [${processor.name}] execution failed`,
+            processor.name,
+            error instanceof Error ? error : new Error(String(error)),
+          );
+        }
+      }
+
+      const totalDuration = Date.now() - startTime;
+      log('Pipeline processing completed in', totalDuration + 'ms');
+
+      return {
+        abortReason: context.abortReason,
+        isAborted: context.isAborted,
+        messages: context.messages,
+        metadata: context.metadata,
+        stats: {
+          processedCount,
+          processorDurations,
+          totalDuration,
+        },
+      };
+    } catch (error) {
+      log('Pipeline processing failed:', error);
+
+      if (error instanceof PipelineError) {
+        throw error;
+      }
+
+      throw new PipelineError(
+        'Unknown error occurred during pipeline processing',
+        undefined,
+        error instanceof Error ? error : new Error(String(error)),
+      );
+    }
+  }
+
+  /**
+   * Get pipeline statistics
+   */
+  getStats() {
+    return {
+      processorCount: this.processors.length,
+      processorNames: this.processors.map((p) => p.name),
+    };
+  }
+
+  /**
+   * Clone pipeline (deep copy processor list)
+   */
+  clone(): ContextEngine {
+    return new ContextEngine({
+      pipeline: [...this.processors],
+      ...this.options,
+    });
+  }
+
+  /**
+   * Validate pipeline configuration
+   */
+  validate(): { errors: string[]; valid: boolean } {
+    const errors: string[] = [];
+
+    // Check for duplicate processor names
+    const names = this.processors.map((p) => p.name);
+    const duplicates = names.filter((name, index) => names.indexOf(name) !== index);
+    if (duplicates.length > 0) {
+      errors.push(`Found duplicate processor names: ${duplicates.join(', ')}`);
+    }
+
+    // Check if processors are empty
+    if (this.processors.length === 0) {
+      errors.push('No processors in pipeline');
+    }
+
+    // Check if processors implement required methods
+    this.processors.forEach((processor) => {
+      if (!processor.name) {
+        errors.push('Processor missing name');
+      }
+      if (typeof processor.process !== 'function') {
+        errors.push(`Processor [${processor.name}] missing process method`);
+      }
+    });
+
+    return {
+      errors,
+      valid: errors.length === 0,
+    };
+  }
+}

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

@@ -0,0 +1,76 @@
+import debug from 'debug';
+
+import { BaseProcessor } from '../base/BaseProcessor';
+import type { PipelineContext, ProcessorOptions } from '../types';
+
+const log = debug('context-engine:processor:HistoryTruncateProcessor');
+
+export interface HistoryTruncateConfig {
+  /** Whether to enable history count limit */
+  enableHistoryCount?: boolean;
+  /** Maximum number of historical messages to keep */
+  historyCount?: number;
+}
+
+/**
+ * Slice messages based on history count configuration
+ * @param messages Original messages array
+ * @param options Configuration options for slicing
+ * @returns Sliced messages array
+ */
+export const getSlicedMessages = (
+  messages: any[],
+  options: {
+    enableHistoryCount?: boolean;
+    historyCount?: number;
+  },
+): any[] => {
+  // if historyCount is not enabled, return all messages
+  if (!options.enableHistoryCount || options.historyCount === undefined) return messages;
+
+  // if historyCount is negative or set to 0, return empty array
+  if (options.historyCount <= 0) return [];
+
+  // if historyCount is positive, return last N messages
+  return messages.slice(-options.historyCount);
+};
+
+/**
+ * History Truncate Processor
+ * Responsible for limiting message history based on configuration
+ */
+export class HistoryTruncateProcessor extends BaseProcessor {
+  readonly name = 'HistoryTruncateProcessor';
+
+  constructor(
+    private config: HistoryTruncateConfig,
+    options: ProcessorOptions = {},
+  ) {
+    super(options);
+  }
+
+  protected async doProcess(context: PipelineContext): Promise<PipelineContext> {
+    const clonedContext = this.cloneContext(context);
+
+    const originalCount = clonedContext.messages.length;
+
+    // Apply history truncation
+    clonedContext.messages = getSlicedMessages(clonedContext.messages, {
+      enableHistoryCount: this.config.enableHistoryCount,
+      historyCount: this.config.historyCount,
+    });
+
+    const finalCount = clonedContext.messages.length;
+    const truncatedCount = originalCount - finalCount;
+
+    // Update metadata
+    clonedContext.metadata.historyTruncated = truncatedCount;
+    clonedContext.metadata.finalMessageCount = finalCount;
+
+    log(
+      `History truncation completed, truncated ${truncatedCount} messages (${originalCount} → ${finalCount})`,
+    );
+
+    return this.markAsExecuted(clonedContext);
+  }
+}

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

@@ -0,0 +1,83 @@
+import debug from 'debug';
+import { template } from 'lodash-es';
+
+import { BaseProcessor } from '../base/BaseProcessor';
+import type { PipelineContext, ProcessorOptions } from '../types';
+
+const log = debug('context-engine:processor:InputTemplateProcessor');
+
+export interface InputTemplateConfig {
+  /** Input message template string */
+  inputTemplate?: string;
+}
+
+/**
+ * Input Template Processor
+ * Responsible for applying input message templates to user messages
+ */
+export class InputTemplateProcessor extends BaseProcessor {
+  readonly name = 'InputTemplateProcessor';
+
+  constructor(
+    private config: InputTemplateConfig,
+    options: ProcessorOptions = {},
+  ) {
+    super(options);
+  }
+
+  protected async doProcess(context: PipelineContext): Promise<PipelineContext> {
+    const clonedContext = this.cloneContext(context);
+
+    // Skip processing if no template is configured
+    if (!this.config.inputTemplate) {
+      log('No input template configured, skipping processing');
+      return this.markAsExecuted(clonedContext);
+    }
+
+    let processedCount = 0;
+
+    try {
+      // Compile the template
+      const compiler = template(this.config.inputTemplate, {
+        interpolate: /{{\s*(text)\s*}}/g,
+      });
+
+      log(`Applying input template: ${this.config.inputTemplate}`);
+
+      // Process each message
+      for (let i = 0; i < clonedContext.messages.length; i++) {
+        const message = clonedContext.messages[i];
+
+        // Only apply template to user messages
+        if (message.role === 'user') {
+          try {
+            const originalContent = message.content;
+            const processedContent = compiler({ text: originalContent });
+
+            if (processedContent !== originalContent) {
+              clonedContext.messages[i] = {
+                ...message,
+                content: processedContent,
+              };
+              processedCount++;
+              log(`Applied template to message ${message.id}`);
+            }
+          } catch (error) {
+            log.extend('error')(`Error applying template to message ${message.id}: ${error}`);
+            // Keep original message on error
+          }
+        }
+      }
+    } catch (error) {
+      log.extend('error')(`Template compilation failed: ${error}`);
+      // Skip processing if template compilation fails
+    }
+
+    // Update metadata
+    clonedContext.metadata.inputTemplateProcessed = processedCount;
+
+    log(`Input template processing completed, processed ${processedCount} messages`);
+
+    return this.markAsExecuted(clonedContext);
+  }
+}

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

@@ -0,0 +1,87 @@
+import debug from 'debug';
+
+import { BaseProcessor } from '../base/BaseProcessor';
+import type { PipelineContext, ProcessorOptions } from '../types';
+
+const log = debug('context-engine:processor:MessageCleanupProcessor');
+
+/**
+ * 消息清理处理器
+ * 负责清理消息中的多余字段，只保留 OpenAI 格式所需的必要字段
+ */
+export class MessageCleanupProcessor extends BaseProcessor {
+  readonly name = 'MessageCleanupProcessor';
+
+  constructor(options: ProcessorOptions = {}) {
+    super(options);
+  }
+
+  protected async doProcess(context: PipelineContext): Promise<PipelineContext> {
+    const clonedContext = this.cloneContext(context);
+
+    let cleanedCount = 0;
+
+    // 清理每条消息，只保留必要字段
+    for (let i = 0; i < clonedContext.messages.length; i++) {
+      const message = clonedContext.messages[i];
+      const cleanedMessage = this.cleanMessage(message);
+
+      if (cleanedMessage !== message) {
+        clonedContext.messages[i] = cleanedMessage;
+        cleanedCount++;
+      }
+    }
+
+    // 更新元数据
+    clonedContext.metadata.messageCleanup = {
+      cleanedCount,
+      totalMessages: clonedContext.messages.length,
+    };
+
+    log(`Message cleanup completed, cleaned ${cleanedCount} messages`);
+    return this.markAsExecuted(clonedContext);
+  }
+
+  /**
+   * 清理单条消息，只保留必要字段
+   */
+  private cleanMessage(message: any): any {
+    switch (message.role) {
+      case 'system': {
+        return {
+          content: message.content,
+          role: message.role,
+        };
+      }
+
+      case 'user': {
+        return {
+          content: message.content,
+          role: message.role,
+        };
+      }
+
+      case 'assistant': {
+        return {
+          content: message.content,
+          role: message.role,
+          ...(message.tool_calls && { tool_calls: message.tool_calls }),
+        };
+      }
+
+      case 'tool': {
+        return {
+          content: message.content,
+          role: message.role,
+          tool_call_id: message.tool_call_id,
+          ...(message.name && { name: message.name }),
+        };
+      }
+
+      default: {
+        // 对于未知角色，保持原样
+        return message;
+      }
+    }
+  }
+}