@blockrun/franklin 3.8.40 → 3.8.42

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;
@@ -494,13 +497,23 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         // negative number disables the cap; a non-numeric / unparseable value
         // is treated as a typo and falls back to the safe default rather than
         // silently removing the wallet guard.
+        //
+        // Default raised from $0.25 → $1.00 in v3.8.42 — the original ceiling
+        // dated from when Franklin was mostly chat. Real workloads (multi-stage
+        // dashboard scaffolds on sonnet, image-to-image edits, research-heavy
+        // turns) routinely land in the $0.20–$0.80 range on a single legit
+        // prompt. $1.00 is still meaningful as a runaway-protection guardrail
+        // (catches the kind of failure v3.8.41's retry-policy was built for)
+        // but doesn't impose a friction tax on every multi-stage task. Users
+        // who liked the old ceiling can opt back in via the config.
+        const TURN_SPEND_DEFAULT_USD = 1.0;
         const turnSpendCap = (() => {
             const raw = loadConfig()['max-turn-spend-usd'];
             if (raw == null)
-                return 0.25;
+                return TURN_SPEND_DEFAULT_USD;
             const parsed = Number(raw);
             if (!Number.isFinite(parsed))
-                return 0.25; // typo → keep default
+                return TURN_SPEND_DEFAULT_USD; // typo → keep default
             if (parsed <= 0)
                 return Infinity; // explicit opt-out
             return parsed;
@@ -897,6 +910,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);
@@ -973,7 +1032,8 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             if (turnSpend > MAX_TURN_SPEND_USD) {
                 onEvent({
                     kind: 'text_delta',
-                    text: `\n\n⚠️ Turn spend limit reached ($${turnSpend.toFixed(3)} > $${MAX_TURN_SPEND_USD}). Stopping to protect your wallet. Try again with a clearer prompt or a different model.\n`,
+                    text: `\n\n⚠️ Turn spend limit reached ($${turnSpend.toFixed(3)} > $${MAX_TURN_SPEND_USD}). Stopping to protect your wallet.\n` +
+                        `Raise the cap with \`franklin config set max-turn-spend-usd 2.0\` (or \`0\` to disable), then \`/retry\`.\n`,
                 });
                 onEvent({ kind: 'turn_done', reason: 'budget' });
                 break;

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/commands/config.d.ts

@@ -7,10 +7,12 @@ export interface AppConfig {
     'permission-mode'?: string;
     'max-turns'?: string;
     /**
-     * Hard per-turn spend ceiling in USD (default $0.25). Numeric string,
-     * e.g. "0.5" or "2". Set to "0" to disable the cap. The agent loop
-     * stops a turn the moment cumulative cost crosses this threshold,
-     * preventing a runaway model + tool combo from draining the wallet.
+     * Hard per-turn spend ceiling in USD (default $1.00 as of v3.8.42).
+     * Numeric string, e.g. "0.5" or "2". Set to "0" to disable the cap.
+     * The agent loop stops a turn the moment cumulative cost crosses this
+     * threshold, preventing a runaway model + tool combo from draining the
+     * wallet. Earlier versions used $0.25, which routinely fired on legit
+     * multi-stage tasks (dashboard scaffolds, image-to-image edits).
      */
     'max-turn-spend-usd'?: string;
     'auto-compact'?: string;

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.42",
   "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",