@blockrun/franklin 3.6.20 → 3.6.22

package/dist/agent/error-classifier.js

@@ -28,9 +28,12 @@ export function classifyAgentError(message) {
     if (includesAny(err, [
         '401',
         'unauthorized',
+        'unauthenticated',
+        'not authenticated',
         'invalid api key',
         'invalid x-api-key',
         'authentication failed',
+        'authentication required',
     ])) {
         return {
             category: 'auth', label: 'Auth', isTransient: false,

package/dist/commands/daemon.js

@@ -22,15 +22,24 @@ function isRunning(pid) {
     catch {
         return false;
     }
-    // PID may have been recycled to an unrelated process. Confirm the
-    // command line actually looks like Franklin before trusting the PID.
+    // PID may have been recycled. Try to confirm command line looks like Franklin.
+    // Platform fallbacks (some env lack `ps`): Linux /proc → ps → give up.
+    try {
+        // Linux (including Alpine/busybox containers) exposes /proc/<pid>/cmdline
+        const procCmdline = `/proc/${pid}/cmdline`;
+        if (fs.existsSync(procCmdline)) {
+            const raw = fs.readFileSync(procCmdline, 'utf-8').replace(/\0/g, ' ').trim();
+            return /franklin|runcode|node.*dist\/index/.test(raw);
+        }
+    }
+    catch { /* fall through to ps */ }
     try {
         const { execSync } = require('node:child_process');
         const cmd = execSync(`ps -p ${pid} -o command=`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
         return /franklin|runcode|node.*dist\/index/.test(cmd);
     }
     catch {
-        // ps failed — fall back to assuming PID is ours (conservative, avoids false "running")
+        // No ps, no /proc — give up and trust the kill-0 check
         return true;
     }
 }

package/dist/commands/panel.js

@@ -5,13 +5,13 @@ import chalk from 'chalk';
 import { createPanelServer } from '../panel/server.js';
 export async function panelCommand(options) {
     const requestedPort = parseInt(options.port || '3100', 10);
-    // Handle port-in-use by trying up to 20 subsequent ports.
+    // Handle port-in-use by trying up to 20 subsequent ports silently.
+    // Only log when we finally bind (or fail completely) — no per-attempt spam.
     const MAX_ATTEMPTS = 20;
     const tryListen = (port, attempt) => {
         const server = createPanelServer(port);
         server.on('error', (err) => {
             if (err.code === 'EADDRINUSE' && attempt < MAX_ATTEMPTS) {
-                console.log(chalk.yellow(`  Port ${port} busy — trying ${port + 1}...`));
                 tryListen(port + 1, attempt + 1);
                 return;
             }
@@ -25,7 +25,8 @@ export async function panelCommand(options) {
         server.listen(port, () => {
             console.log('');
             console.log(chalk.bold('  Franklin Panel'));
-            console.log(chalk.dim(`  http://localhost:${port}`));
+            console.log(chalk.dim(`  http://localhost:${port}`) +
+                (port !== requestedPort ? chalk.yellow(`  (fell back from ${requestedPort})`) : ''));
             console.log('');
             console.log(chalk.dim('  Press Ctrl+C to stop.'));
             console.log('');

package/dist/mcp/client.js

@@ -7,6 +7,40 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 // ─── Connection Management ────────────────────────────────────────────────
 const connections = new Map();
+/**
+ * Sanitize a JSON schema for strict LLM providers (OpenAI o3, etc.).
+ * Walks the schema tree and adds `items` to any array missing it.
+ * Without this, models like o3 reject the tool with:
+ *   "Invalid schema: In context=(...), array schema missing items."
+ */
+function sanitizeSchema(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return { type: 'object', properties: {} };
+    }
+    const s = schema;
+    // If array type without items, add a permissive default
+    if (s.type === 'array' && !s.items) {
+        s.items = {};
+    }
+    // Recurse into properties
+    if (s.properties && typeof s.properties === 'object') {
+        const props = s.properties;
+        for (const key of Object.keys(props)) {
+            props[key] = sanitizeSchema(props[key]);
+        }
+    }
+    // Recurse into items (nested arrays)
+    if (s.items && typeof s.items === 'object') {
+        s.items = sanitizeSchema(s.items);
+    }
+    // Recurse into anyOf / oneOf / allOf
+    for (const key of ['anyOf', 'oneOf', 'allOf']) {
+        if (Array.isArray(s[key])) {
+            s[key] = s[key].map(sanitizeSchema);
+        }
+    }
+    return s;
+}
 /**
  * Connect to an MCP server via stdio transport.
  * Discovers tools and returns them as CapabilityHandlers.
@@ -47,10 +81,7 @@ async function connectStdio(name, config) {
             spec: {
                 name: toolName,
                 description: toolDescription || `MCP tool from ${name}`,
-                input_schema: tool.inputSchema || {
-                    type: 'object',
-                    properties: {},
-                },
+                input_schema: sanitizeSchema(tool.inputSchema),
             },
             execute: async (input, _ctx) => {
                 const MCP_TOOL_TIMEOUT = 30_000;

package/dist/session/storage.js

@@ -95,10 +95,27 @@ export function updateSessionMeta(sessionId, meta) {
         };
         // Atomic write: tmp file + rename. Prevents corruption when parent
         // and sub-agent update the same session meta concurrently.
+        // On Windows, renameSync can throw EEXIST/EPERM on older filesystems —
+        // fall back to a direct write (non-atomic but still functional) and
+        // clean up the orphan tmp file.
         const target = metaPath(sessionId);
         const tmp = target + '.tmp';
-        fs.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-        fs.renameSync(tmp, target);
+        const payload = JSON.stringify(updated, null, 2);
+        try {
+            fs.writeFileSync(tmp, payload);
+            fs.renameSync(tmp, target);
+        }
+        catch {
+            // Best-effort: clean up the orphan tmp, then write target directly.
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch { /* may not exist */ }
+            try {
+                fs.writeFileSync(target, payload);
+            }
+            catch { /* give up; stats just get stale */ }
+        }
     });
 }
 /**

package/dist/tools/task.js

@@ -130,10 +130,12 @@ export const taskCapability = {
                 },
                 addBlocks: {
                     type: 'array',
+                    items: { type: 'number' },
                     description: 'Task IDs that cannot start until this task completes (for update)',
                 },
                 addBlockedBy: {
                     type: 'array',
+                    items: { type: 'number' },
                     description: 'Task IDs that must complete before this task can start (for update)',
                 },
             },

package/dist/ui/app.js

@@ -657,7 +657,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                 const elapsed = Math.round((Date.now() - tool.startTime) / 1000);
                 const elapsedStr = elapsed > 0 ? ` ${elapsed}s` : '';
                 return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), ' ', _jsx(Text, { bold: true, color: "cyan", children: tool.name }), tool.preview ? _jsxs(Text, { dimColor: true, children: ["(", tool.preview.slice(0, 70), ")"] }) : null, _jsx(Text, { dimColor: true, children: elapsedStr })] }), tool.liveLines.length > 0 && (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: tool.liveLines.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ['⎿  ', line.slice(0, 120)] }, i))) }))] }, id));
-            }), 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] }), thinkingText && (() => {
+            }), 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 && (() => {

package/package.json

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