lazlo-ai 1.0.0

package/src/memory/buffer.ts

@@ -0,0 +1,222 @@
+/**
+ * Buffer Memory - Simple conversation history
+ */
+
+import { Message } from '../core/types.js';
+
+// ============================================================================
+// Buffer Memory
+// ============================================================================
+
+export interface BufferMemoryOptions {
+  memoryKey?: string;
+  returnMessages?: boolean;
+  maxTokenLimit?: number;
+}
+
+export class BufferMemory {
+  private messages: Message[] = [];
+  private memoryKey: string;
+  private returnMessages: boolean;
+  private maxTokenLimit?: number;
+  
+  constructor(options: BufferMemoryOptions = {}) {
+    this.memoryKey = options.memoryKey ?? 'history';
+    this.returnMessages = options.returnMessages ?? false;
+    this.maxTokenLimit = options.maxTokenLimit;
+  }
+  
+  /**
+   * Estimate tokens (rough approximation)
+   */
+  private estimateTokens(text: string): number {
+    return Math.ceil(text.length / 4);
+  }
+  
+  /**
+   * Load memory variables for the chain
+   */
+  async loadMemoryVariables(_inputs: Record<string, unknown> = {}): Promise<Record<string, unknown>> {
+    // Trim if over token limit
+    if (this.maxTokenLimit) {
+      let tokenCount = 0;
+      const trimmedMessages: Message[] = [];
+      
+      for (let i = this.messages.length - 1; i >= 0; i--) {
+        const msg = this.messages[i];
+        const msgTokens = this.estimateTokens(msg.content);
+        
+        if (tokenCount + msgTokens <= this.maxTokenLimit) {
+          trimmedMessages.unshift(msg);
+          tokenCount += msgTokens;
+        } else {
+          break;
+        }
+      }
+      
+      this.messages = trimmedMessages;
+    }
+    
+    if (this.returnMessages) {
+      return { [this.memoryKey]: [...this.messages] };
+    }
+    
+    // Return as formatted string
+    const history = this.messages
+      .map(m => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
+      .join('\n');
+    
+    return { [this.memoryKey]: history };
+  }
+  
+  /**
+   * Save context to memory
+   */
+  async saveContext(inputs: Record<string, unknown>, outputs: Record<string, string>): Promise<void> {
+    // Extract input and output content
+    const inputContent = Object.values(inputs)[0]?.toString() ?? '';
+    const outputContent = Object.values(outputs)[0]?.toString() ?? '';
+    
+    if (inputContent) {
+      this.messages.push({ role: 'user', content: inputContent });
+    }
+    if (outputContent) {
+      this.messages.push({ role: 'assistant', content: outputContent });
+    }
+  }
+  
+  /**
+   * Clear memory
+   */
+  async clear(): Promise<void> {
+    this.messages = [];
+  }
+  
+  /**
+   * Get messages
+   */
+  getMessages(): Message[] {
+    return [...this.messages];
+  }
+}
+
+// ============================================================================
+// Token Budget Memory
+// ============================================================================
+
+export interface TokenBudgetMemoryOptions {
+  summarizerLLM?: any;
+  maxTokens?: number;
+  summarizeThreshold?: number;
+  memoryKey?: string;
+  returnMessages?: boolean;
+}
+
+const SUMMARIZE_PROMPT = `Summarize the following conversation history into 2-3 concise sentences. Preserve key facts, decisions, and context. Be extremely terse.
+
+Conversation:
+{history}
+
+Summary:`;
+
+export class TokenBudgetMemory {
+  private messages: Message[] = [];
+  private summarizerLLM?: any;
+  private maxTokens: number;
+  private summarizeThreshold: number;
+  private memoryKey: string;
+  private returnMessages: boolean;
+  private summaryPrefix = '';
+  
+  constructor(options: TokenBudgetMemoryOptions = {}) {
+    this.summarizerLLM = options.summarizerLLM;
+    this.maxTokens = options.maxTokens ?? 4000;
+    this.summarizeThreshold = options.summarizeThreshold ?? 0.8;
+    this.memoryKey = options.memoryKey ?? 'history';
+    this.returnMessages = options.returnMessages ?? false;
+  }
+  
+  private estimateTokens(): number {
+    let text = this.messages.map(m => m.content).join('\n');
+    if (this.summaryPrefix) {
+      text += '\n' + this.summaryPrefix;
+    }
+    return Math.ceil(text.length / 4);
+  }
+  
+  private async compress(): Promise<void> {
+    if (!this.messages.length || !this.summarizerLLM) return;
+    
+    // Keep the second half of messages
+    const half = Math.floor(this.messages.length / 2);
+    const oldMessages = this.messages.slice(0, half);
+    this.messages = this.messages.slice(half);
+    
+    const historyStr = oldMessages
+      .map(m => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
+      .join('\n');
+    
+    const prompt = SUMMARIZE_PROMPT.replace('{history}', 
+      this.summaryPrefix ? `Previous summary: ${this.summaryPrefix}\n\n${historyStr}` : historyStr
+    );
+    
+    try {
+      const response = await this.summarizerLLM.invoke(prompt);
+      this.summaryPrefix = typeof response === 'string' ? response : response.content ?? '';
+    } catch (error) {
+      console.error('[TokenBudgetMemory] Compression failed:', error);
+    }
+  }
+  
+  async loadMemoryVariables(_inputs: Record<string, unknown> = {}): Promise<Record<string, unknown>> {
+    const tokensUsed = this.estimateTokens();
+    
+    if (tokensUsed >= this.maxTokens * this.summarizeThreshold) {
+      await this.compress();
+    }
+    
+    if (this.returnMessages) {
+      const content: Message[] = [];
+      if (this.summaryPrefix) {
+        content.push({ role: 'system', content: `[Earlier context]: ${this.summaryPrefix}` });
+      }
+      content.push(...this.messages);
+      return { [this.memoryKey]: content };
+    }
+    
+    const parts: string[] = [];
+    if (this.summaryPrefix) {
+      parts.push(`[Earlier context]: ${this.summaryPrefix}`);
+    }
+    for (const m of this.messages) {
+      parts.push(`${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`);
+    }
+    
+    return { [this.memoryKey]: parts.join('\n') };
+  }
+  
+  async saveContext(inputs: Record<string, unknown>, outputs: Record<string, string>): Promise<void> {
+    const inputContent = Object.values(inputs)[0]?.toString() ?? '';
+    const outputContent = Object.values(outputs)[0]?.toString() ?? '';
+    
+    if (inputContent) {
+      this.messages.push({ role: 'user', content: inputContent });
+    }
+    if (outputContent) {
+      this.messages.push({ role: 'assistant', content: outputContent });
+    }
+  }
+  
+  async clear(): Promise<void> {
+    this.messages = [];
+    this.summaryPrefix = '';
+  }
+  
+  get tokenUsage(): { estimatedTokens: number; budget: number; messageCount: number } {
+    return {
+      estimatedTokens: this.estimateTokens(),
+      budget: this.maxTokens,
+      messageCount: this.messages.length,
+    };
+  }
+}

package/src/parsers/output.ts

@@ -0,0 +1,195 @@
+/**
+ * Output Parsers
+ * 
+ * Parse LLM outputs into structured formats
+ */
+
+import { z } from 'zod';
+
+/**
+ * Base Output Parser Interface
+ */
+export interface BaseOutputParser<T> {
+  parse(text: string): Promise<T>;
+  format?(text: string): string;
+}
+
+/**
+ * JSON Output Parser
+ */
+export class JSONOutputParser<T extends z.ZodTypeAny = z.ZodTypeAny> {
+  private schema?: T;
+  private schemaName?: string;
+
+  constructor(schema?: T, schemaName?: string) {
+    this.schema = schema;
+    this.schemaName = schemaName;
+  }
+
+  async parse(text: string): Promise<any> {
+    // Try to extract JSON from text
+    const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) || 
+                      text.match(/\{[\s\S]*\}/);
+    
+    if (!jsonMatch) {
+      throw new Error('No JSON found in output');
+    }
+
+    const jsonStr = jsonMatch[1] || jsonMatch[0];
+    
+    try {
+      const parsed = JSON.parse(jsonStr);
+      
+      if (this.schema) {
+        return this.schema.parse(parsed);
+      }
+      
+      return parsed;
+    } catch (error: any) {
+      throw new Error(`Failed to parse JSON: ${error.message}`);
+    }
+  }
+
+  format(text: string): string {
+    return `Output the following as valid JSON:\n${text}`;
+  }
+}
+
+/**
+ * XML Output Parser
+ */
+export class XMLOutputParser {
+  private tags: string[];
+
+  constructor(tags: string[] = ['response']) {
+    this.tags = tags;
+  }
+
+  async parse(text: string): Promise<Record<string, string>> {
+    const result: Record<string, string> = {};
+    
+    for (const tag of this.tags) {
+      const regex = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, 'i');
+      const match = text.match(regex);
+      
+      if (match) {
+        result[tag] = match[1].trim();
+      }
+    }
+    
+    return result;
+  }
+
+  format(text: string): string {
+    const tagsStr = this.tags.map(t => `<${t}>...</${t}>`).join('\n');
+    return `Output the following as XML:\n${tagsStr}\n\nContent:\n${text}`;
+  }
+}
+
+/**
+ * Comma-Separated List Parser
+ */
+export class CommaSeparatedListParser {
+  async parse(text: string): Promise<string[]> {
+    return text
+      .split(',')
+      .map(item => item.trim())
+      .filter(item => item.length > 0);
+  }
+}
+
+/**
+ * Markdown Code Block Parser
+ */
+export class MarkdownCodeBlockParser {
+  private language?: string;
+
+  constructor(language?: string) {
+    this.language = language;
+  }
+
+  async parse(text: string): Promise<string> {
+    const regex = this.language 
+      ? new RegExp(`\`\`\`${this.language}\\s*([\\s\\S]*?)\`\`\``)
+      : /```(?:\w+)?\s*([\s\S]*?)```/;
+    
+    const match = text.match(regex);
+    
+    if (match) {
+      return match[1].trim();
+    }
+    
+    // Return original if no code block found
+    return text.trim();
+  }
+}
+
+/**
+ * Parser for tool calls
+ */
+export interface ToolCall {
+  name: string;
+  arguments: Record<string, any>;
+}
+
+export class ToolCallParser {
+  async parse(text: string): Promise<ToolCall[]> {
+    const toolCalls: ToolCall[] = [];
+    
+    // Try JSON format
+    try {
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (parsed.name && parsed.arguments) {
+          return [parsed as ToolCall];
+        }
+      }
+    } catch {
+      // Not JSON, try other formats
+    }
+    
+    // Try function call format
+    const functionMatch = text.match(/(\w+)\(([\s\S]*?)\)/);
+    if (functionMatch) {
+      const name = functionMatch[1];
+      let args: Record<string, any> = {};
+      
+      try {
+        args = JSON.parse(`{${functionMatch[2]}}`);
+      } catch {
+        // Simple key=value parsing
+        const argPairs = functionMatch[2].split(',');
+        for (const pair of argPairs) {
+          const [key, value] = pair.split('=').map(s => s.trim());
+          if (key) {
+            args[key] = value?.replace(/["']/g, '') || '';
+          }
+        }
+      }
+      
+      toolCalls.push({ name, arguments: args });
+    }
+    
+    return toolCalls;
+  }
+}
+
+/**
+ * Factory functions
+ */
+export function createJSONParser<T extends z.ZodTypeAny>(schema?: T, name?: string): JSONOutputParser<T> {
+  return new JSONOutputParser(schema, name);
+}
+
+export function createXMLParser(tags?: string[]): XMLOutputParser {
+  return new XMLOutputParser(tags);
+}
+
+export function createListParser(): CommaSeparatedListParser {
+  return new CommaSeparatedListParser();
+}
+
+export function createMarkdownParser(language?: string): MarkdownCodeBlockParser {
+  return new MarkdownCodeBlockParser(language);
+}

package/src/prompts/registry.ts

@@ -0,0 +1,205 @@
+/**
+ * Prompt Registry
+ * 
+ * Store, version, and load prompts from YAML files
+ */
+
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join, basename } from 'path';
+import { logger } from '../utils/logger.js';
+
+export interface PromptConfig {
+  template: string;
+  description?: string;
+  version?: string;
+  variables?: string[];
+}
+
+/**
+ * Prompt Registry
+ * 
+ * Load and manage prompts from YAML files
+ */
+export class PromptRegistry {
+  private prompts: Map<string, PromptConfig> = new Map();
+  private directory?: string;
+
+  constructor(directory?: string) {
+    if (directory) {
+      this.directory = directory;
+      this.loadPrompts(directory);
+    }
+  }
+
+  /**
+   * Load prompts from a directory
+   */
+  private loadPrompts(directory: string): void {
+    if (!existsSync(directory)) {
+      logger.warn(`[PromptRegistry] Directory not found: ${directory}`);
+      return;
+    }
+
+    try {
+      const files = readdirSync(directory).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+      
+      for (const file of files) {
+        const content = readFileSync(join(directory, file), 'utf-8');
+        const config = this.parseYAML(content);
+        const name = file.replace(/\.(yaml|yml)$/, '');
+        
+        this.prompts.set(name, config as PromptConfig);
+      }
+      
+      logger.info(`[PromptRegistry] Loaded ${this.prompts.size} prompts from ${directory}`);
+    } catch (error: any) {
+      logger.error(`[PromptRegistry] Error loading prompts: ${error.message}`);
+    }
+  }
+
+  /**
+   * Simple YAML parser
+   */
+  private parseYAML(content: string): any {
+    const result: any = {};
+    const lines = content.split('\n');
+    let currentKey = '';
+    let currentValue: string[] = [];
+    let inArray = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      
+      // Check for key: value
+      const keyMatch = trimmed.match(/^(\w+):\s*(.*)$/);
+      
+      if (keyMatch) {
+        if (currentKey) {
+          result[currentKey] = currentValue.join('\n').trim();
+        }
+        
+        currentKey = keyMatch[1];
+        const value = keyMatch[2];
+        
+        if (value.startsWith('[') && value.endsWith(']')) {
+          // Array
+          result[currentKey] = value.slice(1, -1).split(',').map((s: string) => s.trim());
+          currentKey = '';
+        } else if (value) {
+          currentValue = [value];
+        } else {
+          currentValue = [];
+        }
+      } else if (trimmed.startsWith('- ')) {
+        // Array item
+        if (!Array.isArray(result[currentKey])) {
+          result[currentKey] = [];
+        }
+        (result[currentKey] as any[]).push(trimmed.slice(2).trim());
+      } else {
+        // Continuation
+        currentValue.push(trimmed);
+      }
+    }
+    
+    if (currentKey) {
+      result[currentKey] = currentValue.join('\n').trim();
+    }
+
+    return result;
+  }
+
+  /**
+   * Register a prompt
+   */
+  register(name: string, config: PromptConfig): void {
+    this.prompts.set(name, config);
+    logger.debug(`[PromptRegistry] Registered prompt: ${name}`);
+  }
+
+  /**
+   * Load a prompt by name (supports @version syntax)
+   */
+  load(name: string): string {
+    const [baseName, version] = name.split('@');
+    const prompt = this.prompts.get(baseName);
+    
+    if (!prompt) {
+      throw new Error(`Prompt not found: ${baseName}`);
+    }
+    
+    if (version && prompt.version && prompt.version !== version) {
+      throw new Error(`Version ${version} not found for prompt: ${baseName}`);
+    }
+    
+    return prompt.template;
+  }
+
+  /**
+   * Get prompt config
+   */
+  get(name: string): PromptConfig | undefined {
+    return this.prompts.get(name);
+  }
+
+  /**
+   * List all prompts
+   */
+  list(): string[] {
+    return Array.from(this.prompts.keys());
+  }
+
+  /**
+   * Format a prompt with variables
+   */
+  format(template: string, variables: Record<string, string>): string {
+    let result = template;
+    
+    for (const [key, value] of Object.entries(variables)) {
+      result = result.replace(new RegExp(`\\{${key}\\}`, 'g'), value);
+    }
+    
+    return result;
+  }
+}
+
+/**
+ * Factory function
+ */
+export function createPromptRegistry(directory?: string): PromptRegistry {
+  return new PromptRegistry(directory);
+}
+
+/**
+ * Simple Prompt Template (standalone)
+ */
+export class SimplePromptTemplate {
+  private template: string;
+  private inputVariables: string[];
+
+  constructor(template: string) {
+    this.template = template;
+    this.inputVariables = this.extractVariables(template);
+  }
+
+  private extractVariables(template: string): string[] {
+    const matches = template.match(/\{(\w+)\}/g) || [];
+    return [...new Set(matches.map(m => m.slice(1, -1)))];
+  }
+
+  format(variables: Record<string, string>): string {
+    let result = this.template;
+    
+    for (const [key, value] of Object.entries(variables)) {
+      result = result.replace(new RegExp(`\\{${key}\\}`, 'g'), value);
+    }
+    
+    return result;
+  }
+
+  get inputVars(): string[] {
+    return this.inputVariables;
+  }
+}