@blockrun/franklin 3.22.0 → 3.23.1

package/dist/agent/repair/scavenge.js

@@ -0,0 +1,193 @@
+/**
+ * Scavenge tool calls that the model emitted as text instead of via the
+ * structured tool_use channel. Ported from reasonix (MIT) and adapted to
+ * Franklin's Anthropic-shape `CapabilityInvocation` (parsed `input` object
+ * + synthetic id).
+ *
+ * Triggers we've actually seen:
+ *  - DeepSeek R1 leaks tool-call JSON into `reasoning_content` and forgets
+ *    to populate `tool_calls`. The text channel ends up with raw JSON like
+ *    `{"name":"Read","arguments":{...}}`.
+ *  - DeepSeek V3.1 sometimes emits its chat-template DSML markup
+ *    (`<｜DSML｜invoke …>`) in the content channel.
+ *  - Smaller OpenAI-compatible models (some Qwen / Llama variants behind
+ *    the BlockRun gateway) leak the OpenAI tool-call shape inline.
+ *
+ * All three are recoverable. This module turns the leaked text back into
+ * a `CapabilityInvocation` so the agent loop doesn't waste a turn telling
+ * the model "you forgot to call a tool".
+ */
+import { randomBytes } from 'node:crypto';
+/** Bounds regex input — DSML matchers are O(n²) on adversarial input. */
+const MAX_SCAVENGE_INPUT = 100 * 1024;
+export function scavengeToolCalls(text, opts) {
+    if (!text)
+        return { calls: [], notes: [] };
+    if (text.length > MAX_SCAVENGE_INPUT) {
+        return {
+            calls: [],
+            notes: [`scavenge skipped: input too large (${text.length} chars)`],
+        };
+    }
+    const max = opts.maxCalls ?? 4;
+    const notes = [];
+    const out = [];
+    // Pattern A — DSML invoke blocks (DeepSeek chat-template markup leaked
+    // into the content channel).
+    for (const invoke of iterateDsmlInvokes(text)) {
+        if (out.length >= max)
+            break;
+        if (!opts.allowedNames.has(invoke.name))
+            continue;
+        out.push(makeInvocation(invoke.name, invoke.args));
+        notes.push(`scavenged DSML call: ${invoke.name}`);
+    }
+    // Pattern B — raw JSON objects in the three canonical shapes. Strip
+    // DSML blocks first so their parameter payloads don't get re-scavenged
+    // as standalone JSON calls.
+    const nonDsml = stripDsmlBlocks(text);
+    for (const candidate of iterateJsonObjects(nonDsml)) {
+        if (out.length >= max)
+            break;
+        const call = coerceToInvocation(candidate, opts.allowedNames);
+        if (call) {
+            out.push(call);
+            notes.push(`scavenged call: ${call.name}`);
+        }
+    }
+    return { calls: out, notes };
+}
+function stripDsmlBlocks(text) {
+    let out = text;
+    out = out.replace(/<[｜|]DSML[｜|]function_calls>[\s\S]*?<\/?[｜|]DSML[｜|]function_calls>/g, '');
+    out = out.replace(/<[｜|]DSML[｜|]invoke\s+[^>]*>[\s\S]*?<\/[｜|]DSML[｜|]invoke>/g, '');
+    return out;
+}
+function* iterateDsmlInvokes(text) {
+    // `｜` (U+FF5C) in practice; `|` (ASCII) as a fallback variant.
+    const INVOKE_RE = /<[｜|]DSML[｜|]invoke\s+name="([^"]+)">([\s\S]*?)<\/[｜|]DSML[｜|]invoke>/g;
+    for (const match of text.matchAll(INVOKE_RE)) {
+        const name = match[1];
+        const body = match[2];
+        if (!name || body === undefined)
+            continue;
+        yield { name, args: parseDsmlParameters(body) };
+    }
+}
+function parseDsmlParameters(body) {
+    const PARAM_RE = /<[｜|]DSML[｜|]parameter\s+name="([^"]+)"(?:\s+string="(true|false)")?\s*>([\s\S]*?)<\/[｜|]DSML[｜|]parameter>/g;
+    const args = {};
+    for (const m of body.matchAll(PARAM_RE)) {
+        const key = m[1];
+        const stringFlag = m[2];
+        const raw = (m[3] ?? '').trim();
+        if (!key)
+            continue;
+        if (stringFlag === 'false') {
+            try {
+                args[key] = JSON.parse(raw);
+                continue;
+            }
+            catch {
+                // Fall through — preserve literal so info isn't lost.
+            }
+        }
+        args[key] = raw;
+    }
+    return args;
+}
+function* iterateJsonObjects(text) {
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] !== '{')
+            continue;
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let j = i; j < text.length; j++) {
+            const c = text[j];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (inString) {
+                if (c === '\\') {
+                    escaped = true;
+                    continue;
+                }
+                if (c === '"')
+                    inString = false;
+                continue;
+            }
+            if (c === '"')
+                inString = true;
+            else if (c === '{')
+                depth++;
+            else if (c === '}') {
+                depth--;
+                if (depth === 0) {
+                    yield text.slice(i, j + 1);
+                    i = j;
+                    break;
+                }
+            }
+        }
+    }
+}
+function coerceToInvocation(candidateJson, allowedNames) {
+    let parsed;
+    try {
+        parsed = JSON.parse(candidateJson);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const obj = parsed;
+    // Pattern 1 — { name, arguments } (Anthropic-ish flat form).
+    if (typeof obj.name === 'string' && allowedNames.has(obj.name)) {
+        return makeInvocation(obj.name, normalizeArgs(obj.arguments));
+    }
+    // Pattern 2 — OpenAI-style { type: "function", function: { name, arguments } }.
+    if (obj.type === 'function' &&
+        obj.function &&
+        typeof obj.function === 'object') {
+        const fn = obj.function;
+        if (typeof fn.name === 'string' && allowedNames.has(fn.name)) {
+            return makeInvocation(fn.name, normalizeArgs(fn.arguments));
+        }
+    }
+    // Pattern 3 — { tool_name, tool_args } (R1 free-form variant).
+    if (typeof obj.tool_name === 'string' && allowedNames.has(obj.tool_name)) {
+        return makeInvocation(obj.tool_name, normalizeArgs(obj.tool_args));
+    }
+    return null;
+}
+function normalizeArgs(raw) {
+    if (raw == null)
+        return {};
+    if (typeof raw === 'string') {
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+            return {};
+        }
+        catch {
+            return {};
+        }
+    }
+    if (typeof raw === 'object' && !Array.isArray(raw)) {
+        return raw;
+    }
+    return {};
+}
+function makeInvocation(name, input) {
+    return {
+        type: 'tool_use',
+        id: `toolu_repair_${randomBytes(6).toString('hex')}`,
+        name,
+        input,
+    };
+}

package/dist/agent/repair/truncation.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Truncated-JSON repair — ported from reasonix (MIT). Format-agnostic:
+ * works on any raw JSON argument string. Common trigger: model hits
+ * max_tokens mid-structure; the last useful argument is half-emitted.
+ *
+ * Local-only — never makes a continuation call. The agent loop owns
+ * budgets; this just patches what we have so the dispatcher can either
+ * parse it or report a clean fallback.
+ */
+export interface TruncationRepairResult {
+    repaired: string;
+    changed: boolean;
+    notes: string[];
+    /** True when all repair attempts failed and the result fell back to "{}". */
+    fallback: boolean;
+}
+export declare function repairTruncatedJson(input: string): TruncationRepairResult;

package/dist/agent/repair/truncation.js

@@ -0,0 +1,94 @@
+/**
+ * Truncated-JSON repair — ported from reasonix (MIT). Format-agnostic:
+ * works on any raw JSON argument string. Common trigger: model hits
+ * max_tokens mid-structure; the last useful argument is half-emitted.
+ *
+ * Local-only — never makes a continuation call. The agent loop owns
+ * budgets; this just patches what we have so the dispatcher can either
+ * parse it or report a clean fallback.
+ */
+export function repairTruncatedJson(input) {
+    const notes = [];
+    if (!input || !input.trim()) {
+        return {
+            repaired: '{}',
+            changed: input !== '{}',
+            notes: ['empty input → {}'],
+            fallback: false,
+        };
+    }
+    // Fast path: already valid JSON.
+    try {
+        JSON.parse(input);
+        return { repaired: input, changed: false, notes: [], fallback: false };
+    }
+    catch {
+        /* fall through to repair */
+    }
+    const stack = [];
+    let escaped = false;
+    let inString = false;
+    let lastSignificant = -1;
+    for (let i = 0; i < input.length; i++) {
+        const c = input[i];
+        if (!/\s/.test(c))
+            lastSignificant = i;
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (inString) {
+            if (c === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (c === '"') {
+                inString = false;
+                stack.pop();
+            }
+            continue;
+        }
+        if (c === '"') {
+            inString = true;
+            stack.push('"');
+            continue;
+        }
+        if (c === '{' || c === '[')
+            stack.push(c);
+        else if (c === '}' || c === ']')
+            stack.pop();
+    }
+    let s = input.slice(0, lastSignificant + 1);
+    if (/,$/.test(s)) {
+        s = s.replace(/,$/, '');
+        notes.push('trimmed trailing comma');
+    }
+    if (/"\s*:\s*$/.test(s)) {
+        s += ' null';
+        notes.push('filled dangling key with null');
+    }
+    if (inString) {
+        s += '"';
+        stack.pop();
+        notes.push('closed unterminated string');
+    }
+    while (stack.length > 0) {
+        const top = stack.pop();
+        if (top === '{')
+            s += '}';
+        else if (top === '[')
+            s += ']';
+        else if (top === '"')
+            s += '"';
+    }
+    try {
+        JSON.parse(s);
+        return { repaired: s, changed: s !== input, notes, fallback: false };
+    }
+    catch (err) {
+        const preview = input.length <= 500 ? input : `${input.slice(0, 500)} …[+${input.length - 500} chars]`;
+        notes.push(`fallback to {}: ${err.message}`);
+        notes.push(`unrecoverable truncation — original args preview: ${preview}`);
+        return { repaired: '{}', changed: true, notes, fallback: true };
+    }
+}

package/dist/agent/tokens.js

@@ -191,10 +191,11 @@ export function estimateHistoryTokens(history) {
  */
 const MODEL_CONTEXT_WINDOWS = {
     // Anthropic. The BlockRun gateway model entry advertises 1M context for
-    // Opus 4.7, but the 1M beta header may not be enabled at the gateway
+    // Opus 4.8 / 4.7, but the 1M beta header may not be enabled at the gateway
     // edge yet — sending more than 200k without it 413s. Keep 200k as the
     // safe Franklin baseline; bump to 1_000_000 in a separate commit once
     // a real >200k call has been verified end-to-end.
+    'anthropic/claude-opus-4.8': 200_000,
     'anthropic/claude-opus-4.7': 200_000,
     'anthropic/claude-opus-4.6': 200_000,
     'anthropic/claude-sonnet-4.6': 200_000,

package/dist/commands/init.js

@@ -29,7 +29,7 @@ export async function initCommand(options) {
         ANTHROPIC_AUTH_TOKEN: 'x402-proxy-handles-auth',
         ANTHROPIC_MODEL: 'blockrun/auto',
         ANTHROPIC_DEFAULT_SONNET_MODEL: 'anthropic/claude-sonnet-4.6',
-        ANTHROPIC_DEFAULT_OPUS_MODEL: 'anthropic/claude-opus-4.7',
+        ANTHROPIC_DEFAULT_OPUS_MODEL: 'anthropic/claude-opus-4.8',
         ANTHROPIC_DEFAULT_HAIKU_MODEL: 'anthropic/claude-haiku-4.5-20251001',
     };
     fs.mkdirSync(path.dirname(CLAUDE_SETTINGS_FILE), { recursive: true });

package/dist/commands/start.js

@@ -516,7 +516,15 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
     if (process.env.FRANKLIN_EXTRACT_ON_EXIT === '1') {
         runExitBackgroundTasks(sessionHistory, agentConfig).catch(() => { });
     }
-    disconnectMcpServers().catch(() => { });
+    // Await MCP shutdown with a bounded timeout — previously fire-and-forget,
+    // which left stdio child processes alive and (combined with no explicit
+    // process.exit() below) was the root cause of the "I quit but the
+    // process is still running" report (audited 2026-05-28). A misbehaving
+    // MCP server must not be able to pin shutdown, so cap the wait at 2s.
+    await Promise.race([
+        disconnectMcpServers().catch(() => { }),
+        new Promise((r) => setTimeout(r, 2000)),
+    ]);
     // Session summary — delta vs. snapshot at session start
     try {
         const delta = statsDelta(startSnapshot);
@@ -547,6 +555,14 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
         console.log(chalk.dim('  Latest:  franklin --continue'));
     }
     console.log(chalk.dim('\nGoodbye.\n'));
+    // Explicit exit. Without this, lingering keep-alive sockets (bootstrap
+    // learnings importer, panel HTTP server, gateway client agents) and any
+    // FRANKLIN_EXTRACT_ON_EXIT background promise can hold the event loop
+    // open for seconds-to-minutes after the UI tears down — the user sees
+    // "Goodbye." but `ps` still shows the process, and a subsequent
+    // `franklin` invocation races with the zombie. Force a clean exit. Any
+    // explicit error paths above set process.exitCode = 1 — preserve it.
+    process.exit(process.exitCode ?? 0);
 }
 async function runExitBackgroundTasks(sessionHistory, agentConfig) {
     if (!sessionHistory || sessionHistory.length < 4)
@@ -631,6 +647,13 @@ async function runWithBasicUI(agentConfig, model, workDir, initialInput) {
     catch { /* stats unavailable */ }
     ui.printGoodbye();
     flushStats();
+    // Same explicit-exit reasoning as runWithInkUI — bounded MCP shutdown
+    // then hard exit so background promises can't pin the process alive.
+    await Promise.race([
+        disconnectMcpServers().catch(() => { }),
+        new Promise((r) => setTimeout(r, 2000)),
+    ]);
+    process.exit(process.exitCode ?? 0);
 }
 // ─── Panel auto-start ──────────────────────────────────────────────────────
 async function startPanelBackground(startPort) {

package/dist/pricing.js

@@ -27,6 +27,7 @@ export const MODEL_PRICING = {
     'nvidia/mistral-large-3-675b': { input: 0, output: 0 },
     // Anthropic
     'anthropic/claude-sonnet-4.6': { input: 3.0, output: 15.0 },
+    'anthropic/claude-opus-4.8': { input: 5.0, output: 25.0 },
     'anthropic/claude-opus-4.7': { input: 5.0, output: 25.0 },
     'anthropic/claude-opus-4.6': { input: 5.0, output: 25.0 },
     'anthropic/claude-haiku-4.5': { input: 1.0, output: 5.0 },
@@ -90,7 +91,7 @@ export const MODEL_PRICING = {
     'zai/glm-5.1-turbo': { input: 0, output: 0, perCall: 0.001 }, // client alias for zai/glm-5-turbo
 };
 /** Opus pricing for savings calculations — tracks the current flagship. */
-export const OPUS_PRICING = MODEL_PRICING['anthropic/claude-opus-4.7'];
+export const OPUS_PRICING = MODEL_PRICING['anthropic/claude-opus-4.8'];
 /**
  * Estimate cost in USD for a request.
  * Falls back to $2/$10 per 1M for unknown models.

package/dist/proxy/server.js

@@ -100,7 +100,8 @@ const MODEL_SHORTCUTS = {
     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: 'anthropic/claude-opus-4.8',
+    'opus-4.8': 'anthropic/claude-opus-4.8',
     'opus-4.7': 'anthropic/claude-opus-4.7',
     'opus-4.6': 'anthropic/claude-opus-4.6',
     haiku: 'anthropic/claude-haiku-4.5-20251001',

package/dist/router/index.js

@@ -55,14 +55,15 @@ const AUTO_TIERS = {
         // Hard tasks — multi-file refactors, ambiguous specs, dense reasoning
         // chains — still go to Opus. V4 Pro is great but not a Sonnet/Opus
         // replacement at the high end of difficulty per recent agent-bench runs.
-        primary: 'anthropic/claude-opus-4.7',
-        fallback: ['openai/gpt-5.5', 'anthropic/claude-sonnet-4.6', 'deepseek/deepseek-v4-pro'],
+        primary: 'anthropic/claude-opus-4.8',
+        fallback: ['anthropic/claude-opus-4.7', 'openai/gpt-5.5', 'anthropic/claude-sonnet-4.6', 'deepseek/deepseek-v4-pro'],
     },
     REASONING: {
-        // Opus 4.7: step-change improvement in agentic coding over 4.6 per
-        // Anthropic. 4.6 stays in the fallback chain in case of rollout delays.
-        primary: 'anthropic/claude-opus-4.7',
+        // Opus 4.8: latest flagship, most capable for agentic coding. 4.7 and 4.6
+        // stay in the fallback chain in case of rollout delays.
+        primary: 'anthropic/claude-opus-4.8',
         fallback: [
+            'anthropic/claude-opus-4.7',
             'anthropic/claude-opus-4.6',
             'openai/o3',
             'deepseek/deepseek-v4-pro',

package/dist/router/vision.js

@@ -20,6 +20,7 @@
  */
 const VISION_MODELS = new Set([
     // Anthropic — native vision across the line
+    'anthropic/claude-opus-4.8',
     'anthropic/claude-opus-4.7',
     'anthropic/claude-opus-4.6',
     'anthropic/claude-sonnet-4.6',

package/dist/ui/model-picker.js

@@ -19,7 +19,8 @@ export const MODEL_SHORTCUTS = {
     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: 'anthropic/claude-opus-4.8',
+    'opus-4.8': 'anthropic/claude-opus-4.8',
     'opus-4.7': 'anthropic/claude-opus-4.7',
     'opus-4.6': 'anthropic/claude-opus-4.6',
     haiku: 'anthropic/claude-haiku-4.5-20251001',
@@ -149,7 +150,7 @@ export const PICKER_CATEGORIES = [
         // free-tier entries and v3.9.2 used to retire Kimi K2.5.
         category: '✨ Premium frontier',
         models: [
-            { id: 'anthropic/claude-opus-4.7', shortcut: 'opus', label: 'Claude Opus 4.7', price: '$5/$25', highlight: true },
+            { id: 'anthropic/claude-opus-4.8', shortcut: 'opus', label: 'Claude Opus 4.8', price: '$5/$25', highlight: true },
             { id: 'anthropic/claude-sonnet-4.6', shortcut: 'sonnet', label: 'Claude Sonnet 4.6', price: '$3/$15' },
             { id: 'openai/gpt-5.5', shortcut: 'gpt', label: 'GPT-5.5', price: '$5/$30', highlight: true },
             { id: 'google/gemini-3.1-pro', shortcut: 'gemini-3', label: 'Gemini 3.1 Pro', price: '$2/$12' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.22.0",
+  "version": "3.23.1",
   "description": "Franklin Agent — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {
@@ -31,7 +31,7 @@
     "build": "tsc && node scripts/copy-plugin-assets.mjs",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
-    "test": "npm run build && node --test --test-reporter=spec test/local.mjs test/skills.local.mjs",
+    "test": "npm run build && node --test --test-reporter=spec test/local.mjs test/skills.local.mjs test/repair.mjs",
     "test:e2e": "npm run build && node --test --test-reporter=spec test/e2e.mjs",
     "test:free-models": "npm run build && node --test --test-reporter=spec test/free-model-matrix.mjs",
     "test:all": "npm run test && npm run test:e2e",