clementine-agent 1.0.85 → 1.0.86

package/dist/agent/route-classifier.d.ts

@@ -23,6 +23,8 @@ export interface RouteDecision {
     confidence: number;
     reasoning: string;
 }
+/** Test-only: reset the cache between runs. */
+export declare function _resetRouteCache(): void;
 export declare function isDirectImperative(userMessage: string): {
     match: boolean;
     pattern?: string;

package/dist/agent/route-classifier.js

@@ -18,6 +18,49 @@
  */
 import pino from 'pino';
 const logger = pino({ name: 'clementine.route-classifier' });
+// ── LRU cache for repeated messages ──────────────────────────────────
+// Same text + same available-agents set → same decision. Skips the
+// Haiku LLM call entirely on cache hit (saves 1-2 seconds per repeat).
+// Bounded by both size and TTL so stale rosters can't cause wrong routes.
+const ROUTE_CACHE_MAX = 100;
+const ROUTE_CACHE_TTL_MS = 5 * 60 * 1000;
+// Insertion-ordered Map = LRU when we delete-and-reinsert on hit.
+const routeCache = new Map();
+function cacheKey(text, agents) {
+    // Trim + normalize whitespace so trailing-newline variations of the
+    // same message hit the same cache entry.
+    const normText = text.replace(/\s+/g, ' ').trim();
+    // Sort slugs so order doesn't matter; include count to invalidate on
+    // hire/fire (the agents array changes shape).
+    const slugFingerprint = agents.map(a => a.slug).sort().join(',');
+    return `${slugFingerprint}::${normText}`;
+}
+function cacheGet(key, now) {
+    const entry = routeCache.get(key);
+    if (!entry)
+        return null;
+    if (entry.expiresAt <= now) {
+        routeCache.delete(key);
+        return null;
+    }
+    // LRU touch: remove + re-insert to move to end of insertion order
+    routeCache.delete(key);
+    routeCache.set(key, entry);
+    return entry;
+}
+function cachePut(key, decision, now) {
+    routeCache.set(key, { decision, expiresAt: now + ROUTE_CACHE_TTL_MS });
+    while (routeCache.size > ROUTE_CACHE_MAX) {
+        const oldest = routeCache.keys().next().value;
+        if (oldest === undefined)
+            break;
+        routeCache.delete(oldest);
+    }
+}
+/** Test-only: reset the cache between runs. */
+export function _resetRouteCache() {
+    routeCache.clear();
+}
 /**
  * Direct-imperative guardrail.
  *
@@ -229,6 +272,15 @@ export async function classifyRoute(userMessage, agents, gateway) {
         logger.debug({ trigger: 'question-opener' }, 'Routing skipped — question-opener');
         return null;
     }
+    // Cache hit short-circuit — same message + same roster as a recent
+    // call gets the same decision without firing the Haiku classifier.
+    const now = Date.now();
+    const key = cacheKey(userMessage, agents);
+    const hit = cacheGet(key, now);
+    if (hit) {
+        logger.debug({ trigger: 'cache-hit', cachedAgent: hit.decision?.targetAgent ?? 'clementine' }, 'Route classifier cache hit');
+        return hit.decision;
+    }
     // LLM classifier for everything else.
     const prompt = buildPrompt(userMessage, agents);
     let raw;
@@ -239,6 +291,7 @@ export async function classifyRoute(userMessage, agents, gateway) {
     }
     catch (err) {
         logger.warn({ err }, 'Route classifier call failed');
+        // Don't cache failures — next call should retry the LLM.
         return null;
     }
     const decision = parseResponse(raw);
@@ -254,6 +307,7 @@ export async function classifyRoute(userMessage, agents, gateway) {
         decision.targetAgent = 'clementine';
         decision.confidence = Math.min(decision.confidence, 0.3);
     }
+    cachePut(key, decision, now);
     return decision;
 }
 //# sourceMappingURL=route-classifier.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.0.85",
+  "version": "1.0.86",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",