@blockrun/franklin 3.8.39 → 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

@@ -16,6 +16,7 @@ import { resetToolSessionState } from '../tools/index.js';
 import { CORE_TOOL_NAMES, dynamicToolsEnabled } from '../tools/tool-categories.js';
 import { createActivateToolCapability } from '../tools/activate.js';
 import { recordUsage } from '../stats/tracker.js';
+import { loadConfig } from '../commands/config.js';
 import { recordSessionUsage } from '../stats/session-tracker.js';
 import { appendAudit, extractLastUserPrompt } from '../stats/audit.js';
 import { estimateCost, OPUS_PRICING } from '../pricing.js';
@@ -28,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.
@@ -451,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;
@@ -487,7 +491,24 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         let consecutiveTinyResponses = 0; // Count of consecutive calls with <10 output tokens
         const MAX_TINY_RESPONSES = 2; // Break after N tiny responses — if 2 calls return near-empty, something is wrong
         let turnSpend = 0; // Cost spent this user turn (USD)
-        const MAX_TURN_SPEND_USD = 0.25; // Hard circuit breaker per user message (lowered — user wallets are real money)
+        // Hard circuit breaker per user message — defends user wallets against
+        // a runaway model+tool combo on a single prompt. User-overridable via
+        // `franklin config set max-turn-spend-usd <number>`. Explicit "0" or a
+        // 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.
+        const turnSpendCap = (() => {
+            const raw = loadConfig()['max-turn-spend-usd'];
+            if (raw == null)
+                return 0.25;
+            const parsed = Number(raw);
+            if (!Number.isFinite(parsed))
+                return 0.25; // typo → keep default
+            if (parsed <= 0)
+                return Infinity; // explicit opt-out
+            return parsed;
+        })();
+        const MAX_TURN_SPEND_USD = turnSpendCap;
         // ── Turn analysis (one classifier call, drives routing + prefetch) ──
         // Single LLM pass that answers every routing-adjacent question the
         // harness needs BEFORE the main model runs: tier, ticker intent,
@@ -879,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/commands/config.d.ts

@@ -6,6 +6,13 @@ export interface AppConfig {
     'smart-routing'?: string;
     '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.
+     */
+    'max-turn-spend-usd'?: string;
     'auto-compact'?: string;
     'session-save'?: string;
     'debug'?: string;

package/dist/commands/config.js

@@ -12,6 +12,7 @@ const VALID_KEYS = [
     'smart-routing',
     'permission-mode',
     'max-turns',
+    'max-turn-spend-usd',
     'auto-compact',
     'session-save',
     'debug',

package/dist/proxy/server.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, createSolanaPaymentPayload, parsePaymentRequired, extractPaymentDetails, solanaKeyToBytes, SOLANA_NETWORK, } from '@blockrun/llm';
 import { recordUsage } from '../stats/tracker.js';
 import { appendAudit } from '../stats/audit.js';
-import { buildFallbackChain, DEFAULT_FALLBACK_CONFIG, ROUTING_PROFILES, } from './fallback.js';
+import { fetchWithFallback, buildFallbackChain, DEFAULT_FALLBACK_CONFIG, ROUTING_PROFILES, } from './fallback.js';
 import { routeRequest, parseRoutingProfile, } from '../router/index.js';
 import { estimateCost } from '../pricing.js';
 import { VERSION } from '../config.js';
@@ -41,57 +41,6 @@ function log(...args) {
     catch { /* ignore */ }
 }
 const DEFAULT_MAX_TOKENS = 4096;
-const DEFAULT_PROXY_REQUEST_TIMEOUT_MS = 45_000;
-const DEFAULT_PROXY_STREAM_TIMEOUT_MS = 5 * 60 * 1000;
-function parseTimeoutEnv(name, fallback) {
-    const raw = process.env[name];
-    if (!raw)
-        return fallback;
-    const parsed = Number.parseInt(raw, 10);
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
-}
-function getProxyRequestTimeoutMs() {
-    return parseTimeoutEnv('FRANKLIN_PROXY_REQUEST_TIMEOUT_MS', DEFAULT_PROXY_REQUEST_TIMEOUT_MS);
-}
-function getProxyStreamTimeoutMs() {
-    return parseTimeoutEnv('FRANKLIN_PROXY_STREAM_TIMEOUT_MS', DEFAULT_PROXY_STREAM_TIMEOUT_MS);
-}
-function createProxyTimeoutError(label, timeoutMs) {
-    return new Error(`${label} timed out after ${timeoutMs}ms`);
-}
-async function fetchWithTimeout(url, init, timeoutMs, label) {
-    if (timeoutMs <= 0)
-        return fetch(url, init);
-    const controller = new AbortController();
-    const timeoutError = createProxyTimeoutError(label, timeoutMs);
-    const timeout = setTimeout(() => {
-        try {
-            controller.abort(timeoutError);
-        }
-        catch { /* ignore */ }
-    }, timeoutMs);
-    try {
-        return await fetch(url, { ...init, signal: controller.signal });
-    }
-    catch (err) {
-        if (controller.signal.aborted)
-            throw timeoutError;
-        throw err;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-function replaceModelInBody(body, model) {
-    try {
-        const parsed = JSON.parse(body);
-        parsed.model = model;
-        return JSON.stringify(parsed);
-    }
-    catch {
-        return body;
-    }
-}
 // Per-model last output tokens for adaptive max_tokens (avoids cross-request pollution)
 const MAX_TRACKED_MODELS = 50;
 const lastOutputByModel = new Map();
@@ -420,21 +369,13 @@ export function createProxy(options) {
                 };
                 let response;
                 let finalModel = requestModel;
-                const requestTimeoutMs = getProxyRequestTimeoutMs();
                 // Use fallback chain if enabled
                 if (fallbackEnabled && body && requestPath.includes('messages')) {
                     const fallbackConfig = {
                         ...DEFAULT_FALLBACK_CONFIG,
                         chain: buildFallbackChain(requestModel),
                     };
-                    const result = await fetchWithPaymentFallback(targetUrl, requestInit, body, fallbackConfig, {
-                        method: req.method || 'POST',
-                        headers,
-                        chain,
-                        baseWallet,
-                        solanaWallet,
-                        timeoutMs: requestTimeoutMs,
-                    }, (failedModel, status, nextModel) => {
+                    const result = await fetchWithFallback(targetUrl, requestInit, body, fallbackConfig, (failedModel, status, nextModel) => {
                         log(`⚠️  ${failedModel} returned ${status}, falling back to ${nextModel}`);
                     });
                     response = result.response;
@@ -447,14 +388,20 @@ export function createProxy(options) {
                     }
                 }
                 else {
-                    response = await fetchModelAttempt(targetUrl, requestInit, body, requestModel, {
-                        method: req.method || 'POST',
-                        headers,
-                        chain,
-                        baseWallet,
-                        solanaWallet,
-                        timeoutMs: requestTimeoutMs,
-                    });
+                    // Direct fetch without fallback (with timeout)
+                    const directCtrl = new AbortController();
+                    const directTimeout = setTimeout(() => directCtrl.abort(), 120_000); // 2min
+                    response = await fetch(targetUrl, { ...requestInit, signal: directCtrl.signal });
+                    clearTimeout(directTimeout);
+                }
+                // Handle 402 payment — body now has the correct model after fallback
+                if (response.status === 402) {
+                    if (chain === 'solana' && solanaWallet) {
+                        response = await handleSolanaPayment(response, targetUrl, req.method || 'POST', headers, body, solanaWallet.privateKey, solanaWallet.address);
+                    }
+                    else if (baseWallet) {
+                        response = await handleBasePayment(response, targetUrl, req.method || 'POST', headers, body, baseWallet.privateKey, baseWallet.address);
+                    }
                 }
                 const responseHeaders = {};
                 response.headers.forEach((v, k) => {
@@ -505,7 +452,7 @@ export function createProxy(options) {
                     const decoder = new TextDecoder();
                     let fullResponse = '';
                     const STREAM_CAP = 5_000_000; // 5MB cap on accumulated stream
-                    const STREAM_TIMEOUT_MS = getProxyStreamTimeoutMs();
+                    const STREAM_TIMEOUT_MS = 5 * 60 * 1000; // 5 min timeout for entire stream
                     const streamDeadline = Date.now() + STREAM_TIMEOUT_MS;
                     const pump = async () => {
                         while (true) {
@@ -616,77 +563,10 @@ export function createProxy(options) {
     });
     return server;
 }
-async function fetchModelAttempt(url, init, body, model, payment) {
-    let response = await fetchWithTimeout(url, { ...init, body: body || undefined }, payment.timeoutMs, `Proxy request for ${model}`);
-    if (response.status !== 402)
-        return response;
-    if (payment.chain === 'solana' && payment.solanaWallet) {
-        return handleSolanaPayment(response, url, payment.method, payment.headers, body, payment.solanaWallet.privateKey, payment.solanaWallet.address, payment.timeoutMs, model);
-    }
-    if (payment.baseWallet) {
-        return handleBasePayment(response, url, payment.method, payment.headers, body, payment.baseWallet.privateKey, payment.baseWallet.address, payment.timeoutMs, model);
-    }
-    return response;
-}
-/**
- * Try each fallback model as a full x402 attempt:
- * unpaid 402 probe, payment signing, then the paid provider call. The older
- * flow only applied fallback to the probe, which meant a slow paid call could
- * hang Franklin until the outer client gave up.
- */
-async function fetchWithPaymentFallback(url, init, originalBody, config, payment, onFallback) {
-    const failedModels = [];
-    let attempts = 0;
-    for (let i = 0; i < config.chain.length && attempts < config.maxRetries; i++) {
-        const model = config.chain[i];
-        const body = replaceModelInBody(originalBody, model);
-        try {
-            attempts++;
-            const response = await fetchModelAttempt(url, init, body, model, payment);
-            if (!config.retryOn.includes(response.status)) {
-                return {
-                    response,
-                    modelUsed: model,
-                    bodyUsed: body,
-                    fallbackUsed: i > 0,
-                    attemptsCount: attempts,
-                    failedModels,
-                };
-            }
-            try {
-                await response.body?.cancel();
-            }
-            catch { /* ignore */ }
-            failedModels.push(model);
-            const nextModel = config.chain[i + 1];
-            if (nextModel && onFallback) {
-                onFallback(model, response.status, nextModel);
-            }
-            if (i < config.chain.length - 1) {
-                await sleep(config.retryDelayMs);
-            }
-        }
-        catch (err) {
-            failedModels.push(model);
-            const nextModel = config.chain[i + 1];
-            if (nextModel && onFallback) {
-                onFallback(model, 0, nextModel);
-            }
-            log(`[fallback] ${model} request error: ${err instanceof Error ? err.message : String(err)}`);
-            if (i < config.chain.length - 1) {
-                await sleep(config.retryDelayMs);
-            }
-        }
-    }
-    throw new Error(`All models in fallback chain failed: ${failedModels.join(', ')}`);
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 // ======================================================================
 // Base (EIP-712) payment handler
 // ======================================================================
-async function handleBasePayment(response, url, method, headers, body, privateKey, fromAddress, timeoutMs = getProxyRequestTimeoutMs(), model = 'unknown') {
+async function handleBasePayment(response, url, method, headers, body, privateKey, fromAddress) {
     const paymentHeader = await extractPaymentHeader(response);
     if (!paymentHeader) {
         throw new Error('402 Payment Required — wallet may need funding. Run: franklin balance');
@@ -699,19 +579,19 @@ async function handleBasePayment(response, url, method, headers, body, privateKe
         maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
         extra: details.extra,
     });
-    return fetchWithTimeout(url, {
+    return fetch(url, {
         method,
         headers: {
             ...headers,
             'PAYMENT-SIGNATURE': paymentPayload,
         },
         body: body || undefined,
-    }, timeoutMs, `Paid proxy request for ${model}`);
+    });
 }
 // ======================================================================
 // Solana payment handler
 // ======================================================================
-async function handleSolanaPayment(response, url, method, headers, body, privateKey, fromAddress, timeoutMs = getProxyRequestTimeoutMs(), model = 'unknown') {
+async function handleSolanaPayment(response, url, method, headers, body, privateKey, fromAddress) {
     const paymentHeader = await extractPaymentHeader(response);
     if (!paymentHeader) {
         throw new Error('402 Payment Required — wallet may need funding. Run: franklin balance');
@@ -726,14 +606,14 @@ async function handleSolanaPayment(response, url, method, headers, body, private
         maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
         extra: details.extra,
     });
-    return fetchWithTimeout(url, {
+    return fetch(url, {
         method,
         headers: {
             ...headers,
             'PAYMENT-SIGNATURE': paymentPayload,
         },
         body: body || undefined,
-    }, timeoutMs, `Paid proxy request for ${model}`);
+    });
 }
 export function classifyRequest(body) {
     try {

package/dist/tools/imagegen.js

@@ -215,7 +215,14 @@ function buildExecute(deps) {
             'User-Agent': `franklin/${VERSION}`,
         };
         const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 60_000); // 60s timeout
+        // Reference-image mode (gpt-image-2 edits) is meaningfully slower than
+        // pure text-to-image: the model is reasoning-driven and the request
+        // body carries a few MB of base64. The shared 60s budget has to cover
+        // both x402 retry attempts plus the actual generation, which made
+        // image-to-image effectively always time out. Image-to-image gets 3
+        // minutes; text-to-image keeps the original 60s.
+        const timeoutMs = referenceImage ? 180_000 : 60_000;
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
         try {
             // First request — will get 402
             let response = await fetch(endpoint, {
@@ -330,7 +337,12 @@ function buildExecute(deps) {
         catch (err) {
             const msg = err.message || '';
             if (msg.includes('abort')) {
-                return { output: 'Image generation timed out (60s limit). Try a simpler prompt.', isError: true };
+                return {
+                    output: referenceImage
+                        ? 'Image-to-image timed out (180s limit). The reference image may be too large or the model under load — try a smaller image or simpler prompt.'
+                        : 'Image generation timed out (60s limit). Try a simpler prompt.',
+                    isError: true,
+                };
             }
             return { output: `Error: ${msg}`, isError: true };
         }

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.39",
+  "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",