@blockrun/clawrouter 0.9.12 → 0.9.13

package/dist/cli.js

@@ -2441,12 +2441,13 @@ var DEFAULT_COMPRESSION_CONFIG = {
 // src/compression/layers/deduplication.ts
 import crypto2 from "crypto";
 function hashMessage(message) {
-  const parts = [
-    message.role,
-    message.content || "",
-    message.tool_call_id || "",
-    message.name || ""
-  ];
+  let contentStr = "";
+  if (typeof message.content === "string") {
+    contentStr = message.content;
+  } else if (Array.isArray(message.content)) {
+    contentStr = JSON.stringify(message.content);
+  }
+  const parts = [message.role, contentStr, message.tool_call_id || "", message.name || ""];
   if (message.tool_calls) {
     parts.push(
       JSON.stringify(
@@ -2509,13 +2510,13 @@ function deduplicateMessages(messages) {
 
 // src/compression/layers/whitespace.ts
 function normalizeWhitespace(content) {
-  if (!content) return content;
+  if (!content || typeof content !== "string") return content;
   return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n{3,}/g, "\n\n").replace(/[ \t]+$/gm, "").replace(/([^\n]) {2,}/g, "$1 ").replace(/^[ ]{8,}/gm, (match) => "  ".repeat(Math.ceil(match.length / 4))).replace(/\t/g, "  ").trim();
 }
 function normalizeMessagesWhitespace(messages) {
   let charsSaved = 0;
   const result = messages.map((message) => {
-    if (!message.content) return message;
+    if (!message.content || typeof message.content !== "string") return message;
     const originalLength = message.content.length;
     const normalizedContent = normalizeWhitespace(message.content);
     charsSaved += originalLength - normalizedContent.length;
@@ -2619,6 +2620,9 @@ function generateCodebookHeader(usedCodes, pathMap = {}) {
 
 // src/compression/layers/dictionary.ts
 function encodeContent(content, inverseCodebook) {
+  if (!content || typeof content !== "string") {
+    return { encoded: content, substitutions: 0, codes: /* @__PURE__ */ new Set(), charsSaved: 0 };
+  }
   let encoded = content;
   let substitutions = 0;
   let charsSaved = 0;
@@ -2646,7 +2650,7 @@ function encodeMessages(messages) {
   let totalCharsSaved = 0;
   const allUsedCodes = /* @__PURE__ */ new Set();
   const result = messages.map((message) => {
-    if (!message.content) return message;
+    if (!message.content || typeof message.content !== "string") return message;
     const { encoded, substitutions, codes, charsSaved } = encodeContent(
       message.content,
       inverseCodebook
@@ -2672,7 +2676,7 @@ var PATH_REGEX = /(?:\/[\w.-]+){3,}/g;
 function extractPaths(messages) {
   const paths = [];
   for (const message of messages) {
-    if (!message.content) continue;
+    if (!message.content || typeof message.content !== "string") continue;
     const matches = message.content.match(PATH_REGEX);
     if (matches) {
       paths.push(...matches);
@@ -2714,7 +2718,7 @@ function shortenPaths(messages) {
   });
   let charsSaved = 0;
   const result = messages.map((message) => {
-    if (!message.content) return message;
+    if (!message.content || typeof message.content !== "string") return message;
     let content = message.content;
     const originalLength = content.length;
     for (const [code, prefix] of Object.entries(pathMap)) {
@@ -2765,7 +2769,7 @@ function compactMessagesJson(messages) {
       const newLength = JSON.stringify(newMessage.tool_calls).length;
       charsSaved += originalLength - newLength;
     }
-    if (message.role === "tool" && message.content && looksLikeJson(message.content)) {
+    if (message.role === "tool" && message.content && typeof message.content === "string" && looksLikeJson(message.content)) {
       const originalLength = message.content.length;
       const compacted = compactJson(message.content);
       charsSaved += originalLength - compacted.length;
@@ -2830,7 +2834,7 @@ function deduplicateLargeBlocks(messages) {
   const blockHashes = /* @__PURE__ */ new Map();
   let charsSaved = 0;
   const result = messages.map((msg, idx) => {
-    if (!msg.content || msg.content.length < 500) {
+    if (!msg.content || typeof msg.content !== "string" || msg.content.length < 500) {
       return msg;
     }
     const blockKey = msg.content.slice(0, 200);
@@ -2850,7 +2854,7 @@ function compressObservations(messages) {
   let charsSaved = 0;
   let observationsCompressed = 0;
   let result = messages.map((msg) => {
-    if (msg.role !== "tool" || !msg.content) {
+    if (msg.role !== "tool" || !msg.content || typeof msg.content !== "string") {
       return msg;
     }
     const original = msg.content;
@@ -2903,7 +2907,7 @@ function findRepeatedPhrases(allContent) {
 function buildDynamicCodebook(messages) {
   let allContent = "";
   for (const msg of messages) {
-    if (msg.content) {
+    if (msg.content && typeof msg.content === "string") {
       allContent += msg.content + "\n";
     }
   }
@@ -2928,6 +2932,7 @@ function buildDynamicCodebook(messages) {
   return codebook;
 }
 function escapeRegex2(str) {
+  if (!str || typeof str !== "string") return "";
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function applyDynamicCodebook(messages) {
@@ -2948,7 +2953,7 @@ function applyDynamicCodebook(messages) {
   let charsSaved = 0;
   let substitutions = 0;
   const result = messages.map((msg) => {
-    if (!msg.content) return msg;
+    if (!msg.content || typeof msg.content !== "string") return msg;
     let content = msg.content;
     for (const phrase of sortedPhrases) {
       const code = phraseToCode[phrase];
@@ -2981,7 +2986,12 @@ function generateDynamicCodebookHeader(codebook) {
 // src/compression/index.ts
 function calculateTotalChars(messages) {
   return messages.reduce((total, msg) => {
-    let chars = msg.content?.length || 0;
+    let chars = 0;
+    if (typeof msg.content === "string") {
+      chars = msg.content.length;
+    } else if (Array.isArray(msg.content)) {
+      chars = JSON.stringify(msg.content).length;
+    }
     if (msg.tool_calls) {
       chars += JSON.stringify(msg.tool_calls).length;
     }
@@ -3000,12 +3010,14 @@ function prependCodebookHeader(messages, usedCodes, pathMap) {
   }
   return messages.map((msg, i) => {
     if (i === userIndex) {
-      return {
-        ...msg,
-        content: `${header}
+      if (typeof msg.content === "string") {
+        return {
+          ...msg,
+          content: `${header}
 
-${msg.content || ""}`
-      };
+${msg.content}`
+        };
+      }
     }
     return msg;
   });
@@ -3110,11 +3122,11 @@ async function compressContext(messages, config = {}) {
       const dynHeader = generateDynamicCodebookHeader(dynamicCodes);
       if (dynHeader) {
         const systemIndex = result.findIndex((m) => m.role === "system");
-        if (systemIndex >= 0) {
+        if (systemIndex >= 0 && typeof result[systemIndex].content === "string") {
           result[systemIndex] = {
             ...result[systemIndex],
             content: `${dynHeader}
-${result[systemIndex].content || ""}`
+${result[systemIndex].content}`
           };
         }
       }
@@ -3322,6 +3334,174 @@ var PROXY_PORT = (() => {
   return DEFAULT_PORT;
 })();
 
+// src/journal.ts
+var DEFAULT_CONFIG2 = {
+  maxEntries: 100,
+  maxAgeMs: 24 * 60 * 60 * 1e3,
+  // 24 hours
+  maxEventsPerResponse: 5
+};
+var SessionJournal = class {
+  journals = /* @__PURE__ */ new Map();
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+  }
+  /**
+   * Extract key events from assistant response content.
+   * Looks for patterns like "I created...", "I fixed...", "Successfully..."
+   */
+  extractEvents(content) {
+    if (!content || typeof content !== "string") {
+      return [];
+    }
+    const events = [];
+    const seen = /* @__PURE__ */ new Set();
+    const patterns = [
+      // Creation patterns
+      /I (?:also |then |have |)?(?:created|implemented|added|wrote|built|generated|set up|initialized) ([^.!?\n]{10,150})/gi,
+      // Fix patterns
+      /I (?:also |then |have |)?(?:fixed|resolved|solved|patched|corrected|addressed|debugged) ([^.!?\n]{10,150})/gi,
+      // Completion patterns
+      /I (?:also |then |have |)?(?:completed|finished|done with|wrapped up) ([^.!?\n]{10,150})/gi,
+      // Update patterns
+      /I (?:also |then |have |)?(?:updated|modified|changed|refactored|improved|enhanced|optimized) ([^.!?\n]{10,150})/gi,
+      // Success patterns
+      /Successfully ([^.!?\n]{10,150})/gi,
+      // Tool usage patterns (when agent uses tools)
+      /I (?:also |then |have |)?(?:ran|executed|called|invoked) ([^.!?\n]{10,100})/gi
+    ];
+    for (const pattern of patterns) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const action = match[0].trim();
+        const normalized = action.toLowerCase();
+        if (seen.has(normalized)) {
+          continue;
+        }
+        if (action.length >= 15 && action.length <= 200) {
+          events.push(action);
+          seen.add(normalized);
+        }
+        if (events.length >= this.config.maxEventsPerResponse) {
+          break;
+        }
+      }
+      if (events.length >= this.config.maxEventsPerResponse) {
+        break;
+      }
+    }
+    return events;
+  }
+  /**
+   * Record events to the session journal.
+   */
+  record(sessionId, events, model) {
+    if (!sessionId || !events.length) {
+      return;
+    }
+    const journal = this.journals.get(sessionId) || [];
+    const now = Date.now();
+    for (const action of events) {
+      journal.push({
+        timestamp: now,
+        action,
+        model
+      });
+    }
+    const cutoff = now - this.config.maxAgeMs;
+    const trimmed = journal.filter((e) => e.timestamp > cutoff).slice(-this.config.maxEntries);
+    this.journals.set(sessionId, trimmed);
+  }
+  /**
+   * Check if the user message indicates a need for historical context.
+   */
+  needsContext(lastUserMessage) {
+    if (!lastUserMessage || typeof lastUserMessage !== "string") {
+      return false;
+    }
+    const lower = lastUserMessage.toLowerCase();
+    const triggers = [
+      // Direct questions about past work
+      "what did you do",
+      "what have you done",
+      "what did we do",
+      "what have we done",
+      // Temporal references
+      "earlier",
+      "before",
+      "previously",
+      "this session",
+      "today",
+      "so far",
+      // Summary requests
+      "remind me",
+      "summarize",
+      "summary of",
+      "recap",
+      // Progress inquiries
+      "your work",
+      "your progress",
+      "accomplished",
+      "achievements",
+      "completed tasks"
+    ];
+    return triggers.some((t) => lower.includes(t));
+  }
+  /**
+   * Format the journal for injection into system message.
+   * Returns null if journal is empty.
+   */
+  format(sessionId) {
+    const journal = this.journals.get(sessionId);
+    if (!journal?.length) {
+      return null;
+    }
+    const lines = journal.map((e) => {
+      const time = new Date(e.timestamp).toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: true
+      });
+      return `- ${time}: ${e.action}`;
+    });
+    return `[Session Memory - Key Actions]
+${lines.join("\n")}`;
+  }
+  /**
+   * Get the raw journal entries for a session (for debugging/testing).
+   */
+  getEntries(sessionId) {
+    return this.journals.get(sessionId) || [];
+  }
+  /**
+   * Clear journal for a specific session.
+   */
+  clear(sessionId) {
+    this.journals.delete(sessionId);
+  }
+  /**
+   * Clear all journals.
+   */
+  clearAll() {
+    this.journals.clear();
+  }
+  /**
+   * Get stats about the journal.
+   */
+  getStats() {
+    let totalEntries = 0;
+    for (const entries of this.journals.values()) {
+      totalEntries += entries.length;
+    }
+    return {
+      sessions: this.journals.size,
+      totalEntries
+    };
+  }
+};
+
 // src/proxy.ts
 var BLOCKRUN_API = "https://blockrun.ai/api";
 var AUTO_MODEL = "blockrun/auto";
@@ -3731,6 +3911,7 @@ async function startProxy(options) {
   const deduplicator = new RequestDeduplicator();
   const responseCache = new ResponseCache(options.cacheConfig);
   const sessionStore = new SessionStore(options.sessionConfig);
+  const sessionJournal = new SessionJournal();
   const connections = /* @__PURE__ */ new Set();
   const server = createServer(async (req, res) => {
     req.on("error", (err) => {
@@ -3826,7 +4007,8 @@ async function startProxy(options) {
         deduplicator,
         balanceMonitor,
         sessionStore,
-        responseCache
+        responseCache,
+        sessionJournal
       );
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
@@ -4027,7 +4209,7 @@ async function tryModelRequest(upstreamUrl, method, headers, body, modelId, maxT
     };
   }
 }
-async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, deduplicator, balanceMonitor, sessionStore, responseCache) {
+async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, deduplicator, balanceMonitor, sessionStore, responseCache, sessionJournal) {
   const startTime = Date.now();
   const upstreamUrl = `${apiBase}${req.url}`;
   const bodyChunks = [];
@@ -4040,13 +4222,38 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
   let modelId = "";
   let maxTokens = 4096;
   let routingProfile = null;
+  let accumulatedContent = "";
   const isChatCompletion = req.url?.includes("/chat/completions");
+  const sessionId = getSessionId(req.headers);
   if (isChatCompletion && body.length > 0) {
     try {
       const parsed = JSON.parse(body.toString());
       isStreaming = parsed.stream === true;
       modelId = parsed.model || "";
       maxTokens = parsed.max_tokens || 4096;
+      if (sessionId && Array.isArray(parsed.messages)) {
+        const messages = parsed.messages;
+        const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+        const lastContent = typeof lastUserMsg?.content === "string" ? lastUserMsg.content : "";
+        if (sessionJournal.needsContext(lastContent)) {
+          const journalText = sessionJournal.format(sessionId);
+          if (journalText) {
+            const sysIdx = messages.findIndex((m) => m.role === "system");
+            if (sysIdx >= 0 && typeof messages[sysIdx].content === "string") {
+              messages[sysIdx] = {
+                ...messages[sysIdx],
+                content: journalText + "\n\n" + messages[sysIdx].content
+              };
+            } else {
+              messages.unshift({ role: "system", content: journalText });
+            }
+            parsed.messages = messages;
+            console.log(
+              `[ClawRouter] Injected session journal (${journalText.length} chars) for session ${sessionId.slice(0, 8)}...`
+            );
+          }
+        }
+      }
       let bodyModified = false;
       if (parsed.stream === true) {
         parsed.stream = false;
@@ -4086,18 +4293,18 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
             latencyMs: 0
           });
         } else {
-          const sessionId = getSessionId(
+          const sessionId2 = getSessionId(
             req.headers
           );
-          const existingSession = sessionId ? sessionStore.getSession(sessionId) : void 0;
+          const existingSession = sessionId2 ? sessionStore.getSession(sessionId2) : void 0;
           if (existingSession) {
             console.log(
-              `[ClawRouter] Session ${sessionId?.slice(0, 8)}... using pinned model: ${existingSession.model}`
+              `[ClawRouter] Session ${sessionId2?.slice(0, 8)}... using pinned model: ${existingSession.model}`
             );
             parsed.model = existingSession.model;
             modelId = existingSession.model;
             bodyModified = true;
-            sessionStore.touchSession(sessionId);
+            sessionStore.touchSession(sessionId2);
           } else {
             const messages = parsed.messages;
             let lastUserMsg;
@@ -4126,10 +4333,10 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
             parsed.model = routingDecision.model;
             modelId = routingDecision.model;
             bodyModified = true;
-            if (sessionId) {
-              sessionStore.setSession(sessionId, routingDecision.model, routingDecision.tier);
+            if (sessionId2) {
+              sessionStore.setSession(sessionId2, routingDecision.model, routingDecision.tier);
               console.log(
-                `[ClawRouter] Session ${sessionId.slice(0, 8)}... pinned to model: ${routingDecision.model}`
+                `[ClawRouter] Session ${sessionId2.slice(0, 8)}... pinned to model: ${routingDecision.model}`
               );
             }
             options.onRouted?.(routingDecision);
@@ -4464,6 +4671,9 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
               const content = stripThinkingTokens(rawContent);
               const role = choice.message?.role ?? choice.delta?.role ?? "assistant";
               const index = choice.index ?? 0;
+              if (content) {
+                accumulatedContent += content;
+              }
               const roleChunk = {
                 ...baseChunk,
                 choices: [{ index, delta: { role }, logprobs: null, finish_reason: null }]
@@ -4577,6 +4787,22 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
         });
         console.log(`[ClawRouter] Cached response for ${modelId} (${responseBody.length} bytes)`);
       }
+      try {
+        const rspJson = JSON.parse(responseBody.toString());
+        if (rspJson.choices?.[0]?.message?.content) {
+          accumulatedContent = rspJson.choices[0].message.content;
+        }
+      } catch {
+      }
+    }
+    if (sessionId && accumulatedContent) {
+      const events = sessionJournal.extractEvents(accumulatedContent);
+      if (events.length > 0) {
+        sessionJournal.record(sessionId, events, actualModelUsed);
+        console.log(
+          `[ClawRouter] Recorded ${events.length} events to session journal for session ${sessionId.slice(0, 8)}...`
+        );
+      }
     }
     if (estimatedCostMicros !== void 0) {
       balanceMonitor.deductEstimated(estimatedCostMicros);