@blockrun/franklin 3.8.40 → 3.8.41

package/README.md

@@ -69,6 +69,18 @@ franklin balance           # show address + USDC balance
 
 That's it. Zero signup, zero credit card, zero phone verification. Send **$5 of USDC** to the wallet and you've unlocked every frontier model and every paid tool in the BlockRun gateway.
 
+### Prefer a GUI? Try Franklin for VS Code
+
+The same agent ships as a [VS Code extension](https://marketplace.visualstudio.com/items?itemName=blockrun.franklin-vscode) — chat panel, model picker, wallet balance, image / video generation, inline diff cards — all driven by the wallet you already funded for the CLI.
+
+```
+VS Code → Extensions  (Cmd+Shift+X / Ctrl+Shift+X)
+        → search "Franklin" → Install
+        → click the Franklin icon in the Activity Bar
+```
+
+Free models work immediately. Paid models, image gen, and video gen activate the moment your wallet has USDC. The CLI and the extension share the same `~/.blockrun/` config and session history, so jumping between terminal and VS Code is seamless.
+
 ---
 
 ## YOPO

package/dist/agent/continuation.d.ts

@@ -0,0 +1,17 @@
+import type { Dialogue } from './types.js';
+/**
+ * Cap on how many times a single user turn can auto-continue after a
+ * stream-timeout. One is enough: if the first chunked attempt also times
+ * out, the model isn't going to figure it out by recursion — fall through
+ * to the normal error path so the user can intervene.
+ */
+export declare const MAX_AUTO_CONTINUATIONS_PER_TURN = 1;
+export declare function isAutoContinuationDisabled(): boolean;
+/**
+ * Built when a model call times out at the streaming layer on a task
+ * that's too big to complete in one turn (multi-file scaffolds,
+ * dashboard builds, etc.). Pushed into history before re-firing so the
+ * model treats the next attempt as a single narrow chunk rather than
+ * retrying the whole job and timing out again.
+ */
+export declare function buildContinuationPrompt(): Dialogue;

package/dist/agent/continuation.js

@@ -0,0 +1,35 @@
+/**
+ * Cap on how many times a single user turn can auto-continue after a
+ * stream-timeout. One is enough: if the first chunked attempt also times
+ * out, the model isn't going to figure it out by recursion — fall through
+ * to the normal error path so the user can intervene.
+ */
+export const MAX_AUTO_CONTINUATIONS_PER_TURN = 1;
+export function isAutoContinuationDisabled() {
+    return process.env.FRANKLIN_NO_AUTO_CONTINUE === '1';
+}
+/**
+ * Built when a model call times out at the streaming layer on a task
+ * that's too big to complete in one turn (multi-file scaffolds,
+ * dashboard builds, etc.). Pushed into history before re-firing so the
+ * model treats the next attempt as a single narrow chunk rather than
+ * retrying the whole job and timing out again.
+ */
+export function buildContinuationPrompt() {
+    return {
+        role: 'user',
+        content: [
+            'Your previous attempt timed out at the streaming layer — the task is too large for a single streaming turn.',
+            '',
+            'DO:',
+            '- Pick ONE narrowly scoped next step (one file, one component, one logical chunk).',
+            '- Complete just that step in this response.',
+            '- Save work via Write/Edit and stop. The user will continue from there.',
+            '',
+            'DO NOT:',
+            '- Re-attempt the entire original task in one shot.',
+            '- Make more than 3-4 tool calls before producing a result.',
+            '- Plan the whole multi-stage job — execute one chunk now.',
+        ].join('\n'),
+    };
+}

package/dist/agent/loop.js

@@ -29,6 +29,8 @@ import { shouldVerify, runVerification } from './verification.js';
 import { shouldCheckGrounding, checkGrounding, renderGroundingFollowup, buildGroundingRetryInstruction, extractMissingToolNames, } from './evaluator.js';
 import { augmentUserMessage, prefetchForIntent } from './intent-prefetch.js';
 import { analyzeTurn } from './turn-analyzer.js';
+import { evaluateTimeoutRetry } from './retry-policy.js';
+import { MAX_AUTO_CONTINUATIONS_PER_TURN, buildContinuationPrompt, isAutoContinuationDisabled, } from './continuation.js';
 import { createSessionId, appendToSession, updateSessionMeta, pruneOldSessions, loadSessionHistory, loadSessionMeta, } from '../session/storage.js';
 /**
  * Atomically replace all elements in a history array.
@@ -452,6 +454,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         onAbortReady?.(() => abort.abort());
         let loopCount = 0;
         let recoveryAttempts = 0;
+        let autoContinuationCount = 0;
         const MAX_RECOVERY_ATTEMPTS = 5;
         let compactFailures = 0;
         let maxTokensOverride;
@@ -897,6 +900,52 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 // ── Transient error recovery (network, rate limit, server errors) ──
                 // Respect per-error maxRetries (e.g., 529/overloaded gets only 3 retries)
                 const effectiveMaxRetries = classified.maxRetries ?? MAX_RECOVERY_ATTEMPTS;
+                if (classified.category === 'timeout' && recoveryAttempts < effectiveMaxRetries) {
+                    const retryDecision = evaluateTimeoutRetry(history, resolvedModel);
+                    if (!retryDecision.retry) {
+                        // Before surfacing the timeout error, try auto-continuation:
+                        // for tasks too big to finish in one streaming turn (multi-file
+                        // scaffolds, dashboard builds), inject a chunking-instruction
+                        // prompt and let the model take one narrow next step. Capped at
+                        // MAX_AUTO_CONTINUATIONS_PER_TURN — if the chunked attempt also
+                        // times out, fall through to the normal error path.
+                        if (!isAutoContinuationDisabled() &&
+                            autoContinuationCount < MAX_AUTO_CONTINUATIONS_PER_TURN) {
+                            autoContinuationCount++;
+                            recoveryAttempts++;
+                            const continuationPrompt = buildContinuationPrompt();
+                            history.push(continuationPrompt);
+                            persistSessionMessage(continuationPrompt);
+                            if (config.debug) {
+                                console.error(`[franklin] Stream timeout on ${resolvedModel} — auto-continuing with chunked-task prompt`);
+                            }
+                            onEvent({
+                                kind: 'text_delta',
+                                text: '\n*Task too big for one streaming turn — auto-continuing with a smaller chunk...*\n',
+                            });
+                            lastSessionActivity = Date.now();
+                            continue;
+                        }
+                        const tokenText = retryDecision.estimatedInputTokens.toLocaleString();
+                        const costText = retryDecision.estimatedReplayCostUsd > 0
+                            ? ` and at least $${retryDecision.estimatedReplayCostUsd.toFixed(4)} in input charges`
+                            : '';
+                        if (config.debug) {
+                            console.error(`[franklin] Timeout retry skipped for ${resolvedModel}: ` +
+                                `~${tokenText} input tokens, replayCost=$${retryDecision.estimatedReplayCostUsd.toFixed(4)}`);
+                        }
+                        onEvent({
+                            kind: 'turn_done',
+                            reason: 'error',
+                            error: `[${classified.label}] ${errMsg}\n` +
+                                `Tip: Automatic retry skipped to avoid re-sending ~${tokenText} input tokens${costText}. ` +
+                                'Use /retry if you want to run another full attempt.',
+                        });
+                        lastSessionActivity = Date.now();
+                        persistSessionMeta();
+                        break;
+                    }
+                }
                 if (classified.isTransient && recoveryAttempts < effectiveMaxRetries) {
                     recoveryAttempts++;
                     const backoffMs = getBackoffDelay(recoveryAttempts);

package/dist/agent/retry-policy.d.ts

@@ -0,0 +1,19 @@
+import type { Dialogue } from './types.js';
+export declare const TIMEOUT_RETRY_INPUT_TOKEN_LIMIT = 20000;
+export declare const TIMEOUT_RETRY_MIN_REPLAY_COST_LIMIT_USD = 0.05;
+export type TimeoutRetrySkipReason = 'estimated_cost' | 'input_tokens';
+export interface TimeoutRetryDecision {
+    retry: boolean;
+    estimatedInputTokens: number;
+    estimatedReplayCostUsd: number;
+    reason?: TimeoutRetrySkipReason;
+}
+/**
+ * A timeout retry re-sends the entire conversation. For long paid contexts,
+ * that can cost more than the original useful work and hit the turn budget
+ * before the model gets another chance to finish.
+ */
+export declare function evaluateTimeoutRetry(history: Dialogue[], model: string, opts?: {
+    inputTokenLimit?: number;
+    minReplayCostLimitUsd?: number;
+}): TimeoutRetryDecision;

package/dist/agent/retry-policy.js

@@ -0,0 +1,36 @@
+import { estimateCost } from '../pricing.js';
+import { estimateHistoryTokens } from './tokens.js';
+export const TIMEOUT_RETRY_INPUT_TOKEN_LIMIT = 20_000;
+export const TIMEOUT_RETRY_MIN_REPLAY_COST_LIMIT_USD = 0.05;
+/**
+ * A timeout retry re-sends the entire conversation. For long paid contexts,
+ * that can cost more than the original useful work and hit the turn budget
+ * before the model gets another chance to finish.
+ */
+export function evaluateTimeoutRetry(history, model, opts) {
+    const inputTokenLimit = opts?.inputTokenLimit ?? TIMEOUT_RETRY_INPUT_TOKEN_LIMIT;
+    const minReplayCostLimitUsd = opts?.minReplayCostLimitUsd ?? TIMEOUT_RETRY_MIN_REPLAY_COST_LIMIT_USD;
+    const estimatedInputTokens = estimateHistoryTokens(history);
+    const estimatedReplayCostUsd = estimateCost(model, estimatedInputTokens, 0, 1);
+    if (estimatedReplayCostUsd > minReplayCostLimitUsd) {
+        return {
+            retry: false,
+            estimatedInputTokens,
+            estimatedReplayCostUsd,
+            reason: 'estimated_cost',
+        };
+    }
+    if (estimatedInputTokens > inputTokenLimit) {
+        return {
+            retry: false,
+            estimatedInputTokens,
+            estimatedReplayCostUsd,
+            reason: 'input_tokens',
+        };
+    }
+    return {
+        retry: true,
+        estimatedInputTokens,
+        estimatedReplayCostUsd,
+    };
+}

package/dist/ui/model-picker.js

@@ -14,10 +14,12 @@ export const MODEL_SHORTCUTS = {
     // Anthropic
     sonnet: 'anthropic/claude-sonnet-4.6',
     claude: 'anthropic/claude-sonnet-4.6',
+    'sonnet-4.6': 'anthropic/claude-sonnet-4.6',
     opus: 'anthropic/claude-opus-4.7',
     'opus-4.7': 'anthropic/claude-opus-4.7',
     'opus-4.6': 'anthropic/claude-opus-4.6',
     haiku: 'anthropic/claude-haiku-4.5-20251001',
+    'haiku-4.5': 'anthropic/claude-haiku-4.5-20251001',
     // OpenAI
     // `gpt` / `gpt5` / `gpt-5` follow the gateway's flagship — currently 5.5.
     gpt: 'openai/gpt-5.5',
@@ -39,12 +41,16 @@ export const MODEL_SHORTCUTS = {
     o1: 'openai/o1',
     // Google
     gemini: 'google/gemini-2.5-pro',
+    'gemini-2.5': 'google/gemini-2.5-pro',
     flash: 'google/gemini-2.5-flash',
     'gemini-3': 'google/gemini-3.1-pro',
+    'gemini-3.1': 'google/gemini-3.1-pro',
     // xAI
     grok: 'xai/grok-3',
+    'grok-3': 'xai/grok-3',
     'grok-4': 'xai/grok-4-0709',
     'grok-fast': 'xai/grok-4-1-fast-reasoning',
+    'grok-4.1': 'xai/grok-4-1-fast-reasoning',
     // DeepSeek
     deepseek: 'deepseek/deepseek-chat',
     r1: 'deepseek/deepseek-reasoner',
@@ -65,11 +71,14 @@ export const MODEL_SHORTCUTS = {
     devstral: 'nvidia/qwen3-coder-480b',
     // Others
     minimax: 'minimax/minimax-m2.7',
+    'm2.7': 'minimax/minimax-m2.7',
     glm: 'zai/glm-5.1',
     'glm-turbo': 'zai/glm-5-turbo',
     'glm5': 'zai/glm-5.1',
     kimi: 'moonshot/kimi-k2.6',
+    'k2.6': 'moonshot/kimi-k2.6',
     'kimi-k2.5': 'moonshot/kimi-k2.5',
+    'k2.5': 'moonshot/kimi-k2.5',
 };
 /**
  * Resolve a model name — supports shortcuts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.8.40",
+  "version": "3.8.41",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {
@@ -78,7 +78,8 @@
     "ink-text-input": "^6.0.0",
     "playwright-core": "^1.49.1",
     "qrcode": "^1.5.4",
-    "react": "^19.2.4"
+    "react": "^19.2.4",
+    "viem": "^2.48.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",