llmist 15.4.1 → 15.6.0

package/dist/index.cjs

@@ -186,7 +186,31 @@ var init_execution_tree = __esm({
         });
       }
       /**
-       * Complete an LLM call node.
+       * Mark an LLM call's response as ended (tokens stopped).
+       *
+       * Called when the LLM stream ends, before gadget execution completes.
+       * Use this event to track "LLM thinking time" separately from gadget execution.
+       *
+       * @param nodeId - The LLM call node ID
+       * @param params - Response end parameters (finishReason, usage)
+       */
+      endLLMResponse(nodeId, params) {
+        const node = this.nodes.get(nodeId);
+        if (!node || node.type !== "llm_call") {
+          return;
+        }
+        const llmNode = node;
+        this.emit({
+          type: "llm_response_end",
+          ...this.createBaseEventProps(node),
+          iteration: llmNode.iteration,
+          model: llmNode.model,
+          finishReason: params.finishReason,
+          usage: params.usage
+        });
+      }
+      /**
+       * Complete an LLM call node (after all gadgets finish).
        */
       completeLLMCall(nodeId, params) {
         const node = this.nodes.get(nodeId);
@@ -2631,6 +2655,32 @@ var init_gadget = __esm({
        * while maintaining runtime compatibility.
        */
       examples;
+      /**
+       * Maximum number of concurrent executions allowed for this gadget.
+       * Use this to prevent race conditions in gadgets that modify shared state.
+       *
+       * - `1` = Sequential execution (only one instance runs at a time)
+       * - `0` or `undefined` = Unlimited concurrency (default)
+       * - `N > 1` = At most N concurrent executions
+       *
+       * This property sets a safety floor: external configuration (SubagentConfig)
+       * can only make concurrency MORE restrictive, never less. For example, if
+       * a gadget declares `maxConcurrent: 1`, external config cannot override it
+       * to allow parallel execution.
+       *
+       * @example
+       * ```typescript
+       * // File writer that must run sequentially to avoid race conditions
+       * class WriteFile extends Gadget({
+       *   description: 'Writes content to a file',
+       *   schema: z.object({ path: z.string(), content: z.string() }),
+       *   maxConcurrent: 1, // Sequential - prevents race conditions
+       * }) {
+       *   execute(params: this['params']) { ... }
+       * }
+       * ```
+       */
+      maxConcurrent;
       /**
        * Throws an AbortException if the execution has been aborted.
        *
@@ -2834,6 +2884,7 @@ function createGadget(config) {
     parameterSchema = config.schema;
     timeoutMs = config.timeoutMs;
     examples = config.examples;
+    maxConcurrent = config.maxConcurrent;
     execute(params, ctx) {
       return config.execute(params, ctx);
     }
@@ -10967,6 +11018,7 @@ function Gadget(config) {
     name = config.name;
     timeoutMs = config.timeoutMs;
     examples = config.examples;
+    maxConcurrent = config.maxConcurrent;
     /**
      * Type helper property for accessing inferred parameter type.
      * This is used in the execute method signature: `execute(params: this['params'])`
@@ -11265,7 +11317,8 @@ var init_executor = __esm({
             storedMedia
           };
         } catch (error) {
-          if (error instanceof TaskCompletionSignal) {
+          const isTaskCompletionSignal = error instanceof Error && error.name === "TaskCompletionSignal";
+          if (isTaskCompletionSignal) {
             this.logger.info("Gadget requested loop termination", {
               gadgetName: call.gadgetName,
               message: error.message
@@ -11818,6 +11871,7 @@ var init_stream_processor = __esm({
             }
           }
         }
+        yield { type: "llm_response_end", finishReason, usage };
         for (const event of this.parser.finalize()) {
           for await (const processedEvent of this.processEventGenerator(event)) {
             yield processedEvent;
@@ -12022,12 +12076,23 @@ var init_stream_processor = __esm({
         this.startGadgetWithConcurrencyTracking(call);
       }
       /**
-       * Get the concurrency limit for a gadget from subagent config.
-       * Returns 0 if no limit is set (unlimited).
+       * Get the effective concurrency limit for a gadget.
+       * Uses "most restrictive wins" strategy: the lowest non-zero value from
+       * external config (SubagentConfig) and gadget's intrinsic maxConcurrent.
+       *
+       * This ensures gadget authors can set safety floors (e.g., maxConcurrent: 1
+       * for file writers) that cannot be weakened by external configuration.
+       *
+       * @returns 0 if unlimited, otherwise the effective limit
        */
       getConcurrencyLimit(gadgetName) {
-        const config = this.subagentConfig?.[gadgetName];
-        return config?.maxConcurrent ?? 0;
+        const configLimit = this.subagentConfig?.[gadgetName]?.maxConcurrent;
+        const gadget = this.registry.get(gadgetName);
+        const gadgetLimit = gadget?.maxConcurrent;
+        const config = configLimit || Number.POSITIVE_INFINITY;
+        const intrinsic = gadgetLimit || Number.POSITIVE_INFINITY;
+        const effective = Math.min(config, intrinsic);
+        return effective === Number.POSITIVE_INFINITY ? 0 : effective;
       }
       /**
        * Start a gadget execution with concurrency tracking.
@@ -13039,6 +13104,11 @@ var init_agent = __esm({
                     } else if (event.type === "gadget_result") {
                       gadgetCallCount++;
                       gadgetResults.push(event);
+                    } else if (event.type === "llm_response_end") {
+                      this.tree.endLLMResponse(currentLLMNodeId, {
+                        finishReason: event.finishReason,
+                        usage: event.usage
+                      });
                     }
                     yield event;
                   }