@blockrun/franklin 3.8.2 → 3.8.3

package/dist/tools/videogen.js

@@ -0,0 +1,237 @@
+/**
+ * Video Generation capability — generate short MP4 videos via the BlockRun
+ * /v1/videos/generations endpoint. Uses x402 payment (Base or Solana).
+ *
+ * Default model `xai/grok-imagine-video` returns an 8-second clip for ~$0.42.
+ * The endpoint is synchronous-over-polling: the HTTP connection stays open
+ * until the upstream xAI job finishes (typically 20–60s, timeout 180s), so
+ * the caller only needs to issue a single POST.
+ */
+import fs from 'node:fs';
+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';
+const DEFAULT_MODEL = 'xai/grok-imagine-video';
+const DEFAULT_DURATION = 8;
+const PRICE_PER_SECOND_USD = 0.05;
+// Long ceiling — the endpoint synchronously waits for xAI's async job (up to
+// ~180s). Give ourselves a bit of headroom for the GCS backup + settle step.
+const GEN_TIMEOUT_MS = 210_000;
+const DOWNLOAD_TIMEOUT_MS = 60_000;
+function estimateVideoCostUsd(durationSeconds = DEFAULT_DURATION) {
+    return Math.max(1, durationSeconds) * PRICE_PER_SECOND_USD;
+}
+function buildExecute(deps) {
+    return async function execute(input, ctx) {
+        const { prompt, output_path, model, image_url, duration_seconds, contentId } = input;
+        if (!prompt)
+            return { output: 'Error: prompt is required', isError: true };
+        const videoModel = model || DEFAULT_MODEL;
+        const duration = duration_seconds ?? DEFAULT_DURATION;
+        const estCost = estimateVideoCostUsd(duration);
+        if (contentId && deps.library) {
+            const content = deps.library.get(contentId);
+            if (!content) {
+                return { output: `Content ${contentId} not found. No USDC was spent.` };
+            }
+            if (content.spentUsd + estCost > content.budgetUsd + 1e-9) {
+                return {
+                    output: `## Video generation skipped\n` +
+                        `- Would exceed budget: spent $${content.spentUsd.toFixed(2)} + estimated ` +
+                        `$${estCost.toFixed(2)} > cap $${content.budgetUsd.toFixed(2)}\n\n` +
+                        `No USDC was spent.`,
+                };
+            }
+        }
+        const chain = loadChain();
+        const apiUrl = API_URLS[chain];
+        const endpoint = `${apiUrl}/v1/videos/generations`;
+        const outPath = output_path
+            ? (path.isAbsolute(output_path) ? output_path : path.resolve(ctx.workingDir, output_path))
+            : path.resolve(ctx.workingDir, `generated-${Date.now()}.mp4`);
+        const body = JSON.stringify({
+            model: videoModel,
+            prompt,
+            ...(image_url ? { image_url } : {}),
+            ...(duration_seconds ? { duration_seconds } : {}),
+        });
+        const headers = {
+            'Content-Type': 'application/json',
+            'User-Agent': `franklin/${VERSION}`,
+        };
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), GEN_TIMEOUT_MS);
+        // Abort on user cancel too
+        const onAbort = () => controller.abort();
+        ctx.abortSignal.addEventListener('abort', onAbort, { once: true });
+        try {
+            let response = await fetch(endpoint, {
+                method: 'POST',
+                signal: controller.signal,
+                headers,
+                body,
+            });
+            if (response.status === 402) {
+                const paymentHeaders = await signPayment(response, chain, endpoint);
+                if (!paymentHeaders) {
+                    return { output: 'Payment failed. Check wallet balance with: franklin balance', isError: true };
+                }
+                response = await fetch(endpoint, {
+                    method: 'POST',
+                    signal: controller.signal,
+                    headers: { ...headers, ...paymentHeaders },
+                    body,
+                });
+            }
+            if (!response.ok) {
+                const errText = await response.text().catch(() => '');
+                return {
+                    output: `Video generation failed (${response.status}): ${errText.slice(0, 300)}`,
+                    isError: true,
+                };
+            }
+            const result = (await response.json());
+            const videoData = result.data?.[0];
+            if (!videoData?.url) {
+                return { output: 'No video URL returned from API', isError: true };
+            }
+            // Download the MP4
+            const dlCtrl = new AbortController();
+            const dlTimeout = setTimeout(() => dlCtrl.abort(), DOWNLOAD_TIMEOUT_MS);
+            const vidResp = await fetch(videoData.url, { signal: dlCtrl.signal });
+            clearTimeout(dlTimeout);
+            if (!vidResp.ok) {
+                return { output: `Video fetched URL but download failed (${vidResp.status}): ${videoData.url}`, isError: true };
+            }
+            const buffer = Buffer.from(await vidResp.arrayBuffer());
+            fs.mkdirSync(path.dirname(outPath), { recursive: true });
+            fs.writeFileSync(outPath, buffer);
+            const fileSize = fs.statSync(outPath).size;
+            const sizeMB = (fileSize / 1_048_576).toFixed(1);
+            const dur = videoData.duration_seconds ?? duration;
+            let contentSummary = '';
+            if (contentId && deps.library) {
+                const rec = deps.library.addAsset(contentId, {
+                    kind: 'video',
+                    source: videoModel,
+                    costUsd: estimateVideoCostUsd(dur),
+                    data: outPath,
+                });
+                if (rec.ok) {
+                    if (deps.onContentChange)
+                        await deps.onContentChange();
+                    const c = deps.library.get(contentId);
+                    contentSummary =
+                        `\n\n## Content updated\n` +
+                            `- Attached to \`${contentId}\` at est. $${estimateVideoCostUsd(dur).toFixed(2)}\n` +
+                            (c
+                                ? `- Spent: $${c.spentUsd.toFixed(2)} / $${c.budgetUsd.toFixed(2)} cap ` +
+                                    `(remaining $${(c.budgetUsd - c.spentUsd).toFixed(2)})`
+                                : '');
+                }
+                else {
+                    contentSummary =
+                        `\n\n## Content NOT updated\n` +
+                            `- ${rec.reason}\n` +
+                            `- The video was generated and saved locally; cost was NOT recorded ` +
+                            `against the content budget.`;
+                }
+            }
+            return {
+                output: `Video saved to ${outPath} (${sizeMB}MB, ${dur}s, ${videoModel})\n\n` +
+                    `Open with: open ${outPath}${contentSummary}`,
+            };
+        }
+        catch (err) {
+            const msg = err.message || '';
+            if (msg.includes('abort')) {
+                return {
+                    output: `Video generation timed out or was aborted (limit ${Math.round(GEN_TIMEOUT_MS / 1000)}s).`,
+                    isError: true,
+                };
+            }
+            return { output: `Error: ${msg}`, isError: true };
+        }
+        finally {
+            clearTimeout(timeout);
+            ctx.abortSignal.removeEventListener('abort', onAbort);
+        }
+    };
+}
+// ─── Payment ───────────────────────────────────────────────────────────────
+async function signPayment(response, chain, endpoint) {
+    try {
+        const paymentHeader = await extractPaymentReq(response);
+        if (!paymentHeader)
+            return null;
+        if (chain === 'solana') {
+            const wallet = await getOrCreateSolanaWallet();
+            const paymentRequired = parsePaymentRequired(paymentHeader);
+            const details = extractPaymentDetails(paymentRequired, SOLANA_NETWORK);
+            const secretBytes = await solanaKeyToBytes(wallet.privateKey);
+            const feePayer = details.extra?.feePayer || details.recipient;
+            const payload = await createSolanaPaymentPayload(secretBytes, wallet.address, details.recipient, details.amount, feePayer, {
+                resourceUrl: details.resource?.url || endpoint,
+                resourceDescription: details.resource?.description || 'Franklin video generation',
+                maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+                extra: details.extra,
+            });
+            return { 'PAYMENT-SIGNATURE': payload };
+        }
+        const wallet = getOrCreateWallet();
+        const paymentRequired = parsePaymentRequired(paymentHeader);
+        const details = extractPaymentDetails(paymentRequired);
+        const payload = await createPaymentPayload(wallet.privateKey, wallet.address, details.recipient, details.amount, details.network || 'eip155:8453', {
+            resourceUrl: details.resource?.url || endpoint,
+            resourceDescription: details.resource?.description || 'Franklin video generation',
+            maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+            extra: details.extra,
+        });
+        return { 'PAYMENT-SIGNATURE': payload };
+    }
+    catch (err) {
+        console.error(`[franklin] Video payment error: ${err.message}`);
+        return null;
+    }
+}
+async function extractPaymentReq(response) {
+    let header = response.headers.get('payment-required');
+    if (!header) {
+        try {
+            const body = (await response.json());
+            if (body.x402 || body.accepts)
+                header = btoa(JSON.stringify(body));
+        }
+        catch { /* ignore */ }
+    }
+    return header;
+}
+// ─── Export ────────────────────────────────────────────────────────────────
+export function createVideoGenCapability(deps = {}) {
+    return {
+        spec: {
+            name: 'VideoGen',
+            description: "Generate a short MP4 video from a text prompt (optional seed image). " +
+                "Calls BlockRun's /v1/videos/generations. Costs USDC — default model " +
+                "xai/grok-imagine-video bills $0.05/s (8s default ≈ $0.42). Generation " +
+                "takes ~20–60s. ALWAYS confirm with the user before calling — videos " +
+                "are expensive and slow. Pass contentId to attach to a Content piece " +
+                "(budget is checked before paying; asset is recorded on success).",
+            input_schema: {
+                type: 'object',
+                properties: {
+                    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)' },
+                    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.' },
+                },
+                required: ['prompt'],
+            },
+        },
+        execute: buildExecute(deps),
+        concurrent: false,
+    };
+}
+export const videoGenCapability = createVideoGenCapability();

package/dist/trading/trade-log.d.ts

@@ -8,8 +8,8 @@
  *   - "Am I up or down over the last 30 days?"
  *   - "How many times did I flip BTC in the last session?"
  *
- * Claude Code and Cursor can't answer any of these — they have no
- * persistent economic memory across sessions. Franklin can.
+ * Coding-only agents can't answer any of these — they have no persistent
+ * economic memory across sessions. Franklin can.
  *
  * Format: one JSON object per line, append-only. Reads parse lazily and
  * skip malformed lines rather than crash, so a partial write from a

package/dist/trading/trade-log.js

@@ -8,8 +8,8 @@
  *   - "Am I up or down over the last 30 days?"
  *   - "How many times did I flip BTC in the last session?"
  *
- * Claude Code and Cursor can't answer any of these — they have no
- * persistent economic memory across sessions. Franklin can.
+ * Coding-only agents can't answer any of these — they have no persistent
+ * economic memory across sessions. Franklin can.
  *
  * Format: one JSON object per line, append-only. Reads parse lazily and
  * skip malformed lines rather than crash, so a partial write from a

package/dist/ui/app.js

@@ -9,7 +9,7 @@ import { render, Static, Box, Text, useApp, useInput, useStdout } from 'ink';
 import Spinner from 'ink-spinner';
 import TextInput from 'ink-text-input';
 import VimInput from './vim-input.js';
-import { renderMarkdown } from './markdown.js';
+import { renderMarkdown, renderMarkdownStreaming } from './markdown.js';
 import { resolveModel, PICKER_CATEGORIES, PICKER_MODELS_FLAT, } from './model-picker.js';
 import { estimateCost } from '../pricing.js';
 import { formatTokens, shortModelName } from '../stats/format.js';
@@ -107,6 +107,13 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
     const pendingTextRef = useRef('');
     const pendingThinkingRef = useRef('');
     const flushTimerRef = useRef(null);
+    // Per-turn reasoning meter: first thinking delta starts the clock, first text
+    // delta (or turn_done) stops it. Persists on the committed response as
+    // "✻ Thought for 3.2s · ~420 tokens" so users see the cost of reasoning even
+    // after the live thinking spinner collapses.
+    const thinkStartRef = useRef(null);
+    const thinkCharsRef = useRef(0);
+    const thinkMsRef = useRef(null);
     const flushPendingText = useCallback(() => {
         flushTimerRef.current = null;
         const text = pendingTextRef.current;
@@ -115,12 +122,19 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
             pendingTextRef.current = '';
             setWaiting(false);
             setThinking(false);
+            // Text started: freeze the reasoning meter
+            if (thinkStartRef.current !== null && thinkMsRef.current === null) {
+                thinkMsRef.current = Date.now() - thinkStartRef.current;
+            }
             setStreamText(prev => prev + text);
         }
         if (thinking) {
             pendingThinkingRef.current = '';
             setWaiting(false);
             setThinking(true);
+            if (thinkStartRef.current === null)
+                thinkStartRef.current = Date.now();
+            thinkCharsRef.current += thinking.length;
             setThinkingText(prev => {
                 const updated = prev + thinking;
                 return updated.length > 500 ? updated.slice(-500) : updated;
@@ -162,6 +176,12 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
     const commitResponse = useCallback((text, tokens = turnTokensRef.current, cost = turnCostRef.current) => {
         if (!text.trim())
             return;
+        // Snapshot the thinking meter for this turn (reset happens in turn_done,
+        // which covers the empty-response-but-thinking case too)
+        const thinkMs = thinkMsRef.current ?? (thinkStartRef.current !== null
+            ? Date.now() - thinkStartRef.current
+            : undefined);
+        const thinkChars = thinkCharsRef.current || undefined;
         setCommittedResponses((rs) => {
             const next = [...rs, {
                     key: String(Date.now() + Math.random()),
@@ -171,6 +191,8 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                     model: turnModelRef.current,
                     tier: turnTierRef.current,
                     savings: turnSavingsRef.current,
+                    thinkMs,
+                    thinkChars,
                 }];
             // Cap at 300 items — older items are already in terminal scrollback
             return next.length > 300 ? next.slice(-300) : next;
@@ -597,6 +619,10 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                             pendingTextRef.current = '';
                         }
                         pendingThinkingRef.current = '';
+                        // Freeze reasoning meter if turn ended while thinking (no text emitted)
+                        if (thinkStartRef.current !== null && thinkMsRef.current === null) {
+                            thinkMsRef.current = Date.now() - thinkStartRef.current;
+                        }
                         // Flush expandable tool to Static before committing response
                         setExpandableTool(prev => {
                             if (prev)
@@ -625,6 +651,10 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                         setWaiting(false);
                         setThinking(false);
                         setThinkingText('');
+                        // Reset reasoning meter for the next turn
+                        thinkStartRef.current = null;
+                        thinkMsRef.current = null;
+                        thinkCharsRef.current = 0;
                         // Trigger balance refresh after each completed turn
                         turnDoneCallbackRef.current?.();
                         // Ring the terminal bell so the user knows the AI finished
@@ -670,7 +700,9 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                                         : _jsx(Text, { color: "green", children: "\u2713" }), ' ', _jsx(Text, { bold: true, children: tool.name }), tool.preview ? _jsxs(Text, { dimColor: true, children: ["(", tool.preview.slice(0, 80), ")"] }) : null, _jsxs(Text, { dimColor: true, children: [" ", elapsedFmt] })] }), tool.diff && !tool.error && tool.diff.oldLines.length <= 8 && tool.diff.newLines.length <= 8 && (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [tool.diff.oldLines.map((line, i) => (_jsxs(Text, { color: "red", wrap: "truncate-end", children: ['⎿  ', "- ", line.slice(0, 120)] }, `old-${i}`))), tool.diff.newLines.map((line, i) => (_jsxs(Text, { color: "green", wrap: "truncate-end", children: ['⎿  ', "+ ", line.slice(0, 120)] }, `new-${i}`)))] })), tool.diff && !tool.error && (tool.diff.oldLines.length > 8 || tool.diff.newLines.length > 8) && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: ['⎿  ', tool.diff.oldLines.length, " lines \u2192 ", tool.diff.newLines.length, " lines"] }) })), tool.error && tool.fullOutput && (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: tool.fullOutput.split('\n').filter(Boolean).slice(0, 3).map((line, i) => (_jsxs(Text, { color: "red", wrap: "truncate-end", children: ['⎿  ', line.slice(0, 120)] }, i))) }))] }, tool.key));
                 } }), _jsx(Static, { items: committedResponses, children: (r) => {
                     const isUserMsg = r.key.startsWith('user-');
-                    return (_jsxs(Box, { flexDirection: "column", children: [!isUserMsg && (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '─'.repeat(60) }) })), isUserMsg && (_jsx(Box, { marginTop: 1 })), _jsx(Box, { paddingLeft: isUserMsg ? 0 : 2, children: _jsx(Text, { wrap: "wrap", children: renderMarkdown(r.text) }) }), (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginLeft: 1, marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: [r.tier && _jsxs(Text, { color: "cyan", children: ["[", r.tier, "] "] }), r.model ? shortModelName(r.model) : '', r.model ? '  ·  ' : '', r.tokens.calls > 0 && r.tokens.input === 0
+                    return (_jsxs(Box, { flexDirection: "column", children: [!isUserMsg && (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '─'.repeat(60) }) })), isUserMsg && (_jsx(Box, { marginTop: 1 })), !isUserMsg && r.thinkMs !== undefined && r.thinkMs >= 500 && (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: "magenta", dimColor: true, children: ["\u273B Thought for ", (r.thinkMs / 1000).toFixed(1), "s", r.thinkChars && r.thinkChars > 20
+                                            ? ` · ~${Math.round(r.thinkChars / 4)} tokens`
+                                            : ''] }) })), _jsx(Box, { paddingLeft: isUserMsg ? 0 : 2, children: _jsx(Text, { wrap: "wrap", children: renderMarkdown(r.text) }) }), (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginLeft: 1, marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: [r.tier && _jsxs(Text, { color: "cyan", children: ["[", r.tier, "] "] }), r.model ? shortModelName(r.model) : '', r.model ? '  ·  ' : '', r.tokens.calls > 0 && r.tokens.input === 0
                                             ? `${r.tokens.calls} calls`
                                             : `${formatTokens(r.tokens.input)} in / ${formatTokens(r.tokens.output)} out`, r.cost > 0 ? `  ·  $${r.cost.toFixed(4)}` : '', r.savings !== undefined && r.savings > 0 ? _jsxs(Text, { color: "green", children: ["  saved ", Math.round(r.savings * 100), "%"] }) : ''] }) }))] }, r.key));
                 } }), permissionRequest && (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 1, children: [_jsx(Text, { color: "yellow", children: "  \u256D\u2500 Permission required \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Text, { color: "yellow", children: ["  \u2502 ", _jsx(Text, { bold: true, children: permissionRequest.toolName })] }), permissionRequest.description.split('\n').map((line, i) => (_jsxs(Text, { dimColor: true, children: ["  \u2502 ", line] }, i))), _jsx(Text, { color: "yellow", children: "  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsx(Box, { marginLeft: 3, children: _jsxs(Text, { children: [_jsx(Text, { bold: true, color: "green", children: "[y]" }), _jsx(Text, { dimColor: true, children: " yes  " }), _jsx(Text, { bold: true, color: "cyan", children: "[a]" }), _jsx(Text, { dimColor: true, children: " always  " }), _jsx(Text, { bold: true, color: "red", children: "[n]" }), _jsx(Text, { dimColor: true, children: " no" })] }) })] })), askUserRequest && (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 1, children: [_jsx(Text, { color: "cyan", children: "  \u256D\u2500 Question \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Text, { color: "cyan", children: ["  \u2502 ", _jsx(Text, { bold: true, children: askUserRequest.question })] }), askUserRequest.options && askUserRequest.options.length > 0 && (askUserRequest.options.map((opt, i) => (_jsxs(Text, { dimColor: true, children: ["  \u2502 ", i + 1, ". ", opt] }, i)))), _jsx(Text, { color: "cyan", children: "  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Box, { marginLeft: 3, children: [_jsx(Text, { bold: true, children: "answer> " }), _jsx(TextInput, { value: askUserInput, onChange: setAskUserInput, onSubmit: (val) => {
@@ -693,7 +725,10 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
             }), thinking && (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Text, { color: "magenta", children: [_jsx(Spinner, { type: "dots" }), ' ', _jsx(Text, { bold: true, children: "thinking" }), completedTools.length > 0 ? _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 step ", completedTools.length + 1] }) : null] }), process.env.FRANKLIN_SHOW_THINKING === '1' && thinkingText && (() => {
                         const lines = thinkingText.split('\n').filter(Boolean).slice(-3);
                         return (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: lines.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ['⎿  ', line.slice(0, 120)] }, i))) }));
-                    })()] })), waiting && !thinking && tools.size === 0 && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), ' ', _jsxs(Text, { dimColor: true, children: [shortModelName(currentModel), completedTools.length > 0 ? ` · step ${completedTools.length + 1}` : ''] })] }) })), streamText && (_jsx(Box, { marginTop: 0, marginBottom: 0, children: _jsx(Text, { wrap: "wrap", children: renderMarkdown(streamText) }) })), responsePreview && !streamText && (_jsx(Box, { flexDirection: "column", marginBottom: 0, children: _jsx(Text, { wrap: "wrap", children: renderMarkdown(responsePreview) }) })), inPicker && (() => {
+                    })()] })), waiting && !thinking && tools.size === 0 && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), ' ', _jsxs(Text, { dimColor: true, children: [shortModelName(currentModel), completedTools.length > 0 ? ` · step ${completedTools.length + 1}` : ''] })] }) })), streamText && (() => {
+                const { rendered, partial } = renderMarkdownStreaming(streamText);
+                return (_jsx(Box, { marginTop: 0, marginBottom: 0, children: _jsxs(Text, { wrap: "wrap", children: [rendered, rendered && partial ? '\n' : '', partial] }) }));
+            })(), responsePreview && !streamText && (_jsx(Box, { flexDirection: "column", marginBottom: 0, children: _jsx(Text, { wrap: "wrap", children: renderMarkdown(responsePreview) }) })), inPicker && (() => {
                 let flatIdx = 0;
                 return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { bold: true, children: "Select a model " }), _jsx(Text, { dimColor: true, children: "(\u2191\u2193 navigate, Enter select, Esc cancel)" })] }), PICKER_CATEGORIES.map((cat) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["\u2500\u2500 ", cat.category, " \u2500\u2500"] }) }), cat.models.map((m) => {
                                     const myIdx = flatIdx++;

package/dist/ui/markdown.d.ts

@@ -9,6 +9,22 @@
  * - Nested blockquotes
  * - Task lists (- [x] done, - [ ] todo)
  */
+/**
+ * Render markdown for a *streaming* buffer: everything up to the last newline
+ * is treated as complete and rendered with full inline formatting; the
+ * trailing partial line is returned as plain text.
+ *
+ * Why this exists: running `renderInline` over a half-written `**bold`,
+ * ``code`` , or `[link](` pair produces broken/unbalanced ANSI, which Ink's
+ * word-wrap then mangles around the wrap boundary (observed as `1mMusic` /
+ * `[Epidemic Sound (https://…)` in terminal output). Keeping the unfinished
+ * line plain until a newline arrives avoids the mid-regex failure mode with
+ * zero latency penalty — the partial line re-renders on the very next delta.
+ */
+export declare function renderMarkdownStreaming(text: string): {
+    rendered: string;
+    partial: string;
+};
 /**
  * Render a complete markdown string to ANSI-colored terminal output.
  */

package/dist/ui/markdown.js

@@ -26,6 +26,27 @@ const LANG_LABELS = {
     swift: 'Swift', kt: 'Kotlin', kotlin: 'Kotlin',
     tsx: 'TSX', jsx: 'JSX',
 };
+/**
+ * Render markdown for a *streaming* buffer: everything up to the last newline
+ * is treated as complete and rendered with full inline formatting; the
+ * trailing partial line is returned as plain text.
+ *
+ * Why this exists: running `renderInline` over a half-written `**bold`,
+ * ``code`` , or `[link](` pair produces broken/unbalanced ANSI, which Ink's
+ * word-wrap then mangles around the wrap boundary (observed as `1mMusic` /
+ * `[Epidemic Sound (https://…)` in terminal output). Keeping the unfinished
+ * line plain until a newline arrives avoids the mid-regex failure mode with
+ * zero latency penalty — the partial line re-renders on the very next delta.
+ */
+export function renderMarkdownStreaming(text) {
+    const lastNl = text.lastIndexOf('\n');
+    if (lastNl === -1)
+        return { rendered: '', partial: text };
+    return {
+        rendered: renderMarkdown(text.slice(0, lastNl)),
+        partial: text.slice(lastNl + 1),
+    };
+}
 /**
  * Render a complete markdown string to ANSI-colored terminal output.
  */
@@ -148,6 +169,9 @@ function renderInline(text) {
         .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, t) => chalk.italic(t))
         // Strikethrough
         .replace(/~~([^~]+)~~/g, (_, t) => chalk.strikethrough(t))
-        // Links — show label in blue, URL dimmed
-        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => chalk.blue.underline(label) + chalk.dim(` (${url})`));
+        // Links — show label in blue, URL dimmed. URL must not contain parens or
+        // whitespace; that's true for almost every real URL (parens in URLs are
+        // percent-encoded) and rejecting the pathological case keeps the regex
+        // greed from eating past a `)` in adjacent prose.
+        .replace(/\[([^\]]+)\]\(([^()\s]+)\)/g, (_, label, url) => chalk.blue.underline(label) + chalk.dim(` (${url})`));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.8.2",
+  "version": "3.8.3",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {
@@ -52,7 +52,10 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/BlockRunAI/franklin"
+    "url": "https://gitlab.com/blockrunai/franklin"
+  },
+  "bugs": {
+    "url": "https://gitlab.com/blockrunai/franklin/-/issues"
   },
   "homepage": "https://Franklin.run",
   "engines": {