llmist 16.2.0 → 16.2.1

package/dist/index.cjs

@@ -13964,8 +13964,9 @@ var init_parser2 = __esm({
        * - `GadgetName` - Auto-generate ID, no dependencies
        * - `GadgetName:my_id` - Explicit ID, no dependencies
        * - `GadgetName:my_id:dep1,dep2` - Explicit ID with dependencies
+       * - `GadgetName:my_id:dep1:dep2:dep3` - Colons treated as dep separators (LLM resilience)
        *
-       * Dependencies must be comma-separated invocation IDs.
+       * Dependencies can be comma-separated or colon-separated invocation IDs.
        */
       parseInvocationMetadata(headerLine) {
         const parts = headerLine.split(":");
@@ -13982,7 +13983,12 @@ var init_parser2 = __esm({
             dependencies: []
           };
         } else {
-          const deps = parts[2].split(",").map((d) => d.trim()).filter((d) => d.length > 0);
+          const depsRaw = parts.slice(2).join(",");
+          const deps = [
+            ...new Set(
+              depsRaw.split(",").map((d) => d.trim()).filter((d) => d.length > 0)
+            )
+          ];
           return {
             gadgetName: parts[0],
             invocationId: parts[1].trim(),
@@ -14555,6 +14561,8 @@ var init_gadget_concurrency_manager = __esm({
       concurrencyQueue = /* @__PURE__ */ new Map();
       /** All active gadget promises, keyed by invocationId */
       inFlightExecutions = /* @__PURE__ */ new Map();
+      /** Gadget name for each in-flight invocationId (for timeout event emission) */
+      inFlightGadgetNames = /* @__PURE__ */ new Map();
       /** Queue of exclusive gadgets deferred until in-flight gadgets complete */
       exclusiveQueue = [];
       constructor(options) {
@@ -14682,6 +14690,7 @@ var init_gadget_concurrency_manager = __esm({
         const currentCount = this.activeCountByGadget.get(gadgetName) ?? 0;
         this.activeCountByGadget.set(gadgetName, currentCount + 1);
         this.inFlightExecutions.set(invocationId, promise);
+        this.inFlightGadgetNames.set(invocationId, gadgetName);
       }
       /**
        * Called when a gadget execution completes.
@@ -14725,11 +14734,25 @@ var init_gadget_concurrency_manager = __esm({
         this.exclusiveQueue.push(call);
       }
       /**
-       * Clear the inFlightExecutions map after all promises have completed.
-       * Called after waitForAll resolves.
+       * Clear all in-flight tracking state.
+       * Called after all promises have completed, or on force-timeout.
+       * Also clears active gadget counts to prevent stale state when
+       * hanging promises eventually resolve into the void.
        */
       clearInFlight() {
         this.inFlightExecutions.clear();
+        this.inFlightGadgetNames.clear();
+        this.activeCountByGadget.clear();
+      }
+      /**
+       * Get metadata for all currently in-flight executions.
+       * Used by the dispatcher to emit skip events when the in-flight timeout fires.
+       */
+      getInFlightEntries() {
+        return Array.from(this.inFlightGadgetNames.entries()).map(([invocationId, gadgetName]) => ({
+          invocationId,
+          gadgetName
+        }));
       }
       // ==========================================================================
       // Waiting
@@ -15054,6 +15077,7 @@ var init_gadget_dispatcher = __esm({
       logger;
       pushToQueue;
       drainQueue;
+      inFlightTimeoutMs;
       constructor(options) {
         this.iteration = options.iteration;
         this.hookLifecycle = options.hookLifecycle;
@@ -15068,6 +15092,7 @@ var init_gadget_dispatcher = __esm({
         this.logger = options.logger ?? createLogger({ name: "llmist:gadget-dispatcher" });
         this.pushToQueue = options.pushToQueue;
         this.drainQueue = options.drainQueue;
+        this.inFlightTimeoutMs = options.inFlightTimeoutMs ?? 3e5;
       }
       // ==========================================================================
       // Primary dispatch entry point
@@ -15099,39 +15124,54 @@ var init_gadget_dispatcher = __esm({
             parentId: this.parentNodeId
           });
         }
+        let effectiveCall = call;
         if (call.dependencies.length > 0) {
-          if (call.dependencies.includes(call.invocationId)) {
-            this.logger.warn("Gadget has self-referential dependency (depends on itself)", {
+          const selfRefs = [];
+          const validDeps = [];
+          for (const dep of call.dependencies) {
+            (dep === call.invocationId ? selfRefs : validDeps).push(dep);
+          }
+          if (selfRefs.length > 0) {
+            this.logger.warn("Filtering self-referential dependencies", {
               gadgetName: call.gadgetName,
-              invocationId: call.invocationId
+              invocationId: call.invocationId,
+              removedSelfRefs: selfRefs,
+              remainingDeps: validDeps
             });
-            const errorMessage = `Gadget "${call.invocationId}" cannot depend on itself (self-referential dependency)`;
-            for await (const evt of this.emitGadgetSkipEvents(call, call.invocationId, errorMessage)) {
-              yield evt;
+            effectiveCall = { ...call, dependencies: validDeps };
+            if (validDeps.length === 0) {
+              const errorMessage = `Gadget "${call.invocationId}" cannot depend on itself (self-referential dependency)`;
+              for await (const evt of this.emitGadgetSkipEvents(
+                effectiveCall,
+                call.invocationId,
+                errorMessage
+              )) {
+                yield evt;
+              }
+              return;
             }
-            return;
           }
-          const failedDep = this.dependencyResolver.getFailedDependency(call);
+          const failedDep = this.dependencyResolver.getFailedDependency(effectiveCall);
           if (failedDep) {
-            const skipEvents = await this.handleFailedDependency(call, failedDep);
+            const skipEvents = await this.handleFailedDependency(effectiveCall, failedDep);
             for (const evt of skipEvents) {
               yield evt;
             }
             return;
           }
-          if (!this.dependencyResolver.isAllSatisfied(call)) {
-            const unsatisfied = call.dependencies.filter(
+          if (!this.dependencyResolver.isAllSatisfied(effectiveCall)) {
+            const unsatisfied = effectiveCall.dependencies.filter(
               (dep) => !this.dependencyResolver.isCompleted(dep)
             );
             this.logger.debug("Queueing gadget for later - waiting on dependencies", {
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
+              gadgetName: effectiveCall.gadgetName,
+              invocationId: effectiveCall.invocationId,
               waitingOn: unsatisfied
             });
-            this.dependencyResolver.addPending(call);
+            this.dependencyResolver.addPending(effectiveCall);
             return;
           }
-          for await (const evt of this._checkLimitThenExecute(call)) {
+          for await (const evt of this._checkLimitThenExecute(effectiveCall)) {
             yield evt;
           }
           for await (const evt of this.processPendingGadgets()) {
@@ -15270,7 +15310,31 @@ var init_gadget_dispatcher = __esm({
           queuedCount: this.concurrencyManager.getQueuedGadgetCount()
         });
         const POLL_INTERVAL_MS = 100;
+        const startTime = Date.now();
         while (this.concurrencyManager.inFlightCount > 0 || this.concurrencyManager.hasQueuedGadgets()) {
+          if (Date.now() - startTime >= this.inFlightTimeoutMs) {
+            const timedOutEntries = this.concurrencyManager.getInFlightEntries();
+            this.logger.error("In-flight gadget timeout exceeded, force-clearing remaining gadgets", {
+              timeoutMs: this.inFlightTimeoutMs,
+              remainingInFlight: timedOutEntries.length,
+              remainingQueued: this.concurrencyManager.getQueuedGadgetCount(),
+              timedOutInvocations: timedOutEntries.map((e) => e.invocationId)
+            });
+            const timeoutError = `Gadget execution timed out after ${this.inFlightTimeoutMs}ms`;
+            for (const { invocationId, gadgetName } of timedOutEntries) {
+              this.dependencyResolver.markFailed(invocationId);
+              yield {
+                type: "gadget_skipped",
+                gadgetName,
+                invocationId,
+                parameters: {},
+                failedDependency: invocationId,
+                failedDependencyError: timeoutError
+              };
+            }
+            this.concurrencyManager.clearInFlight();
+            break;
+          }
           const allDone = this.concurrencyManager.getAllDonePromise();
           const result = await Promise.race([
             allDone,
@@ -15856,7 +15920,8 @@ var init_stream_processor = __esm({
             const evts = [...this.completedResultsQueue];
             this.completedResultsQueue = [];
             return evts;
-          }
+          },
+          inFlightTimeoutMs: options.inFlightTimeoutMs
         });
       }
       /**
@@ -16080,6 +16145,7 @@ var init_stream_processor_factory = __esm({
       logger;
       requestHumanInput;
       defaultGadgetTimeoutMs;
+      inFlightTimeoutMs;
       gadgetExecutionMode;
       client;
       mediaStore;
@@ -16098,6 +16164,7 @@ var init_stream_processor_factory = __esm({
         this.logger = options.logger;
         this.requestHumanInput = options.requestHumanInput;
         this.defaultGadgetTimeoutMs = options.defaultGadgetTimeoutMs;
+        this.inFlightTimeoutMs = options.inFlightTimeoutMs;
         this.gadgetExecutionMode = options.gadgetExecutionMode;
         this.client = options.client;
         this.mediaStore = options.mediaStore;
@@ -16129,6 +16196,7 @@ var init_stream_processor_factory = __esm({
           logger: this.logger.getSubLogger({ name: "stream-processor" }),
           requestHumanInput: this.requestHumanInput,
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
+          inFlightTimeoutMs: this.inFlightTimeoutMs,
           gadgetExecutionMode: this.gadgetExecutionMode,
           client: this.client,
           mediaStore: this.mediaStore,