@blockrun/franklin 3.15.84 → 3.15.86

package/dist/agent/llm.d.ts

@@ -133,6 +133,7 @@ export declare class ModelClient {
      */
     private resolveVirtualModel;
     streamCompletion(request: ModelRequest, signal?: AbortSignal): AsyncGenerator<StreamChunk>;
+    private parseNonStreamingMessage;
     /**
      * Non-streaming completion for simple requests.
      */

package/dist/agent/llm.js

@@ -337,6 +337,8 @@ export class ModelClient {
         }
         const isAnthropic = request.model.startsWith('anthropic/');
         const isGLM = request.model.startsWith('zai/') || request.model.includes('glm');
+        const isGeminiThinkingRequired = request.model.startsWith('google/gemini-3.1') ||
+            request.model.startsWith('google/gemini-2.5-pro');
         // Build the request payload, injecting model-specific optimizations
         let requestPayload = { ...request, stream: true };
         // Safety: tool_choice without tools causes upstream 400. Strip rather
@@ -368,6 +370,30 @@ export class ModelClient {
                 requestPayload['thinking'] = { type: 'enabled' };
             }
         }
+        // Gemini Pro reasoning models reject a missing/zero thinking budget. Normalize
+        // the gateway default so fallback routing doesn't fail with "Budget 0 is invalid."
+        if (isGeminiThinkingRequired) {
+            // The gateway's streaming path currently drops Gemini's thinking budget;
+            // non-streaming preserves it. We convert the JSON response back into the
+            // same internal chunks below so callers keep one code path.
+            requestPayload['stream'] = false;
+            const maxOut = request.max_tokens ?? 16_384;
+            const budgetTokens = Math.min(maxOut, 8_192);
+            const thinking = requestPayload['thinking'];
+            if (thinking && typeof thinking === 'object' && !Array.isArray(thinking)) {
+                requestPayload['thinking'] = {
+                    ...thinking,
+                    type: 'enabled',
+                    budget_tokens: budgetTokens,
+                };
+            }
+            else {
+                requestPayload['thinking'] = {
+                    type: 'enabled',
+                    budget_tokens: budgetTokens,
+                };
+            }
+        }
         if (isAnthropic) {
             // ─ Anthropic extended thinking ──────────────────────────────────────
             // Enable the `thinking` API block only for models that accept it.
@@ -529,6 +555,10 @@ export class ModelClient {
                     return;
                 }
             }
+            if (requestPayload['stream'] === false) {
+                yield* this.parseNonStreamingMessage(response, request.model);
+                return;
+            }
             // Parse SSE stream
             yield* this.parseSSEStream(response, requestController, streamTimeoutMs, request.model);
         }
@@ -536,6 +566,51 @@ export class ModelClient {
             unlinkAbort();
         }
     }
+    async *parseNonStreamingMessage(response, model) {
+        const parsed = await response.json();
+        yield { kind: 'message_start', payload: { message: parsed } };
+        const content = Array.isArray(parsed['content']) ? parsed['content'] : [];
+        for (let index = 0; index < content.length; index++) {
+            const block = content[index];
+            yield { kind: 'content_block_start', payload: { index, content_block: block } };
+            if (block.type === 'text' && typeof block.text === 'string') {
+                yield {
+                    kind: 'content_block_delta',
+                    payload: { index, delta: { type: 'text_delta', text: block.text } },
+                };
+            }
+            else if (block.type === 'thinking' && typeof block.thinking === 'string') {
+                yield {
+                    kind: 'content_block_delta',
+                    payload: { index, delta: { type: 'thinking_delta', thinking: block.thinking } },
+                };
+                if (typeof block.signature === 'string') {
+                    yield {
+                        kind: 'content_block_delta',
+                        payload: { index, delta: { type: 'signature_delta', signature: block.signature } },
+                    };
+                }
+            }
+            else if (block.type === 'tool_use') {
+                yield {
+                    kind: 'content_block_delta',
+                    payload: { index, delta: { type: 'input_json_delta', partial_json: JSON.stringify(block.input ?? {}) } },
+                };
+            }
+            yield { kind: 'content_block_stop', payload: { index } };
+        }
+        yield {
+            kind: 'message_delta',
+            payload: {
+                delta: { stop_reason: parsed['stop_reason'] ?? 'end_turn' },
+                usage: parsed['usage'] ?? {},
+            },
+        };
+        yield { kind: 'message_stop', payload: {} };
+        if (this.debug) {
+            console.error(`[franklin] Parsed non-streaming response for ${model}`);
+        }
+    }
     /**
      * Non-streaming completion for simple requests.
      */

package/dist/commands/start.js

@@ -311,6 +311,7 @@ export async function startCommand(options) {
     }
     // Resolve resume target, if requested.
     let resumeSessionId;
+    let resumeTranscript;
     if (options.resume || options.continue) {
         const { pickSession } = await import('../ui/session-picker.js');
         const { loadSessionMeta, loadSessionHistory } = await import('../session/storage.js');
@@ -338,10 +339,11 @@ export async function startCommand(options) {
         }
         if (resumeSessionId) {
             const meta = loadSessionMeta(resumeSessionId);
-            const msgs = loadSessionHistory(resumeSessionId).length;
+            const history = loadSessionHistory(resumeSessionId);
             const when = meta ? new Date(meta.updatedAt).toLocaleString() : 'unknown';
             console.log(chalk.green(`  Resuming session ${resumeSessionId.slice(0, 24)}…`));
-            console.log(chalk.dim(`  ${msgs} messages · last active ${when}\n`));
+            console.log(chalk.dim(`  ${history.length} messages · last active ${when}\n`));
+            resumeTranscript = buildResumeTranscript(history);
         }
     }
     // Agent config
@@ -376,7 +378,7 @@ export async function startCommand(options) {
     if (process.stdin.isTTY) {
         await runWithInkUI(agentConfig, model, workDir, version, walletInfo, (cb) => {
             onBalanceFetched = cb;
-        }, fetchBalance, importedKickoffPrompt);
+        }, fetchBalance, importedKickoffPrompt, resumeTranscript);
     }
     else {
         await runWithBasicUI(agentConfig, model, workDir, importedKickoffPrompt);
@@ -409,8 +411,40 @@ async function runOneShot(agentConfig, prompt) {
     });
     return exitCode;
 }
+function buildResumeTranscript(history) {
+    const entries = history
+        .map((msg) => {
+        const text = extractVisibleText(msg).replace(/\s+/g, ' ').trim();
+        if (!text)
+            return null;
+        return { role: msg.role, text: text.length > 180 ? `${text.slice(0, 177)}...` : text };
+    })
+        .filter((entry) => entry !== null);
+    if (entries.length === 0)
+        return [];
+    const started = entries.slice(0, 4);
+    const recentStart = entries.length > 10 ? -6 : 4;
+    const recent = entries.slice(recentStart);
+    return entries.length > 10
+        ? [...started, { role: 'assistant', text: '...' }, ...recent]
+        : [...started, ...recent];
+}
+function extractVisibleText(msg) {
+    if (typeof msg.content === 'string')
+        return msg.content;
+    if (!Array.isArray(msg.content))
+        return '';
+    return msg.content
+        .map((part) => {
+        if ('type' in part && part.type === 'text')
+            return part.text;
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
 // ─── Ink UI (interactive terminal) ─────────────────────────────────────────
-async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, onBalanceReady, fetchBalance, initialInput) {
+async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, onBalanceReady, fetchBalance, initialInput, initialTranscript) {
     const startSnapshot = snapshotStats();
     const ui = launchInkUI({
         model,
@@ -418,6 +452,7 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
         version,
         walletAddress: walletInfo?.address,
         walletBalance: walletInfo?.balance,
+        initialTranscript,
         chain: walletInfo?.chain,
         onModelChange: (newModel, reason) => {
             agentConfig.model = newModel;

package/dist/ui/app.d.ts

@@ -20,6 +20,10 @@ export declare function launchInkUI(opts: {
     version: string;
     walletAddress?: string;
     walletBalance?: string;
+    initialTranscript?: Array<{
+        role: 'user' | 'assistant';
+        text: string;
+    }>;
     chain?: string;
     showPicker?: boolean;
     onModelChange?: (model: string, reason?: 'user' | 'system') => void;

package/dist/ui/app.js

@@ -345,7 +345,7 @@ function formatAgentErrorForDisplay(error) {
         out.push(`- Tip: ${tip}`);
     return out.join('\n');
 }
-function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain, startWithPicker, onSubmit, onModelChange, onAbort, onExit, }) {
+function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain, initialTranscript, startWithPicker, onSubmit, onModelChange, onAbort, onExit, }) {
     const { exit } = useApp();
     // Track terminal rows so we can cap the dynamic-region height. Ink wipes the
     // terminal scrollback (via ansiEscapes.clearTerminal → \x1b[3J) whenever the
@@ -362,7 +362,14 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
     // Last completed tool — shown in dynamic area so it can be expanded/collapsed with Tab
     const [expandableTool, setExpandableTool] = useState(null);
     // Full responses committed to Static immediately — goes into terminal scrollback
-    const [committedResponses, setCommittedResponses] = useState([]);
+    const [committedResponses, setCommittedResponses] = useState(() => (initialTranscript ?? []).map((entry, idx) => ({
+        key: `${entry.role === 'user' ? 'user' : 'resume'}-${idx}`,
+        text: entry.role === 'user'
+            ? chalk.hex('#FFD700').bold('❯ ') + chalk.hex('#FFD700').bold(entry.text)
+            : entry.text,
+        tokens: { input: 0, output: 0, calls: 0 },
+        cost: 0,
+    })));
     // Short preview of latest response shown in dynamic area (last ~5 lines, cleared on next turn)
     const [responsePreview, setResponsePreview] = useState('');
     const [currentModel, setCurrentModel] = useState(initialModel || PICKER_MODELS_FLAT[0].id);
@@ -1138,7 +1145,7 @@ export function launchInkUI(opts) {
         restoreTerminalAutoWrap?.();
         instance?.unmount();
     };
-    instance = render(_jsx(RunCodeApp, { initialModel: opts.model, workDir: opts.workDir, walletAddress: opts.walletAddress || 'not set — run: franklin setup', walletBalance: opts.walletBalance || 'unknown', chain: opts.chain || 'base', startWithPicker: opts.showPicker, onSubmit: (value) => {
+    instance = render(_jsx(RunCodeApp, { initialModel: opts.model, workDir: opts.workDir, walletAddress: opts.walletAddress || 'not set — run: franklin setup', walletBalance: opts.walletBalance || 'unknown', initialTranscript: opts.initialTranscript, chain: opts.chain || 'base', startWithPicker: opts.showPicker, onSubmit: (value) => {
             if (resolveInput) {
                 resolveInput(value);
                 resolveInput = null;

package/package.json

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