adaptive-memory-multi-model-router 2.14.46 → 2.14.48

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

@@ -1,232 +0,0 @@
-/**
- * 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

@@ -1,257 +0,0 @@
-/**
- * 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
- */