@blockrun/franklin 3.15.59 → 3.15.61

package/dist/agent/loop.d.ts

@@ -20,6 +20,15 @@ export declare function looksLikeGatewayErrorAsText(parts: ContentPart[]): {
     match: boolean;
     message: string;
 };
+/**
+ * Walk a Dialogue and replace large `image.source.data` (base64) blocks
+ * inside `tool_result.content` arrays with a tiny placeholder. The
+ * accompanying text block already names the file path so the model on
+ * resume can re-Read it if it needs to see the image again. Returns a
+ * shallow clone so the in-memory history (used for the rest of the
+ * current turn) keeps the full image data.
+ */
+export declare function stripLargeImageData(message: Dialogue): Dialogue;
 /**
  * Identify models known to hallucinate tool calls (invented names, literal
  * `[TOOLCALL]` / `<tool_call>` text in answers) — they need the explicit

package/dist/agent/loop.js

@@ -288,6 +288,64 @@ function getBackoffDelay(attempt, maxDelayMs = 32_000) {
     const jitter = base * 0.25 * (Math.random() * 2 - 1); // ±25%
     return Math.max(500, Math.round(base + jitter));
 }
+/**
+ * Threshold for stripping inline base64 image data on session-disk
+ * writes. Mirrors `streaming-executor.ts:PERSIST_THRESHOLD` so a Read of
+ * a small icon (favicon-sized PNG, ~3 KB base64) round-trips through
+ * resume intact, while a Read of a screenshot or generated artwork
+ * (typically 200 KB+ base64) gets path-stubbed.
+ */
+const SESSION_IMAGE_STRIP_THRESHOLD = 50_000;
+/**
+ * Walk a Dialogue and replace large `image.source.data` (base64) blocks
+ * inside `tool_result.content` arrays with a tiny placeholder. The
+ * accompanying text block already names the file path so the model on
+ * resume can re-Read it if it needs to see the image again. Returns a
+ * shallow clone so the in-memory history (used for the rest of the
+ * current turn) keeps the full image data.
+ */
+export function stripLargeImageData(message) {
+    if (!Array.isArray(message.content))
+        return message;
+    let mutated = false;
+    // Cast through `unknown` because Dialogue's content union doesn't expose
+    // the tool_result shape with image blocks at the type level — they flow
+    // in via the loop's outcome-building path. Runtime structure is what
+    // matters here; we only mutate when we positively identify the shape.
+    const newContent = message.content.map((part) => {
+        if (typeof part === 'object' &&
+            part !== null &&
+            part.type === 'tool_result' &&
+            Array.isArray(part.content)) {
+            const tr = part;
+            let inner = tr.content;
+            let innerMutated = false;
+            const cleaned = inner.map((block) => {
+                if (block &&
+                    typeof block === 'object' &&
+                    block.type === 'image' &&
+                    block.source?.type === 'base64' &&
+                    (block.source.data?.length ?? 0) > SESSION_IMAGE_STRIP_THRESHOLD) {
+                    innerMutated = true;
+                    const sz = (block.source.data ?? '').length;
+                    return {
+                        type: 'text',
+                        text: `<image stripped from session log: ${(sz / 1024).toFixed(1)} KB base64. ` +
+                            `See accompanying text block for the source path; re-Read to inline again.>`,
+                    };
+                }
+                return block;
+            });
+            if (innerMutated) {
+                mutated = true;
+                inner = cleaned;
+                return { ...tr, content: inner };
+            }
+        }
+        return part;
+    });
+    return mutated ? { ...message, content: newContent } : message;
+}
 /**
  * Format the user-facing "switching model" line. Includes the resolved
  * concrete model in parentheses when the user-facing alias (e.g.
@@ -483,7 +541,16 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         });
     };
     const persistSessionMessage = (message) => {
-        appendToSession(sessionId, message);
+        // Strip large base64 image bytes before writing to session jsonl. The
+        // tool_result wrap at line ~1788 inlines image data so vision models
+        // can see it during the live turn — but PNG bytes can be ~600 KB
+        // each, and the inline content bypasses persistLargeResult (which
+        // only checks `result.output.length`). Verified 2026-05-05: a single
+        // Read of `/tmp/mamba_hd_p9.png` produced an 850 KB session jsonl
+        // line; a 5-turn session with multiple .png reads grew to 12 MB.
+        // The model already saw the bytes in this turn's in-memory history,
+        // so disk only needs the path reference for resume.
+        appendToSession(sessionId, stripLargeImageData(message));
         persistSessionMeta();
     };
     pruneOldSessions(sessionId); // Cleanup old sessions on start, protect current
@@ -987,6 +1054,15 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             // llm.ts if `tools` ended up empty, so it's safe to attach here.
             const callToolChoice = forceToolChoiceNextRound;
             forceToolChoiceNextRound = null;
+            // Wall-clock start of the model call. Used by the recordUsage call
+            // a few hundred lines below so franklin-stats.json captures real
+            // latency. Verified 2026-05-05: `franklin stats` reported
+            // `avgLat=0.0s` for every model across 5300+ requests because the
+            // agent-loop callsite always passed 0 for latencyMs (proxy path
+            // already measured correctly). `franklin insights` couldn't surface
+            // "this model is consistently slow" or "fallback was faster" until
+            // this was fixed.
+            const llmCallStartedAt = Date.now();
             try {
                 const result = await client.complete({
                     model: resolvedModel,
@@ -1287,7 +1363,8 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             // franklin-debug.log; `franklin insights` was therefore useless
             // for spotting a hot routing chain.
             const costEstimate = estimateCost(resolvedModel, inputTokens, usage.outputTokens, 1);
-            recordUsage(resolvedModel, inputTokens, usage.outputTokens, costEstimate, 0, turnFailedModels.size > 0);
+            const llmLatencyMs = Date.now() - llmCallStartedAt;
+            recordUsage(resolvedModel, inputTokens, usage.outputTokens, costEstimate, llmLatencyMs, turnFailedModels.size > 0);
             // ── Circuit breakers: prevent infinite-loop wallet drain ──
             // Per-turn $-cap was removed in v3.11.0 — runaway loops are caught by
             // MAX_TOOL_CALLS_PER_TURN (25) and MAX_TINY_RESPONSES (2) above; the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.15.59",
+  "version": "3.15.61",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {