whale-code 6.4.0 → 6.5.1

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
@@ -88,6 +88,8 @@ export declare function addPromptCaching(tools: Array<Record<string, unknown>>,
     tools: Array<Record<string, unknown>>;
     messages: Array<Record<string, unknown>>;
 };
+/** djb2 string hash — fast, deterministic, no dependencies */
+export declare function djb2Hash(str: string): string;
 export declare class LoopDetector {
     private history;
     private consecutiveErrors;
@@ -97,16 +99,24 @@ 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;
     recordCall(name: string, input: Record<string, unknown>): LoopCheckResult;
+    /**
+     * Track file read frequency — call when the tool is known to be a file read.
+     * Blocks re-reading the same path more than FILE_READ_LIMIT times per session.
+     */
+    trackRead(path: string): LoopCheckResult;
     recordResult(name: string, success: boolean, input?: Record<string, unknown>): void;
     endTurn(): BailCheckResult;
     resetTurn(): void;
@@ -136,6 +146,11 @@ export declare const MODEL_PRICING: Record<string, {
     outputPer1M: number;
     thinkingPer1M?: number;
 }>;
+/**
+ * Emit graduated cost warnings at 25%, 50%, 75% thresholds.
+ * Single source of truth — replaces copy-pasted blocks in server + CLI.
+ */
+export declare function emitCostWarningIfNeeded(sessionCostUsd: number, maxCostUsd: number, costWarningsEmitted: Set<number>, onText?: (text: string) => void): void;
 export declare function estimateCostUsd(inputTokens: number, outputTokens: number, model: string, thinkingTokens?: number, cacheReadTokens?: number, cacheCreationTokens?: number): number;
 /**
  * Route to cheaper model when the task is simple enough.
@@ -154,4 +169,12 @@ export declare function truncateToolResult(content: string, maxChars: number): s
 export declare function getMaxToolResultChars(contextConfig?: {
     max_tool_result_chars?: number;
 } | null): number;
+/**
+ * Demote subagent model requests — single source of truth for server + CLI.
+ * - explore/research: always haiku
+ * - opus: demoted to sonnet
+ * - sonnet: kept for plan, demoted to haiku for others
+ * - default/undefined: haiku
+ */
+export declare function demoteSubagentModel(requested: string | undefined, agentType?: string): "haiku" | "sonnet";
 export declare function sanitizeError(err: unknown): string;

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) {
@@ -187,7 +195,7 @@ export function addPromptCaching(tools, messages) {
 // LOOP DETECTION
 // ============================================================================
 /** djb2 string hash — fast, deterministic, no dependencies */
-function djb2Hash(str) {
+export function djb2Hash(str) {
     let hash = 5381;
     for (let i = 0; i < str.length; i++) {
         hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0xffffffff;
@@ -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) {
@@ -259,6 +270,21 @@ export class LoopDetector {
         }
         return { blocked: false };
     }
+    /**
+     * Track file read frequency — call when the tool is known to be a file read.
+     * Blocks re-reading the same path more than FILE_READ_LIMIT times per session.
+     */
+    trackRead(path) {
+        const readCount = (this.fileReadCounts.get(path) || 0) + 1;
+        this.fileReadCounts.set(path, readCount);
+        if (readCount > LoopDetector.FILE_READ_LIMIT) {
+            return {
+                blocked: true,
+                reason: `File "${path}" already read ${readCount - 1} times this session. Use the content from a previous read instead of re-reading.`,
+            };
+        }
+        return { blocked: false };
+    }
     recordResult(name, success, input) {
         const eKey = this.errorKey(name, input);
         if (success) {
@@ -319,15 +345,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;
     }
@@ -419,6 +448,20 @@ export const MODEL_PRICING = {
     "o3-mini": { inputPer1M: 1.10, outputPer1M: 4.40, thinkingPer1M: 4.40 },
     "o4-mini": { inputPer1M: 1.10, outputPer1M: 4.40, thinkingPer1M: 4.40 },
 };
+/**
+ * Emit graduated cost warnings at 25%, 50%, 75% thresholds.
+ * Single source of truth — replaces copy-pasted blocks in server + CLI.
+ */
+export function emitCostWarningIfNeeded(sessionCostUsd, maxCostUsd, costWarningsEmitted, onText) {
+    if (!isFinite(maxCostUsd) || !onText)
+        return;
+    for (const pct of [25, 50, 75]) {
+        if (!costWarningsEmitted.has(pct) && sessionCostUsd >= maxCostUsd * (pct / 100)) {
+            costWarningsEmitted.add(pct);
+            onText(`\n[Cost warning: ${pct}% of budget used ($${sessionCostUsd.toFixed(2)}/$${maxCostUsd.toFixed(2)}).${pct >= 75 ? " Wrap up soon." : ""}]`);
+        }
+    }
+}
 export function estimateCostUsd(inputTokens, outputTokens, model, thinkingTokens = 0, cacheReadTokens = 0, cacheCreationTokens = 0) {
     // Exact match first, then find a pricing key that is a prefix of the model ID
     const pricing = MODEL_PRICING[model]
@@ -521,6 +564,24 @@ export function getMaxToolResultChars(contextConfig) {
 // ============================================================================
 // UTILITY — sanitize errors (strip API keys, passwords)
 // ============================================================================
+/**
+ * Demote subagent model requests — single source of truth for server + CLI.
+ * - explore/research: always haiku
+ * - opus: demoted to sonnet
+ * - sonnet: kept for plan, demoted to haiku for others
+ * - default/undefined: haiku
+ */
+export function demoteSubagentModel(requested, agentType) {
+    if (agentType === "explore" || agentType === "research")
+        return "haiku";
+    if (!requested)
+        return "haiku";
+    if (requested === "opus")
+        return "sonnet";
+    if (requested === "sonnet")
+        return agentType === "plan" ? "sonnet" : "haiku";
+    return "haiku";
+}
 export function sanitizeError(err) {
     const msg = String(err);
     return msg

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 });