@probelabs/probe 0.6.0-rc215 → 0.6.0-rc217

package/build/agent/ProbeAgent.js

@@ -72,6 +72,7 @@ import { FallbackManager, createFallbackManagerFromEnv, buildFallbackProvidersFr
 import { handleContextLimitError } from './contextCompactor.js';
 import { formatErrorForAI, ParameterError } from '../utils/error-types.js';
 import { truncateIfNeeded, getMaxOutputTokens } from './outputTruncator.js';
+import { DelegationManager } from '../delegate.js';
 import {
   TaskManager,
   createTaskTool,
@@ -315,6 +316,10 @@ export class ProbeAgent {
     this.enableTasks = !!options.enableTasks;
     this.taskManager = null; // Initialized per-request in answer()
 
+    // Per-instance delegation manager for concurrent delegation limits
+    // Each ProbeAgent instance has its own limits, not shared globally
+    this.delegationManager = new DelegationManager();
+
     // Retry configuration
     this.retryConfig = options.retry || {};
     this.retryManager = null; // Will be initialized lazily when needed
@@ -538,6 +543,7 @@ export class ProbeAgent {
       architectureFileName: this.architectureFileName,
       provider: this.clientApiProvider,
       model: this.clientApiModel,
+      delegationManager: this.delegationManager,  // Per-instance delegation limits
       isToolAllowed
     };
 
@@ -4371,6 +4377,18 @@ Convert your previous response content into actual JSON data that follows this s
       }
     }
 
+    // Clean up delegation manager
+    if (this.delegationManager) {
+      try {
+        this.delegationManager.cleanup();
+        if (this.debug) {
+          console.log('[DEBUG] Delegation manager cleaned up');
+        }
+      } catch (error) {
+        console.error('Error cleaning up delegation manager:', error);
+      }
+    }
+
     // Clear history and other resources
     this.clearHistory();
   }

package/build/agent/index.js

@@ -3767,11 +3767,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 = randomUUID();
   const startTime = Date.now();
   const remainingIterations = Math.max(1, maxIterations - currentIteration);
@@ -3779,17 +3782,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({
@@ -3883,7 +3886,7 @@ async function delegate({
       }
     }
     if (acquired) {
-      delegationManager.release(parentSessionId, debug);
+      manager.release(parentSessionId, debug);
     }
     return response;
   } catch (error) {
@@ -3893,7 +3896,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`);
@@ -3921,7 +3924,7 @@ async function delegate({
     throw new Error(`Delegation failed: ${error.message}`);
   }
 }
-var DelegationManager, delegationManager;
+var DelegationManager, defaultDelegationManager;
 var init_delegate = __esm({
   "src/delegate.js"() {
     "use strict";
@@ -3930,8 +3933,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();
@@ -3946,13 +3951,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);
@@ -3961,6 +3967,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);
@@ -3974,10 +3988,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((resolve8, 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);
+            resolve8(value);
+          };
+          entry.reject = (error) => {
+            if (settled) return;
+            settled = true;
+            if (entry.timeoutId) clearTimeout(entry.timeoutId);
+            reject2(error);
+          };
+          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);
@@ -3991,7 +4055,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: resolve8, 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}`);
+          }
+          resolve8(true);
         }
       }
       /**
@@ -4002,7 +4095,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
         };
       }
       /**
@@ -4024,11 +4119,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();
   }
 });
 
@@ -4140,7 +4244,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 };
@@ -4238,7 +4344,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;
@@ -4301,7 +4409,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));
@@ -4357,7 +4467,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);
@@ -4379,7 +4491,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.');
@@ -4391,7 +4505,9 @@ async function analyzeAll(options) {
     allowedFolders,
     provider,
     model,
-    tracer
+    tracer,
+    delegationManager
+    // Per-instance delegation limits
   };
   if (debug) {
     console.error(`[analyze_all] Starting analysis`);
@@ -10318,7 +10434,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 tool2({
         name: "delegate",
         description: delegateDescription,
@@ -10380,14 +10496,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 tool2({
         name: "analyze_all",
         description: analyzeAllDescription,
@@ -10415,7 +10533,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 (error) {
@@ -69835,6 +69955,7 @@ var init_ProbeAgent = __esm({
     init_contextCompactor();
     init_error_types();
     init_outputTruncator();
+    init_delegate();
     init_tasks();
     dotenv2.config();
     MAX_TOOL_ITERATIONS = (() => {
@@ -69976,6 +70097,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;
@@ -70147,6 +70269,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);
@@ -73165,6 +73289,16 @@ Convert your previous response content into actual JSON data that follows this s
             console.error("Error cleaning up MCP bridge:", error);
           }
         }
+        if (this.delegationManager) {
+          try {
+            this.delegationManager.cleanup();
+            if (this.debug) {
+              console.log("[DEBUG] Delegation manager cleaned up");
+            }
+          } catch (error) {
+            console.error("Error cleaning up delegation manager:", error);
+          }
+        }
         this.clearHistory();
       }
       /**