whale-code 6.4.0 → 6.5.0

package/dist/server/proxy-handlers.js

@@ -20,6 +20,151 @@ const GEMINI_MAX_TOKENS = 65536;
 const OPENAI_MAX_TOKENS = 128000;
 const OPENAI_REASONING_MAX_TOKENS = 100000;
 // ============================================================================
+// IMAGE MIME TYPE CORRECTION
+// ============================================================================
+// Detects actual image format from base64 magic bytes and corrects media_type
+// mismatches. Prevents Anthropic API 400 errors that permanently poison the
+// conversation when a file extension doesn't match the actual image content
+// (e.g. a .webp file that's actually PNG).
+const IMAGE_SIGNATURES = [
+    { prefix: "iVBORw0KGgo", type: "image/png" },
+    { prefix: "/9j/", type: "image/jpeg" },
+    { prefix: "R0lGOD", type: "image/gif" },
+    { prefix: "UklGR", type: "image/webp" },
+];
+function detectImageType(base64Data) {
+    for (const sig of IMAGE_SIGNATURES) {
+        if (base64Data.startsWith(sig.prefix)) {
+            // RIFF header could be WebP or other formats — verify WEBP marker at offset 8
+            if (sig.prefix === "UklGR") {
+                try {
+                    const buf = Buffer.from(base64Data.slice(0, 24), "base64");
+                    if (buf.length >= 12 && buf.toString("ascii", 8, 12) === "WEBP") {
+                        return "image/webp";
+                    }
+                }
+                catch {
+                    return null;
+                }
+                return null;
+            }
+            return sig.type;
+        }
+    }
+    return null;
+}
+function fixImageBlock(block) {
+    if (block.type === "image" && block.source?.type === "base64" && block.source?.data) {
+        const actual = detectImageType(block.source.data);
+        if (actual && actual !== block.source.media_type) {
+            console.log(`[proxy] Fixed image MIME: declared=${block.source.media_type} actual=${actual}`);
+            block.source.media_type = actual;
+            return true;
+        }
+    }
+    return false;
+}
+function fixImageMimeTypes(messages) {
+    let fixes = 0;
+    for (const msg of messages) {
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (fixImageBlock(block))
+                fixes++;
+            // Also check tool_result blocks — images from Read tool end up here
+            if (block.type === "tool_result" && Array.isArray(block.content)) {
+                for (const sub of block.content) {
+                    if (fixImageBlock(sub))
+                        fixes++;
+                }
+            }
+        }
+    }
+    if (fixes > 0) {
+        console.log(`[proxy] Corrected ${fixes} image MIME type(s)`);
+    }
+}
+// ============================================================================
+// IMAGE PRUNING — strip base64 from old turns to keep conversation size bounded
+// ============================================================================
+// Conversation history with many images grows unboundedly. We keep full image
+// data only in the most recent user turn; older turns get their base64 replaced
+// with a lightweight "[image]" text placeholder. The model already processed
+// those images — it doesn't need the raw bytes again.
+function replaceImageBlock(block) {
+    // Replace a base64 image block with a text placeholder.
+    // Matches both full-data blocks AND blocks whose data was zeroed by the raw pruner.
+    if (block.type === "image" && block.source?.type === "base64") {
+        block.type = "text";
+        block.text = "[image]";
+        delete block.source;
+        return true;
+    }
+    return false;
+}
+function pruneOldImages(messages) {
+    // Find index of last user message — that turn keeps full image data
+    let lastUserIdx = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user") {
+            lastUserIdx = i;
+            break;
+        }
+    }
+    let pruned = 0;
+    for (let i = 0; i < messages.length; i++) {
+        if (i === lastUserIdx)
+            continue; // keep latest user turn intact
+        const msg = messages[i];
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (replaceImageBlock(block)) {
+                pruned++;
+                continue;
+            }
+            if (block.type === "tool_result" && Array.isArray(block.content)) {
+                for (const sub of block.content) {
+                    if (replaceImageBlock(sub))
+                        pruned++;
+                }
+            }
+        }
+    }
+    if (pruned > 0)
+        console.log(`[proxy] Pruned ${pruned} base64 image(s) from old conversation turns`);
+}
+/** Remove any image blocks with empty/missing data — left by the raw body pruner.
+ *  These would cause a 400 from Anthropic regardless of which turn they're in. */
+function removeEmptyImageBlocks(messages) {
+    let removed = 0;
+    for (const msg of messages) {
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block.type === "image" && block.source?.type === "base64" && !block.source?.data) {
+                block.type = "text";
+                block.text = "[image]";
+                delete block.source;
+                removed++;
+            }
+            if (block.type === "tool_result" && Array.isArray(block.content)) {
+                for (const sub of block.content) {
+                    if (sub.type === "image" && sub.source?.type === "base64" && !sub.source?.data) {
+                        sub.type = "text";
+                        sub.text = "[image]";
+                        delete sub.source;
+                        removed++;
+                    }
+                }
+            }
+        }
+    }
+    if (removed > 0)
+        console.log(`[proxy] Removed ${removed} empty image block(s) from messages`);
+}
+// ============================================================================
 // MAIN PROXY DISPATCHER
 // ============================================================================
 export async function handleProxy(res, body, corsHeaders) {
@@ -28,6 +173,12 @@ export async function handleProxy(res, body, corsHeaders) {
         jsonResponse(res, 400, { error: "messages array required" }, corsHeaders);
         return;
     }
+    // Fix mismatched image MIME types before they hit the API
+    fixImageMimeTypes(messages);
+    // Strip base64 data from old turns — keeps request size bounded across long conversations
+    pruneOldImages(messages);
+    // Remove empty image blocks left by the raw body pruner (data:"") — would cause Anthropic 400
+    removeEmptyImageBlocks(messages);
     // Resolve aliases (e.g. "whale/agent" → "claude-opus-4-6", "opus" → "claude-opus-4-6")
     const resolved = MODEL_MAP[requestedModel] || requestedModel;
     const model = ALLOWED_MODELS.includes(resolved) ? resolved : MODELS.SONNET;

package/dist/server/tool-router.d.ts

@@ -17,7 +17,8 @@
  *   That's it — MCP, WhaleChat, workflows, CLI all pick it up automatically.
  */
 import type { SupabaseClient } from "@supabase/supabase-js";
-export declare function flushAuditLogs(supabase: SupabaseClient): Promise<void>;
+import { flushSpans } from "./lib/clickhouse-buffer.js";
+export { flushSpans };
 export declare function getToolMetrics(): Record<string, {
     invocations: number;
     errors: number;
@@ -146,4 +147,3 @@ skipAudit?: boolean): Promise<{
     error?: string;
 }>;
 export declare function loadAgentConfig(supabase: SupabaseClient, agentId: string, storeId?: string): Promise<AgentConfig | null>;
-export {};

package/dist/server/tool-router.js

@@ -35,6 +35,8 @@ import { handleWorkflows } from "./handlers/workflows.js";
 import { handleEmbeddings } from "./handlers/embeddings.js";
 import { handleLLM } from "./handlers/llm-providers.js";
 import { handleImageGen } from "./handlers/image-gen.js";
+import { handleRemoveBg } from "./handlers/remove-bg.js";
+import { handleMedia } from "./handlers/media.js";
 import { handleVideoGen } from "./handlers/video-gen.js";
 import { handleAPIKeys } from "./handlers/api-keys.js";
 import { handleCreations } from "./handlers/creations.js";
@@ -42,39 +44,15 @@ import { handleMetaAds } from "./handlers/meta-ads.js";
 import { handleKali } from "./handlers/kali.js";
 import { handleLocalAgent } from "./handlers/local-agent.js";
 import { handleEnrichment } from "./handlers/enrichment.js";
+import { handleStorefront } from "./handlers/storefront.js";
+import { handleClickHouse } from "./handlers/clickhouse.js";
 import { summarizeResult, withTimeout } from "./lib/utils.js";
 // ============================================================================
-// AUDIT LOG BATCHING — buffer inserts and flush periodically
+// TELEMETRY — ClickHouse span buffer (replaces Postgres audit_logs buffer)
 // ============================================================================
-const auditLogBuffer = [];
-const AUDIT_FLUSH_INTERVAL = 500; // ms
-const AUDIT_FLUSH_MAX = 100; // max records before force flush
-let auditFlushTimer = null;
-export async function flushAuditLogs(supabase) {
-    if (auditLogBuffer.length === 0)
-        return;
-    const batch = auditLogBuffer.splice(0, auditLogBuffer.length);
-    try {
-        const { error } = await supabase.from("audit_logs").insert(batch);
-        if (error)
-            console.error("[audit-batch] flush error:", error.message, "lost", batch.length, "records");
-    }
-    catch (err) {
-        console.error("[audit-batch] flush exception:", err.message, "lost", batch.length, "records");
-    }
-}
-function queueAuditLog(supabase, row) {
-    auditLogBuffer.push(row);
-    if (auditLogBuffer.length >= AUDIT_FLUSH_MAX) {
-        flushAuditLogs(supabase);
-    }
-    else if (!auditFlushTimer) {
-        auditFlushTimer = setTimeout(() => {
-            auditFlushTimer = null;
-            flushAuditLogs(supabase);
-        }, AUDIT_FLUSH_INTERVAL);
-    }
-}
+import { queueSpan, flushSpans, auditRowToSpan, classifyErrorType } from "./lib/clickhouse-buffer.js";
+// Re-export for callers that used flushAuditLogs (e.g. index.ts shutdown)
+export { flushSpans };
 // ============================================================================
 // IN-MEMORY EXECUTION METRICS
 // ============================================================================
@@ -299,9 +277,10 @@ export const TOOL_HANDLERS = {
     locations: { handler: handleLocations, timeout: DEFAULT_TIMEOUT, requiresStore: true },
     suppliers: { handler: handleSuppliers, timeout: DEFAULT_TIMEOUT, requiresStore: true },
     store: { handler: handleStore, timeout: DEFAULT_TIMEOUT, requiresStore: true },
+    storefront: { handler: handleStorefront, timeout: DEFAULT_TIMEOUT, requiresStore: true },
     // --- Communication ---
     email: { handler: handleEmail, timeout: DEFAULT_TIMEOUT, requiresStore: true },
-    documents: { handler: handleDocuments, timeout: DEFAULT_TIMEOUT, requiresStore: true },
+    documents: { handler: handleDocuments, timeout: 120_000, requiresStore: true },
     // --- Operations ---
     alerts: { handler: handleAlerts, timeout: DEFAULT_TIMEOUT, requiresStore: true },
     audit_trail: { handler: handleAuditTrail, timeout: DEFAULT_TIMEOUT, requiresStore: true },
@@ -309,6 +288,8 @@ export const TOOL_HANDLERS = {
     // --- AI & Generation ---
     voice: { handler: handleVoice, timeout: 120_000, requiresStore: true },
     image_gen: { handler: handleImageGen, timeout: 60_000, requiresStore: true },
+    remove_bg: { handler: handleRemoveBg, timeout: 60_000, requiresStore: true },
+    media: { handler: handleMedia, timeout: 60_000, requiresStore: true },
     video_gen: { handler: handleVideoGen, timeout: 600_000, requiresStore: true },
     llm: { handler: handleLLM, timeout: 120_000, requiresStore: true },
     embeddings: { handler: handleEmbeddings, timeout: 60_000, requiresStore: true },
@@ -326,6 +307,8 @@ export const TOOL_HANDLERS = {
     local_agent: { handler: handleLocalAgent, timeout: 600_000, requiresStore: false },
     // --- Customer Data Protection ---
     enrichment: { handler: handleEnrichment, timeout: 60_000, requiresStore: true },
+    // --- Observability (ClickHouse) ---
+    clickhouse: { handler: handleClickHouse, timeout: 60_000, requiresStore: false },
     // --- Meta: Tool Discovery (lazy loading) ---
     discover_tools: { handler: handleDiscoverTools, timeout: 5000, requiresStore: false },
 };
@@ -377,14 +360,14 @@ const TOOL_CATEGORIES = {
     inventory: "business", purchase_orders: "business", transfers: "business",
     products: "business", collections: "business", customers: "business",
     orders: "business", analytics: "business", locations: "business",
-    suppliers: "business", store: "business",
+    suppliers: "business", store: "business", storefront: "business",
     // Communication
     email: "communication", documents: "communication",
     // Operations
     alerts: "operations", audit_trail: "operations", workflows: "operations",
     telemetry: "operations",
     // Media & AI
-    voice: "media", image_gen: "media", video_gen: "media",
+    voice: "media", image_gen: "media", video_gen: "media", remove_bg: "media", media: "media",
     llm: "ai", embeddings: "ai", creations: "media",
     // Platform
     web_search: "platform", browser: "platform", discovery: "platform",
@@ -750,6 +733,9 @@ skipAudit) {
         }
         if (result.error) {
             details.tool_error = result.error;
+            const errorType = classifyErrorType(result.error);
+            if (errorType)
+                details.error_type = errorType;
         }
         const bytes = new Uint8Array(8);
         crypto.getRandomValues(bytes);
@@ -765,9 +751,12 @@ skipAudit) {
             source: source || "fly_container",
             details,
             error_message: result.error || null,
+            error_type: classifyErrorType(result.error) || undefined,
             duration_ms: endTime - startTime,
             user_id: userId || null,
             user_email: userEmail || null,
+            input_bytes: inputBytes,
+            output_bytes: outputBytes,
             // OTEL fields
             trace_id: traceId || null,
             span_id: spanId,
@@ -777,7 +766,7 @@ skipAudit) {
             start_time: new Date(startTime).toISOString(),
             end_time: new Date(endTime).toISOString(),
         };
-        queueAuditLog(supabase, auditRow);
+        queueSpan(auditRowToSpan(auditRow));
     }
     catch (err) {
         console.error("[audit] exception:", err);
@@ -788,11 +777,12 @@ skipAudit) {
 // AGENT LOADER
 // ============================================================================
 export async function loadAgentConfig(supabase, agentId, storeId) {
+    // storeId is required for tenant isolation — only omit for internal/migration callers
     let query = supabase
         .from("ai_agent_config")
         .select("*")
         .eq("id", agentId);
-    // P0 FIX: Filter by store_id to prevent cross-tenant agent access
+    // ALWAYS filter by store_id when provided (which should be always for user requests)
     if (storeId) {
         query = query.eq("store_id", storeId);
     }

package/dist/shared/agent-core.d.ts

@@ -56,8 +56,8 @@ export interface ContextManagementConfig {
 export declare const COMPACTION_TRIGGER_TOKENS = 120000;
 /** Max cumulative tokens before forcing wrap-up (prevents runaway compaction cost) */
 export declare const COMPACTION_TOTAL_BUDGET = 2000000;
-/** Default session cost budget in USD — Infinity = no limit (budget enforcement disabled by default) */
-export declare const DEFAULT_SESSION_COST_BUDGET_USD: number;
+/** Default session cost budget in USD — hard cap to prevent runaway spending */
+export declare const DEFAULT_SESSION_COST_BUDGET_USD = 5;
 /**
  * Provider-aware compaction configuration.
  * - Anthropic/Bedrock: native server-side compaction via compact_20260112
@@ -97,12 +97,15 @@ export declare class LoopDetector {
     private failedStrategies;
     private consecutiveFailedTurns;
     private totalSessionErrors;
+    /** Tracks how many times the same file path has been read this session */
+    private fileReadCounts;
     static IDENTICAL_CALL_LIMIT: number;
     static CONSECUTIVE_ERROR_LIMIT: number;
     static TURN_ERROR_LIMIT: number;
     static WINDOW: number;
     static SESSION_TOOL_ERROR_LIMIT: number;
     static CONSECUTIVE_FAILED_TURN_LIMIT: number;
+    static FILE_READ_LIMIT: number;
     /** Get the error-tracking key for a tool call. Tools with an `action` param
      *  are tracked per-action so e.g. voice/speak failing won't block voice/music_compose. */
     private errorKey;

package/dist/shared/agent-core.js

@@ -25,6 +25,14 @@ export function resolveToolChoice(opts) {
             return "none";
         }
     }
+    // 2b. Alternating pattern detection: catch A→B→A→B→A→B death spirals (e.g. read→edit→read→edit)
+    if (opts.recentToolUses.length >= 6) {
+        const last6 = opts.recentToolUses.slice(-6);
+        const isRepeatingPair = last6[2] === last6[0] && last6[3] === last6[1] &&
+            last6[4] === last6[0] && last6[5] === last6[1];
+        if (isRepeatingPair)
+            return "none";
+    }
     // 3. Keyword matching: check if the user message mentions a specific tool name
     //    Only on the first turn (avoids false positives on multi-turn conversations)
     if (opts.turnCount === 1 && opts.userMessage && opts.availableToolNames.length > 0) {
@@ -47,8 +55,8 @@ export function resolveToolChoice(opts) {
 export const COMPACTION_TRIGGER_TOKENS = 120_000;
 /** Max cumulative tokens before forcing wrap-up (prevents runaway compaction cost) */
 export const COMPACTION_TOTAL_BUDGET = 2_000_000;
-/** Default session cost budget in USD — Infinity = no limit (budget enforcement disabled by default) */
-export const DEFAULT_SESSION_COST_BUDGET_USD = Infinity;
+/** Default session cost budget in USD — hard cap to prevent runaway spending */
+export const DEFAULT_SESSION_COST_BUDGET_USD = 5.00;
 export function getCompactionConfig(model) {
     const provider = getProvider(model);
     switch (provider) {
@@ -203,12 +211,15 @@ export class LoopDetector {
     failedStrategies = new Set();
     consecutiveFailedTurns = 0;
     totalSessionErrors = 0;
+    /** Tracks how many times the same file path has been read this session */
+    fileReadCounts = new Map();
     static IDENTICAL_CALL_LIMIT = 4;
     static CONSECUTIVE_ERROR_LIMIT = 3;
     static TURN_ERROR_LIMIT = 5;
     static WINDOW = 20;
     static SESSION_TOOL_ERROR_LIMIT = 10;
     static CONSECUTIVE_FAILED_TURN_LIMIT = 3;
+    static FILE_READ_LIMIT = 3;
     /** Get the error-tracking key for a tool call. Tools with an `action` param
      *  are tracked per-action so e.g. voice/speak failing won't block voice/music_compose. */
     errorKey(name, input) {
@@ -219,6 +230,18 @@ export class LoopDetector {
     recordCall(name, input) {
         const inputHash = djb2Hash(JSON.stringify({ name, ...input }));
         const eKey = this.errorKey(name, input);
+        // File read frequency tracking — block re-reading the same file >3 times per session
+        if (name === "read_file" && typeof input.path === "string") {
+            const filePath = input.path;
+            const readCount = (this.fileReadCounts.get(filePath) || 0) + 1;
+            this.fileReadCounts.set(filePath, readCount);
+            if (readCount > LoopDetector.FILE_READ_LIMIT) {
+                return {
+                    blocked: true,
+                    reason: `File "${filePath}" already read ${readCount - 1} times this session. Use the content from a previous read instead of re-reading.`,
+                };
+            }
+        }
         if (this.failedStrategies.has(inputHash)) {
             return {
                 blocked: true,
@@ -319,15 +342,18 @@ export class LoopDetector {
         return { shouldBail: false };
     }
     resetTurn() {
-        this.history = [];
-        this.consecutiveErrors.clear();
+        // Only reset per-turn counters — history and consecutiveErrors persist
+        // for cross-turn detection. The full reset() clears everything for new sessions.
         this.turnErrors = 0;
         this.turnHadErrors = false;
     }
     reset() {
         this.resetTurn();
+        this.history = [];
+        this.consecutiveErrors.clear();
         this.sessionErrors.clear();
         this.failedStrategies.clear();
+        this.fileReadCounts.clear();
         this.consecutiveFailedTurns = 0;
         this.totalSessionErrors = 0;
     }

package/dist/shared/api-client.js

@@ -50,6 +50,18 @@ export function buildAPIRequest(opts) {
                         keep: { type: "tool_uses", value: 2 },
                     },
                 ];
+                // Compaction for sub-agents on models that support it (lower threshold than main agent).
+                // Trigger at 80K — above the 60K clear_tool_uses threshold so clearing fires first.
+                const supportsCompaction = model.includes("opus-4-6") || model.includes("sonnet-4-6");
+                if (supportsCompaction) {
+                    edits.push({
+                        type: "compact_20260112",
+                        trigger: { type: "input_tokens", value: 80_000 },
+                        pause_after_compaction: true,
+                        instructions: "Summarize preserving: task goal, files found/modified, key findings, next steps.",
+                    });
+                    betas.push("compact-2026-01-12");
+                }
             }
             break;
         case "teammate": {
@@ -113,16 +125,46 @@ export async function callServerProxy(config) {
             if (config.storeId) {
                 body.store_id = config.storeId;
             }
+            // Prune old base64 images from conversation history before serializing.
+            // Keep images only in the last 2 messages to avoid multi-MB request bodies
+            // that can cause "Invalid JSON" errors from body truncation on the proxy.
+            if (Array.isArray(body.messages) && body.messages.length > 4) {
+                const msgs = body.messages;
+                const keepFrom = Math.max(0, msgs.length - 2);
+                for (let i = 0; i < keepFrom; i++) {
+                    const msg = msgs[i];
+                    if (!Array.isArray(msg?.content))
+                        continue;
+                    for (const block of msg.content) {
+                        if (block.type === "image" && block.source?.type === "base64") {
+                            block.type = "text";
+                            block.text = "[image]";
+                            delete block.source;
+                        }
+                        if (block.type === "tool_result" && Array.isArray(block.content)) {
+                            for (const sub of block.content) {
+                                if (sub.type === "image" && sub.source?.type === "base64") {
+                                    sub.type = "text";
+                                    sub.text = "[image]";
+                                    delete sub.source;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            const serialized = JSON.stringify(body);
             const fetchOpts = {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
                     "Authorization": `Bearer ${config.token}`,
+                    "Content-Length": String(Buffer.byteLength(serialized)),
                 },
-                body: JSON.stringify(body),
+                body: serialized,
                 signal,
             };
-            // Apply timeout if specified
+            // Apply timeout only when the caller did NOT already supply a signal
             let controller;
             let timeout;
             if (timeoutMs && !signal) {
@@ -162,7 +204,16 @@ export async function callServerProxy(config) {
                 const errMsg = err instanceof Error ? err.message : String(err);
                 config.onRetry?.(attempt + 1, MAX_RETRIES, errMsg);
                 const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
-                await new Promise((resolve) => setTimeout(resolve, delay));
+                // Abort-aware backoff — ESC can interrupt the wait immediately
+                await new Promise((resolve, reject) => {
+                    if (signal?.aborted) {
+                        reject(signal.reason ?? new Error("Aborted"));
+                        return;
+                    }
+                    const timer = setTimeout(resolve, delay);
+                    const onAbort = () => { clearTimeout(timer); reject(signal.reason ?? new Error("Aborted")); };
+                    signal?.addEventListener("abort", onAbort, { once: true });
+                });
                 // Fallback model on last retry
                 if (attempt === MAX_RETRIES - 1 && config.fallbackModel) {
                     const fromModel = config.model;

package/dist/shared/sse-parser.d.ts

@@ -13,7 +13,7 @@ import type { StreamResult, StreamCallbacks } from "./types.js";
  * Parse SSE stream from proxy HTTP response into typed events.
  * Handles `data: {...}\n\n` format with [DONE] sentinel.
  */
-export declare function parseSSEStream(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<BetaStreamEvent>;
+export declare function parseSSEStream(body: ReadableStream<Uint8Array>, signal?: AbortSignal, readTimeoutMs?: number): AsyncGenerator<BetaStreamEvent>;
 /**
  * Collect all events into a StreamResult. No callbacks — used by
  * subagent and teammate where real-time text isn't needed.

package/dist/shared/sse-parser.js

@@ -14,7 +14,7 @@
  * Parse SSE stream from proxy HTTP response into typed events.
  * Handles `data: {...}\n\n` format with [DONE] sentinel.
  */
-export async function* parseSSEStream(body, signal) {
+export async function* parseSSEStream(body, signal, readTimeoutMs = 90_000) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -22,7 +22,10 @@ export async function* parseSSEStream(body, signal) {
         while (true) {
             if (signal?.aborted)
                 break;
-            const { done, value } = await reader.read();
+            // Read with timeout — abort if no data arrives within readTimeoutMs
+            const readPromise = reader.read();
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`SSE stream stalled — no data for ${readTimeoutMs / 1000}s`)), readTimeoutMs));
+            const { done, value } = await Promise.race([readPromise, timeoutPromise]);
             if (done)
                 break;
             buffer += decoder.decode(value, { stream: true });

package/dist/shared/tool-dispatch.js

@@ -14,7 +14,7 @@
 const SAFETY_MAX_CHARS = 30_000;
 /** Tools that spawn workers/subprocesses and need much longer than 2 min */
 const LONG_RUNNING_TOOL_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
-const LONG_RUNNING_TOOLS = new Set(["team_create", "task", "kali", "delegate_task"]);
+const LONG_RUNNING_TOOLS = new Set(["team_create", "task", "kali", "delegate_task", "exit_plan_mode", "ask_user_question"]);
 // ============================================================================
 // DISPATCH
 // ============================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whale-code",
-  "version": "6.4.0",
+  "version": "6.5.0",
   "description": "whale code — local-first AI agent CLI for inventory, orders, and analytics powered by MCP",
   "type": "module",
   "main": "dist/index.js",
@@ -15,20 +15,21 @@
     "build": "tsc",
     "test": "vitest run",
     "test:watch": "vitest",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "postinstall": "chmod +x node_modules/node-pty/prebuilds/darwin-arm64/spawn-helper 2>/dev/null || true; node scripts/patch-ink-resize.js 2>/dev/null || true"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.74.0",
-    "@aws-sdk/client-bedrock-runtime": "^3.990.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.1000.0",
     "@google/genai": "^1.41.0",
     "@modelcontextprotocol/sdk": "^1.25.3",
+    "@react-pdf/renderer": "^4.3.2",
     "@supabase/supabase-js": "2.95.3",
     "bonjour-service": "^1.3.0",
     "chalk": "^5.6.2",
-    "cli-highlight": "^2.1.11",
-    "diff": "^7.0.0",
-    "ink": "^5.1.0",
-    "ink-select-input": "^6.0.0",
+    "diff": "^8.0.3",
+    "ink": "^6.8.0",
+    "ink-select-input": "^6.2.0",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "marked": "^15.0.12",
@@ -39,7 +40,10 @@
     "pg": "^8.18.0",
     "pino": "^10.3.1",
     "playwright-core": "^1.58.2",
-    "react": "^18.3.1",
+    "qrcode": "^1.5.4",
+    "react": "^19.2.4",
+    "react-pdf-html": "^2.1.5",
+    "shiki": "^4.0.0",
     "ws": "^8.19.0",
     "zod": "^4.3.6"
   },
@@ -50,7 +54,8 @@
     "@types/node": "^20.10.0",
     "@types/pg": "^8.16.0",
     "@types/pino": "^7.0.4",
-    "@types/react": "^18.3.0",
+    "@types/qrcode": "^1.5.6",
+    "@types/react": "^19.2.14",
     "@types/ws": "^8.18.1",
     "@vitest/coverage-v8": "^4.0.18",
     "dotenv": "^17.3.1",
@@ -90,6 +95,7 @@
   ],
   "license": "MIT",
   "overrides": {
-    "minimatch": ">=10.2.1"
+    "minimatch": ">=10.2.1",
+    "fast-xml-parser": ">=5.3.8"
   }
 }

package/dist/server/handlers/__test-utils__/mock-supabase.d.ts

@@ -1,11 +0,0 @@
-/** Pre-populate a table with rows for the current test */
-export declare function setTableData(table: string, rows: unknown[]): void;
-/** Pre-configure the return value for an RPC call */
-export declare function setRpcResponse(name: string, data: unknown, error?: unknown): void;
-/** Force a table to return an error on any operation */
-export declare function setTableError(table: string, message: string, code?: string): void;
-/** Reset all in-memory state between tests */
-export declare function resetMock(): void;
-/** Get current in-memory rows for a table (for post-operation assertions) */
-export declare function getTableData(table: string): unknown[];
-export declare function createMockSupabase(): unknown;