@blockrun/franklin 3.9.3 → 3.9.5

package/dist/agent/llm.d.ts

@@ -90,6 +90,7 @@ export declare function modelHasExtendedThinking(model: string): boolean;
  * direct unit testing — the happy path hits it only on stream error.
  */
 export declare function classifyToolCallFailure(toolName: string, rawInput: string, signal: AbortSignal | undefined, model: string): string;
+export declare function isRoleplayedJsonToolCallText(text: string): boolean;
 export declare class ModelClient {
     private apiUrl;
     private chain;

package/dist/agent/llm.js

@@ -7,6 +7,7 @@ import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, creat
 import { USER_AGENT } from '../config.js';
 import { routeRequest, parseRoutingProfile } from '../router/index.js';
 import { ThinkTagStripper } from './think-tag-stripper.js';
+import { isNemotronProseModel, stripNemotronProse } from './nemotron-prose-stripper.js';
 function parseTimeoutEnv(name) {
     const raw = process.env[name];
     const parsed = raw ? Number.parseInt(raw, 10) : NaN;
@@ -170,6 +171,23 @@ export function classifyToolCallFailure(toolName, rawInput, signal, model) {
         `Preview: ${preview}${rawInput.length > 120 ? '…' : ''} — ` +
         `this is usually a model output bug; try \`/model <other>\` or retry.]`;
 }
+export function isRoleplayedJsonToolCallText(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}'))
+        return false;
+    try {
+        const parsed = JSON.parse(trimmed);
+        return (parsed !== null &&
+            typeof parsed === 'object' &&
+            !Array.isArray(parsed) &&
+            parsed.type === 'function' &&
+            typeof parsed.name === 'string' &&
+            ('parameters' in parsed || 'arguments' in parsed));
+    }
+    catch {
+        return false;
+    }
+}
 function applyAnthropicPromptCaching(payload, request) {
     const out = { ...payload };
     const cacheMarker = { type: 'ephemeral' };
@@ -402,6 +420,8 @@ export class ModelClient {
         let currentToolId = '';
         let currentToolName = '';
         let currentToolInput = '';
+        const textEmission = { mode: 'undecided' };
+        const isNemotronProse = isNemotronProseModel(request.model);
         // Split inline <think>…</think> emitted by reasoning models (nemotron,
         // deepseek-r1, qwq, etc.) that use the text field instead of the native
         // thinking block. Thinking emitted this way is display-only — we don't
@@ -413,6 +433,26 @@ export class ModelClient {
         // system-prompt guard in loop.ts is responsible for preventing this.
         // Debug-only because the user already sees the literal text in the UI.
         let toolCallRoleplayWarned = false;
+        const appendText = (text) => {
+            if (!text)
+                return;
+            currentText += text;
+            if (textEmission.mode === 'undecided') {
+                const trimmed = currentText.trimStart();
+                if (!trimmed)
+                    return;
+                // Nemotron Omni leaks reasoning prose into the text channel without
+                // <think> tags. Hold the buffer for end-of-stream stripping.
+                textEmission.mode = isNemotronProse || trimmed.startsWith('{') ? 'hold' : 'stream';
+                if (textEmission.mode === 'stream') {
+                    onStreamDelta?.({ type: 'text', text: currentText });
+                }
+                return;
+            }
+            if (textEmission.mode === 'stream') {
+                onStreamDelta?.({ type: 'text', text });
+            }
+        };
         for await (const chunk of this.streamCompletion(request, signal)) {
             switch (chunk.kind) {
                 case 'content_block_start': {
@@ -429,6 +469,7 @@ export class ModelClient {
                     }
                     else if (cblock?.type === 'text') {
                         currentText = '';
+                        textEmission.mode = 'undecided';
                         textStripper = new ThinkTagStripper();
                     }
                     break;
@@ -458,9 +499,7 @@ export class ModelClient {
                         }
                         for (const seg of textStripper.push(raw)) {
                             if (seg.type === 'text') {
-                                currentText += seg.text;
-                                if (seg.text)
-                                    onStreamDelta?.({ type: 'text', text: seg.text });
+                                appendText(seg.text);
                             }
                             else if (seg.text) {
                                 onStreamDelta?.({ type: 'thinking', text: seg.text });
@@ -537,20 +576,37 @@ export class ModelClient {
                         // Flush any partial tag held in the stripper
                         for (const seg of textStripper.flush()) {
                             if (seg.type === 'text') {
-                                currentText += seg.text;
-                                if (seg.text)
-                                    onStreamDelta?.({ type: 'text', text: seg.text });
+                                appendText(seg.text);
                             }
                             else if (seg.text) {
                                 onStreamDelta?.({ type: 'thinking', text: seg.text });
                             }
                         }
                         if (currentText) {
-                            collected.push({
-                                type: 'text',
-                                text: currentText,
-                            });
+                            if (textEmission.mode === 'hold' && isRoleplayedJsonToolCallText(currentText)) {
+                                if (this.debug) {
+                                    console.error(`[franklin] Model ${request.model} emitted a raw JSON function-call object as text. ` +
+                                        'Treating it as non-productive output so recovery can try another model.');
+                                }
+                            }
+                            else if (textEmission.mode === 'hold' && isNemotronProse) {
+                                const { thinking, answer } = stripNemotronProse(currentText);
+                                if (thinking)
+                                    onStreamDelta?.({ type: 'thinking', text: thinking });
+                                onStreamDelta?.({ type: 'text', text: answer });
+                                collected.push({ type: 'text', text: answer });
+                            }
+                            else {
+                                if (textEmission.mode !== 'stream') {
+                                    onStreamDelta?.({ type: 'text', text: currentText });
+                                }
+                                collected.push({
+                                    type: 'text',
+                                    text: currentText,
+                                });
+                            }
                             currentText = '';
+                            textEmission.mode = 'undecided';
                         }
                     }
                     break;
@@ -588,16 +644,32 @@ export class ModelClient {
         // Flush any remaining text (stream ended without content_block_stop)
         for (const seg of textStripper.flush()) {
             if (seg.type === 'text') {
-                currentText += seg.text;
-                if (seg.text)
-                    onStreamDelta?.({ type: 'text', text: seg.text });
+                appendText(seg.text);
             }
             else if (seg.text) {
                 onStreamDelta?.({ type: 'thinking', text: seg.text });
             }
         }
         if (currentText) {
-            collected.push({ type: 'text', text: currentText });
+            if (textEmission.mode === 'hold' && isRoleplayedJsonToolCallText(currentText)) {
+                if (this.debug) {
+                    console.error(`[franklin] Model ${request.model} emitted a raw JSON function-call object as text. ` +
+                        'Treating it as non-productive output so recovery can try another model.');
+                }
+            }
+            else if (textEmission.mode === 'hold' && isNemotronProse) {
+                const { thinking, answer } = stripNemotronProse(currentText);
+                if (thinking)
+                    onStreamDelta?.({ type: 'thinking', text: thinking });
+                onStreamDelta?.({ type: 'text', text: answer });
+                collected.push({ type: 'text', text: answer });
+            }
+            else {
+                if (textEmission.mode !== 'stream') {
+                    onStreamDelta?.({ type: 'text', text: currentText });
+                }
+                collected.push({ type: 'text', text: currentText });
+            }
         }
         return { content: collected, usage, stopReason };
     }

package/dist/agent/loop.js

@@ -822,8 +822,10 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     '\n\n# Available tools\n' +
                     `You have exactly these tools: ${names}.\n` +
                     'Do not invent other tool names. Do not emit literal "[TOOLCALL]", ' +
-                    '"<tool_call>", or similar tokens in your text — call tools via the ' +
-                    'proper API only. If no tool fits, explain plainly in prose.';
+                    '"<tool_call>", raw JSON function-call objects like {"type":"function","name":"Tool","parameters":{}}, ' +
+                    'or similar tokens in your text — call tools via the proper API only. ' +
+                    'If the user asks you to echo a token, marker, or string, echo it as plain text; ' +
+                    'do not call Wallet or any other tool unless the user explicitly asks for that tool-backed information.';
             }
             // Safety net: handled in llm.ts resolveVirtualModel()
             // Sanitize: remove orphaned tool results that could confuse the API

package/dist/agent/nemotron-prose-stripper.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Strip leaked reasoning prose from Nemotron-family models.
+ *
+ * NVIDIA's Nemotron Omni reasoning model emits its chain of thought as plain
+ * text — without `<think>` tags or a separate reasoning_content channel — so
+ * the think-tag stripper can't catch it. The reasoning prose is then concatenated
+ * directly with the answer (often without even a separator), e.g.:
+ *
+ *   "The user asks: ... According to instructions, we must obey. Just output
+ *    the tokenOMNI_E2E_OK"
+ *
+ * This module detects the reasoning preamble (heuristic: leading sentence
+ * matches a known meta-reasoning opener) and strips everything up to and
+ * including the last "answer-introducer" phrase ("just output the token",
+ * "the answer is:", "output:", etc.). The stripped portion is returned as
+ * `thinking` so it can be routed to the thinking display channel; the
+ * remainder is the user-facing `answer`.
+ */
+export declare function isNemotronProseModel(model: string): boolean;
+export declare function stripNemotronProse(text: string): {
+    thinking: string;
+    answer: string;
+};

package/dist/agent/nemotron-prose-stripper.js

@@ -0,0 +1,77 @@
+/**
+ * Strip leaked reasoning prose from Nemotron-family models.
+ *
+ * NVIDIA's Nemotron Omni reasoning model emits its chain of thought as plain
+ * text — without `<think>` tags or a separate reasoning_content channel — so
+ * the think-tag stripper can't catch it. The reasoning prose is then concatenated
+ * directly with the answer (often without even a separator), e.g.:
+ *
+ *   "The user asks: ... According to instructions, we must obey. Just output
+ *    the tokenOMNI_E2E_OK"
+ *
+ * This module detects the reasoning preamble (heuristic: leading sentence
+ * matches a known meta-reasoning opener) and strips everything up to and
+ * including the last "answer-introducer" phrase ("just output the token",
+ * "the answer is:", "output:", etc.). The stripped portion is returned as
+ * `thinking` so it can be routed to the thinking display channel; the
+ * remainder is the user-facing `answer`.
+ */
+const REASONING_OPENERS = [
+    /^the user (asks|wants|says|requested|is asking|wants me|wrote|just|said)/i,
+    /^looking at (this|the)/i,
+    /^based on (the|this)/i,
+    /^according to/i,
+    /^we (must|should|need)/i,
+    /^i (need|should|must|will|'ll|am going to|have to)\s/i,
+    /^let me/i,
+    /^there'?s? no need/i,
+    /^okay,?\s+(the user|so|let|i)/i,
+    /^alright,?\s+(the user|so|let|i)/i,
+    /^so,?\s+the user/i,
+    /^the question (is|asks)/i,
+    /^the prompt (is|says|asks)/i,
+];
+const ANSWER_INTRODUCERS = [
+    /\bjust\s+(?:output|respond|say|reply|return|emit|write|give|print)\s+(?:the|a|with|out|to|exactly|back|only)?\s*(?:token|word|answer|response|string|text|output|message)?\s*:?\s*/gi,
+    /\b(?:the|my)\s+(?:answer|response|token|output|reply)\s+is\s*:?\s*/gi,
+    /\bhere'?s?\s+(?:the|my)?\s*(?:response|answer|output|token|reply):?\s*/gi,
+    /(?:^|[\s.])(?:output|response|answer|reply|token)\s*:\s*/gi,
+    /\bi(?:'ll| will| shall)\s+(?:output|respond|say|reply|return|emit|write|give|print)\s+(?:the|a|with|out|to|exactly|back|only)?\s*(?:token|word|answer|response|string|text|output|message)?\s*:?\s*/gi,
+];
+export function isNemotronProseModel(model) {
+    return /^nvidia\/nemotron-3-nano-omni/i.test(model);
+}
+export function stripNemotronProse(text) {
+    if (!text)
+        return { thinking: '', answer: '' };
+    const leadingWhitespaceMatch = text.match(/^\s*/);
+    const leadingWhitespace = leadingWhitespaceMatch ? leadingWhitespaceMatch[0] : '';
+    const trimmed = text.slice(leadingWhitespace.length);
+    if (!trimmed)
+        return { thinking: '', answer: text };
+    // Reject early: if no reasoning opener at the start, this isn't leaked prose.
+    if (!REASONING_OPENERS.some((p) => p.test(trimmed))) {
+        return { thinking: '', answer: text };
+    }
+    let lastEnd = -1;
+    for (const re of ANSWER_INTRODUCERS) {
+        const matches = [...trimmed.matchAll(re)];
+        for (const m of matches) {
+            const end = (m.index ?? 0) + m[0].length;
+            if (end > lastEnd)
+                lastEnd = end;
+        }
+    }
+    if (lastEnd === -1) {
+        // Reasoning detected but no transition phrase found. Conservative: leave
+        // the text intact rather than swallow what might be a legitimate answer.
+        return { thinking: '', answer: text };
+    }
+    const thinking = leadingWhitespace + trimmed.slice(0, lastEnd);
+    const answer = trimmed.slice(lastEnd).replace(/^[\s.,:;\-—]+/, '');
+    // Don't return an empty answer — fall back to the original text so the user
+    // gets *something* even if our heuristic over-stripped.
+    if (!answer)
+        return { thinking: '', answer: text };
+    return { thinking, answer };
+}

package/dist/agent/tokens.js

@@ -197,6 +197,9 @@ const MODEL_CONTEXT_WINDOWS = {
     'moonshot/kimi-k2.6': 256_000,
     'moonshot/kimi-k2.5': 128_000,
     'minimax/minimax-m2.7': 128_000,
+    // NVIDIA-hosted free tier (2026-04-29 V4 Flash + Omni launch)
+    'nvidia/deepseek-v4-flash': 1_000_000,
+    'nvidia/nemotron-3-nano-omni-30b-a3b-reasoning': 256_000,
 };
 /**
  * Get the context window size for a model, with a conservative default.

package/dist/commands/start.js

@@ -3,7 +3,7 @@ import { getOrCreateWallet, getOrCreateSolanaWallet } from '@blockrun/llm';
 import { loadChain, API_URLS } from '../config.js';
 import { retryFetchBalance } from './balance-retry.js';
 import { flushStats, loadStats } from '../stats/tracker.js';
-import { OPUS_PRICING } from '../pricing.js';
+import { OPUS_PRICING, MODEL_PRICING } from '../pricing.js';
 import { loadConfig } from './config.js';
 import { printBanner } from '../banner.js';
 import { assembleInstructions } from '../agent/context.js';
@@ -126,17 +126,11 @@ export async function startCommand(options) {
         return;
     }
     // Warn when a paid model is active so users know they'll be charged.
-    // Set members = BlockRun gateway's current live free tier (refreshed 2026-04).
-    const FREE_MODELS = new Set([
-        'nvidia/glm-4.7',
-        'nvidia/qwen3-next-80b-a3b-thinking',
-        'nvidia/qwen3-coder-480b',
-        'nvidia/mistral-small-4-119b',
-        'nvidia/llama-4-maverick',
-        'nvidia/deepseek-v3.2',
-        'blockrun/free',
-    ]);
-    if (!FREE_MODELS.has(model)) {
+    // Derive "free" from MODEL_PRICING so adding a new free entry there is enough —
+    // no second hardcoded list to keep in sync.
+    const pricing = MODEL_PRICING[model];
+    const isFree = pricing != null && pricing.input === 0 && pricing.output === 0 && (pricing.perCall ?? 0) === 0;
+    if (!isFree) {
         console.log(chalk.yellow(`  Model: ${model}  (paid — charges from your wallet per call)`));
         console.log(chalk.dim(`  Switch to free with: /model free\n`));
     }

package/dist/pricing.js

@@ -8,7 +8,9 @@ export const MODEL_PRICING = {
     'blockrun/eco': { input: 0.2, output: 1.0 },
     'blockrun/premium': { input: 3.0, output: 15.0 },
     'blockrun/free': { input: 0, output: 0 },
-    // FREE — BlockRun gateway free tier (refreshed 2026-04)
+    // FREE — BlockRun gateway free tier (refreshed 2026-04-29 with V4 Flash + Omni launch)
+    'nvidia/deepseek-v4-flash': { input: 0, output: 0 },
+    'nvidia/nemotron-3-nano-omni-30b-a3b-reasoning': { input: 0, output: 0 },
     'nvidia/glm-4.7': { input: 0, output: 0 },
     'nvidia/qwen3-next-80b-a3b-thinking': { input: 0, output: 0 },
     'nvidia/qwen3-coder-480b': { input: 0, output: 0 },

package/dist/tools/imagegen.js

@@ -118,7 +118,7 @@ function buildExecute(deps) {
             };
         }
         let imageModel = model || (referenceImage ? 'openai/gpt-image-2' : 'openai/gpt-image-1');
-        const imageSize = size || '1024x1024';
+        let imageSize = size || '1024x1024';
         let chosenPrompt = prompt;
         // Skip the proposal flow when a reference image is set: the media router
         // doesn't know which models support image-to-image, so its suggestions
@@ -171,6 +171,12 @@ function buildExecute(deps) {
                 // Router / AskUser failed — fall back to default model silently.
             }
         }
+        // gpt-image-2 reliably serves 1024x1024 only — other sizes time out at
+        // the gateway. Force the supported size regardless of caller / router
+        // input so we never burn USDC on a request that's going to abort.
+        if (imageModel === 'openai/gpt-image-2' && imageSize !== '1024x1024') {
+            imageSize = '1024x1024';
+        }
         if (contentId && deps.library) {
             const decision = checkImageBudget(deps.library, contentId, imageModel, imageSize);
             if (!decision.ok) {
@@ -427,7 +433,7 @@ export function createImageGenCapability(deps = {}) {
                 properties: {
                     prompt: { type: 'string', description: 'Text description of the image to generate' },
                     output_path: { type: 'string', description: 'Where to save the image. Default: generated-<timestamp>.png in working directory' },
-                    size: { type: 'string', description: 'Image size: 1024x1024, 1792x1024, or 1024x1792. Default: 1024x1024' },
+                    size: { type: 'string', description: 'Image size: 1024x1024, 1792x1024, or 1024x1792. Default: 1024x1024. Note: openai/gpt-image-2 is forced to 1024x1024 (other sizes time out at the gateway).' },
                     model: { type: 'string', description: 'Image model to use. Default: openai/gpt-image-1' },
                     image_url: { type: 'string', description: 'Optional reference image (image-to-image / style transfer). Accepts an http(s) URL, a data URI, or a local file path. Only works with edit-capable models.' },
                     contentId: { type: 'string', description: 'Optional Content id to attach this generation to. Pre-flight budget check + auto-record on success.' },

package/package.json

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