@superatomai/sdk-node 0.0.51-mds → 0.0.52-mds

package/dist/index.d.mts

@@ -904,6 +904,13 @@ interface SuperatomSDKConfig {
      * Default: 5 minutes
      */
     queryCacheTTL?: number;
+    /**
+     * Byte budget for cached query results, in MB.
+     * The cache evicts least-recently-used entries to stay under it, so a long TTL
+     * cannot grow the process until the host kills it. Keep it well below the
+     * process memory limit. Default: 1024 MB
+     */
+    queryCacheMaxMB?: number;
     /**
      * Dashboard conversation history TTL (Time To Live) in minutes
      * Per-dashboard conversation histories expire after this duration
@@ -2780,10 +2787,33 @@ declare class QueryCache {
     private cache;
     private ttlMs;
     private maxCacheSize;
+    private maxCacheBytes;
+    private currentBytes;
     private cleanupInterval;
     private readonly algorithm;
     private encryptionKey;
     constructor();
+    /**
+     * Set the byte budget for cached result data.
+     * @param megabytes - Budget in MB. Keep it well under the process memory limit.
+     */
+    setMaxBytes(megabytes: number): void;
+    /** Current estimated bytes held by the data cache. */
+    getCurrentBytes(): number;
+    /**
+     * Rough retained size of a result, in bytes.
+     *
+     * Sampled rather than exact: stringifying a multi-megabyte result on every set()
+     * would allocate the very memory this budget exists to protect. Estimated from a
+     * few rows of the largest array in the payload, at 2 bytes per UTF-16 char.
+     * Both error directions are safe — under-estimating evicts less than ideal,
+     * over-estimating evicts more, and a miss only re-runs the query.
+     */
+    private estimateBytes;
+    /** Largest array at the top level or one level in — where result rows live. */
+    private largestArray;
+    /** Drop least-recently-used entries until the budget is satisfied. */
+    private evictUntilUnderBudget;
     /**
      * Set the cache TTL (Time To Live)
      * @param minutes - TTL in minutes (default: 10)
@@ -2926,6 +2956,7 @@ declare class SuperatomSDK {
     private components;
     private tools;
     private workflows;
+    private registryWaiters;
     private anthropicApiKey;
     private groqApiKey;
     private geminiApiKey;
@@ -3044,6 +3075,19 @@ declare class SuperatomSDK {
      * the workflow component is returned directly, with the LLM-extracted props.
      */
     setWorkflows(workflows: WorkflowDescriptor[]): void;
+    /**
+     * Make sure the agent has a tool surface before answering a prompt.
+     *
+     * Components and workflows are pushed by the browser once per page load and
+     * kept only in memory, so a backend restart leaves both lists empty until
+     * someone reloads a tab. The agent still answers — with no workflows to route
+     * to and no components to render — which looks like a model regression rather
+     * than lost state. Ask the client to re-send instead, and proceed regardless
+     * so a stale or silent client degrades no worse than it does today.
+     */
+    private ensureRegistry;
+    /** Release anyone blocked in ensureRegistry() now that the list has arrived. */
+    private resolveRegistryWaiters;
     /**
      * Get the registered workflow components.
      */

package/dist/index.d.ts

@@ -904,6 +904,13 @@ interface SuperatomSDKConfig {
      * Default: 5 minutes
      */
     queryCacheTTL?: number;
+    /**
+     * Byte budget for cached query results, in MB.
+     * The cache evicts least-recently-used entries to stay under it, so a long TTL
+     * cannot grow the process until the host kills it. Keep it well below the
+     * process memory limit. Default: 1024 MB
+     */
+    queryCacheMaxMB?: number;
     /**
      * Dashboard conversation history TTL (Time To Live) in minutes
      * Per-dashboard conversation histories expire after this duration
@@ -2780,10 +2787,33 @@ declare class QueryCache {
     private cache;
     private ttlMs;
     private maxCacheSize;
+    private maxCacheBytes;
+    private currentBytes;
     private cleanupInterval;
     private readonly algorithm;
     private encryptionKey;
     constructor();
+    /**
+     * Set the byte budget for cached result data.
+     * @param megabytes - Budget in MB. Keep it well under the process memory limit.
+     */
+    setMaxBytes(megabytes: number): void;
+    /** Current estimated bytes held by the data cache. */
+    getCurrentBytes(): number;
+    /**
+     * Rough retained size of a result, in bytes.
+     *
+     * Sampled rather than exact: stringifying a multi-megabyte result on every set()
+     * would allocate the very memory this budget exists to protect. Estimated from a
+     * few rows of the largest array in the payload, at 2 bytes per UTF-16 char.
+     * Both error directions are safe — under-estimating evicts less than ideal,
+     * over-estimating evicts more, and a miss only re-runs the query.
+     */
+    private estimateBytes;
+    /** Largest array at the top level or one level in — where result rows live. */
+    private largestArray;
+    /** Drop least-recently-used entries until the budget is satisfied. */
+    private evictUntilUnderBudget;
     /**
      * Set the cache TTL (Time To Live)
      * @param minutes - TTL in minutes (default: 10)
@@ -2926,6 +2956,7 @@ declare class SuperatomSDK {
     private components;
     private tools;
     private workflows;
+    private registryWaiters;
     private anthropicApiKey;
     private groqApiKey;
     private geminiApiKey;
@@ -3044,6 +3075,19 @@ declare class SuperatomSDK {
      * the workflow component is returned directly, with the LLM-extracted props.
      */
     setWorkflows(workflows: WorkflowDescriptor[]): void;
+    /**
+     * Make sure the agent has a tool surface before answering a prompt.
+     *
+     * Components and workflows are pushed by the browser once per page load and
+     * kept only in memory, so a backend restart leaves both lists empty until
+     * someone reloads a tab. The agent still answers — with no workflows to route
+     * to and no components to render — which looks like a model regression rather
+     * than lost state. Ask the client to re-send instead, and proceed regardless
+     * so a stale or silent client degrades no worse than it does today.
+     */
+    private ensureRegistry;
+    /** Release anyone blocked in ensureRegistry() now that the list has arrived. */
+    private resolveRegistryWaiters;
     /**
      * Get the registered workflow components.
      */

package/dist/index.js

@@ -61,7 +61,7 @@ module.exports = __toCommonJS(index_exports);
 // src/websocket.ts
 var import_ws = __toESM(require("ws"));
 function createWebSocket(url) {
-  return new import_ws.default(url);
+  return new import_ws.default(url, { handshakeTimeout: 15e3 });
 }
 
 // src/types.ts
@@ -1572,6 +1572,13 @@ var QueryCache = class {
     // Default: 10 minutes
     this.maxCacheSize = 5e3;
     // Max data cache entries
+    // A count cap cannot bound memory when entries range from 1KB to 10MB, so the
+    // real limit is in bytes. Without it the process grows until pm2 kills it, which
+    // evicts 100% of the cache — the worst possible eviction policy. LRU sheds the
+    // coldest entries instead and keeps the expensive, frequently-asked queries warm.
+    this.maxCacheBytes = 1024 * 1024 * 1024;
+    // Default: 1 GiB
+    this.currentBytes = 0;
     this.cleanupInterval = null;
     // Encryption for queryId tokens
     this.algorithm = "aes-256-gcm";
@@ -1582,6 +1589,74 @@ var QueryCache = class {
   // ============================================
   // Data Cache (TTL-based, max size)
   // ============================================
+  /**
+   * Set the byte budget for cached result data.
+   * @param megabytes - Budget in MB. Keep it well under the process memory limit.
+   */
+  setMaxBytes(megabytes) {
+    this.maxCacheBytes = Math.max(1, megabytes) * 1024 * 1024;
+    logger.info(`[QueryCache] Byte budget set to ${megabytes} MB`);
+    this.evictUntilUnderBudget();
+  }
+  /** Current estimated bytes held by the data cache. */
+  getCurrentBytes() {
+    return this.currentBytes;
+  }
+  /**
+   * Rough retained size of a result, in bytes.
+   *
+   * Sampled rather than exact: stringifying a multi-megabyte result on every set()
+   * would allocate the very memory this budget exists to protect. Estimated from a
+   * few rows of the largest array in the payload, at 2 bytes per UTF-16 char.
+   * Both error directions are safe — under-estimating evicts less than ideal,
+   * over-estimating evicts more, and a miss only re-runs the query.
+   */
+  estimateBytes(data) {
+    if (data == null) return 0;
+    const rows = this.largestArray(data);
+    if (rows && rows.length > 0) {
+      const sample = Math.min(5, rows.length);
+      let chars = 0;
+      for (let i = 0; i < sample; i++) {
+        try {
+          chars += JSON.stringify(rows[i])?.length ?? 0;
+        } catch {
+          chars += 200;
+        }
+      }
+      return Math.round(chars / sample * rows.length * 2);
+    }
+    try {
+      return (JSON.stringify(data)?.length ?? 0) * 2;
+    } catch {
+      return 1024;
+    }
+  }
+  /** Largest array at the top level or one level in — where result rows live. */
+  largestArray(data) {
+    if (Array.isArray(data)) return data;
+    if (typeof data !== "object") return null;
+    let best = null;
+    for (const value of Object.values(data)) {
+      if (Array.isArray(value) && (!best || value.length > best.length)) best = value;
+    }
+    return best;
+  }
+  /** Drop least-recently-used entries until the budget is satisfied. */
+  evictUntilUnderBudget() {
+    let evicted = 0;
+    while (this.currentBytes > this.maxCacheBytes && this.cache.size > 1) {
+      const oldestKey = this.cache.keys().next().value;
+      if (!oldestKey) break;
+      const entry = this.cache.get(oldestKey);
+      this.cache.delete(oldestKey);
+      if (entry) this.currentBytes -= entry.bytes;
+      evicted++;
+    }
+    if (evicted > 0) {
+      logger.info(`[QueryCache] Evicted ${evicted} LRU entr${evicted === 1 ? "y" : "ies"} for the ${Math.round(this.maxCacheBytes / 1048576)}MB budget (now ${Math.round(this.currentBytes / 1048576)}MB over ${this.cache.size} entries)`);
+    }
+  }
   /**
    * Set the cache TTL (Time To Live)
    * @param minutes - TTL in minutes (default: 10)
@@ -1603,16 +1678,32 @@ var QueryCache = class {
    * a genuinely new key past the size limit.
    */
   set(query, data) {
-    this.cache.delete(query);
+    const previous = this.cache.get(query);
+    if (previous) {
+      this.cache.delete(query);
+      this.currentBytes -= previous.bytes;
+    }
+    const bytes = this.estimateBytes(data);
+    if (bytes > this.maxCacheBytes / 4) {
+      logger.warn(`[QueryCache] Not caching a ${Math.round(bytes / 1048576)}MB result \u2014 over a quarter of the ${Math.round(this.maxCacheBytes / 1048576)}MB budget`);
+      return;
+    }
     if (this.cache.size >= this.maxCacheSize) {
       const oldestKey = this.cache.keys().next().value;
-      if (oldestKey) this.cache.delete(oldestKey);
+      if (oldestKey) {
+        const oldest = this.cache.get(oldestKey);
+        this.cache.delete(oldestKey);
+        if (oldest) this.currentBytes -= oldest.bytes;
+      }
     }
     this.cache.set(query, {
       query,
       data,
-      timestamp: Date.now()
+      timestamp: Date.now(),
+      bytes
     });
+    this.currentBytes += bytes;
+    this.evictUntilUnderBudget();
     logger.debug(`[QueryCache] Stored result for query (${query.substring(0, 50)}...)`);
   }
   /**
@@ -1625,6 +1716,7 @@ var QueryCache = class {
     if (!entry) return null;
     if (Date.now() - entry.timestamp > this.ttlMs) {
       this.cache.delete(query);
+      this.currentBytes -= entry.bytes;
       return null;
     }
     this.cache.delete(query);
@@ -1642,13 +1734,16 @@ var QueryCache = class {
    * Remove a specific query from cache
    */
   delete(query) {
+    const entry = this.cache.get(query);
     this.cache.delete(query);
+    if (entry) this.currentBytes -= entry.bytes;
   }
   /**
    * Clear all cached entries
    */
   clear() {
     this.cache.clear();
+    this.currentBytes = 0;
     logger.info("[QueryCache] Cache cleared");
   }
   /**
@@ -1678,6 +1773,7 @@ var QueryCache = class {
       for (const [key, entry] of this.cache.entries()) {
         if (now - entry.timestamp > this.ttlMs) {
           this.cache.delete(key);
+          this.currentBytes -= entry.bytes;
           expiredCount++;
         }
       }
@@ -6136,6 +6232,7 @@ var LLM = class {
             try {
               currentToolUse.input = currentToolUse.inputJson ? JSON.parse(currentToolUse.inputJson) : {};
             } catch (error) {
+              logger.error(`[LLM] Tool "${currentToolUse.name}" input was not valid JSON, falling back to {}: ${String(currentToolUse.inputJson).substring(0, 500)}`);
               currentToolUse.input = {};
             }
             delete currentToolUse.inputJson;
@@ -6182,6 +6279,7 @@ var LLM = class {
       if (stopReason === "tool_use") {
         const toolUses = contentBlocks.filter((block) => block.type === "tool_use");
         if (toolUses.length === 0) {
+          logger.error(`[LLM] stop_reason=tool_use but no tool_use block survived parsing (${contentBlocks.length} content block(s))`);
           break;
         }
         conversationMessages.push({
@@ -6208,10 +6306,12 @@ var LLM = class {
               content: stripLoneSurrogates(resultContent)
             };
           } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`[LLM] Tool "${toolUse.name}" threw: ${message} | input: ${JSON.stringify(toolUse.input).substring(0, 300)}`);
             return {
               type: "tool_result",
               tool_use_id: toolUse.id,
-              content: error instanceof Error ? error.message : String(error),
+              content: message,
               is_error: true
             };
           }
@@ -17546,6 +17646,8 @@ var SuperatomSDK = class {
     this.components = [];
     this.tools = [];
     this.workflows = [];
+    // Resolvers waiting on a registry re-send, keyed by the RES type expected.
+    this.registryWaiters = /* @__PURE__ */ new Map();
     // Heartbeat properties for keeping WebSocket connection alive.
     // 25s ping + 10s grace stays under common NAT/LB idle thresholds (~60-100s)
     // so we detect dead sockets within seconds instead of minutes.
@@ -17577,6 +17679,9 @@ var SuperatomSDK = class {
     if (config.queryCacheTTL !== void 0) {
       queryCache.setTTL(config.queryCacheTTL);
     }
+    if (config.queryCacheMaxMB !== void 0) {
+      queryCache.setMaxBytes(config.queryCacheMaxMB);
+    }
     if (config.dashboardHistoryTTL !== void 0) {
       dashboardConversationHistory.setTTL(config.dashboardHistoryTTL);
     }
@@ -17728,7 +17833,9 @@ var SuperatomSDK = class {
           });
           break;
         case "USER_PROMPT_REQ":
-          handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders, this.collections, this.tools, this.mainAgentModel, this.sourceAgentModel, this.workflows).catch((error) => {
+          this.ensureRegistry().then(
+            () => handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders, this.collections, this.tools, this.mainAgentModel, this.sourceAgentModel, this.workflows)
+          ).catch((error) => {
             logger.error("Failed to handle user prompt request:", error);
           });
           break;
@@ -17743,13 +17850,21 @@ var SuperatomSDK = class {
           });
           break;
         case "COMPONENT_LIST_RES":
-          handleComponentListResponse(parsed, (com) => this.storeComponents(com), this.collections).catch((error) => {
+          handleComponentListResponse(parsed, (com) => {
+            this.storeComponents(com);
+            this.resolveRegistryWaiters("COMPONENT_LIST_RES");
+          }, this.collections).catch((error) => {
             logger.error("Failed to handle component list request:", error);
+            this.resolveRegistryWaiters("COMPONENT_LIST_RES");
           });
           break;
         case "WORKFLOW_LIST_RES":
-          handleWorkflowListResponse(parsed, (wf) => this.setWorkflows(wf)).catch((error) => {
+          handleWorkflowListResponse(parsed, (wf) => {
+            this.setWorkflows(wf);
+            this.resolveRegistryWaiters("WORKFLOW_LIST_RES");
+          }).catch((error) => {
             logger.error("Failed to handle workflow list request:", error);
+            this.resolveRegistryWaiters("WORKFLOW_LIST_RES");
           });
           break;
         case "USERS":
@@ -18003,6 +18118,50 @@ var SuperatomSDK = class {
     this.workflows = workflows;
     logger.info(`Workflows stored in SDK: ${workflows.length} workflow(s)`);
   }
+  /**
+   * Make sure the agent has a tool surface before answering a prompt.
+   *
+   * Components and workflows are pushed by the browser once per page load and
+   * kept only in memory, so a backend restart leaves both lists empty until
+   * someone reloads a tab. The agent still answers — with no workflows to route
+   * to and no components to render — which looks like a model regression rather
+   * than lost state. Ask the client to re-send instead, and proceed regardless
+   * so a stale or silent client degrades no worse than it does today.
+   */
+  async ensureRegistry(timeoutMs = 4e3) {
+    const missing = [];
+    if (this.workflows.length === 0) missing.push(["WORKFLOW_LIST_REQ", "WORKFLOW_LIST_RES"]);
+    if (this.components.length === 0) missing.push(["COMPONENT_LIST_REQ", "COMPONENT_LIST_RES"]);
+    if (missing.length === 0) return;
+    logger.warn(`Registry empty, requesting from client: ${missing.map(([req]) => req).join(", ")}`);
+    await Promise.all(missing.map(([reqType, resType]) => new Promise((resolve) => {
+      let settled = false;
+      const finish = () => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      };
+      const waiters = this.registryWaiters.get(resType) ?? [];
+      waiters.push(finish);
+      this.registryWaiters.set(resType, waiters);
+      const sent = this.send({
+        type: reqType,
+        from: { type: this.type },
+        to: { type: "runtime" },
+        payload: {}
+      });
+      if (!sent) finish();
+      else setTimeout(finish, timeoutMs);
+    })));
+  }
+  /** Release anyone blocked in ensureRegistry() now that the list has arrived. */
+  resolveRegistryWaiters(resType) {
+    const waiters = this.registryWaiters.get(resType);
+    if (!waiters || waiters.length === 0) return;
+    this.registryWaiters.delete(resType);
+    waiters.forEach((resolve) => resolve());
+  }
   /**
    * Get the registered workflow components.
    */

package/dist/index.mjs

@@ -1,7 +1,7 @@
 // src/websocket.ts
 import WebSocket from "ws";
 function createWebSocket(url) {
-  return new WebSocket(url);
+  return new WebSocket(url, { handshakeTimeout: 15e3 });
 }
 
 // src/types.ts
@@ -1512,6 +1512,13 @@ var QueryCache = class {
     // Default: 10 minutes
     this.maxCacheSize = 5e3;
     // Max data cache entries
+    // A count cap cannot bound memory when entries range from 1KB to 10MB, so the
+    // real limit is in bytes. Without it the process grows until pm2 kills it, which
+    // evicts 100% of the cache — the worst possible eviction policy. LRU sheds the
+    // coldest entries instead and keeps the expensive, frequently-asked queries warm.
+    this.maxCacheBytes = 1024 * 1024 * 1024;
+    // Default: 1 GiB
+    this.currentBytes = 0;
     this.cleanupInterval = null;
     // Encryption for queryId tokens
     this.algorithm = "aes-256-gcm";
@@ -1522,6 +1529,74 @@ var QueryCache = class {
   // ============================================
   // Data Cache (TTL-based, max size)
   // ============================================
+  /**
+   * Set the byte budget for cached result data.
+   * @param megabytes - Budget in MB. Keep it well under the process memory limit.
+   */
+  setMaxBytes(megabytes) {
+    this.maxCacheBytes = Math.max(1, megabytes) * 1024 * 1024;
+    logger.info(`[QueryCache] Byte budget set to ${megabytes} MB`);
+    this.evictUntilUnderBudget();
+  }
+  /** Current estimated bytes held by the data cache. */
+  getCurrentBytes() {
+    return this.currentBytes;
+  }
+  /**
+   * Rough retained size of a result, in bytes.
+   *
+   * Sampled rather than exact: stringifying a multi-megabyte result on every set()
+   * would allocate the very memory this budget exists to protect. Estimated from a
+   * few rows of the largest array in the payload, at 2 bytes per UTF-16 char.
+   * Both error directions are safe — under-estimating evicts less than ideal,
+   * over-estimating evicts more, and a miss only re-runs the query.
+   */
+  estimateBytes(data) {
+    if (data == null) return 0;
+    const rows = this.largestArray(data);
+    if (rows && rows.length > 0) {
+      const sample = Math.min(5, rows.length);
+      let chars = 0;
+      for (let i = 0; i < sample; i++) {
+        try {
+          chars += JSON.stringify(rows[i])?.length ?? 0;
+        } catch {
+          chars += 200;
+        }
+      }
+      return Math.round(chars / sample * rows.length * 2);
+    }
+    try {
+      return (JSON.stringify(data)?.length ?? 0) * 2;
+    } catch {
+      return 1024;
+    }
+  }
+  /** Largest array at the top level or one level in — where result rows live. */
+  largestArray(data) {
+    if (Array.isArray(data)) return data;
+    if (typeof data !== "object") return null;
+    let best = null;
+    for (const value of Object.values(data)) {
+      if (Array.isArray(value) && (!best || value.length > best.length)) best = value;
+    }
+    return best;
+  }
+  /** Drop least-recently-used entries until the budget is satisfied. */
+  evictUntilUnderBudget() {
+    let evicted = 0;
+    while (this.currentBytes > this.maxCacheBytes && this.cache.size > 1) {
+      const oldestKey = this.cache.keys().next().value;
+      if (!oldestKey) break;
+      const entry = this.cache.get(oldestKey);
+      this.cache.delete(oldestKey);
+      if (entry) this.currentBytes -= entry.bytes;
+      evicted++;
+    }
+    if (evicted > 0) {
+      logger.info(`[QueryCache] Evicted ${evicted} LRU entr${evicted === 1 ? "y" : "ies"} for the ${Math.round(this.maxCacheBytes / 1048576)}MB budget (now ${Math.round(this.currentBytes / 1048576)}MB over ${this.cache.size} entries)`);
+    }
+  }
   /**
    * Set the cache TTL (Time To Live)
    * @param minutes - TTL in minutes (default: 10)
@@ -1543,16 +1618,32 @@ var QueryCache = class {
    * a genuinely new key past the size limit.
    */
   set(query, data) {
-    this.cache.delete(query);
+    const previous = this.cache.get(query);
+    if (previous) {
+      this.cache.delete(query);
+      this.currentBytes -= previous.bytes;
+    }
+    const bytes = this.estimateBytes(data);
+    if (bytes > this.maxCacheBytes / 4) {
+      logger.warn(`[QueryCache] Not caching a ${Math.round(bytes / 1048576)}MB result \u2014 over a quarter of the ${Math.round(this.maxCacheBytes / 1048576)}MB budget`);
+      return;
+    }
     if (this.cache.size >= this.maxCacheSize) {
       const oldestKey = this.cache.keys().next().value;
-      if (oldestKey) this.cache.delete(oldestKey);
+      if (oldestKey) {
+        const oldest = this.cache.get(oldestKey);
+        this.cache.delete(oldestKey);
+        if (oldest) this.currentBytes -= oldest.bytes;
+      }
     }
     this.cache.set(query, {
       query,
       data,
-      timestamp: Date.now()
+      timestamp: Date.now(),
+      bytes
     });
+    this.currentBytes += bytes;
+    this.evictUntilUnderBudget();
     logger.debug(`[QueryCache] Stored result for query (${query.substring(0, 50)}...)`);
   }
   /**
@@ -1565,6 +1656,7 @@ var QueryCache = class {
     if (!entry) return null;
     if (Date.now() - entry.timestamp > this.ttlMs) {
       this.cache.delete(query);
+      this.currentBytes -= entry.bytes;
       return null;
     }
     this.cache.delete(query);
@@ -1582,13 +1674,16 @@ var QueryCache = class {
    * Remove a specific query from cache
    */
   delete(query) {
+    const entry = this.cache.get(query);
     this.cache.delete(query);
+    if (entry) this.currentBytes -= entry.bytes;
   }
   /**
    * Clear all cached entries
    */
   clear() {
     this.cache.clear();
+    this.currentBytes = 0;
     logger.info("[QueryCache] Cache cleared");
   }
   /**
@@ -1618,6 +1713,7 @@ var QueryCache = class {
       for (const [key, entry] of this.cache.entries()) {
         if (now - entry.timestamp > this.ttlMs) {
           this.cache.delete(key);
+          this.currentBytes -= entry.bytes;
           expiredCount++;
         }
       }
@@ -6076,6 +6172,7 @@ var LLM = class {
             try {
               currentToolUse.input = currentToolUse.inputJson ? JSON.parse(currentToolUse.inputJson) : {};
             } catch (error) {
+              logger.error(`[LLM] Tool "${currentToolUse.name}" input was not valid JSON, falling back to {}: ${String(currentToolUse.inputJson).substring(0, 500)}`);
               currentToolUse.input = {};
             }
             delete currentToolUse.inputJson;
@@ -6122,6 +6219,7 @@ var LLM = class {
       if (stopReason === "tool_use") {
         const toolUses = contentBlocks.filter((block) => block.type === "tool_use");
         if (toolUses.length === 0) {
+          logger.error(`[LLM] stop_reason=tool_use but no tool_use block survived parsing (${contentBlocks.length} content block(s))`);
           break;
         }
         conversationMessages.push({
@@ -6148,10 +6246,12 @@ var LLM = class {
               content: stripLoneSurrogates(resultContent)
             };
           } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`[LLM] Tool "${toolUse.name}" threw: ${message} | input: ${JSON.stringify(toolUse.input).substring(0, 300)}`);
             return {
               type: "tool_result",
               tool_use_id: toolUse.id,
-              content: error instanceof Error ? error.message : String(error),
+              content: message,
               is_error: true
             };
           }
@@ -17486,6 +17586,8 @@ var SuperatomSDK = class {
     this.components = [];
     this.tools = [];
     this.workflows = [];
+    // Resolvers waiting on a registry re-send, keyed by the RES type expected.
+    this.registryWaiters = /* @__PURE__ */ new Map();
     // Heartbeat properties for keeping WebSocket connection alive.
     // 25s ping + 10s grace stays under common NAT/LB idle thresholds (~60-100s)
     // so we detect dead sockets within seconds instead of minutes.
@@ -17517,6 +17619,9 @@ var SuperatomSDK = class {
     if (config.queryCacheTTL !== void 0) {
       queryCache.setTTL(config.queryCacheTTL);
     }
+    if (config.queryCacheMaxMB !== void 0) {
+      queryCache.setMaxBytes(config.queryCacheMaxMB);
+    }
     if (config.dashboardHistoryTTL !== void 0) {
       dashboardConversationHistory.setTTL(config.dashboardHistoryTTL);
     }
@@ -17668,7 +17773,9 @@ var SuperatomSDK = class {
           });
           break;
         case "USER_PROMPT_REQ":
-          handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders, this.collections, this.tools, this.mainAgentModel, this.sourceAgentModel, this.workflows).catch((error) => {
+          this.ensureRegistry().then(
+            () => handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders, this.collections, this.tools, this.mainAgentModel, this.sourceAgentModel, this.workflows)
+          ).catch((error) => {
             logger.error("Failed to handle user prompt request:", error);
           });
           break;
@@ -17683,13 +17790,21 @@ var SuperatomSDK = class {
           });
           break;
         case "COMPONENT_LIST_RES":
-          handleComponentListResponse(parsed, (com) => this.storeComponents(com), this.collections).catch((error) => {
+          handleComponentListResponse(parsed, (com) => {
+            this.storeComponents(com);
+            this.resolveRegistryWaiters("COMPONENT_LIST_RES");
+          }, this.collections).catch((error) => {
             logger.error("Failed to handle component list request:", error);
+            this.resolveRegistryWaiters("COMPONENT_LIST_RES");
           });
           break;
         case "WORKFLOW_LIST_RES":
-          handleWorkflowListResponse(parsed, (wf) => this.setWorkflows(wf)).catch((error) => {
+          handleWorkflowListResponse(parsed, (wf) => {
+            this.setWorkflows(wf);
+            this.resolveRegistryWaiters("WORKFLOW_LIST_RES");
+          }).catch((error) => {
             logger.error("Failed to handle workflow list request:", error);
+            this.resolveRegistryWaiters("WORKFLOW_LIST_RES");
           });
           break;
         case "USERS":
@@ -17943,6 +18058,50 @@ var SuperatomSDK = class {
     this.workflows = workflows;
     logger.info(`Workflows stored in SDK: ${workflows.length} workflow(s)`);
   }
+  /**
+   * Make sure the agent has a tool surface before answering a prompt.
+   *
+   * Components and workflows are pushed by the browser once per page load and
+   * kept only in memory, so a backend restart leaves both lists empty until
+   * someone reloads a tab. The agent still answers — with no workflows to route
+   * to and no components to render — which looks like a model regression rather
+   * than lost state. Ask the client to re-send instead, and proceed regardless
+   * so a stale or silent client degrades no worse than it does today.
+   */
+  async ensureRegistry(timeoutMs = 4e3) {
+    const missing = [];
+    if (this.workflows.length === 0) missing.push(["WORKFLOW_LIST_REQ", "WORKFLOW_LIST_RES"]);
+    if (this.components.length === 0) missing.push(["COMPONENT_LIST_REQ", "COMPONENT_LIST_RES"]);
+    if (missing.length === 0) return;
+    logger.warn(`Registry empty, requesting from client: ${missing.map(([req]) => req).join(", ")}`);
+    await Promise.all(missing.map(([reqType, resType]) => new Promise((resolve) => {
+      let settled = false;
+      const finish = () => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      };
+      const waiters = this.registryWaiters.get(resType) ?? [];
+      waiters.push(finish);
+      this.registryWaiters.set(resType, waiters);
+      const sent = this.send({
+        type: reqType,
+        from: { type: this.type },
+        to: { type: "runtime" },
+        payload: {}
+      });
+      if (!sent) finish();
+      else setTimeout(finish, timeoutMs);
+    })));
+  }
+  /** Release anyone blocked in ensureRegistry() now that the list has arrived. */
+  resolveRegistryWaiters(resType) {
+    const waiters = this.registryWaiters.get(resType);
+    if (!waiters || waiters.length === 0) return;
+    this.registryWaiters.delete(resType);
+    waiters.forEach((resolve) => resolve());
+  }
   /**
    * Get the registered workflow components.
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superatomai/sdk-node",
-  "version": "0.0.51-mds",
+  "version": "0.0.52-mds",
   "description": "Node.js TypeScript SDK for Superatom",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",