@blockrun/franklin 3.3.2 → 3.5.0

package/dist/agent/llm.d.ts

@@ -1,5 +1,5 @@
 /**
- * LLM Client for runcode
+ * LLM Client for Franklin
  * Calls BlockRun API directly with x402 payment handling and streaming.
  * Original implementation — not derived from any existing codebase.
  */
@@ -42,6 +42,13 @@ export declare class ModelClient {
      * Yields parsed SSE chunks as they arrive.
      * Handles x402 payment automatically on 402 responses.
      */
+    /**
+     * Resolve virtual routing profiles (blockrun/auto, blockrun/eco, etc.)
+     * to concrete models. This is the final safety net — if the router in
+     * loop.ts didn't resolve it (e.g. old global install without router),
+     * we resolve it here before hitting the API.
+     */
+    private resolveVirtualModel;
     streamCompletion(request: ModelRequest, signal?: AbortSignal): AsyncGenerator<StreamChunk>;
     /**
      * Non-streaming completion for simple requests.

package/dist/agent/llm.js

@@ -1,5 +1,5 @@
 /**
- * LLM Client for runcode
+ * LLM Client for Franklin
  * Calls BlockRun API directly with x402 payment handling and streaming.
  * Original implementation — not derived from any existing codebase.
  */
@@ -82,7 +82,44 @@ export class ModelClient {
      * Yields parsed SSE chunks as they arrive.
      * Handles x402 payment automatically on 402 responses.
      */
+    /**
+     * Resolve virtual routing profiles (blockrun/auto, blockrun/eco, etc.)
+     * to concrete models. This is the final safety net — if the router in
+     * loop.ts didn't resolve it (e.g. old global install without router),
+     * we resolve it here before hitting the API.
+     */
+    resolveVirtualModel(model) {
+        if (!model.startsWith('blockrun/'))
+            return model;
+        // Import router dynamically to avoid circular deps
+        try {
+            const { routeRequest, parseRoutingProfile } = require('../router/index.js');
+            const profile = parseRoutingProfile(model);
+            if (profile) {
+                const result = routeRequest('', profile);
+                if (result?.model && !result.model.startsWith('blockrun/')) {
+                    return result.model;
+                }
+            }
+        }
+        catch {
+            // Router not available (e.g. old build) — use hardcoded fallback table
+        }
+        // Static fallback if router is unavailable
+        const FALLBACKS = {
+            'blockrun/auto': 'zai/glm-5.1',
+            'blockrun/eco': 'nvidia/nemotron-ultra-253b',
+            'blockrun/premium': 'anthropic/claude-sonnet-4.6',
+            'blockrun/free': 'nvidia/nemotron-ultra-253b',
+        };
+        return FALLBACKS[model] || 'zai/glm-5.1';
+    }
     async *streamCompletion(request, signal) {
+        // Resolve virtual models before any API call
+        const resolvedModel = this.resolveVirtualModel(request.model);
+        if (resolvedModel !== request.model) {
+            request = { ...request, model: resolvedModel };
+        }
         const isAnthropic = request.model.startsWith('anthropic/');
         const isGLM = request.model.startsWith('zai/') || request.model.includes('glm');
         // Build the request payload, injecting model-specific optimizations
@@ -100,6 +137,27 @@ export class ModelClient {
             }
         }
         if (isAnthropic) {
+            // ─ Anthropic extended thinking ──────────────────────────────────────
+            // Enable thinking for Claude models that support it (Opus 4.6, Sonnet 4.6).
+            // This is the single biggest quality lever — Claude with thinking enabled
+            // is dramatically better at complex multi-step tasks, reasoning, and code.
+            //
+            // Uses adaptive thinking: the model decides how much to think per request.
+            // budget_tokens is the MAX it can use (not a minimum), so the model won't
+            // waste tokens on simple tasks. Set to 80% of max_tokens to leave room
+            // for the actual response.
+            const supportsThinking = request.model.includes('opus') ||
+                request.model.includes('sonnet-4') ||
+                request.model.includes('sonnet-3.7');
+            if (supportsThinking) {
+                const maxOut = (request.max_tokens ?? 16_384);
+                requestPayload['thinking'] = {
+                    type: 'enabled',
+                    budget_tokens: Math.min(maxOut, 16_384), // Cap thinking budget — most benefit comes from first few K tokens
+                };
+                // Extended thinking requires temperature=1 on Anthropic API
+                requestPayload['temperature'] = 1;
+            }
             // ─ Anthropic prompt caching: `system_and_3` strategy ─────────────────
             // 4 cache_control breakpoints (Anthropic max):
             //   1. System prompt (stable across turns)
@@ -110,6 +168,20 @@ export class ModelClient {
             // multi-turn conversations. Pattern adopted from nousresearch/hermes-agent.
             requestPayload = applyAnthropicPromptCaching(requestPayload, request);
         }
+        // ── GPT-5 / Codex: use "developer" role for system prompt ──────────────
+        // OpenAI GPT models give stronger instruction-following weight to the
+        // "developer" role. Move the top-level system prompt into messages[0]
+        // with role "developer" instead of the default "system".
+        const isGPT5OrCodex = request.model.includes('gpt-5') || request.model.includes('codex');
+        if (isGPT5OrCodex && typeof request.system === 'string' && request.system.length > 0) {
+            const systemRole = 'developer';
+            const existingMessages = requestPayload['messages'] || [];
+            requestPayload['messages'] = [
+                { role: systemRole, content: request.system },
+                ...existingMessages,
+            ];
+            delete requestPayload['system'];
+        }
         const body = JSON.stringify(requestPayload);
         const endpoint = `${this.apiUrl}/v1/messages`;
         const headers = {
@@ -118,12 +190,12 @@ export class ModelClient {
             'x-api-key': 'x402-agent-handles-auth',
             'User-Agent': USER_AGENT,
         };
-        // Enable prompt caching beta for Anthropic models
+        // Enable prompt caching + extended thinking betas for Anthropic models
         if (isAnthropic) {
             headers['anthropic-beta'] = 'prompt-caching-2024-07-31';
         }
         if (this.debug) {
-            console.error(`[runcode] POST ${endpoint} model=${request.model}`);
+            console.error(`[franklin] POST ${endpoint} model=${request.model}`);
         }
         let response = await fetch(endpoint, {
             method: 'POST',
@@ -134,7 +206,7 @@ export class ModelClient {
         // Handle x402 payment
         if (response.status === 402) {
             if (this.debug)
-                console.error('[runcode] Payment required — signing...');
+                console.error('[franklin] Payment required — signing...');
             const paymentHeader = await this.signPayment(response);
             if (!paymentHeader) {
                 yield { kind: 'error', payload: { message: 'Payment signing failed' } };
@@ -175,6 +247,7 @@ export class ModelClient {
         // Accumulate from stream
         let currentText = '';
         let currentThinking = '';
+        let currentThinkingSignature = '';
         let currentToolId = '';
         let currentToolName = '';
         let currentToolInput = '';
@@ -190,6 +263,7 @@ export class ModelClient {
                     }
                     else if (cblock?.type === 'thinking') {
                         currentThinking = '';
+                        currentThinkingSignature = '';
                     }
                     else if (cblock?.type === 'text') {
                         currentText = '';
@@ -212,6 +286,10 @@ export class ModelClient {
                         if (text)
                             onStreamDelta?.({ type: 'thinking', text });
                     }
+                    else if (delta.type === 'signature_delta') {
+                        // Accumulate signature for multi-turn thinking continuity
+                        currentThinkingSignature += delta.signature || '';
+                    }
                     else if (delta.type === 'input_json_delta') {
                         currentToolInput += delta.partial_json || '';
                     }
@@ -220,24 +298,39 @@ export class ModelClient {
                 case 'content_block_stop': {
                     if (currentToolId) {
                         let parsedInput = {};
+                        let inputParseError = false;
                         try {
                             parsedInput = JSON.parse(currentToolInput || '{}');
                         }
                         catch (parseErr) {
-                            // Log malformed JSON instead of silently defaulting to {}
+                            // Incomplete JSON from stream abort or model error.
+                            // Mark as error so the executor returns an error result
+                            // instead of silently invoking the tool with empty/wrong params.
+                            inputParseError = true;
                             if (this.debug) {
-                                console.error(`[runcode] Malformed tool input JSON for ${currentToolName}: ${parseErr.message}`);
+                                console.error(`[franklin] Malformed tool input JSON for ${currentToolName}: ${parseErr.message}`);
+                                console.error(`[franklin] Raw input was: ${currentToolInput.slice(0, 200)}`);
                             }
                         }
-                        const toolInvocation = {
-                            type: 'tool_use',
-                            id: currentToolId,
-                            name: currentToolName,
-                            input: parsedInput,
-                        };
-                        collected.push(toolInvocation);
-                        // Notify caller so concurrent tools can start immediately
-                        onToolReady?.(toolInvocation);
+                        if (inputParseError) {
+                            // Don't invoke the tool — add a text block explaining the error
+                            // and skip the tool_use entirely. The model will see the error and retry.
+                            collected.push({
+                                type: 'text',
+                                text: `[Tool call to ${currentToolName} failed: incomplete JSON input from stream. The request may have been interrupted.]`,
+                            });
+                        }
+                        else {
+                            const toolInvocation = {
+                                type: 'tool_use',
+                                id: currentToolId,
+                                name: currentToolName,
+                                input: parsedInput,
+                            };
+                            collected.push(toolInvocation);
+                            // Notify caller so concurrent tools can start immediately
+                            onToolReady?.(toolInvocation);
+                        }
                         currentToolId = '';
                         currentToolName = '';
                         currentToolInput = '';
@@ -246,8 +339,10 @@ export class ModelClient {
                         collected.push({
                             type: 'thinking',
                             thinking: currentThinking,
+                            ...(currentThinkingSignature ? { signature: currentThinkingSignature } : {}),
                         });
                         currentThinking = '';
+                        currentThinkingSignature = '';
                     }
                     else if (currentText) {
                         collected.push({
@@ -305,13 +400,13 @@ export class ModelClient {
         catch (err) {
             const msg = err.message || '';
             if (msg.includes('insufficient') || msg.includes('balance')) {
-                console.error(`[runcode] Insufficient USDC balance. Run 'runcode balance' to check.`);
+                console.error(`[franklin] Insufficient USDC balance. Run 'franklin balance' to check.`);
             }
             else if (this.debug) {
-                console.error('[runcode] Payment error:', msg);
+                console.error('[franklin] Payment error:', msg);
             }
             else {
-                console.error(`[runcode] Payment failed: ${msg.slice(0, 100)}`);
+                console.error(`[franklin] Payment failed: ${msg.slice(0, 100)}`);
             }
             return null;
         }
@@ -398,7 +493,7 @@ export class ModelClient {
                 // Safety: if buffer grows too large without newlines, something is wrong
                 if (buffer.length > MAX_BUFFER) {
                     if (this.debug) {
-                        console.error(`[runcode] SSE buffer overflow (${(buffer.length / 1024).toFixed(0)}KB) — truncating to prevent OOM`);
+                        console.error(`[franklin] SSE buffer overflow (${(buffer.length / 1024).toFixed(0)}KB) — truncating to prevent OOM`);
                     }
                     buffer = buffer.slice(-MAX_BUFFER / 2);
                 }

package/dist/agent/loop.d.ts

@@ -1,7 +1,6 @@
 /**
- * runcode Agent Loop
+ * Franklin Agent Loop
  * The core reasoning-action cycle: prompt → model → extract capabilities → execute → repeat.
- * Original implementation with different architecture from any reference codebase.
  */
 import type { AgentConfig, Dialogue, StreamEvent } from './types.js';
 /**