@blockrun/franklin 3.9.4 → 3.9.6

package/dist/agent/context.js

@@ -174,6 +174,7 @@ function getToolPatternsSection() {
 - **Research**: WebSearch for discovery → WebFetch for specific URLs from search results. Don't WebFetch URLs you invented.
 - **Complex tasks**: Use Agent to spawn sub-agents for 2+ independent research or implementation tasks. Don't do sequentially what can be done in parallel.
 - **Multiple independent lookups**: Call all tools in a single response. NEVER make sequential calls when parallel calls would work.
+- **Long-running iteration (>20 items)**: Do NOT loop in the agent (one tool call per item burns turns and trips timeouts on the 21st item). Instead: Write a script (Node/Bash/Python), have it iterate with a checkpoint file (\`./.franklin/<task>.checkpoint.json\` storing cursor + processedCount), then Bash it once. The agent re-engages only on errors or completion. Pattern fits paginated APIs, batch enrichment, large CSV emit, anything where the loop body is deterministic. The agent's job is to design and orchestrate, not to be the for-loop.
 
 # Grounding Before Answering
 Your training data is frozen in the past. Live-world questions MUST be answered from tool results, not memory.

package/dist/agent/llm.js

@@ -7,15 +7,25 @@ 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;
     return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
 }
 function getModelRequestTimeoutMs() {
+    // 180s budget for *time-to-headers* (the gateway flushes SSE headers only
+    // once the upstream model emits its first token). Reasoning-class models
+    // (zai/glm-*, nemotron *-reasoning, deepseek-r*, gpt-5-codex, anthropic
+    // extended-thinking) routinely take 60–120s to first token on cache-cold
+    // prompts or when the gateway is under load — the old 45s default cut
+    // those off and wasted USDC on retries that hit the same wall. 180s is
+    // generous enough for any realistic first-token latency, still bounded
+    // enough that genuinely dead requests surface within ~6 min after the
+    // single timeout retry.
     return (parseTimeoutEnv('FRANKLIN_MODEL_REQUEST_TIMEOUT_MS') ??
         parseTimeoutEnv('FRANKLIN_MODEL_IDLE_TIMEOUT_MS') ??
-        45_000);
+        180_000);
 }
 function getModelStreamIdleTimeoutMs() {
     return (parseTimeoutEnv('FRANKLIN_MODEL_STREAM_IDLE_TIMEOUT_MS') ??
@@ -420,6 +430,7 @@ export class ModelClient {
         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
@@ -439,7 +450,9 @@ export class ModelClient {
                 const trimmed = currentText.trimStart();
                 if (!trimmed)
                     return;
-                textEmission.mode = trimmed.startsWith('{') ? 'hold' : 'stream';
+                // 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 });
                 }
@@ -585,6 +598,13 @@ export class ModelClient {
                                         '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 });
@@ -646,6 +666,13 @@ export class ModelClient {
                         '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 });

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/proxy/server.js

@@ -41,7 +41,13 @@ function log(...args) {
     catch { /* ignore */ }
 }
 const DEFAULT_MAX_TOKENS = 4096;
-const DEFAULT_PROXY_REQUEST_TIMEOUT_MS = 45_000;
+// 180s budget for *time-to-headers* — reasoning-class models (zai/glm-*,
+// nemotron *-reasoning, deepseek-r*, gpt-5-codex, anthropic extended-thinking)
+// routinely take 60–120s to first token on cache-cold prompts or busy
+// gateways. The old 45s default cut those off and the proxy returned a
+// failed response that downstream agents (Cline, Claude Desktop, etc.) had
+// to retry blindly.
+const DEFAULT_PROXY_REQUEST_TIMEOUT_MS = 180_000;
 const DEFAULT_PROXY_STREAM_TIMEOUT_MS = 5 * 60 * 1000;
 function parseTimeoutEnv(name, fallback) {
     const raw = process.env[name];

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.4",
+  "version": "3.9.6",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {