llmist 10.0.0 → 10.1.0

package/dist/index.cjs

@@ -8331,6 +8331,13 @@ var init_stream_processor = __esm({
       inFlightExecutions = /* @__PURE__ */ new Map();
       /** Queue of completed gadget results ready to be yielded (for real-time streaming) */
       completedResultsQueue = [];
+      // Concurrency limiting
+      /** Subagent configuration map for checking maxConcurrent limits */
+      subagentConfig;
+      /** Track active execution count per gadget name */
+      activeCountByGadget = /* @__PURE__ */ new Map();
+      /** Queue of gadgets waiting for a concurrency slot (per gadget name) */
+      concurrencyQueue = /* @__PURE__ */ new Map();
       // Cross-iteration dependency tracking
       /** Invocation IDs completed in previous iterations (read-only reference from Agent) */
       priorCompletedInvocations;
@@ -8346,6 +8353,7 @@ var init_stream_processor = __esm({
         this.baseDepth = options.baseDepth ?? 0;
         this.priorCompletedInvocations = options.priorCompletedInvocations ?? /* @__PURE__ */ new Set();
         this.priorFailedInvocations = options.priorFailedInvocations ?? /* @__PURE__ */ new Set();
+        this.subagentConfig = options.subagentConfig;
         this.parser = new GadgetCallParser({
           startPrefix: options.gadgetStartPrefix,
           endPrefix: options.gadgetEndPrefix,
@@ -8609,9 +8617,63 @@ var init_stream_processor = __esm({
           }
           return;
         }
-        const executionPromise = this.executeGadgetAndCollect(call);
+        const limit = this.getConcurrencyLimit(call.gadgetName);
+        const activeCount = this.activeCountByGadget.get(call.gadgetName) ?? 0;
+        if (limit > 0 && activeCount >= limit) {
+          this.logger.debug("Gadget queued due to concurrency limit", {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            activeCount,
+            limit
+          });
+          const queue = this.concurrencyQueue.get(call.gadgetName) ?? [];
+          queue.push(call);
+          this.concurrencyQueue.set(call.gadgetName, queue);
+          return;
+        }
+        this.startGadgetWithConcurrencyTracking(call);
+      }
+      /**
+       * Get the concurrency limit for a gadget from subagent config.
+       * Returns 0 if no limit is set (unlimited).
+       */
+      getConcurrencyLimit(gadgetName) {
+        const config = this.subagentConfig?.[gadgetName];
+        return config?.maxConcurrent ?? 0;
+      }
+      /**
+       * Start a gadget execution with concurrency tracking.
+       * Increments active count, starts execution, and schedules queue processing on completion.
+       */
+      startGadgetWithConcurrencyTracking(call) {
+        const gadgetName = call.gadgetName;
+        const currentCount = this.activeCountByGadget.get(gadgetName) ?? 0;
+        this.activeCountByGadget.set(gadgetName, currentCount + 1);
+        const executionPromise = this.executeGadgetAndCollect(call).finally(() => {
+          const newCount = (this.activeCountByGadget.get(gadgetName) ?? 1) - 1;
+          this.activeCountByGadget.set(gadgetName, newCount);
+          this.processQueuedGadget(gadgetName);
+        });
         this.inFlightExecutions.set(call.invocationId, executionPromise);
       }
+      /**
+       * Process the next queued gadget for a given gadget name if a slot is available.
+       */
+      processQueuedGadget(gadgetName) {
+        const queue = this.concurrencyQueue.get(gadgetName);
+        if (!queue || queue.length === 0) return;
+        const limit = this.getConcurrencyLimit(gadgetName);
+        const activeCount = this.activeCountByGadget.get(gadgetName) ?? 0;
+        if (limit === 0 || activeCount < limit) {
+          const nextCall = queue.shift();
+          this.logger.debug("Processing queued gadget", {
+            gadgetName,
+            invocationId: nextCall.invocationId,
+            remainingInQueue: queue.length
+          });
+          this.startGadgetWithConcurrencyTracking(nextCall);
+        }
+      }
       /**
        * Execute a gadget through the full hook lifecycle and yield events.
        * Handles parameter interception, before/after controllers, observers,
@@ -8799,27 +8861,58 @@ var init_stream_processor = __esm({
        * Clears the inFlightExecutions map after all gadgets complete.
        */
       async *waitForInFlightExecutions() {
-        if (this.inFlightExecutions.size === 0) {
+        if (this.inFlightExecutions.size === 0 && !this.hasQueuedGadgets()) {
           return;
         }
         this.logger.debug("Waiting for in-flight gadget executions", {
           count: this.inFlightExecutions.size,
-          invocationIds: Array.from(this.inFlightExecutions.keys())
+          invocationIds: Array.from(this.inFlightExecutions.keys()),
+          queuedCount: this.getQueuedGadgetCount()
         });
-        const allDone = Promise.all(this.inFlightExecutions.values()).then(() => "done");
         const POLL_INTERVAL_MS = 100;
-        while (true) {
+        while (this.inFlightExecutions.size > 0 || this.hasQueuedGadgets()) {
+          const allDone = this.inFlightExecutions.size > 0 ? Promise.all(this.inFlightExecutions.values()).then(() => "done") : Promise.resolve("done");
           const result = await Promise.race([
             allDone,
             new Promise((resolve) => setTimeout(() => resolve("poll"), POLL_INTERVAL_MS))
           ]);
           yield* this.drainCompletedResults();
-          if (result === "done") {
+          if (result === "done" && this.getTotalActiveGadgetCount() === 0 && !this.hasQueuedGadgets()) {
             break;
           }
         }
         this.inFlightExecutions.clear();
       }
+      /**
+       * Check if there are any gadgets waiting in concurrency queues.
+       */
+      hasQueuedGadgets() {
+        for (const queue of this.concurrencyQueue.values()) {
+          if (queue.length > 0) return true;
+        }
+        return false;
+      }
+      /**
+       * Get total count of queued gadgets across all queues.
+       */
+      getQueuedGadgetCount() {
+        let count = 0;
+        for (const queue of this.concurrencyQueue.values()) {
+          count += queue.length;
+        }
+        return count;
+      }
+      /**
+       * Get total count of actively executing gadgets across all types.
+       * Used to know when all work is truly complete (not just when allDone resolves).
+       */
+      getTotalActiveGadgetCount() {
+        let total = 0;
+        for (const count of this.activeCountByGadget.values()) {
+          total += count;
+        }
+        return total;
+      }
       /**
        * Handle a gadget that cannot execute because a dependency failed.
        * Calls the onDependencySkipped controller to allow customization.