@blockrun/franklin 3.15.84 → 3.15.85

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/package.json

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