whale-code 6.4.0 → 6.5.1

package/dist/server/lib/server-subagent.d.ts

@@ -12,10 +12,13 @@ export interface SubagentResult {
     tokensUsed: {
         input: number;
         output: number;
+        cacheRead: number;
+        cacheCreation: number;
     };
     costUsd: number;
     toolsUsed: string[];
     turnCount: number;
+    stopReason: string;
 }
 export interface SubagentProgressEvent {
     subagentId: string;

package/dist/server/lib/server-subagent.js

@@ -5,7 +5,7 @@
  * from index.ts (avoids circular deps) and is fully testable in isolation.
  */
 import { randomUUID } from "node:crypto";
-import { LoopDetector, estimateCostUsd, sanitizeError, isRetryableError, } from "../../shared/agent-core.js";
+import { LoopDetector, estimateCostUsd, sanitizeError, isRetryableError, addPromptCaching, } from "../../shared/agent-core.js";
 import { buildAPIRequest } from "../../shared/api-client.js";
 import { MODELS, MODEL_MAP } from "../../shared/constants.js";
 import { dispatchTools } from "../../shared/tool-dispatch.js";
@@ -26,8 +26,8 @@ export const DELEGATE_TASK_TOOL_DEF = {
             },
             model: {
                 type: "string",
-                enum: ["haiku", "sonnet", "opus"],
-                description: "haiku (fast/$1) for simple lookups. sonnet ($3) for multi-step chains. opus ($5) for complex reasoning. Default: haiku.",
+                enum: ["haiku", "sonnet"],
+                description: "haiku (fast/$1) for simple lookups. sonnet ($3) for multi-step chains. Default: haiku.",
             },
             max_turns: {
                 type: "number",
@@ -90,6 +90,8 @@ export async function runServerSubagent(opts) {
         turn++;
         loopDetector.resetTurn();
         onProgress?.({ subagentId, event: "turn", turn, maxTurns });
+        // Apply prompt caching to tools and messages for cache hits on repeated context
+        const { tools: cachedTools, messages: cachedMessages } = addPromptCaching(tools, messages);
         // Non-streaming API call with retry
         let response;
         try {
@@ -99,8 +101,8 @@ export async function runServerSubagent(opts) {
                     max_tokens: apiConfig.maxTokens,
                     temperature: shouldThink ? 1 : 0.3, // Anthropic requires temp=1 with thinking
                     system,
-                    tools: tools,
-                    messages: messages,
+                    tools: cachedTools,
+                    messages: cachedMessages,
                     betas: apiConfig.betas,
                     context_management: apiConfig.contextManagement,
                     ...(apiConfig.thinking ? { thinking: apiConfig.thinking } : {}),
@@ -178,10 +180,11 @@ function makeResult(success, output, inputTokens, outputTokens, modelId, toolsUs
     return {
         success,
         output,
-        tokensUsed: { input: inputTokens, output: outputTokens },
+        tokensUsed: { input: inputTokens, output: outputTokens, cacheRead: cacheReadTokens, cacheCreation: cacheCreationTokens },
         costUsd: estimateCostUsd(inputTokens, outputTokens, modelId, 0, cacheReadTokens, cacheCreationTokens),
         toolsUsed: [...new Set(toolsUsed)],
         turnCount,
+        stopReason: "end_turn", // subagent always runs to completion or error
     };
 }
 async function withSubagentRetry(fn, maxRetries = 2) {

package/dist/server/lib/supabase-client.js

@@ -1,13 +1,53 @@
-// lib/supabase-client.ts — Resilient Supabase client with retry logic
+// lib/supabase-client.ts — Resilient Supabase client with circuit breaker
 // Fixes intermittent 520 errors from Cloudflare by retrying failed requests
 // and reusing client instances instead of creating new ones per request.
+// Circuit breaker prevents retry storms when Supabase is down.
 import { createClient } from "@supabase/supabase-js";
 const MAX_RETRIES = 3;
 const INITIAL_BACKOFF_MS = 500;
 const MAX_BACKOFF_MS = 5_000;
-/** Custom fetch with retry for 5xx errors (Cloudflare 520/522/524) */
+// ── Circuit breaker ──
+// When Supabase is consistently failing, stop retrying to prevent:
+// 1. Retry storms that make Supabase worse
+// 2. Event loop blocking that causes health check failures
+// 3. SSE stream stalls that freeze the CLI
+const CIRCUIT_FAILURE_THRESHOLD = 10; // Open circuit after 10 consecutive failures
+const CIRCUIT_RESET_MS = 30_000; // Try again after 30s
+let circuitFailures = 0;
+let circuitOpenUntil = 0;
+/** Check if circuit breaker allows the request */
+function isCircuitOpen() {
+    if (circuitFailures < CIRCUIT_FAILURE_THRESHOLD)
+        return false;
+    if (Date.now() >= circuitOpenUntil) {
+        // Half-open: allow one probe request
+        return false;
+    }
+    return true;
+}
+function recordCircuitFailure() {
+    circuitFailures++;
+    if (circuitFailures >= CIRCUIT_FAILURE_THRESHOLD) {
+        circuitOpenUntil = Date.now() + CIRCUIT_RESET_MS;
+        if (circuitFailures === CIRCUIT_FAILURE_THRESHOLD) {
+            console.warn(`[supabase] Circuit breaker OPEN — ${circuitFailures} consecutive failures, pausing for ${CIRCUIT_RESET_MS / 1000}s`);
+        }
+    }
+}
+function recordCircuitSuccess() {
+    if (circuitFailures > 0) {
+        console.info(`[supabase] Circuit breaker reset — connection recovered`);
+    }
+    circuitFailures = 0;
+    circuitOpenUntil = 0;
+}
+/** Custom fetch with retry for 5xx errors + circuit breaker */
 function createRetryFetch(maxRetries = MAX_RETRIES) {
     return async (input, init) => {
+        // Circuit breaker: fail fast when Supabase is known to be down
+        if (isCircuitOpen()) {
+            throw new Error("Supabase circuit breaker open — skipping request");
+        }
         let lastError = null;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             try {
@@ -18,17 +58,25 @@ function createRetryFetch(maxRetries = MAX_RETRIES) {
                 });
                 // Retry on 5xx errors (Cloudflare 520 = origin error, 522 = timeout, 524 = timeout)
                 if (res.status >= 500 && attempt < maxRetries) {
+                    recordCircuitFailure();
+                    if (isCircuitOpen()) {
+                        return res; // Don't retry if circuit just opened
+                    }
                     const backoff = Math.min(INITIAL_BACKOFF_MS * Math.pow(2, attempt), MAX_BACKOFF_MS);
                     console.warn(`[supabase] ${res.status} on ${typeof input === 'string' ? input.split('?')[0] : 'request'}, retry ${attempt + 1}/${maxRetries} in ${backoff}ms`);
                     await new Promise(r => setTimeout(r, backoff));
                     continue;
                 }
+                if (res.status < 500) {
+                    recordCircuitSuccess();
+                }
                 return res;
             }
             catch (err) {
                 lastError = err;
+                recordCircuitFailure();
                 // Retry on network errors (ECONNRESET, ETIMEDOUT, etc.)
-                if (attempt < maxRetries) {
+                if (attempt < maxRetries && !isCircuitOpen()) {
                     const backoff = Math.min(INITIAL_BACKOFF_MS * Math.pow(2, attempt), MAX_BACKOFF_MS);
                     console.warn(`[supabase] Network error: ${lastError.message}, retry ${attempt + 1}/${maxRetries} in ${backoff}ms`);
                     await new Promise(r => setTimeout(r, backoff));

package/dist/server/lib/template-resolver.js

@@ -159,14 +159,24 @@ export function evaluateCondition(expression, ctx) {
         [/\scontains\s/, "contains"],
         [/\s!contains\s/, "!contains"],
     ];
+    // Identify quoted regions to avoid matching operators inside them
+    const quoteRegions = [];
+    const quoteRe = /(['"])(?:(?!\1).)*\1/g;
+    let qm;
+    while ((qm = quoteRe.exec(expr)) !== null) {
+        quoteRegions.push([qm.index, qm.index + qm[0].length]);
+    }
     for (const [pattern, op] of operatorPatterns) {
-        // Use the LAST match: resolved template data (left side) may contain
-        // operator-like strings, but the actual operator is the rightmost one.
+        // Use the LAST match that is NOT inside a quoted string.
         const globalRe = new RegExp(pattern.source, "g");
         let lastMatch = null;
         let m;
-        while ((m = globalRe.exec(expr)) !== null)
-            lastMatch = m;
+        while ((m = globalRe.exec(expr)) !== null) {
+            const idx = m.index;
+            const insideQuotes = quoteRegions.some(([s, e]) => idx > s && idx < e);
+            if (!insideQuotes)
+                lastMatch = m;
+        }
         if (!lastMatch || lastMatch.index === undefined)
             continue;
         let left = expr.substring(0, lastMatch.index).trim();

package/dist/server/lib/utils.js

@@ -114,6 +114,21 @@ export function summarizeResult(toolName, action, data) {
                 if (action === "browse")
                     return { categories: d.data ? d.data.categories?.length || 0 : 0, status_summary: d.data ? d.data.product_status_summary : undefined };
                 return { action, count: Array.isArray(d) ? d.length : (d.count ?? (d.products ? d.products.length : (d.id ? 1 : 0))) };
+            case "media": {
+                if (action === "list" || action === "search")
+                    return { count: d.count, total: d.total };
+                if (action === "analytics")
+                    return { total_items: d.total_items, orphan_count: d.orphan_count, storage_mb: d.total_storage_mb };
+                if (action === "upload")
+                    return { media_id: d.media_id, file_name: d.file_name };
+                if (action === "bulk_upload")
+                    return { uploaded_count: d.uploaded_count, failed_count: d.failed_count };
+                if (action === "bulk_update")
+                    return { updated_count: d.updated_count, failed_count: d.failed_count };
+                if (action === "usage")
+                    return { reference_count: d.reference_count };
+                return { action };
+            }
             case "audit_trail":
                 return { count: d.count, days: d.days, actions: d.summary ? Object.keys(d.summary).length : 0 };
             case "telemetry":

package/dist/server/local-agent-gateway.d.ts

@@ -16,6 +16,7 @@ export interface LocalAgent {
     ws: WebSocket;
     storeId: string;
     userId: string | null;
+    nodeId: string | null;
     capabilities: string[];
     connectedAt: Date;
     lastPong: number;
@@ -50,6 +51,7 @@ export declare function getAgentInfo(storeId: string): Array<{
     capabilities: string[];
     connected_at: string;
     uptime_seconds: number;
+    node_id: string | null;
 }>;
 /**
  * Execute a command on the user's local machine via their connected agent.
@@ -79,4 +81,46 @@ export declare function getGatewayStats(): {
     pending_requests: number;
     agents_by_store: Record<string, number>;
 };
+/**
+ * Get active remote desktop sessions.
+ */
+export declare function getRemoteDesktopSessions(): Array<{
+    session_id: string;
+    store_id: string;
+    user_id: string;
+    agent_id: string;
+    started_at: string;
+    frames_relayed: number;
+    bytes_relayed: number;
+}>;
+/**
+ * Get active portal sessions.
+ */
+export declare function getPortalSessions(): Array<{
+    session_id: string;
+    store_id: string;
+    initiator_agent_id: string;
+    target_agent_id: string;
+    capabilities: string[];
+    started_at: string;
+    bytes_relayed: number;
+}>;
+export interface ClusterCommandArgs {
+    action: string;
+    task?: string;
+    max_cells?: number;
+    working_directory?: string;
+    cluster_id?: string;
+    channel_id?: string;
+    conversation_id?: string;
+}
+/**
+ * Execute a cluster command on the connected whale-node.
+ * Sends via WebSocket and waits for the result.
+ */
+export declare function executeClusterCommand(storeId: string, args: ClusterCommandArgs, options?: {
+    timeout?: number;
+    agent_id?: string;
+    node_id?: string;
+}): Promise<AgentResult>;
 export declare function shutdownGateway(): void;