@blockrun/franklin 3.8.35 → 3.8.37

package/dist/tools/videogen.d.ts

@@ -3,9 +3,20 @@
  * /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.
+ * Seedance 2.0 (bytedance/seedance-2.0 and -fast) runs longer — up to a few
+ * minutes for a 10s clip.
+ *
+ * Flow (async since blockrun@654cd35):
+ *   1. POST /v1/videos/generations with signed x-payment header. The server
+ *      verifies payment (does NOT settle), submits the upstream job, and
+ *      returns 202 { id, poll_url, status: "queued" }.
+ *   2. GET the poll_url with the SAME x-payment header every ~5s until
+ *      status=completed. On the first completed poll the server backs up
+ *      the MP4 to GCS, settles payment, and returns the video URL.
+ *   3. Download the MP4 and write it locally.
+ *
+ * If the upstream job fails, the server returns status=failed and no USDC
+ * is ever transferred. If the client never polls, no charge either.
  */
 import type { CapabilityHandler } from '../agent/types.js';
 import type { ContentLibrary } from '../content/library.js';

package/dist/tools/videogen.js

@@ -3,9 +3,20 @@
  * /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.
+ * Seedance 2.0 (bytedance/seedance-2.0 and -fast) runs longer — up to a few
+ * minutes for a 10s clip.
+ *
+ * Flow (async since blockrun@654cd35):
+ *   1. POST /v1/videos/generations with signed x-payment header. The server
+ *      verifies payment (does NOT settle), submits the upstream job, and
+ *      returns 202 { id, poll_url, status: "queued" }.
+ *   2. GET the poll_url with the SAME x-payment header every ~5s until
+ *      status=completed. On the first completed poll the server backs up
+ *      the MP4 to GCS, settles payment, and returns the video URL.
+ *   3. Download the MP4 and write it locally.
+ *
+ * If the upstream job fails, the server returns status=failed and no USDC
+ * is ever transferred. If the client never polls, no charge either.
  */
 import fs from 'node:fs';
 import path from 'node:path';
@@ -13,12 +24,17 @@ import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, creat
 import { loadChain, API_URLS, VERSION } from '../config.js';
 import { ModelClient } from '../agent/llm.js';
 import { analyzeMediaRequest, renderProposalForAskUser } from '../agent/media-router.js';
+import { recordUsage } from '../stats/tracker.js';
+import { findModel, estimateCostUsd } from '../gateway-models.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;
+// POST submit is fast (~3-20s). Generation is async upstream (60-300s for
+// Seedance, 20-90s for Grok). We poll until completed, then download. The
+// server signs authorizations for 600s — keep the overall budget below that.
+const SUBMIT_TIMEOUT_MS = 30_000;
+const POLL_INTERVAL_MS = 5_000;
+const POLL_MAX_WAIT_MS = 480_000; // 8 min — covers Seedance worst case
 const DOWNLOAD_TIMEOUT_MS = 60_000;
 function estimateVideoCostUsd(durationSeconds = DEFAULT_DURATION) {
     return Math.max(1, durationSeconds) * PRICE_PER_SECOND_USD;
@@ -121,26 +137,32 @@ function buildExecute(deps) {
             '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 });
+        const onAbort = (ctrl) => () => ctrl.abort();
+        // Phase 1: submit the job. First POST triggers a 402; we sign and retry.
+        // The signed paymentHeaders must be reused on every GET poll — the server
+        // uses the authorization to verify identity on each poll and settles on
+        // the first completed response.
+        const submitCtrl = new AbortController();
+        const submitTimeout = setTimeout(() => submitCtrl.abort(), SUBMIT_TIMEOUT_MS);
+        const submitAbort = onAbort(submitCtrl);
+        ctx.abortSignal.addEventListener('abort', submitAbort, { once: true });
+        let paymentHeaders = null;
+        let submitResult;
         try {
             let response = await fetch(endpoint, {
                 method: 'POST',
-                signal: controller.signal,
+                signal: submitCtrl.signal,
                 headers,
                 body,
             });
             if (response.status === 402) {
-                const paymentHeaders = await signPayment(response, chain, endpoint);
+                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,
+                    signal: submitCtrl.signal,
                     headers: { ...headers, ...paymentHeaders },
                     body,
                 });
@@ -148,22 +170,71 @@ function buildExecute(deps) {
             if (!response.ok) {
                 const errText = await response.text().catch(() => '');
                 return {
-                    output: `Video generation failed (${response.status}): ${errText.slice(0, 300)}`,
+                    output: `Video submit 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 };
+            submitResult = await response.json();
+        }
+        catch (err) {
+            const msg = err.message || '';
+            if (msg.includes('abort')) {
+                return {
+                    output: `Video submit timed out or was aborted after ${Math.round(SUBMIT_TIMEOUT_MS / 1000)}s.`,
+                    isError: true,
+                };
             }
+            return { output: `Error submitting video job: ${msg}`, isError: true };
+        }
+        finally {
+            clearTimeout(submitTimeout);
+            ctx.abortSignal.removeEventListener('abort', submitAbort);
+        }
+        if (!submitResult.poll_url || !paymentHeaders) {
+            return { output: 'API did not return a poll_url for the video job', isError: true };
+        }
+        // Phase 2: poll GET /v1/videos/generations/{id} with the SAME signed
+        // x-payment header until the job completes. Server settles on the first
+        // completed poll and returns the backed-up video URL.
+        const origin = new URL(apiUrl).origin;
+        const pollEndpoint = submitResult.poll_url.startsWith('http')
+            ? submitResult.poll_url
+            : `${origin}${submitResult.poll_url}`;
+        const outcome = await pollUntilReady(pollEndpoint, { ...headers, ...paymentHeaders }, ctx.abortSignal);
+        if (outcome.kind === 'timed_out') {
+            return {
+                output: `Video generation did not complete within ${Math.round(POLL_MAX_WAIT_MS / 1000)}s. ` +
+                    `No USDC was charged (settlement only fires on completion).`,
+                isError: true,
+            };
+        }
+        if (outcome.kind === 'failed') {
+            return {
+                output: `Video generation failed upstream: ${outcome.error ?? 'unknown error'}. No USDC was charged.`,
+                isError: true,
+            };
+        }
+        const videoData = outcome.data;
+        const videoUrl = videoData.url;
+        if (!videoUrl) {
+            return { output: 'No video URL returned from API', isError: true };
+        }
+        try {
             // 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);
+            const dlAbort = onAbort(dlCtrl);
+            ctx.abortSignal.addEventListener('abort', dlAbort, { once: true });
+            let vidResp;
+            try {
+                vidResp = await fetch(videoUrl, { signal: dlCtrl.signal });
+            }
+            finally {
+                clearTimeout(dlTimeout);
+                ctx.abortSignal.removeEventListener('abort', dlAbort);
+            }
             if (!vidResp.ok) {
-                return { output: `Video fetched URL but download failed (${vidResp.status}): ${videoData.url}`, isError: true };
+                return { output: `Video fetched URL but download failed (${vidResp.status}): ${videoUrl}`, isError: true };
             }
             const buffer = Buffer.from(await vidResp.arrayBuffer());
             fs.mkdirSync(path.dirname(outPath), { recursive: true });
@@ -171,6 +242,21 @@ function buildExecute(deps) {
             const fileSize = fs.statSync(outPath).size;
             const sizeMB = (fileSize / 1_048_576).toFixed(1);
             const dur = videoData.duration_seconds ?? duration;
+            // Stats: record this generation so it shows up in `franklin insights`
+            // alongside chat spend. Before this, media generations bypassed
+            // recordUsage entirely, so the insights panel under-reported total
+            // spend and never surfaced video models in its "top models" list.
+            // Prefer the live gateway price when the model is in the catalog;
+            // fall back to the legacy $0.05/s estimate otherwise. Fire-and-
+            // forget — stats write must not fail a user-visible generation.
+            void (async () => {
+                try {
+                    const m = await findModel(videoModel);
+                    const estCost = m ? estimateCostUsd(m, { duration_seconds: dur }) : estimateVideoCostUsd(dur);
+                    recordUsage(videoModel, 0, 0, estCost, 0);
+                }
+                catch { /* ignore stats errors */ }
+            })();
             let contentSummary = '';
             if (contentId && deps.library) {
                 const rec = deps.library.addAsset(contentId, {
@@ -208,18 +294,63 @@ function buildExecute(deps) {
             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).`,
+                    output: `Video download timed out or was aborted after ${Math.round(DOWNLOAD_TIMEOUT_MS / 1000)}s.`,
                     isError: true,
                 };
             }
             return { output: `Error: ${msg}`, isError: true };
         }
-        finally {
-            clearTimeout(timeout);
-            ctx.abortSignal.removeEventListener('abort', onAbort);
-        }
     };
 }
+/**
+ * Poll the GET /v1/videos/generations/{id} endpoint until the job reaches a
+ * terminal state. Reuses the caller's signed x-payment header verbatim on
+ * every request — the server verifies the same authorization each poll and
+ * settles on the first completed response.
+ */
+async function pollUntilReady(pollEndpoint, headers, userAbort) {
+    const deadline = Date.now() + POLL_MAX_WAIT_MS;
+    while (Date.now() < deadline) {
+        if (userAbort.aborted)
+            throw new Error('aborted');
+        const resp = await fetch(pollEndpoint, { method: 'GET', headers, signal: userAbort });
+        // 202 = still queued/in_progress; 200 = completed or failed.
+        if (resp.status === 202 || resp.status === 200) {
+            const body = (await resp.json().catch(() => ({})));
+            if (body.status === 'completed' && body.data?.[0]?.url) {
+                return { kind: 'completed', data: body.data[0] };
+            }
+            if (body.status === 'failed') {
+                return { kind: 'failed', error: body.error };
+            }
+            // queued / in_progress — sleep and try again.
+        }
+        else if (resp.status === 429 || resp.status >= 500) {
+            // Transient — back off briefly. Fall through to the sleep below.
+        }
+        else {
+            const text = await resp.text().catch(() => '');
+            throw new Error(`Poll failed (${resp.status}): ${text.slice(0, 300)}`);
+        }
+        await sleep(POLL_INTERVAL_MS, userAbort);
+    }
+    return { kind: 'timed_out' };
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted)
+            return reject(new Error('aborted'));
+        const t = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(t);
+            reject(new Error('aborted'));
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
 // ─── Payment ───────────────────────────────────────────────────────────────
 async function signPayment(response, chain, endpoint) {
     try {
@@ -235,7 +366,9 @@ async function signPayment(response, chain, endpoint) {
             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,
+                // Video poll can take up to 8 min; honor the server's advertised
+                // value (blockrun sends 600s) and fall back to 600 not 300.
+                maxTimeoutSeconds: details.maxTimeoutSeconds || 600,
                 extra: details.extra,
             });
             return { 'PAYMENT-SIGNATURE': payload };

package/dist/tools/webhook.js

@@ -15,6 +15,7 @@
  * session.
  */
 import { isIP } from 'node:net';
+import { VERSION } from '../config.js';
 const DEFAULT_TIMEOUT_MS = 15_000;
 const MAX_BODY_BYTES = 512 * 1024; // 512 KB is generous for a chat push.
 function isPrivateHost(hostname) {
@@ -101,7 +102,7 @@ async function execute(input, ctx) {
     }
     const finalHeaders = {
         'Content-Type': contentType,
-        'User-Agent': 'franklin/3.8.9 (webhook)',
+        'User-Agent': `franklin/${VERSION} (webhook)`,
         ...(headers ?? {}),
     };
     const ctrl = new AbortController();

package/dist/trading/providers/coingecko/client.js

@@ -6,8 +6,9 @@
  * cooldown, user-agent, timeout, and in-memory cache.
  */
 import { recordFetch } from '../telemetry.js';
+import { VERSION } from '../../../config.js';
 const BASE = 'https://api.coingecko.com/api/v3';
-const UA = 'franklin/3.8.9 (trading)';
+const UA = `franklin/${VERSION} (trading)`;
 const TIMEOUT_MS = 10_000;
 // Ticker → CoinGecko slug. Not exhaustive; unknown tickers fall through to
 // lowercase and let CoinGecko either accept the slug or 404.

package/dist/ui/app.js

@@ -509,7 +509,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
     }, []);
     // Expose event handler, balance updater, and permission bridge
     useEffect(() => {
-        globalThis.__runcode_ui = {
+        globalThis.__franklin_ui = {
             updateModel: (model) => { setCurrentModel(model); },
             updateBalance: (bal) => {
                 setBalance(bal);
@@ -703,7 +703,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                             setQueuedInputs((prev) => prev.slice(1));
                             // Small delay so React can flush the ready=true state first
                             setTimeout(() => {
-                                const fn = globalThis.__runcode_submit;
+                                const fn = globalThis.__franklin_submit;
                                 if (typeof fn === 'function')
                                     fn(queued);
                             }, 50);
@@ -713,12 +713,12 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                 }
             },
         };
-        globalThis.__runcode_submit = (msg) => {
+        globalThis.__franklin_submit = (msg) => {
             handleSubmit(msg);
         };
         return () => {
-            delete globalThis.__runcode_ui;
-            delete globalThis.__runcode_submit;
+            delete globalThis.__franklin_ui;
+            delete globalThis.__franklin_submit;
         };
     }, [handleSubmit, commitResponse, showStatus]);
     // ── Render ──
@@ -781,7 +781,7 @@ export function launchInkUI(opts) {
     let pendingInput = null; // Queue for inputs that arrive before waitForInput
     let exiting = false;
     let abortCallback = null;
-    const instance = render(_jsx(RunCodeApp, { initialModel: opts.model, workDir: opts.workDir, walletAddress: opts.walletAddress || 'not set — run: runcode setup', walletBalance: opts.walletBalance || 'unknown', chain: opts.chain || 'base', startWithPicker: opts.showPicker, onSubmit: (value) => {
+    const 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) => {
             if (resolveInput) {
                 resolveInput(value);
                 resolveInput = null;
@@ -799,19 +799,19 @@ export function launchInkUI(opts) {
         } }));
     return {
         handleEvent: (event) => {
-            const ui = globalThis.__runcode_ui;
+            const ui = globalThis.__franklin_ui;
             ui?.handleEvent(event);
         },
         updateModel: (model) => {
-            const ui = globalThis.__runcode_ui;
+            const ui = globalThis.__franklin_ui;
             ui?.updateModel(model);
         },
         updateBalance: (bal) => {
-            const ui = globalThis.__runcode_ui;
+            const ui = globalThis.__franklin_ui;
             ui?.updateBalance(bal);
         },
         onTurnDone: (cb) => {
-            const ui = globalThis.__runcode_ui;
+            const ui = globalThis.__franklin_ui;
             ui?.onTurnDone(cb);
         },
         waitForInput: () => {
@@ -828,11 +828,11 @@ export function launchInkUI(opts) {
         onAbort: (cb) => { abortCallback = cb; },
         cleanup: () => { mouse.disable(); instance.unmount(); },
         requestPermission: (toolName, description) => {
-            const ui = globalThis.__runcode_ui;
+            const ui = globalThis.__franklin_ui;
             return ui?.requestPermission(toolName, description) ?? Promise.resolve('no');
         },
         requestAskUser: (question, options) => {
-            const ui = globalThis.__runcode_ui;
+            const ui = globalThis.__franklin_ui;
             return ui?.requestAskUser(question, options) ?? Promise.resolve('(no response)');
         },
     };

package/dist/ui/model-picker.js

@@ -19,9 +19,11 @@ export const MODEL_SHORTCUTS = {
     'opus-4.6': 'anthropic/claude-opus-4.6',
     haiku: 'anthropic/claude-haiku-4.5-20251001',
     // OpenAI
-    gpt: 'openai/gpt-5.4',
-    gpt5: 'openai/gpt-5.4',
-    'gpt-5': 'openai/gpt-5.4',
+    // `gpt` / `gpt5` / `gpt-5` follow the gateway's flagship — currently 5.5.
+    gpt: 'openai/gpt-5.5',
+    gpt5: 'openai/gpt-5.5',
+    'gpt-5': 'openai/gpt-5.5',
+    'gpt-5.5': 'openai/gpt-5.5',
     'gpt-5.4': 'openai/gpt-5.4',
     'gpt-5.4-pro': 'openai/gpt-5.4-pro',
     'gpt-5.3': 'openai/gpt-5.3',
@@ -107,7 +109,8 @@ export const PICKER_CATEGORIES = [
             { id: 'anthropic/claude-opus-4.7', shortcut: 'opus', label: 'Claude Opus 4.7', price: '$5/$25', highlight: true },
             { id: 'anthropic/claude-sonnet-4.6', shortcut: 'sonnet', label: 'Claude Sonnet 4.6', price: '$3/$15' },
             { id: 'anthropic/claude-opus-4.6', shortcut: 'opus-4.6', label: 'Claude Opus 4.6', price: '$5/$25' },
-            { id: 'openai/gpt-5.4', shortcut: 'gpt', label: 'GPT-5.4', price: '$2.5/$15' },
+            { id: 'openai/gpt-5.5', shortcut: 'gpt', label: 'GPT-5.5', price: '$5/$30', highlight: true },
+            { id: 'openai/gpt-5.4', shortcut: 'gpt-5.4', label: 'GPT-5.4', price: '$2.5/$15' },
             { id: 'openai/gpt-5.4-pro', shortcut: 'gpt-5.4-pro', label: 'GPT-5.4 Pro', price: '$30/$180' },
             { id: 'google/gemini-2.5-pro', shortcut: 'gemini', label: 'Gemini 2.5 Pro', price: '$1.25/$10' },
             { id: 'google/gemini-3.1-pro', shortcut: 'gemini-3', label: 'Gemini 3.1 Pro', price: '$2/$12' },

package/dist/wallet/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Public wallet surface for `@blockrun/franklin/wallet`.
+ *
+ * Thin pass-through over Franklin's wallet/manager helpers plus the
+ * lower-level primitives from `@blockrun/llm` that downstream code
+ * typically needs (setup, address, load/save, funding messages, types).
+ *
+ * Modelled after the flat wallet surface in `@blockrun/clawrouter` —
+ * but exposed under a subpath because Franklin's `.` entry is a CLI
+ * (side-effectful shebang) and can't double as a library.
+ */
+export { walletExists, setupWallet, setupSolanaWallet, getAddress, } from './manager.js';
+export { getOrCreateWallet, getOrCreateSolanaWallet, setupAgentWallet, setupAgentSolanaWallet, createWallet, createSolanaWallet, } from '@blockrun/llm';
+export { getWalletAddress, scanWallets, scanSolanaWallets, loadWallet, loadSolanaWallet, saveWallet, saveSolanaWallet, } from '@blockrun/llm';
+export { formatWalletCreatedMessage, formatNeedsFundingMessage, formatFundingMessageCompact, getEip681Uri, getPaymentLinks, } from '@blockrun/llm';
+export { WALLET_DIR_PATH, WALLET_FILE_PATH, SOLANA_WALLET_FILE_PATH, } from '@blockrun/llm';
+export type { WalletInfo, SolanaWalletInfo, PaymentLinks, } from '@blockrun/llm';

package/dist/wallet/index.js

@@ -0,0 +1,22 @@
+/**
+ * Public wallet surface for `@blockrun/franklin/wallet`.
+ *
+ * Thin pass-through over Franklin's wallet/manager helpers plus the
+ * lower-level primitives from `@blockrun/llm` that downstream code
+ * typically needs (setup, address, load/save, funding messages, types).
+ *
+ * Modelled after the flat wallet surface in `@blockrun/clawrouter` —
+ * but exposed under a subpath because Franklin's `.` entry is a CLI
+ * (side-effectful shebang) and can't double as a library.
+ */
+export { walletExists, setupWallet, setupSolanaWallet, getAddress, } from './manager.js';
+// ─── Re-exports from @blockrun/llm ────────────────────────────────────────
+// So callers only need one import: `@blockrun/franklin/wallet`.
+// Setup / create
+export { getOrCreateWallet, getOrCreateSolanaWallet, setupAgentWallet, setupAgentSolanaWallet, createWallet, createSolanaWallet, } from '@blockrun/llm';
+// Query / load / save
+export { getWalletAddress, scanWallets, scanSolanaWallets, loadWallet, loadSolanaWallet, saveWallet, saveSolanaWallet, } from '@blockrun/llm';
+// Funding / payment link helpers
+export { formatWalletCreatedMessage, formatNeedsFundingMessage, formatFundingMessageCompact, getEip681Uri, getPaymentLinks, } from '@blockrun/llm';
+// File-system paths (useful for dotfiles / migration scripts)
+export { WALLET_DIR_PATH, WALLET_FILE_PATH, SOLANA_WALLET_FILE_PATH, } from '@blockrun/llm';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.8.35",
+  "version": "3.8.37",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {
@@ -12,11 +12,14 @@
       "types": "./dist/plugin-sdk/index.d.ts",
       "default": "./dist/plugin-sdk/index.js"
     },
+    "./wallet": {
+      "types": "./dist/wallet/index.d.ts",
+      "default": "./dist/wallet/index.js"
+    },
     "./package.json": "./package.json"
   },
   "bin": {
-    "franklin": "dist/index.js",
-    "runcode": "dist/index.js"
+    "franklin": "dist/index.js"
   },
   "files": [
     "dist",
@@ -47,8 +50,7 @@
     "ai-marketing",
     "ai-trading",
     "crypto-native",
-    "blockrun",
-    "runcode"
+    "blockrun"
   ],
   "license": "Apache-2.0",
   "repository": {