@probelabs/probe 0.6.0-rc215 → 0.6.0-rc217

package/cjs/agent/ProbeAgent.cjs

@@ -33092,11 +33092,14 @@ async function delegate({
   enableTasks = false,
   enableMcp = false,
   mcpConfig = null,
-  mcpConfigPath = null
+  mcpConfigPath = null,
+  delegationManager = null
+  // Optional per-instance manager, falls back to default singleton
 }) {
   if (!task || typeof task !== "string") {
     throw new Error("Task parameter is required and must be a string");
   }
+  const manager = delegationManager || defaultDelegationManager;
   const sessionId = (0, import_crypto2.randomUUID)();
   const startTime = Date.now();
   const remainingIterations = Math.max(1, maxIterations - currentIteration);
@@ -33104,17 +33107,17 @@ async function delegate({
   let timeoutId = null;
   let acquired = false;
   try {
-    delegationManager.tryAcquire(parentSessionId);
+    await manager.acquire(parentSessionId, debug);
     acquired = true;
     if (debug) {
-      const stats = delegationManager.getStats();
+      const stats = manager.getStats();
       console.error(`[DELEGATE] Starting delegation session ${sessionId}`);
       console.error(`[DELEGATE] Parent session: ${parentSessionId || "none"}`);
       console.error(`[DELEGATE] Task: ${task}`);
       console.error(`[DELEGATE] Current iteration: ${currentIteration}/${maxIterations}`);
       console.error(`[DELEGATE] Remaining iterations for subagent: ${remainingIterations}`);
       console.error(`[DELEGATE] Timeout configured: ${timeout} seconds`);
-      console.error(`[DELEGATE] Global active delegations: ${stats.globalActive}/${stats.maxConcurrent}`);
+      console.error(`[DELEGATE] Global active delegations: ${stats.globalActive}/${stats.maxConcurrent}, queue: ${stats.queueSize}`);
       console.error(`[DELEGATE] Using ProbeAgent SDK with ${promptType} prompt`);
     }
     const subagent = new ProbeAgent({
@@ -33208,7 +33211,7 @@ async function delegate({
       }
     }
     if (acquired) {
-      delegationManager.release(parentSessionId, debug);
+      manager.release(parentSessionId, debug);
     }
     return response;
   } catch (error2) {
@@ -33218,7 +33221,7 @@ async function delegate({
     }
     const duration = Date.now() - startTime;
     if (acquired) {
-      delegationManager.release(parentSessionId, debug);
+      manager.release(parentSessionId, debug);
     }
     if (debug) {
       console.error(`[DELEGATE] Task failed for session ${sessionId} after ${duration}ms`);
@@ -33246,7 +33249,7 @@ async function delegate({
     throw new Error(`Delegation failed: ${error2.message}`);
   }
 }
-var import_crypto2, DelegationManager, delegationManager;
+var import_crypto2, DelegationManager, defaultDelegationManager;
 var init_delegate = __esm({
   "src/delegate.js"() {
     "use strict";
@@ -33256,8 +33259,10 @@ var init_delegate = __esm({
       constructor() {
         this.maxConcurrent = parseInt(process.env.MAX_CONCURRENT_DELEGATIONS || "3", 10);
         this.maxPerSession = parseInt(process.env.MAX_DELEGATIONS_PER_SESSION || "10", 10);
+        this.defaultQueueTimeout = parseInt(process.env.DELEGATION_QUEUE_TIMEOUT || "60000", 10);
         this.sessionDelegations = /* @__PURE__ */ new Map();
         this.globalActive = 0;
+        this.waitQueue = [];
         this.cleanupInterval = setInterval(() => {
           try {
             this.cleanupStaleSessions();
@@ -33272,13 +33277,14 @@ var init_delegate = __esm({
       /**
        * Check limits and increment counters (synchronous, atomic in Node.js event loop)
        * @param {string|null|undefined} parentSessionId - Parent session ID for tracking
+       * @returns {boolean} true if acquired, false if would need to wait
        */
       tryAcquire(parentSessionId) {
         if (parentSessionId !== null && parentSessionId !== void 0 && typeof parentSessionId !== "string") {
           throw new TypeError("parentSessionId must be a string, null, or undefined");
         }
         if (this.globalActive >= this.maxConcurrent) {
-          throw new Error(`Maximum concurrent delegations (${this.maxConcurrent}) reached. Please wait for some delegations to complete.`);
+          return false;
         }
         if (parentSessionId) {
           const sessionData = this.sessionDelegations.get(parentSessionId);
@@ -33287,6 +33293,14 @@ var init_delegate = __esm({
             throw new Error(`Maximum delegations per session (${this.maxPerSession}) reached for session ${parentSessionId}`);
           }
         }
+        this._incrementCounters(parentSessionId);
+        return true;
+      }
+      /**
+       * Internal helper to increment counters
+       * @private
+       */
+      _incrementCounters(parentSessionId) {
         this.globalActive++;
         if (parentSessionId) {
           const sessionData = this.sessionDelegations.get(parentSessionId);
@@ -33300,10 +33314,60 @@ var init_delegate = __esm({
             });
           }
         }
-        return true;
       }
       /**
-       * Decrement counters (synchronous, atomic in Node.js event loop)
+       * Acquire a delegation slot, waiting in queue if necessary
+       * @param {string|null|undefined} parentSessionId - Parent session ID for tracking
+       * @param {boolean} debug - Enable debug logging
+       * @param {number|null} queueTimeout - Max time to wait in queue (ms). Defaults to this.defaultQueueTimeout. Set to 0 to disable.
+       * @returns {Promise<boolean>} Resolves when slot is acquired, rejects on timeout or session limit error
+       */
+      async acquire(parentSessionId, debug = false, queueTimeout = null) {
+        const effectiveTimeout = queueTimeout !== null ? queueTimeout : this.defaultQueueTimeout;
+        if (this.tryAcquire(parentSessionId)) {
+          return true;
+        }
+        if (debug) {
+          console.error(`[DelegationManager] Slot unavailable (${this.globalActive}/${this.maxConcurrent}), queuing... (queue size: ${this.waitQueue.length}, timeout: ${effectiveTimeout}ms)`);
+        }
+        return new Promise((resolve7, reject2) => {
+          const entry = {
+            resolve: null,
+            // Will be wrapped below
+            reject: null,
+            // Will be wrapped below
+            parentSessionId,
+            debug,
+            queuedAt: Date.now(),
+            timeoutId: null
+          };
+          let settled = false;
+          entry.resolve = (value) => {
+            if (settled) return;
+            settled = true;
+            if (entry.timeoutId) clearTimeout(entry.timeoutId);
+            resolve7(value);
+          };
+          entry.reject = (error2) => {
+            if (settled) return;
+            settled = true;
+            if (entry.timeoutId) clearTimeout(entry.timeoutId);
+            reject2(error2);
+          };
+          if (effectiveTimeout > 0) {
+            entry.timeoutId = setTimeout(() => {
+              const index = this.waitQueue.indexOf(entry);
+              if (index !== -1) {
+                this.waitQueue.splice(index, 1);
+              }
+              entry.reject(new Error(`Delegation queue timeout: waited ${effectiveTimeout}ms for an available slot`));
+            }, effectiveTimeout);
+          }
+          this.waitQueue.push(entry);
+        });
+      }
+      /**
+       * Decrement counters and process queue (synchronous, atomic in Node.js event loop)
        */
       release(parentSessionId, debug = false) {
         this.globalActive = Math.max(0, this.globalActive - 1);
@@ -33317,7 +33381,36 @@ var init_delegate = __esm({
           }
         }
         if (debug) {
-          console.error(`[DELEGATE] Released. Global active: ${this.globalActive}`);
+          console.error(`[DELEGATE] Released. Global active: ${this.globalActive}, queue size: ${this.waitQueue.length}`);
+        }
+        this._processQueue(debug);
+      }
+      /**
+       * Process the wait queue - grant slot to next waiting delegation
+       * @private
+       */
+      _processQueue(debug = false) {
+        while (this.waitQueue.length > 0 && this.globalActive < this.maxConcurrent) {
+          const next = this.waitQueue.shift();
+          if (!next) break;
+          const { resolve: resolve7, reject: reject2, parentSessionId, queuedAt } = next;
+          if (parentSessionId) {
+            const sessionData = this.sessionDelegations.get(parentSessionId);
+            const sessionCount = sessionData?.count || 0;
+            if (sessionCount >= this.maxPerSession) {
+              if (debug) {
+                console.error(`[DelegationManager] Session limit (${this.maxPerSession}) reached for queued item, rejecting`);
+              }
+              reject2(new Error(`Maximum delegations per session (${this.maxPerSession}) reached for session ${parentSessionId}`));
+              continue;
+            }
+          }
+          this._incrementCounters(parentSessionId);
+          if (debug) {
+            const waitTime = Date.now() - queuedAt;
+            console.error(`[DelegationManager] Granted slot from queue (waited ${waitTime}ms). Active: ${this.globalActive}/${this.maxConcurrent}`);
+          }
+          resolve7(true);
         }
       }
       /**
@@ -33328,7 +33421,9 @@ var init_delegate = __esm({
           globalActive: this.globalActive,
           maxConcurrent: this.maxConcurrent,
           maxPerSession: this.maxPerSession,
-          sessionCount: this.sessionDelegations.size
+          defaultQueueTimeout: this.defaultQueueTimeout,
+          sessionCount: this.sessionDelegations.size,
+          queueSize: this.waitQueue.length
         };
       }
       /**
@@ -33350,11 +33445,20 @@ var init_delegate = __esm({
           clearInterval(this.cleanupInterval);
           this.cleanupInterval = null;
         }
+        for (const entry of this.waitQueue) {
+          if (entry.timeoutId) {
+            clearTimeout(entry.timeoutId);
+          }
+          if (entry.reject) {
+            entry.reject(new Error("DelegationManager was cleaned up"));
+          }
+        }
+        this.waitQueue = [];
         this.sessionDelegations.clear();
         this.globalActive = 0;
       }
     };
-    delegationManager = new DelegationManager();
+    defaultDelegationManager = new DelegationManager();
   }
 });
 
@@ -33466,7 +33570,9 @@ Instructions:
       enableBash: false,
       promptType: "code-researcher",
       allowedTools: ["extract"],
-      maxIterations: 5
+      maxIterations: 5,
+      delegationManager: options.delegationManager
+      // Per-instance delegation limits
       // timeout removed - inherit default from delegate (300s)
     });
     return { chunk, result };
@@ -33564,7 +33670,9 @@ Organize all findings into clear categories with items listed under each.${compl
       enableBash: false,
       promptType: "code-researcher",
       allowedTools: [],
-      maxIterations: 5
+      maxIterations: 5,
+      delegationManager: options.delegationManager
+      // Per-instance delegation limits
       // timeout removed - inherit default from delegate (300s)
     });
     return result;
@@ -33627,7 +33735,9 @@ CRITICAL: Do NOT guess keywords. Actually run searches and see what returns resu
       enableBash: false,
       promptType: "code-researcher",
       // Full tool access for exploration and experimentation
-      maxIterations: 15
+      maxIterations: 15,
+      delegationManager: options.delegationManager
+      // Per-instance delegation limits
       // timeout removed - inherit default from delegate (300s)
     });
     const plan = parsePlanningResult(stripResultTags(result));
@@ -33683,7 +33793,9 @@ IMPORTANT: When completing, use the FULL format: <attempt_completion><result>YOU
       enableBash: false,
       promptType: "code-researcher",
       allowedTools: [],
-      maxIterations: 5
+      maxIterations: 5,
+      delegationManager: options.delegationManager
+      // Per-instance delegation limits
       // timeout removed - inherit default from delegate (300s)
     });
     return stripResultTags(result);
@@ -33705,7 +33817,9 @@ async function analyzeAll(options) {
     model,
     tracer,
     chunkSizeTokens = DEFAULT_CHUNK_SIZE_TOKENS,
-    maxChunks = MAX_CHUNKS
+    maxChunks = MAX_CHUNKS,
+    delegationManager = null
+    // Per-instance delegation limits
   } = options;
   if (!question) {
     throw new Error('The "question" parameter is required.');
@@ -33717,7 +33831,9 @@ async function analyzeAll(options) {
     allowedFolders,
     provider,
     model,
-    tracer
+    tracer,
+    delegationManager
+    // Per-instance delegation limits
   };
   if (debug) {
     console.error(`[analyze_all] Starting analysis`);
@@ -39644,7 +39760,7 @@ var init_vercel = __esm({
       });
     };
     delegateTool = (options = {}) => {
-      const { debug = false, timeout = 300, cwd, allowedFolders, enableBash = false, bashConfig, architectureFileName, enableMcp = false, mcpConfig = null, mcpConfigPath = null } = options;
+      const { debug = false, timeout = 300, cwd, allowedFolders, enableBash = false, bashConfig, architectureFileName, enableMcp = false, mcpConfig = null, mcpConfigPath = null, delegationManager = null } = options;
       return (0, import_ai2.tool)({
         name: "delegate",
         description: delegateDescription,
@@ -39706,14 +39822,16 @@ var init_vercel = __esm({
             searchDelegate,
             enableMcp,
             mcpConfig,
-            mcpConfigPath
+            mcpConfigPath,
+            delegationManager
+            // Per-instance delegation limits
           });
           return result;
         }
       });
     };
     analyzeAllTool = (options = {}) => {
-      const { sessionId, debug = false } = options;
+      const { sessionId, debug = false, delegationManager = null } = options;
       return (0, import_ai2.tool)({
         name: "analyze_all",
         description: analyzeAllDescription,
@@ -39741,7 +39859,9 @@ var init_vercel = __esm({
               allowedFolders: options.allowedFolders,
               provider: options.provider,
               model: options.model,
-              tracer: options.tracer
+              tracer: options.tracer,
+              delegationManager
+              // Per-instance delegation limits
             });
             return result;
           } catch (error2) {
@@ -98904,6 +99024,7 @@ var init_ProbeAgent = __esm({
     init_contextCompactor();
     init_error_types();
     init_outputTruncator();
+    init_delegate();
     init_tasks();
     import_dotenv2.default.config();
     MAX_TOOL_ITERATIONS = (() => {
@@ -99045,6 +99166,7 @@ var init_ProbeAgent = __esm({
         this._mcpInitialized = false;
         this.enableTasks = !!options.enableTasks;
         this.taskManager = null;
+        this.delegationManager = new DelegationManager();
         this.retryConfig = options.retry || {};
         this.retryManager = null;
         this.fallbackConfig = options.fallback || null;
@@ -99216,6 +99338,8 @@ var init_ProbeAgent = __esm({
           architectureFileName: this.architectureFileName,
           provider: this.clientApiProvider,
           model: this.clientApiModel,
+          delegationManager: this.delegationManager,
+          // Per-instance delegation limits
           isToolAllowed
         };
         const baseTools = createTools(configOptions);
@@ -102234,6 +102358,16 @@ Convert your previous response content into actual JSON data that follows this s
             console.error("Error cleaning up MCP bridge:", error2);
           }
         }
+        if (this.delegationManager) {
+          try {
+            this.delegationManager.cleanup();
+            if (this.debug) {
+              console.log("[DEBUG] Delegation manager cleaned up");
+            }
+          } catch (error2) {
+            console.error("Error cleaning up delegation manager:", error2);
+          }
+        }
         this.clearHistory();
       }
       /**