@blockrun/franklin 3.15.50 → 3.15.52

package/dist/agent/llm.js

@@ -431,11 +431,64 @@ export class ModelClient {
             if (!response.ok) {
                 const errorBody = await response.text().catch(() => 'unknown error');
                 const message = extractApiErrorMessage(errorBody);
-                yield {
-                    kind: 'error',
-                    payload: { status: response.status, message },
-                };
-                return;
+                // Runtime tool_choice retry. The static allowlist at line ~35
+                // catches the case where the request goes directly to a model
+                // whose name contains `deepseek-reasoner` / `openai/o1` /
+                // `openai/o3`. But the gateway sometimes ALIASES a different
+                // model name to a reasoner backend — verified 2026-05-04 in a
+                // live session: a request for `deepseek/deepseek-v4-pro`
+                // returned `400 Invalid request: 400 deepseek-reasoner does not
+                // support this tool_choice`, because the gateway routed v4-pro
+                // to a deepseek-reasoner upstream. The static allowlist can't
+                // know that. Catch the error, drop tool_choice, re-fire once.
+                // No payment re-sign needed — original 402 already settled, and
+                // the gateway treats this as the same logical request.
+                const lc = message.toLowerCase();
+                const looksLikeToolChoiceReject = response.status === 400 &&
+                    lc.includes('tool_choice') &&
+                    (lc.includes('not support') || lc.includes('unsupported') || lc.includes('does not support'));
+                if (looksLikeToolChoiceReject && requestPayload['tool_choice'] !== undefined) {
+                    delete requestPayload['tool_choice'];
+                    const retryBody = JSON.stringify(requestPayload);
+                    if (this.debug) {
+                        console.error(`[franklin] tool_choice rejected by upstream; retrying without it (model=${request.model})`);
+                    }
+                    response = await withAbortableTimeout(() => fetch(endpoint, {
+                        method: 'POST',
+                        headers,
+                        body: retryBody,
+                        signal: requestController.signal,
+                    }), requestController, createModelTimeoutError('request', request.model, requestTimeoutMs), requestTimeoutMs);
+                    if (response.status === 402) {
+                        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: retryBody,
+                            signal: requestController.signal,
+                        }), requestController, createModelTimeoutError('request', request.model, requestTimeoutMs), requestTimeoutMs);
+                    }
+                    if (!response.ok) {
+                        const retryBodyText = await response.text().catch(() => 'unknown error');
+                        yield {
+                            kind: 'error',
+                            payload: { status: response.status, message: extractApiErrorMessage(retryBodyText) },
+                        };
+                        return;
+                    }
+                    // Successful retry — fall through to SSE parsing below.
+                }
+                else {
+                    yield {
+                        kind: 'error',
+                        payload: { status: response.status, message },
+                    };
+                    return;
+                }
             }
             // Parse SSE stream
             yield* this.parseSSEStream(response, requestController, streamTimeoutMs, request.model);

package/dist/tools/videogen.js

@@ -23,6 +23,7 @@ import path from 'node:path';
 import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, createSolanaPaymentPayload, parsePaymentRequired, extractPaymentDetails, solanaKeyToBytes, SOLANA_NETWORK, } from '@blockrun/llm';
 import { loadChain, API_URLS, VERSION } from '../config.js';
 import { logger } from '../logger.js';
+import { resolveReferenceImage } from './imagegen.js';
 import { ModelClient } from '../agent/llm.js';
 import { analyzeMediaRequest, renderProposalForAskUser } from '../agent/media-router.js';
 import { recordUsage } from '../stats/tracker.js';
@@ -46,6 +47,28 @@ function buildExecute(deps) {
         const { output_path, model, image_url, duration_seconds, contentId } = rawInput;
         if (!rawInput.prompt)
             return { output: 'Error: prompt is required', isError: true };
+        // Resolve image_url before sending. The gateway requires a URL (http(s)
+        // or data: URI), but agents naturally pass a local file path —
+        // verified 2026-05-04 in a live session: agent passed
+        // `/Users/.../keyframe.png` and the gateway returned
+        // `400 Invalid request body: invalid_format url path: image_url`.
+        // ImageGen already had `resolveReferenceImage` for the same problem;
+        // sharing the helper keeps the contract consistent across both tools
+        // (local path → base64 data URI; http(s) URL → fetched + inlined;
+        // data: URI → passes through). On any resolution failure, surface
+        // the message instead of letting the gateway 400 bubble back.
+        let resolvedImageUrl;
+        if (image_url) {
+            try {
+                resolvedImageUrl = await resolveReferenceImage(image_url, ctx.workingDir);
+            }
+            catch (err) {
+                return {
+                    output: `Could not resolve image_url ${JSON.stringify(image_url)}: ${err.message}`,
+                    isError: true,
+                };
+            }
+        }
         // One-shot refinement opt-out: leading `///` tells Franklin "don't
         // refine this prompt." Strip the prefix and pass skipRefine through.
         let prompt = rawInput.prompt;
@@ -131,7 +154,7 @@ function buildExecute(deps) {
         const body = JSON.stringify({
             model: videoModel,
             prompt: chosenPrompt,
-            ...(image_url ? { image_url } : {}),
+            ...(resolvedImageUrl ? { image_url: resolvedImageUrl } : {}),
             ...(duration_seconds ? { duration_seconds } : {}),
         });
         const headers = {
@@ -440,7 +463,7 @@ export function createVideoGenCapability(deps = {}) {
                     prompt: { type: 'string', description: 'Text description of the video to generate' },
                     output_path: { type: 'string', description: 'Where to save the MP4. Default: generated-<timestamp>.mp4 in working directory' },
                     model: { type: 'string', description: 'Video model. Default: xai/grok-imagine-video' },
-                    image_url: { type: 'string', description: 'Optional seed image URL (image-to-video)' },
+                    image_url: { type: 'string', description: 'Optional seed image (image-to-video). Accepts http(s) URL, data: URI, or local file path — local paths get inlined as base64 data URIs automatically.' },
                     duration_seconds: { type: 'number', description: 'Duration billed for. Default depends on model (8s for grok-imagine-video).' },
                     contentId: { type: 'string', description: 'Optional Content id to attach and budget against.' },
                 },

package/package.json

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