@blockrun/franklin 3.8.41 → 3.8.43

package/dist/agent/loop.js

@@ -497,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;
@@ -1022,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/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/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 { fetchWithFallback, buildFallbackChain, DEFAULT_FALLBACK_CONFIG, ROUTING_PROFILES, } from './fallback.js';
+import { 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,6 +41,57 @@ 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();
@@ -62,10 +113,12 @@ 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',
+    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',
@@ -87,12 +140,16 @@ 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',
@@ -111,9 +168,15 @@ const MODEL_SHORTCUTS = {
     devstral: 'nvidia/qwen3-coder-480b',
     // Minimax
     minimax: 'minimax/minimax-m2.7',
+    'm2.7': 'minimax/minimax-m2.7',
     // Others
     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',
 };
 // Model pricing now uses shared source from src/pricing.ts
 function detectModelSwitch(parsed) {
@@ -369,13 +432,21 @@ 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 fetchWithFallback(targetUrl, requestInit, body, fallbackConfig, (failedModel, status, nextModel) => {
+                    const result = await fetchWithPaymentFallback(targetUrl, requestInit, body, fallbackConfig, {
+                        method: req.method || 'POST',
+                        headers,
+                        chain,
+                        baseWallet,
+                        solanaWallet,
+                        timeoutMs: requestTimeoutMs,
+                    }, (failedModel, status, nextModel) => {
                         log(`⚠️  ${failedModel} returned ${status}, falling back to ${nextModel}`);
                     });
                     response = result.response;
@@ -388,20 +459,14 @@ export function createProxy(options) {
                     }
                 }
                 else {
-                    // 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);
-                    }
+                    response = await fetchModelAttempt(targetUrl, requestInit, body, requestModel, {
+                        method: req.method || 'POST',
+                        headers,
+                        chain,
+                        baseWallet,
+                        solanaWallet,
+                        timeoutMs: requestTimeoutMs,
+                    });
                 }
                 const responseHeaders = {};
                 response.headers.forEach((v, k) => {
@@ -452,7 +517,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 = 5 * 60 * 1000; // 5 min timeout for entire stream
+                    const STREAM_TIMEOUT_MS = getProxyStreamTimeoutMs();
                     const streamDeadline = Date.now() + STREAM_TIMEOUT_MS;
                     const pump = async () => {
                         while (true) {
@@ -563,10 +628,77 @@ 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) {
+async function handleBasePayment(response, url, method, headers, body, privateKey, fromAddress, timeoutMs = getProxyRequestTimeoutMs(), model = 'unknown') {
     const paymentHeader = await extractPaymentHeader(response);
     if (!paymentHeader) {
         throw new Error('402 Payment Required — wallet may need funding. Run: franklin balance');
@@ -579,19 +711,19 @@ async function handleBasePayment(response, url, method, headers, body, privateKe
         maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
         extra: details.extra,
     });
-    return fetch(url, {
+    return fetchWithTimeout(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) {
+async function handleSolanaPayment(response, url, method, headers, body, privateKey, fromAddress, timeoutMs = getProxyRequestTimeoutMs(), model = 'unknown') {
     const paymentHeader = await extractPaymentHeader(response);
     if (!paymentHeader) {
         throw new Error('402 Payment Required — wallet may need funding. Run: franklin balance');
@@ -606,14 +738,14 @@ async function handleSolanaPayment(response, url, method, headers, body, private
         maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
         extra: details.extra,
     });
-    return fetch(url, {
+    return fetchWithTimeout(url, {
         method,
         headers: {
             ...headers,
             'PAYMENT-SIGNATURE': paymentPayload,
         },
         body: body || undefined,
-    });
+    }, timeoutMs, `Paid proxy request for ${model}`);
 }
 export function classifyRequest(body) {
     try {

package/package.json

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