@blockrun/franklin 3.8.32 → 3.8.33

package/dist/agent/error-classifier.js

@@ -68,7 +68,7 @@ export function classifyAgentError(message) {
         'deadline exceeded',
     ])) {
         return {
-            category: 'timeout', label: 'Timeout', isTransient: true,
+            category: 'timeout', label: 'Timeout', isTransient: true, maxRetries: 1,
             suggestion: 'Check your network connection. Use /retry to try again.',
         };
     }

package/dist/agent/llm.js

@@ -5,7 +5,50 @@
  */
 import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, createSolanaPaymentPayload, parsePaymentRequired, extractPaymentDetails, solanaKeyToBytes, SOLANA_NETWORK, } from '@blockrun/llm';
 import { USER_AGENT } from '../config.js';
+import { routeRequest, parseRoutingProfile } from '../router/index.js';
 import { ThinkTagStripper } from './think-tag-stripper.js';
+function getModelIdleTimeoutMs() {
+    const raw = process.env.FRANKLIN_MODEL_IDLE_TIMEOUT_MS;
+    const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 25_000;
+}
+function linkAbortSignal(parent, child) {
+    if (!parent)
+        return () => { };
+    if (parent.aborted) {
+        child.abort(parent.reason);
+        return () => { };
+    }
+    const forward = () => child.abort(parent.reason);
+    parent.addEventListener('abort', forward, { once: true });
+    return () => parent.removeEventListener('abort', forward);
+}
+function createModelTimeoutError(stage, model, timeoutMs) {
+    return new Error(`Model ${stage} timed out after ${timeoutMs}ms on ${model}`);
+}
+async function withAbortableTimeout(work, controller, timeoutError, timeoutMs) {
+    if (timeoutMs <= 0)
+        return work();
+    let timer;
+    try {
+        return await Promise.race([
+            work(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    try {
+                        controller.abort(timeoutError);
+                    }
+                    catch { /* ignore */ }
+                    reject(timeoutError);
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 /**
  * Extract the most human-readable message from an error body.
  * Some gateways wrap provider errors multiple times, e.g.
@@ -188,9 +231,7 @@ export class ModelClient {
     resolveVirtualModel(model) {
         if (!model.startsWith('blockrun/'))
             return model;
-        // Import router dynamically to avoid circular deps
         try {
-            const { routeRequest, parseRoutingProfile } = require('../router/index.js');
             const profile = parseRoutingProfile(model);
             if (profile) {
                 const result = routeRequest('', profile);
@@ -288,39 +329,47 @@ export class ModelClient {
         if (this.debug) {
             console.error(`[franklin] POST ${endpoint} model=${request.model}`);
         }
-        let response = await fetch(endpoint, {
-            method: 'POST',
-            headers,
-            body,
-            signal,
-        });
-        // Handle x402 payment
-        if (response.status === 402) {
-            if (this.debug)
-                console.error('[franklin] Payment required — signing...');
-            const paymentHeader = await this.signPayment(response);
-            if (!paymentHeader) {
-                yield { kind: 'error', payload: { message: 'Payment signing failed' } };
-                return;
-            }
-            response = await fetch(endpoint, {
+        const timeoutMs = getModelIdleTimeoutMs();
+        const requestController = new AbortController();
+        const unlinkAbort = linkAbortSignal(signal, requestController);
+        try {
+            let response = await withAbortableTimeout(() => fetch(endpoint, {
                 method: 'POST',
-                headers: { ...headers, ...paymentHeader },
+                headers,
                 body,
-                signal,
-            });
+                signal: requestController.signal,
+            }), requestController, createModelTimeoutError('request', request.model, timeoutMs), timeoutMs);
+            // Handle x402 payment
+            if (response.status === 402) {
+                if (this.debug)
+                    console.error('[franklin] Payment required — signing...');
+                const paymentHeader = await this.signPayment(response);
+                if (!paymentHeader) {
+                    yield { kind: 'error', payload: { message: 'Payment signing failed' } };
+                    return;
+                }
+                response = await withAbortableTimeout(() => fetch(endpoint, {
+                    method: 'POST',
+                    headers: { ...headers, ...paymentHeader },
+                    body,
+                    signal: requestController.signal,
+                }), requestController, createModelTimeoutError('request', request.model, timeoutMs), timeoutMs);
+            }
+            if (!response.ok) {
+                const errorBody = await response.text().catch(() => 'unknown error');
+                const message = extractApiErrorMessage(errorBody);
+                yield {
+                    kind: 'error',
+                    payload: { status: response.status, message },
+                };
+                return;
+            }
+            // Parse SSE stream
+            yield* this.parseSSEStream(response, requestController, timeoutMs, request.model);
         }
-        if (!response.ok) {
-            const errorBody = await response.text().catch(() => 'unknown error');
-            const message = extractApiErrorMessage(errorBody);
-            yield {
-                kind: 'error',
-                payload: { status: response.status, message },
-            };
-            return;
+        finally {
+            unlinkAbort();
         }
-        // Parse SSE stream
-        yield* this.parseSSEStream(response, signal);
     }
     /**
      * Non-streaming completion for simple requests.
@@ -617,7 +666,7 @@ export class ModelClient {
         return header;
     }
     // ─── SSE Parsing ───────────────────────────────────────────────────────
-    async *parseSSEStream(response, signal) {
+    async *parseSSEStream(response, controller, timeoutMs, model) {
         const reader = response.body?.getReader();
         if (!reader) {
             yield { kind: 'error', payload: { message: 'No response body' } };
@@ -630,9 +679,9 @@ export class ModelClient {
         const MAX_BUFFER = 1_000_000; // 1MB buffer cap
         try {
             while (true) {
-                if (signal?.aborted)
+                if (controller.signal.aborted)
                     break;
-                const { done, value } = await reader.read();
+                const { done, value } = await withAbortableTimeout(() => reader.read(), controller, createModelTimeoutError('stream', model, timeoutMs), timeoutMs);
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });

package/dist/commands/daemon.js

@@ -34,7 +34,6 @@ function isRunning(pid) {
     }
     catch { /* fall through to ps */ }
     try {
-        const { execSync } = require('node:child_process');
         const cmd = execSync(`ps -p ${pid} -o command=`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
         return /franklin|runcode|node.*dist\/index/.test(cmd);
     }

package/dist/telemetry/store.d.ts

@@ -20,7 +20,7 @@
  * files — telemetry is just a stable, aggregation-friendly view of
  * information the user already has.
  */
-import type { SessionMeta } from '../session/storage.js';
+import { type SessionMeta } from '../session/storage.js';
 interface ConsentRecord {
     enabled: boolean;
     enabledAt?: number;

package/dist/telemetry/store.js

@@ -24,6 +24,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { BLOCKRUN_DIR, VERSION } from '../config.js';
+import { listSessions } from '../session/storage.js';
 const CONSENT_FILE = path.join(BLOCKRUN_DIR, 'telemetry-consent.json');
 const LOG_FILE = path.join(BLOCKRUN_DIR, 'telemetry.jsonl');
 const INSTALL_ID_FILE = path.join(BLOCKRUN_DIR, 'telemetry-install-id.txt');
@@ -120,11 +121,6 @@ export function recordSession(meta, chain) {
 export function recordLatestSessionIfEnabled(workingDir, chain) {
     if (!isTelemetryEnabled())
         return;
-    // Lazy import to avoid a circular session/storage <-> telemetry dependency.
-    // Using require() here keeps this module synchronous for tests.
-    /* eslint-disable @typescript-eslint/no-require-imports */
-    const { listSessions } = require('../session/storage.js');
-    /* eslint-enable @typescript-eslint/no-require-imports */
     const sessions = listSessions();
     const match = sessions.find(s => s.workDir === workingDir);
     if (!match)

package/dist/ui/app.js

@@ -333,6 +333,18 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
         const trimmed = value.trim();
         if (!trimmed)
             return;
+        // Exit commands bypass the busy-queue gate — if the user wants out,
+        // they want out immediately, not after whatever turn is in flight.
+        // Covers bare 'exit' / 'quit' / 'q' and slash-prefixed /exit / /quit.
+        const lower = trimmed.toLowerCase();
+        const isExit = lower === 'exit' || lower === 'quit' || lower === 'q' ||
+            lower === '/exit' || lower === '/quit';
+        if (isExit) {
+            onAbort();
+            onExit();
+            exit();
+            return;
+        }
         // If agent is busy, queue the message — it will be auto-submitted when the turn finishes
         if (!ready) {
             setQueuedInputs(prev => [...prev, trimmed]);
@@ -340,13 +352,6 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
             showStatus(`Queued message (${queuedInputsRef.current.length + 1} pending)`, 'warning', 1500);
             return;
         }
-        // Bare exit/quit (no slash needed)
-        const lower = trimmed.toLowerCase();
-        if (lower === 'exit' || lower === 'quit' || lower === 'q') {
-            onExit();
-            exit();
-            return;
-        }
         // ── Slash commands ──
         if (trimmed.startsWith('/')) {
             setInput('');
@@ -355,11 +360,8 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
             const parts = trimmed.split(/\s+/);
             const cmd = parts[0].toLowerCase();
             switch (cmd) {
-                case '/exit':
-                case '/quit':
-                    onExit();
-                    exit();
-                    return;
+                // /exit and /quit are handled earlier (before the busy-queue gate)
+                // so they exit the session immediately even mid-turn.
                 case '/model':
                 case '/models':
                     if (parts[1]) {

package/dist/ui/session-picker.js

@@ -46,7 +46,9 @@ function modelShort(model) {
  * Returns { ok, id } on success, or { ok, error, candidates } on failure.
  */
 export function resolveSessionIdInput(input) {
-    const sessions = listSessions();
+    return resolveSessionIdFromList(input, listSessions());
+}
+function resolveSessionIdFromList(input, sessions) {
     // Exact match first
     const exact = sessions.find((s) => s.id === input);
     if (exact)
@@ -72,7 +74,7 @@ export function resolvePickerSelection(input, shown, sessions) {
     const exact = sessions.find((s) => s.id === trimmed);
     if (exact)
         return { kind: 'selected', id: exact.id };
-    const resolved = resolveSessionIdInput(trimmed);
+    const resolved = resolveSessionIdFromList(trimmed, sessions);
     if (resolved.ok) {
         return { kind: 'selected', id: resolved.id };
     }

package/package.json

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