adaptive-memory-multi-model-router 2.14.49 → 2.14.52

package/tmlpd-pi-extension/src/index.ts

@@ -0,0 +1,232 @@
+/**
+ * TMLPD PI Extension - v1.1.0
+ * 
+ * Parallel Multi-LLM Processing with Streaming, Caching, Cost Tracking, Reliability
+ * + Reference Architecture to Full TMLPD (Episodic Memory, MCTS, HALO)
+ * 
+ * @example
+ * ```typescript
+ * import { createTMLPD, HALOOrchestrator, EpisodicMemoryStore } from "tmlpd-pi";
+ * 
+ * // Lightweight usage (core features)
+ * const tmlpd = createTMLPD({ cache: { ttl_seconds: 3600 } });
+ * const result = await tmlpd.executeParallel(prompt, ["gpt-4o", "claude"]);
+ * 
+ * // Advanced: HALO orchestration with episodic memory
+ * const halo = new HALOOrchestrator({ maxConcurrent: 3, enableMCTS: true });
+ * const haloResult = await halo.execute("Build a REST API", async (subtask, agent) => {
+ *   // Execute via agent
+ * });
+ * 
+ * // Query episodic memory
+ * const similar = memory.getSimilarTasks("Python async API", 5);
+ * ```
+ */
+
+import { createTMLPD, TMLPDTools, TMLPDConfig, ExecuteResult, ParallelResult, StreamingConfig } from "./tools/tmlpdTools";
+import { ResponseCache, CacheConfig, CacheEntry } from "./cache/responseCache";
+import { CostTracker, BudgetConfig, CostAlert, CostSummary, CostSnapshot } from "./cost/costTracker";
+import { ProviderRegistry, ProviderConfig, ProviderRegistryConfig } from "./providers/registry";
+import { CircuitBreaker, withRetry, RetryConfig, CircuitState, calculateRetryDelay, isRetryableStatus, DEFAULT_RETRY_CONFIG } from "./utils/reliability";
+import { EpisodicMemoryStore, EpisodicEntry, MemoryQuery } from "./memory/episodicMemory";
+import { MCTSWorkflowOptimizer, WorkflowState, WorkflowAction, MCTSConfig } from "./orchestration/mctsWorkflow";
+import { HALOOrchestrator, SubTask, AgentAssignment, ExecutionResult, HALOConfig } from "./orchestration/haloOrchestrator";
+import { countTokens, estimateCost, estimateCostFromText, getModelCost, listModelsByCost, findCheapestModels, MODEL_COSTS, TokenCost } from "./utils/tokenUtils";
+import { isonEncode, isonDecode, compressText, truncateMessages, truncateToTokenBudget, calculateCompressionRatio, Message, CompressionStrategy } from "./utils/compression";
+import { LocalProvider, LocalProviderManager, createOllamaProvider, createVLLMProvider, createLMStudioProvider, LocalRuntime, LocalProviderConfig, LocalModelInfo, LocalGenerationResult, LocalParallelResult } from "./providers/localProvider";
+import { BatchProcessor, executeBatch, BatchItem, BatchResult, BatchOptions, BatchProgress, ProgressCallback } from "./utils/batchProcessor";
+import { routeQuery, routeBatch, recommendForTask, extractQueryFeatures, updateModelProfile, MODEL_PROFILES, QueryFeatures, ModelProfile, RouteDecision } from "./routing/advancedRouter";
+import { PrefixCache, createWarmedCache, PrefixCacheStats } from "./cache/prefixCache";
+import { SpeculativeDecoder, speculativeBatch, estimateSpeedupPotential, MedusaPredictor, EagleSpeculative, SpeculativeConfig, SpeculativeResult } from "./utils/speculativeDecoding";
+import { executeEnsemble, mergeComplementary, recordFeedback, EnsembleResult, EnsembleConfig } from "./routing/ensembleVoting";
+import { createPresetRouter, getPresetForQuery, DEFAULT_PRESETS, QueryPreset, PresetRouter } from "./routing/queryTypePresets";
+
+// Re-exports
+export { createTMLPD, TMLPDTools, TMLPDConfig, ExecuteResult, ParallelResult, StreamingConfig };
+export { ResponseCache, CacheConfig, CacheEntry };
+export { CostTracker, BudgetConfig, CostAlert, CostSummary, CostSnapshot };
+export { ProviderRegistry, ProviderConfig, ProviderRegistryConfig };
+export { CircuitBreaker, withRetry, RetryConfig, CircuitState, calculateRetryDelay, isRetryableStatus, DEFAULT_RETRY_CONFIG };
+export { EpisodicMemoryStore, EpisodicEntry, MemoryQuery };
+export { MCTSWorkflowOptimizer, WorkflowState, WorkflowAction, MCTSConfig };
+export { HALOOrchestrator, SubTask, AgentAssignment, ExecutionResult, HALOConfig };
+
+// Token utilities
+export { countTokens, estimateCost, estimateCostFromText, getModelCost, listModelsByCost, findCheapestModels, MODEL_COSTS, TokenCost };
+
+// Compression utilities
+export { isonEncode, isonDecode, compressText, truncateMessages, truncateToTokenBudget, calculateCompressionRatio, Message, CompressionStrategy };
+
+// Local provider support (Ollama, vLLM, LM Studio)
+export { LocalProvider, LocalProviderManager, createOllamaProvider, createVLLMProvider, createLMStudioProvider, LocalRuntime, LocalProviderConfig, LocalModelInfo, LocalGenerationResult, LocalParallelResult };
+
+// Batch processing
+export { BatchProcessor, executeBatch, BatchItem, BatchResult, BatchOptions, BatchProgress, ProgressCallback };
+
+// Advanced routing (RouteLLM-style)
+export { routeQuery, routeBatch, recommendForTask, extractQueryFeatures, updateModelProfile, MODEL_PROFILES, QueryFeatures, ModelProfile as ModelProfileType, RouteDecision };
+
+// Ensemble voting (P0) — Core differentiator: parallel multi-LLM execution with confidence merging
+export { executeEnsemble, mergeComplementary, recordFeedback, EnsembleResult, EnsembleConfig };
+
+// Query-type presets (P1) — Configurable provider+temp profiles per query type
+export { createPresetRouter, getPresetForQuery, DEFAULT_PRESETS, QueryPreset, PresetRouter };
+
+// Prefix caching (RadixAttention-style)
+export { PrefixCache, createWarmedCache, PrefixCacheStats };
+
+// Speculative decoding (Medusa/EAGLE-style)
+export { SpeculativeDecoder, speculativeBatch, estimateSpeedupPotential, MedusaPredictor, EagleSpeculative, SpeculativeConfig, SpeculativeResult };
+
+// PI Tool definitions (for PI agent integration)
+export const TMLPD_PI_TOOLS = [
+  {
+    name: "tmlpd_execute",
+    description: "Execute prompt across multiple LLM providers in parallel. Optimizes for cost-quality tradeoff with automatic model selection. Use when comparing multiple AI responses or needing faster results via parallel execution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "The prompt to execute" },
+        models: { type: "array", items: { type: "string" }, description: "Optional model list (auto-selects if omitted)" },
+        streaming: { type: "object", properties: { enabled: { type: "boolean" }, chunk_size: { type: "number" } } }
+      },
+      required: ["prompt"]
+    }
+  },
+  {
+    name: "tmlpd_execute_single",
+    description: "Execute with single model via smart routing. Analyzes prompt to select optimal agent based on task type (coding, explanation, analysis, etc.) with cost-quality optimization.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "The prompt to execute" },
+        model: { type: "string", description: "Optional specific model" }
+      },
+      required: ["prompt"]
+    }
+  },
+  {
+    name: "tmlpd_cost_summary",
+    description: "Get real-time cost tracking summary. Shows spending by provider, model, daily/monthly breakdowns, and remaining budget. Essential for cost monitoring in production.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "tmlpd_cache_stats",
+    description: "Get response cache statistics. Shows hit rate, cache size, and effectiveness. Cache hits cost $0 and provide instant responses.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "tmlpd_provider_status",
+    description: "Get status of all configured LLM providers. Shows readiness, cooldown status, failure counts. Use for debugging or selecting specific providers.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "tmlpd_invalidate_cache",
+    description: "Invalidate cached responses. Use when prompt content has changed and fresh response needed, or to clear stale cache entries.",
+    inputSchema: {
+      type: "object",
+      properties: { model: { type: "string", description: "Optional model to invalidate (all if omitted)" } }
+    }
+  },
+  {
+    name: "tmlpd_get_budget",
+    description: "Get remaining budget for cost controls. Returns daily, monthly, and per-model limits. Use for budget enforcement and alerting.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "tmlpd_halo_execute",
+    description: "Execute via HALO (Hierarchical Autonomous Logic-Oriented) orchestrator with 3-tier planning: decompose → assign → execute. Includes episodic memory for learning from past executions. For complex multi-step tasks.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task_description: { type: "string", description: "Task to execute" },
+        max_concurrent: { type: "number", description: "Max parallel executions (default: 3)" },
+        enable_mcts: { type: "boolean", description: "Enable MCTS optimization (slower but better)" }
+      },
+      required: ["task_description"]
+    }
+  },
+  {
+    name: "tmlpd_episodic_query",
+    description: "Query episodic memory for similar past tasks. Useful for learning from past executions and improving future routing decisions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task_description: { type: "string", description: "Task to find similar executions for" },
+        limit: { type: "number", description: "Max results (default: 5)" }
+      },
+      required: ["task_description"]
+    }
+  },
+  {
+    name: "tmlpd_count_tokens",
+    description: "Count tokens in text for cost estimation. Supports all major models (GPT-4, Claude, Gemini, Llama). Use for estimating costs before execution or calculating context window usage.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to count tokens in" },
+        model: { type: "string", description: "Model for tokenization (default: gpt-4o)" }
+      },
+      required: ["text"]
+    }
+  },
+  {
+    name: "tmlpd_compress_context",
+    description: "Compress context/messages using ISON encoding for token reduction. Reduces context by ~20-40% while preserving meaning. Useful for fitting more content in context windows.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        messages: { type: "array", description: "Messages to compress", items: { type: "object" } },
+        strategy: { type: "string", enum: ["smart", "first", "last"], description: "Compression strategy (default: smart)" },
+        max_tokens: { type: "number", description: "Target token budget" }
+      },
+      required: ["messages"]
+    }
+  },
+  {
+    name: "tmlpd_local_generate",
+    description: "Generate using local LLM runtime (Ollama, vLLM, LM Studio). Zero cost, privacy-preserving. Use for development, testing, or when local GPU available. Falls back to cloud if local unavailable.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "Prompt for generation" },
+        runtime: { type: "string", enum: ["ollama", "vllm", "lmstudio"], description: "Local runtime type" },
+        model: { type: "string", description: "Model name (default: llama-3.3-70b)" }
+      },
+      required: ["prompt", "runtime"]
+    }
+  },
+  {
+    name: "tmlpd_batch_execute",
+    description: "Execute batch of prompts with concurrency control. Supports priority queuing, progress callbacks, rate limiting. Use for processing multiple prompts efficiently.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompts: { type: "array", items: { type: "string" }, description: "Prompts to execute" },
+        concurrency: { type: "number", description: "Max parallel executions (default: 5)" },
+        model: { type: "string", description: "Model to use (default: gpt-4o)" }
+      },
+      required: ["prompts"]
+    }
+  }
+];
+
+/**
+ * Reference to Full TMLPD
+ * 
+ * This package provides:
+ * - Core: streaming, caching, cost tracking, reliability
+ * - Reference: episodic memory, MCTS, HALO orchestrator
+ * 
+ * For production with full features:
+ * - Python TMLPD: https://github.com/Das-rebel/tmlpd-skill
+ * - Full memory: 3-tier (episodic + semantic + working)
+ * - Full MCTS: UCB1, deterministic rollouts, strategy caching
+ * - Full HALO: NLP decomposition, capability matching, verification
+ */
+
+export default {
+  createTMLPD: createTMLPD,
+  TMLPDTools: TMLPDTools,
+  TMLPD_PI_TOOLS: TMLPD_PI_TOOLS
+};

package/tmlpd-pi-extension/src/memory/episodicMemory.ts

@@ -0,0 +1,257 @@
+/**
+ * TMLPD Episodic Memory Store
+ * 
+ * Stores specific task executions with full context.
+ * Reference implementation - for full features see TMLPD v2.x
+ * 
+ * Full TMLPD includes:
+ * - JSON-based episodic storage with keyword indexing
+ * - Importance scoring and time-based decay
+ * - Episodic retrieval by task similarity
+ */
+
+import { nanoid } from "nanoid";
+
+export interface EpisodicEntry {
+  id: string;
+  timestamp: number;
+  task: {
+    description: string;
+    type: string;
+    complexity: number;
+  };
+  result: {
+    success: boolean;
+    output: string;
+    duration_ms: number;
+  };
+  agent: {
+    id: string;
+    model: string;
+    provider: string;
+  };
+  metadata: Record<string, any>;
+  importance: number;
+}
+
+export interface MemoryQuery {
+  task_type?: string;
+  keywords?: string[];
+  limit?: number;
+}
+
+export class EpisodicMemoryStore {
+  private entries: EpisodicEntry[] = [];
+  private maxEntries: number;
+  private keywordIndex: Map<string, string[]>;
+  private persistencePath: string | null;
+
+  constructor(maxEntries = 1000, persistencePath?: string) {
+    this.maxEntries = maxEntries;
+    this.keywordIndex = new Map();
+    this.persistencePath = persistencePath || null;
+    if (this.persistencePath) this.loadFromDisk();
+  }
+
+  /**
+   * Store an episodic memory
+   */
+  store(entry: Omit<EpisodicEntry, "id" | "timestamp">): string {
+    const id = nanoid(12);
+    const fullEntry: EpisodicEntry = {
+      ...entry,
+      id,
+      timestamp: Date.now()
+    };
+
+    this.entries.push(fullEntry);
+    this.autoPersist();
+
+    // Index keywords
+    if (entry.task.description) {
+      const words = entry.task.description.toLowerCase().split(/\s+/);
+      words.forEach(word => {
+        if (word.length > 3) {
+          const existing = this.keywordIndex.get(word) || [];
+          existing.push(id);
+          this.keywordIndex.set(word, existing);
+        }
+      });
+    }
+
+    // Evict oldest if at capacity
+    if (this.entries.length > this.maxEntries) {
+      const evicted = this.entries.shift();
+      if (evicted) {
+        // Clean up keyword index for evicted entry
+        for (const [word, ids] of this.keywordIndex.entries()) {
+          const filtered = ids.filter(existingId => existingId !== evicted.id);
+          if (filtered.length === 0) {
+            this.keywordIndex.delete(word);
+          } else {
+            this.keywordIndex.set(word, filtered);
+          }
+        }
+      }
+    }
+
+    return id;
+  }
+
+  /**
+   * Query episodic memories
+   */
+  query(query: MemoryQuery): EpisodicEntry[] {
+    let results = [...this.entries];
+
+    if (query.task_type) {
+      results = results.filter(e => e.task.type === query.task_type);
+    }
+
+    if (query.keywords && query.keywords.length > 0) {
+      const matchingIds = new Set<string>();
+      query.keywords.forEach(kw => {
+        const lower = kw.toLowerCase();
+        for (const [word, ids] of this.keywordIndex.entries()) {
+          if (word.includes(lower)) {
+            ids.forEach(id => matchingIds.add(id));
+          }
+        }
+      });
+      if (matchingIds.size > 0) {
+        results = results.filter(e => matchingIds.has(e.id));
+      }
+    }
+
+    return results.slice(-(query.limit || 10));
+  }
+
+  /**
+   * Get similar tasks (for learning)
+   */
+  getSimilarTasks(taskDescription: string, limit = 5): EpisodicEntry[] {
+    const words = taskDescription.toLowerCase().split(/\s+/);
+    const scores = new Map<string, number>();
+
+    this.entries.forEach(entry => {
+      let score = 0;
+      const entryWords = entry.task.description.toLowerCase().split(/\s+/);
+      words.forEach(w => {
+        if (entryWords.includes(w)) score++;
+      });
+      if (score > 0) {
+        scores.set(entry.id, score);
+      }
+    });
+
+    const sorted = Array.from(scores.entries())
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, limit)
+      .map(([id]) => this.entries.find(e => e.id === id))
+      .filter(Boolean) as EpisodicEntry[];
+
+    return sorted;
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      total_entries: this.entries.length,
+      indexed_keywords: this.keywordIndex.size,
+      success_rate: this.entries.filter(e => e.result.success).length / Math.max(1, this.entries.length),
+      avg_duration_ms: this.entries.reduce((sum, e) => sum + e.result.duration_ms, 0) / Math.max(1, this.entries.length)
+    };
+  }
+
+  /**
+   * Persist current memory to disk as JSON
+   */
+  saveToDisk(): boolean {
+    if (!this.persistencePath) return false;
+    try {
+      const fs = require('fs');
+      const data = JSON.stringify({ entries: this.entries, maxEntries: this.maxEntries }, null, 2);
+      fs.writeFileSync(this.persistencePath, data, 'utf8');
+      return true;
+    } catch (e) {
+      console.error('❌ Memory persist failed:', (e as Error).message);
+      return false;
+    }
+  }
+
+  /**
+   * Load memory from disk JSON
+   */
+  loadFromDisk(): boolean {
+    if (!this.persistencePath) return false;
+    try {
+      const fs = require('fs');
+      if (!fs.existsSync(this.persistencePath)) return false;
+      const data = JSON.parse(fs.readFileSync(this.persistencePath, 'utf8'));
+      if (data.entries && Array.isArray(data.entries)) {
+        this.entries = data.entries;
+        this.maxEntries = data.maxEntries || this.maxEntries;
+        this.rebuildIndex();
+        return true;
+      }
+      return false;
+    } catch (e) {
+      console.error('❌ Memory load failed:', (e as Error).message);
+      return false;
+    }
+  }
+
+  /**
+   * Rebuild keyword index from loaded entries
+   */
+  private rebuildIndex(): void {
+    this.keywordIndex.clear();
+    for (const entry of this.entries) {
+      const words = (entry.task.description + ' ' + (entry.result.output || '')).toLowerCase().split(/\s+/);
+      for (const word of new Set(words)) {
+        if (word.length < 3) continue;
+        if (!this.keywordIndex.has(word)) this.keywordIndex.set(word, []);
+        this.keywordIndex.get(word)!.push(entry.id);
+      }
+    }
+  }
+
+  /**
+   * Auto-persist after adding new entries (if path configured)
+   */
+  private autoPersist(): void {
+    if (this.persistencePath && this.entries.length % 3 === 0) {
+      this.saveToDisk();
+    }
+  }
+
+  /**
+   * Clear all memories (also removes persisted file)
+   */
+  clear() {
+    this.entries = [];
+    this.keywordIndex.clear();
+    if (this.persistencePath) {
+      try {
+        const fs = require('fs');
+        if (fs.existsSync(this.persistencePath)) fs.unlinkSync(this.persistencePath);
+      } catch {}
+    }
+  }
+}
+
+/**
+ * Reference to Full TMLPD Memory System
+ * 
+ * For production use with full features:
+ * - Install: npm install tmlpd-skill (Python)
+ * - Or integrate with tmlpd-clean/src/memory/
+ * 
+ * Full features include:
+ * - Semantic memory with ChromaDB vector embeddings
+ * - Time-based importance decay (A-Mem pattern)
+ * - Cross-session learning
+ * - Episodic + Semantic + Working 3-tier architecture
+ */