@blockrun/franklin 3.8.31 → 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/session/search.js

@@ -11,9 +11,9 @@ import { listSessions, getSessionFilePath } from './storage.js';
 function tokenize(text) {
     return text
         .toLowerCase()
-        .replace(/[^\w\s]/g, ' ')
-        .split(/\s+/)
-        .filter(t => t.length > 1);
+        .replace(/[^\p{L}\p{N}_\s]/gu, ' ')
+        .split(/\s+/u)
+        .filter(t => t.length > 1 || /[^\x00-\x7F]/.test(t));
 }
 function parseQuery(query) {
     const phrases = [];

package/dist/session/storage.js

@@ -158,10 +158,7 @@ export function loadSessionHistory(sessionId) {
         return [];
     }
 }
-/**
- * List all saved sessions, newest first.
- */
-export function listSessions() {
+function readSessionMetas(includeGhosts = false) {
     const sessionsDir = getSessionsDir();
     try {
         const files = fs.readdirSync(sessionsDir)
@@ -174,14 +171,19 @@ export function listSessions() {
             }
             catch { /* skip corrupted */ }
         }
-        // Filter out ghost sessions (0 messages)
-        const filtered = metas.filter(m => m.messageCount > 0);
-        return filtered.sort((a, b) => b.updatedAt - a.updatedAt);
+        const visible = includeGhosts ? metas : metas.filter(m => m.messageCount > 0);
+        return visible.sort((a, b) => b.updatedAt - a.updatedAt);
     }
     catch {
         return [];
     }
 }
+/**
+ * List all saved sessions, newest first.
+ */
+export function listSessions() {
+    return readSessionMetas(false);
+}
 /**
  * Find the latest saved session tagged with a given channel (e.g.
  * `telegram:12345`). Used by non-CLI drivers to resume across process
@@ -198,25 +200,26 @@ export function findLatestSessionByChannel(channel) {
  * Accepts optional activeSessionId to protect from deletion.
  */
 export function pruneOldSessions(activeSessionId) {
-    const sessions = listSessions();
-    if (sessions.length <= MAX_SESSIONS)
-        return;
-    const toDelete = sessions
-        .slice(MAX_SESSIONS)
-        .filter(s => s.id !== activeSessionId); // Never delete active session
-    for (const s of toDelete) {
-        try {
-            fs.unlinkSync(sessionPath(s.id));
-        }
-        catch { /* ok */ }
-        try {
-            fs.unlinkSync(metaPath(s.id));
+    const sessions = readSessionMetas(false);
+    const allSessions = readSessionMetas(true);
+    if (sessions.length > MAX_SESSIONS) {
+        const toDelete = sessions
+            .slice(MAX_SESSIONS)
+            .filter(s => s.id !== activeSessionId); // Never delete active session
+        for (const s of toDelete) {
+            try {
+                fs.unlinkSync(sessionPath(s.id));
+            }
+            catch { /* ok */ }
+            try {
+                fs.unlinkSync(metaPath(s.id));
+            }
+            catch { /* ok */ }
         }
-        catch { /* ok */ }
     }
     // Also clean up ghost sessions (0 messages, older than 5 minutes)
     const fiveMinAgo = Date.now() - 5 * 60 * 1000;
-    for (const s of sessions) {
+    for (const s of allSessions) {
         if (s.id === activeSessionId)
             continue;
         if (s.messageCount === 0 && s.createdAt < fiveMinAgo) {

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]) {
@@ -614,7 +616,16 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                         break;
                     }
                     case 'usage': {
-                        setCurrentModel(event.model);
+                        // DO NOT setCurrentModel(event.model) here. currentModel
+                        // represents the user's selection (e.g. 'blockrun/auto'),
+                        // not what the router resolved for this specific turn. The
+                        // per-turn resolved model is already captured in
+                        // turnModelRef (rendered in the turn-summary line below
+                        // each response) and in onModelChange('system') when the
+                        // loop itself decides to swap (empty-response / 402 fallback).
+                        // Overriding currentModel from every usage event made the
+                        // status bar permanently show the last resolved model and
+                        // create a false impression that auto mode was stuck.
                         setTurnTokens(prev => ({
                             input: prev.input + event.inputTokens,
                             output: prev.output + event.outputTokens,

package/dist/ui/session-picker.d.ts

@@ -3,6 +3,15 @@
  * Lists recent sessions (newest first) and returns the selected ID.
  */
 import { type SessionMeta } from '../session/storage.js';
+type SessionPickerSelection = {
+    kind: 'cancel';
+} | {
+    kind: 'selected';
+    id: string;
+} | {
+    kind: 'invalid';
+    message: string;
+};
 /**
  * Resolve a user-provided session identifier to a full session ID.
  * Supports exact match and unambiguous prefix match (minimum 8 chars).
@@ -16,6 +25,7 @@ export declare function resolveSessionIdInput(input: string): {
     error: 'not-found' | 'ambiguous';
     candidates: SessionMeta[];
 };
+export declare function resolvePickerSelection(input: string, shown: SessionMeta[], sessions: SessionMeta[]): SessionPickerSelection;
 /**
  * Find the most recent session for a given working directory.
  * Returns null if none exists.
@@ -28,3 +38,4 @@ export declare function findLatestSessionForDir(workDir: string): SessionMeta |
 export declare function pickSession(opts?: {
     workDir?: string;
 }): Promise<string | null>;
+export {};

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)
@@ -61,6 +63,33 @@ export function resolveSessionIdInput(input) {
     }
     return { ok: false, error: 'not-found', candidates: [] };
 }
+export function resolvePickerSelection(input, shown, sessions) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return { kind: 'cancel' };
+    const num = parseInt(trimmed, 10);
+    if (!isNaN(num) && num >= 1 && num <= shown.length) {
+        return { kind: 'selected', id: shown[num - 1].id };
+    }
+    const exact = sessions.find((s) => s.id === trimmed);
+    if (exact)
+        return { kind: 'selected', id: exact.id };
+    const resolved = resolveSessionIdFromList(trimmed, sessions);
+    if (resolved.ok) {
+        return { kind: 'selected', id: resolved.id };
+    }
+    if (resolved.error === 'ambiguous') {
+        const preview = resolved.candidates
+            .slice(0, 3)
+            .map((candidate) => candidate.id)
+            .join(', ');
+        return {
+            kind: 'invalid',
+            message: `Ambiguous session prefix: ${trimmed}${preview ? ` (${preview}${resolved.candidates.length > 3 ? ', …' : ''})` : ''}`,
+        };
+    }
+    return { kind: 'invalid', message: `No session found matching: ${trimmed}` };
+}
 /**
  * Find the most recent session for a given working directory.
  * Returns null if none exists.
@@ -109,21 +138,23 @@ export async function pickSession(opts = {}) {
         terminal: process.stdin.isTTY ?? false,
     });
     return new Promise((resolve) => {
-        rl.question(chalk.bold('  session> '), (answer) => {
-            rl.close();
-            const trimmed = answer.trim();
-            if (!trimmed) {
-                resolve(null);
-                return;
-            }
-            const num = parseInt(trimmed, 10);
-            if (!isNaN(num) && num >= 1 && num <= shown.length) {
-                resolve(shown[num - 1].id);
-                return;
-            }
-            // Allow raw ID as well
-            const match = sessions.find(s => s.id === trimmed || s.id.startsWith(trimmed));
-            resolve(match ? match.id : null);
-        });
+        const prompt = () => {
+            rl.question(chalk.bold('  session> '), (answer) => {
+                const selection = resolvePickerSelection(answer, shown, sessions);
+                if (selection.kind === 'cancel') {
+                    rl.close();
+                    resolve(null);
+                    return;
+                }
+                if (selection.kind === 'selected') {
+                    rl.close();
+                    resolve(selection.id);
+                    return;
+                }
+                console.error(chalk.yellow(`  ${selection.message}`));
+                prompt();
+            });
+        };
+        prompt();
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.8.31",
+  "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": {