@blockrun/franklin 3.21.9 → 3.23.0

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/content/image-pricing.d.ts

@@ -11,4 +11,10 @@
  * gateway ever exposes the realized payment amount on the response, that
  * should be preferred — fall back to this estimate when it's missing.
  */
-export declare function estimateImageCostUsd(model: string, size: string): number;
+/**
+ * Estimate the USD cost of `n` images for a model + size. `n` defaults to 1.
+ * Unknown models return 0 rather than a guess — a free/custom model should not
+ * carry a phantom charge against the Content budget, and surprise overcharging
+ * from a wrong guess is worse than under-counting.
+ */
+export declare function estimateImageCostUsd(model: string, size: string, n?: number): number;

package/dist/content/image-pricing.js

@@ -11,22 +11,45 @@
  * gateway ever exposes the realized payment amount on the response, that
  * should be preferred — fall back to this estimate when it's missing.
  */
-export function estimateImageCostUsd(model, size) {
-    const m = model.toLowerCase();
+/**
+ * Per-image base price by model + size. Mirrors the gateway's IMAGE_MODELS.sizes
+ * (blockrun src/lib/models.ts). These are base prices — the realized x402 charge
+ * adds a small markup — but they're close enough for budget tracking. Sizes not
+ * listed for a model fall back to that model's 1024x1024 tier.
+ */
+const PRICE_TABLE = {
+    'openai/dall-e-3': {
+        base: 0.04,
+        sizes: { '1024x1024': 0.04, '1792x1024': 0.08, '1024x1792': 0.08 },
+    },
+    'openai/gpt-image-1': {
+        base: 0.02,
+        sizes: { '1024x1024': 0.02, '1536x1024': 0.04, '1024x1536': 0.04 },
+    },
+    'openai/gpt-image-2': {
+        base: 0.06,
+        sizes: { '1024x1024': 0.06, '1536x1024': 0.12, '1024x1536': 0.12 },
+    },
+    'google/nano-banana': {
+        base: 0.05,
+        sizes: { '1024x1024': 0.05 },
+    },
+    'google/nano-banana-pro': {
+        base: 0.1,
+        sizes: { '1024x1024': 0.1, '2048x2048': 0.1, '4096x4096': 0.15 },
+    },
+};
+/**
+ * Estimate the USD cost of `n` images for a model + size. `n` defaults to 1.
+ * Unknown models return 0 rather than a guess — a free/custom model should not
+ * carry a phantom charge against the Content budget, and surprise overcharging
+ * from a wrong guess is worse than under-counting.
+ */
+export function estimateImageCostUsd(model, size, n = 1) {
+    const entry = PRICE_TABLE[model.toLowerCase()];
+    if (!entry)
+        return 0;
     const s = size.replace(/\s+/g, '');
-    if (m === 'openai/dall-e-3') {
-        if (s === '1792x1024' || s === '1024x1792')
-            return 0.08;
-        // All other sizes fall back to the standard 1024x1024 tier.
-        return 0.04;
-    }
-    if (m === 'openai/gpt-image-1') {
-        // gpt-image-1 standard tier; larger sizes would tier up but Franklin
-        // sends 1024x1024 as default.
-        return 0.042;
-    }
-    // Unknown model: return 0 rather than a guess. A free/custom model should
-    // not have a phantom charge against the Content budget, and surprise
-    // overcharging from a wrong guess is worse than under-counting.
-    return 0;
+    const perImage = entry.sizes[s] ?? entry.base;
+    return perImage * Math.max(1, n);
 }

package/dist/content/record-image.d.ts

@@ -34,7 +34,7 @@ export type RecordImageDecision = {
  * estimated cost fits; `{ ok: false, reason }` when it doesn't or the
  * content doesn't exist. Non-mutating.
  */
-export declare function checkImageBudget(library: ContentLibrary, contentId: string, model: string, size: string): {
+export declare function checkImageBudget(library: ContentLibrary, contentId: string, model: string, size: string, count?: number): {
     ok: true;
 } | {
     ok: false;

package/dist/content/record-image.js

@@ -20,12 +20,12 @@ import { estimateImageCostUsd } from './image-pricing.js';
  * estimated cost fits; `{ ok: false, reason }` when it doesn't or the
  * content doesn't exist. Non-mutating.
  */
-export function checkImageBudget(library, contentId, model, size) {
+export function checkImageBudget(library, contentId, model, size, count = 1) {
     const content = library.get(contentId);
     if (!content) {
         return { ok: false, reason: `Content ${contentId} not found` };
     }
-    const cost = estimateImageCostUsd(model, size);
+    const cost = estimateImageCostUsd(model, size, count);
     if (content.spentUsd + cost > content.budgetUsd + 1e-9) {
         return {
             ok: false,

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/tools/blockrun.js

@@ -237,12 +237,21 @@ export const blockrunCapability = {
         }
         catch { /* best-effort */ }
         if (!result.ok) {
-            const detail = typeof result.body?.error === 'string'
-                ? result.body.error
-                : `HTTP ${result.status}`;
+            const b = result.body;
+            const detail = typeof b?.error === 'string' ? b.error : `HTTP ${result.status}`;
             const fullOutput = result.raw || JSON.stringify(result.body, null, 2);
+            // Surface the gateway's self-correction hints into the model-visible
+            // output. On a wrong path the Surf route returns `available: [...all
+            // valid paths]` (and often a `message`); without this the model only
+            // saw "Not Found" and kept guessing until the tool-failure circuit
+            // breaker tripped. The list comes straight from the live registry, so
+            // it's always complete and in sync — no drift.
+            const hint = typeof b?.message === 'string' ? `\n${b.message}` : '';
+            const avail = Array.isArray(b?.available)
+                ? `\nValid endpoints: ${b.available.filter((x) => typeof x === 'string').join(', ')}`
+                : '';
             return {
-                output: `BlockRun ${method} ${path} failed: ${detail} (status ${result.status}). No charge if status is 4xx pre-payment.`,
+                output: `BlockRun ${method} ${path} failed: ${detail} (status ${result.status}). No charge if status is 4xx pre-payment.${hint}${avail}`,
                 fullOutput,
                 isError: true,
             };

package/dist/tools/imagegen.d.ts

@@ -5,11 +5,28 @@
 import type { CapabilityHandler } from '../agent/types.js';
 import type { ContentLibrary } from '../content/library.js';
 /**
- * Models that accept a reference image via /v1/images/image2image. Currently
- * limited to OpenAI's edit endpoint — Gemini Nano Banana Pro and Grok Imagine
- * Image Pro need gateway-side support before they can be wired in here.
+ * Models that accept a reference image via /v1/images/image2image. Mirrors the
+ * gateway's EDIT_SUPPORTED_MODELS (src/app/api/v1/images/image2image/route.ts):
+ * both OpenAI gpt-image-* and Google Nano Banana support image-to-image edits.
  */
 export declare const EDIT_SUPPORTED_MODELS: Set<string>;
+/**
+ * Mask-based inpainting is OpenAI-only. Gemini (Nano Banana) does prompt-based
+ * edits with no mask concept. Mirrors the gateway's MASK_SUPPORTED_MODELS.
+ */
+export declare const MASK_SUPPORTED_MODELS: Set<string>;
+/**
+ * Output-image count ceiling. The gateway has no hard max but price scales with
+ * n, so cap client-side to keep a typo from draining the wallet.
+ */
+export declare const MAX_OUTPUT_IMAGES = 4;
+/**
+ * Valid sizes per known image model, mirroring the gateway's IMAGE_MODELS.sizes
+ * (src/lib/models.ts). Used to fail cheaply before paying when a caller or the
+ * media router picks a size the model rejects. Models absent from this table
+ * (custom / future gateway models) skip validation and let the gateway decide.
+ */
+export declare const IMAGE_MODEL_SIZES: Record<string, string[]>;
 export declare const REFERENCE_IMAGE_MAX_BYTES = 4000000;
 /**
  * Normalize a reference image into a base64 data URI for the gateway. The
@@ -24,6 +41,8 @@ export interface ImageGenDeps {
     /** Invoked after successful content-linked generation; lets callers persist. */
     onContentChange?: () => void | Promise<void>;
 }
+/** Insert a `-{idx}` suffix before the file extension: a.png → a-2.png. */
+export declare function withIndexSuffix(p: string, idx: number): string;
 /**
  * Build the ImageGen capability. Passing `deps.library` enables the
  * contentId flow: pre-flight budget check + post-generation asset