lazlo-ai 1.0.0

package/src/router/smartrouter.ts

@@ -0,0 +1,172 @@
+/**
+ * Smart Router - Route prompts to fast or smart models based on complexity
+ */
+
+import { BaseChatModel, Message } from '../core/types.js';
+import { logger } from '../utils/logger.js';
+
+// ============================================================================
+// Complexity Signals
+// ============================================================================
+
+const COMPLEX_SIGNALS = [
+  'explain', 'compare', 'analyze', 'design', 'implement', 'prove',
+  'write code', 'refactor', 'debug', 'architecture', 'difference between',
+  'step by step', 'tradeoffs', 'evaluate', 'research', 'synthesize',
+  'multi-step', 'complex', 'detailed', 'comprehensive', 'why does',
+  'algorithm', 'system', 'distributed', 'optimize', 'refactor',
+];
+
+const SIMPLE_SIGNALS = [
+  'what is', 'who is', 'when did', 'where is', 'define',
+  'list', 'how many', 'translate', 'convert', 'yes or no',
+  'true or false', 'capital', 'president', 'date of',
+];
+
+// ============================================================================
+// Heuristic Complexity Calculation
+// ============================================================================
+
+function heuristicComplexity(prompt: string): number {
+  const text = prompt.toLowerCase();
+  let score = 0.0;
+  
+  // Word count factor
+  const wordCount = text.split(/\s+/).length;
+  if (wordCount > 100) {
+    score += 0.3;
+  } else if (wordCount > 40) {
+    score += 0.15;
+  }
+  
+  // Question count
+  const questionCount = (text.match(/\?/g) || []).length;
+  score += Math.min(questionCount * 0.1, 0.2);
+  
+  // Complex signals
+  for (const signal of COMPLEX_SIGNALS) {
+    if (text.includes(signal)) {
+      score += 0.15;
+      break;
+    }
+  }
+  
+  // Simple signals (reduce complexity)
+  for (const signal of SIMPLE_SIGNALS) {
+    if (text.includes(signal)) {
+      score -= 0.15;
+      break;
+    }
+  }
+  
+  // Code detection
+  if (/```|def |function |class |import |const |let |var /.test(text)) {
+    score += 0.25;
+  }
+  
+  return Math.max(0.0, Math.min(1.0, score));
+}
+
+// ============================================================================
+// Smart Router
+// ============================================================================
+
+export interface RouterOptions {
+  fast: BaseChatModel;
+  smart: BaseChatModel;
+  threshold?: number;
+  classifierLLM?: BaseChatModel;
+}
+
+export class SmartRouter {
+  private fast: BaseChatModel;
+  private smart: BaseChatModel;
+  private threshold: number;
+  private classifierLLM?: BaseChatModel;
+  private fastCalls = 0;
+  private smartCalls = 0;
+  
+  constructor(options: RouterOptions) {
+    this.fast = options.fast;
+    this.smart = options.smart;
+    this.threshold = options.threshold ?? 0.5;
+    this.classifierLLM = options.classifierLLM;
+    
+    logger.info(`SmartRouter ready. Threshold: ${this.threshold}. Classifier: ${this.classifierLLM ? 'LLM' : 'heuristic'}`);
+  }
+  
+  private async classify(prompt: string): Promise<number> {
+    if (!this.classifierLLM) {
+      return heuristicComplexity(prompt);
+    }
+    
+    // Use LLM classifier
+    const classificationPrompt = `Rate the complexity of the following task on a scale of 0.0 to 1.0.
+0.0 = trivial fact lookup. 1.0 = requires deep reasoning, code writing, or multi-step analysis.
+Output ONLY a single decimal number, nothing else.
+
+Task: ${prompt}`;
+    
+    try {
+      const response = await this.classifierLLM.invoke([
+        { role: 'user', content: classificationPrompt }
+      ]);
+      
+      const match = response.content.match(/[0-9]*\.?[0-9]+/);
+      if (match) {
+        return parseFloat(match[0]);
+      }
+    } catch (error) {
+      logger.warn(`SmartRouter classifier failed: ${error}. Using heuristic.`);
+    }
+    
+    return heuristicComplexity(prompt);
+  }
+  
+  async invoke(prompt: string, options?: {
+    model?: string;  // Override for specific model
+    temperature?: number;
+  }): Promise<{ content: string; model: string }> {
+    const score = await this.classify(prompt);
+    
+    if (score >= this.threshold) {
+      logger.info(`[SmartRouter] Complexity=${score.toFixed(2)} → SMART model`);
+      this.smartCalls++;
+      const response = await this.smart.invoke([{ role: 'user', content: prompt }], options);
+      return { content: response.content, model: (this.smart as any).defaultModel ?? 'smart' };
+    } else {
+      logger.info(`[SmartRouter] Complexity=${score.toFixed(2)} → FAST model`);
+      this.fastCalls++;
+      const response = await this.fast.invoke([{ role: 'user', content: prompt }], options);
+      return { content: response.content, model: (this.fast as any).defaultModel ?? 'fast' };
+    }
+  }
+  
+  async ainvoke(prompt: string, options?: {
+    model?: string;
+    temperature?: number;
+  }): Promise<{ content: string; model: string }> {
+    return this.invoke(prompt, options);
+  }
+  
+  printStats(): void {
+    const total = this.fastCalls + this.smartCalls;
+    if (total === 0) {
+      console.log('No calls routed yet.');
+      return;
+    }
+    
+    const fastPct = (this.fastCalls / total * 100).toFixed(1);
+    const smartPct = (this.smartCalls / total * 100).toFixed(1);
+    
+    console.log(`
+${'='.repeat(50)}
+  Lazlo SmartRouter Stats
+${'='.repeat(50)}
+  Total calls  : ${total}
+  Fast model   : ${this.fastCalls} (${fastPct}%)
+  Smart model  : ${this.smartCalls} (${smartPct}%)
+${'='.repeat(50)}
+`);
+  }
+}

package/src/text_splitters/index.ts

@@ -0,0 +1,145 @@
+/**
+ * Text Splitters - Split documents into chunks
+ */
+
+import { Document } from '../core/types.js';
+
+// ============================================================================
+// Character Text Splitter
+// ============================================================================
+
+export interface TextSplitterOptions {
+  separator?: string;
+  chunkSize?: number;
+  chunkOverlap?: number;
+}
+
+export class CharacterTextSplitter {
+  private separator: string;
+  private chunkSize: number;
+  private chunkOverlap: number;
+  
+  constructor(options: TextSplitterOptions = {}) {
+    this.separator = options.separator ?? '\n\n';
+    this.chunkSize = options.chunkSize ?? 1000;
+    this.chunkOverlap = options.chunkOverlap ?? 200;
+  }
+  
+  splitText(text: string): string[] {
+    if (this.chunkSize === 0 || this.chunkSize >= text.length) {
+      return [text];
+    }
+    
+    const splits = text.split(this.separator);
+    const chunks: string[] = [];
+    let currentChunk: string[] = [];
+    let currentLength = 0;
+    
+    for (const split of splits) {
+      const splitLen = split.length;
+      
+      if (currentLength + splitLen > this.chunkSize && currentChunk.length > 0) {
+        chunks.push(currentChunk.join(this.separator));
+        
+        // Remove from front until under overlap threshold
+        while (currentLength > this.chunkOverlap && currentChunk.length > 0) {
+          const removed = currentChunk.shift();
+          currentLength -= (removed?.length ?? 0) + this.separator.length;
+        }
+      }
+      
+      currentChunk.push(split);
+      currentLength += splitLen + (currentChunk.length > 1 ? this.separator.length : 0);
+    }
+    
+    if (currentChunk.length > 0) {
+      chunks.push(currentChunk.join(this.separator));
+    }
+    
+    return chunks;
+  }
+  
+  splitDocuments(documents: Document[]): Document[] {
+    const newDocs: Document[] = [];
+    
+    for (const doc of documents) {
+      const chunks = this.splitText(doc.pageContent);
+      
+      chunks.forEach((chunk, i) => {
+        newDocs.push({
+          pageContent: chunk,
+          metadata: { ...doc.metadata, chunk_id: i },
+        });
+      });
+    }
+    
+    return newDocs;
+  }
+}
+
+// ============================================================================
+// Recursive Character Text Splitter
+// ============================================================================
+
+export class RecursiveCharacterTextSplitter extends CharacterTextSplitter {
+  private separators: string[];
+  
+  constructor(options: TextSplitterOptions & { separators?: string[] } = {}) {
+    super(options);
+    this.separators = options.separators ?? ['\n\n', '\n', ' ', ''];
+  }
+  
+  splitText(text: string): string[] {
+    const finalChunks: string[] = [];
+    
+    // If text is small enough, return as-is
+    if (text.length <= (this as any).chunkSize) {
+      return [text];
+    }
+    
+    // Try each separator in order
+    const separator = this.separators[0];
+    const splits = text.split(separator);
+    
+    for (const split of splits) {
+      if (!split.trim()) continue;
+      
+      if (split.length <= (this as any).chunkSize) {
+        finalChunks.push(split);
+      } else if (this.separators.length > 1) {
+        // Recursively split with next separator
+        const nextSplitter = new RecursiveCharacterTextSplitter({
+          separators: this.separators.slice(1),
+          chunkSize: (this as any).chunkSize,
+          chunkOverlap: (this as any).chunkOverlap,
+        });
+        finalChunks.push(...nextSplitter.splitText(split));
+      } else {
+        // Last resort - force split
+        finalChunks.push(...this.forceSplit(split));
+      }
+    }
+    
+    return finalChunks;
+  }
+  
+  private forceSplit(text: string): string[] {
+    const chunks: string[] = [];
+    const chunkSize = (this as any).chunkSize;
+    
+    for (let i = 0; i < text.length; i += chunkSize) {
+      chunks.push(text.slice(i, i + chunkSize));
+    }
+    
+    return chunks;
+  }
+}
+
+// Factory helpers
+export function createCharacterSplitter(options?: TextSplitterOptions): CharacterTextSplitter {
+  return new CharacterTextSplitter(options);
+}
+
+export function createRecursiveSplitter(options?: TextSplitterOptions): RecursiveCharacterTextSplitter {
+  return new RecursiveCharacterTextSplitter(options);
+}

package/src/tools/decorator.ts

@@ -0,0 +1,145 @@
+/**
+ * Tool Decorator - Turn functions into Lazlo tools
+ */
+
+import { BaseTool } from '../core/types.js';
+import { logger } from '../utils/logger.js';
+
+// ============================================================================
+// Tool Class
+// ============================================================================
+
+export interface ToolOptions {
+  name?: string;
+  description?: string;
+  argsSchema?: Record<string, unknown>;
+}
+
+export class Tool implements BaseTool {
+  name: string;
+  description: string;
+  argsSchema?: Record<string, unknown>;
+  private func: Function;
+  
+  constructor(func: Function, options: ToolOptions = {}) {
+    this.func = func;
+    this.name = options.name ?? func.name ?? 'unnamed_tool';
+    this.description = options.description ?? func.toString().slice(0, 100) ?? '';
+    this.argsSchema = options.argsSchema;
+  }
+  
+  async invoke(input: string | Record<string, unknown>): Promise<string> {
+    try {
+      let args: Record<string, unknown>;
+      
+      if (typeof input === 'string') {
+        try {
+          args = JSON.parse(input);
+        } catch {
+          args = { input };
+        }
+      } else {
+        args = input;
+      }
+      
+      const result = await this.func(args);
+      return typeof result === 'string' ? result : JSON.stringify(result);
+    } catch (error) {
+      logger.error(`Tool ${this.name} failed:`, error);
+      return `Error: ${error}`;
+    }
+  }
+  
+  toJSON(): Record<string, unknown> {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: this.argsSchema ?? {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}
+
+// ============================================================================
+// Tool Decorator Factory
+// ============================================================================
+
+export function createToolDecorator(options?: ToolOptions) {
+  return function(func: Function): Tool {
+    return new Tool(func, options);
+  };
+}
+
+// Shorthand: @tool
+export const tool = createToolDecorator();
+
+// With options: @tool({ name: 'calc', description: '...' })
+export const toolWithOptions = createToolDecorator;
+
+// ============================================================================
+// Create Tool Helper
+// ============================================================================
+
+export function defineTool(
+  func: Function,
+  name: string,
+  description: string,
+  argsSchema?: Record<string, unknown>
+): Tool {
+  return new Tool(func, { name, description, argsSchema });
+}
+
+// ============================================================================
+// Example Tools
+// ============================================================================
+
+// Calculator
+export const calculator = defineTool(
+  (args: { expression: string }) => {
+    try {
+      const result = Function(`"use strict"; return (${args.expression})`)();
+      return String(result);
+    } catch (e) {
+      return `Error: ${e}`;
+    }
+  },
+  'calculator',
+  'Perform a mathematical calculation',
+  {
+    type: 'object',
+    properties: {
+      expression: { type: 'string', description: 'Mathematical expression' },
+    },
+    required: ['expression'],
+  }
+);
+
+// Search
+export const search = defineTool(
+  (args: { query: string }) => `Search results for "${args.query}"`,
+  'search',
+  'Search the web',
+  {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search query' },
+    },
+    required: ['query'],
+  }
+);
+
+// Weather
+export const weather = defineTool(
+  (args: { location: string }) => `Weather for ${args.location}: Sunny, 72°F`,
+  'weather',
+  'Get weather info',
+  {
+    type: 'object',
+    properties: {
+      location: { type: 'string', description: 'City name' },
+    },
+    required: ['location'],
+  }
+);

package/src/tools/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Tools - Function calling for LLM agents
+ */
+
+export { Tool, tool, createToolDecorator, defineTool, calculator, search, weather } from './decorator.js';
+export { KeiroSearch } from './keiro.js';
+export type { ToolOptions } from './decorator.js';

package/src/tools/keiro.ts

@@ -0,0 +1,92 @@
+/**
+ * Keiro Search - Web search tool for LLM agents
+ */
+
+import axios, { AxiosInstance } from 'axios';
+import { BaseTool } from '../core/types.js';
+import { logger } from '../utils/logger.js';
+
+// ============================================================================
+// Keiro Search Tool
+// ============================================================================
+
+export interface KeiroSearchOptions {
+  apiKey?: string;
+  cacheSearch?: boolean;
+}
+
+export class KeiroSearch implements BaseTool {
+  name = 'keiro_search';
+  description = 'A powerful web search engine. Use this to find current events, up-to-date information, or if you do not know the answer. Input should be a specific search query string.';
+  
+  private client: AxiosInstance;
+  private apiKey?: string;
+  private cacheSearch: boolean;
+  
+  constructor(options: KeiroSearchOptions = {}) {
+    this.apiKey = options.apiKey ?? process.env.KEIRO_API_KEY;
+    this.cacheSearch = options.cacheSearch ?? true;
+    
+    this.client = axios.create({
+      baseURL: 'https://kierolabs.space/api',
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+    
+    logger.info('KeiroSearch tool initialized.');
+  }
+  
+  private parseInput(input: string | Record<string, unknown>): string {
+    if (typeof input === 'string') {
+      return input;
+    }
+    // If it's an object with a query field, use that
+    if ('query' in input && typeof input.query === 'string') {
+      return input.query;
+    }
+    // Otherwise stringify
+    return JSON.stringify(input);
+  }
+  
+  async invoke(input: string | Record<string, unknown>): Promise<string> {
+    const query = this.parseInput(input);
+    
+    logger.debug(`KeiroSearch: "${query}"`);
+    
+    try {
+      const response = await this.client.post('/search-pro', {
+        apiKey: this.apiKey,
+        query,
+        cache_search: this.cacheSearch,
+      });
+      
+      const results = response.data.results ?? [];
+      const answer = response.data.answer;
+      
+      if (answer) {
+        return answer;
+      }
+      
+      if (results.length === 0) {
+        return 'No search results found.';
+      }
+      
+      // Format results
+      const formatted = results.slice(0, 5).map((r: any, i: number) => {
+        return `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.content?.slice(0, 200) ?? ''}`;
+      }).join('\n\n');
+      
+      return `Search results for "${query}":\n\n${formatted}`;
+      
+    } catch (error: any) {
+      logger.error(`KeiroSearch error: ${error.message}`);
+      return `Error searching the web: ${error.message}`;
+    }
+  }
+  
+  async ainvoke(input: string | Record<string, unknown>): Promise<string> {
+    return this.invoke(input);
+  }
+}