llmist 10.0.0 → 10.1.0

package/dist/index.d.cts

@@ -2545,6 +2545,13 @@ interface SubagentConfig {
      * Set to 0 to disable timeout for this gadget.
      */
     timeoutMs?: number;
+    /**
+     * Maximum number of concurrent executions allowed for this gadget.
+     * When the limit is reached, additional calls are queued and processed
+     * as earlier executions complete (FIFO order).
+     * Set to 0 or omit to allow unlimited concurrent executions (default).
+     */
+    maxConcurrent?: number;
     /** Additional subagent-specific options */
     [key: string]: unknown;
 }
@@ -7294,6 +7301,12 @@ declare class StreamProcessor {
     private inFlightExecutions;
     /** Queue of completed gadget results ready to be yielded (for real-time streaming) */
     private completedResultsQueue;
+    /** Subagent configuration map for checking maxConcurrent limits */
+    private readonly subagentConfig?;
+    /** Track active execution count per gadget name */
+    private activeCountByGadget;
+    /** Queue of gadgets waiting for a concurrency slot (per gadget name) */
+    private concurrencyQueue;
     /** Invocation IDs completed in previous iterations (read-only reference from Agent) */
     private readonly priorCompletedInvocations;
     /** Invocation IDs that failed in previous iterations (read-only reference from Agent) */
@@ -7325,6 +7338,20 @@ declare class StreamProcessor {
      * enabling real-time UI feedback.
      */
     private processGadgetCallGenerator;
+    /**
+     * Get the concurrency limit for a gadget from subagent config.
+     * Returns 0 if no limit is set (unlimited).
+     */
+    private getConcurrencyLimit;
+    /**
+     * Start a gadget execution with concurrency tracking.
+     * Increments active count, starts execution, and schedules queue processing on completion.
+     */
+    private startGadgetWithConcurrencyTracking;
+    /**
+     * Process the next queued gadget for a given gadget name if a slot is available.
+     */
+    private processQueuedGadget;
     /**
      * Execute a gadget through the full hook lifecycle and yield events.
      * Handles parameter interception, before/after controllers, observers,
@@ -7352,6 +7379,19 @@ declare class StreamProcessor {
      * Clears the inFlightExecutions map after all gadgets complete.
      */
     private waitForInFlightExecutions;
+    /**
+     * Check if there are any gadgets waiting in concurrency queues.
+     */
+    private hasQueuedGadgets;
+    /**
+     * Get total count of queued gadgets across all queues.
+     */
+    private getQueuedGadgetCount;
+    /**
+     * Get total count of actively executing gadgets across all types.
+     * Used to know when all work is truly complete (not just when allDone resolves).
+     */
+    private getTotalActiveGadgetCount;
     /**
      * Handle a gadget that cannot execute because a dependency failed.
      * Calls the onDependencySkipped controller to allow customization.

package/dist/index.d.ts

@@ -2545,6 +2545,13 @@ interface SubagentConfig {
      * Set to 0 to disable timeout for this gadget.
      */
     timeoutMs?: number;
+    /**
+     * Maximum number of concurrent executions allowed for this gadget.
+     * When the limit is reached, additional calls are queued and processed
+     * as earlier executions complete (FIFO order).
+     * Set to 0 or omit to allow unlimited concurrent executions (default).
+     */
+    maxConcurrent?: number;
     /** Additional subagent-specific options */
     [key: string]: unknown;
 }
@@ -7294,6 +7301,12 @@ declare class StreamProcessor {
     private inFlightExecutions;
     /** Queue of completed gadget results ready to be yielded (for real-time streaming) */
     private completedResultsQueue;
+    /** Subagent configuration map for checking maxConcurrent limits */
+    private readonly subagentConfig?;
+    /** Track active execution count per gadget name */
+    private activeCountByGadget;
+    /** Queue of gadgets waiting for a concurrency slot (per gadget name) */
+    private concurrencyQueue;
     /** Invocation IDs completed in previous iterations (read-only reference from Agent) */
     private readonly priorCompletedInvocations;
     /** Invocation IDs that failed in previous iterations (read-only reference from Agent) */
@@ -7325,6 +7338,20 @@ declare class StreamProcessor {
      * enabling real-time UI feedback.
      */
     private processGadgetCallGenerator;
+    /**
+     * Get the concurrency limit for a gadget from subagent config.
+     * Returns 0 if no limit is set (unlimited).
+     */
+    private getConcurrencyLimit;
+    /**
+     * Start a gadget execution with concurrency tracking.
+     * Increments active count, starts execution, and schedules queue processing on completion.
+     */
+    private startGadgetWithConcurrencyTracking;
+    /**
+     * Process the next queued gadget for a given gadget name if a slot is available.
+     */
+    private processQueuedGadget;
     /**
      * Execute a gadget through the full hook lifecycle and yield events.
      * Handles parameter interception, before/after controllers, observers,
@@ -7352,6 +7379,19 @@ declare class StreamProcessor {
      * Clears the inFlightExecutions map after all gadgets complete.
      */
     private waitForInFlightExecutions;
+    /**
+     * Check if there are any gadgets waiting in concurrency queues.
+     */
+    private hasQueuedGadgets;
+    /**
+     * Get total count of queued gadgets across all queues.
+     */
+    private getQueuedGadgetCount;
+    /**
+     * Get total count of actively executing gadgets across all types.
+     * Used to know when all work is truly complete (not just when allDone resolves).
+     */
+    private getTotalActiveGadgetCount;
     /**
      * Handle a gadget that cannot execute because a dependency failed.
      * Calls the onDependencySkipped controller to allow customization.

package/dist/index.js

@@ -8318,6 +8318,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;
@@ -8333,6 +8340,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,
@@ -8596,9 +8604,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,
@@ -8786,27 +8848,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.