llmist 18.1.0 → 18.3.0

package/dist/index.js

@@ -1305,7 +1305,8 @@ function resolveRetryConfig(config) {
     onRetriesExhausted: config.onRetriesExhausted,
     shouldRetry: config.shouldRetry,
     respectRetryAfter: config.respectRetryAfter ?? DEFAULT_RETRY_CONFIG.respectRetryAfter,
-    maxRetryAfterMs: config.maxRetryAfterMs ?? DEFAULT_RETRY_CONFIG.maxRetryAfterMs
+    maxRetryAfterMs: config.maxRetryAfterMs ?? DEFAULT_RETRY_CONFIG.maxRetryAfterMs,
+    retryOnEmpty: config.retryOnEmpty ?? DEFAULT_RETRY_CONFIG.retryOnEmpty
   };
 }
 function getErrorStatusCode(error) {
@@ -1557,8 +1558,9 @@ var init_retry = __esm({
       factor: 2,
       randomize: true,
       respectRetryAfter: true,
-      maxRetryAfterMs: 12e4
+      maxRetryAfterMs: 12e4,
       // 2 minutes cap
+      retryOnEmpty: true
     };
   }
 });
@@ -2465,6 +2467,18 @@ async function runWithHandlers(agentGenerator, handlers) {
           });
         }
         break;
+      case "gadget_args_partial":
+        if (handlers.onGadgetArgsPartial) {
+          await handlers.onGadgetArgsPartial({
+            gadgetName: event.gadgetName,
+            invocationId: event.invocationId,
+            fieldPath: event.fieldPath,
+            value: event.value,
+            delta: event.delta,
+            isFieldComplete: event.isFieldComplete
+          });
+        }
+        break;
       case "gadget_result":
         if (handlers.onGadgetResult) {
           await handlers.onGadgetResult(event.result);
@@ -3773,11 +3787,51 @@ var init_output_limit_manager = __esm({
   }
 });
 
+// src/core/errors.ts
+function isAbortError(error) {
+  if (!(error instanceof Error)) return false;
+  if (error.name === "AbortError") return true;
+  if (error.name === "APIConnectionAbortedError") return true;
+  if (error.name === "APIUserAbortError") return true;
+  const message = error.message.toLowerCase();
+  if (message.includes("abort")) return true;
+  if (message.includes("cancelled")) return true;
+  if (message.includes("canceled")) return true;
+  return false;
+}
+var EmptyCompletionError;
+var init_errors2 = __esm({
+  "src/core/errors.ts"() {
+    "use strict";
+    EmptyCompletionError = class extends Error {
+      /** Agent iteration on which the empty completion was observed. */
+      iteration;
+      /** Finish reason reported alongside the empty body (often null). */
+      finishReason;
+      constructor(params) {
+        super(
+          `LLM returned an empty completion (no text, tool calls, or reasoning) on iteration ${params.iteration}`
+        );
+        this.name = "EmptyCompletionError";
+        this.iteration = params.iteration;
+        this.finishReason = params.finishReason;
+      }
+    };
+  }
+});
+
 // src/agent/retry-orchestrator.ts
+function isEmptyCompletion(meta) {
+  if (meta.didExecuteGadgets) return false;
+  if (meta.rawResponse?.trim() || meta.finalMessage?.trim()) return false;
+  if (meta.thinkingContent?.trim()) return false;
+  return true;
+}
 var RetryOrchestrator;
 var init_retry_orchestrator = __esm({
   "src/agent/retry-orchestrator.ts"() {
     "use strict";
+    init_errors2();
     init_retry();
     init_safe_observe();
     init_tree_hook_bridge();
@@ -3843,6 +3897,7 @@ var init_retry_orchestrator = __esm({
         let gadgetCallCount = 0;
         const textOutputs = [];
         const gadgetResults = [];
+        let emptyFailure = null;
         while (streamAttempt < maxStreamAttempts) {
           streamAttempt++;
           try {
@@ -3851,6 +3906,7 @@ var init_retry_orchestrator = __esm({
             for await (const event of processor.process(stream2)) {
               if (event.type === "stream_complete") {
                 streamMetadata = event;
+                continue;
               }
               if (event.type === "llm_response_end") {
                 this.tree.endLLMResponse(llmNodeId, {
@@ -3872,43 +3928,44 @@ var init_retry_orchestrator = __esm({
             for (const id of processor.getFailedInvocationIds()) {
               this.failedInvocationIds.add(id);
             }
+            if (this.retryConfig.enabled && this.retryConfig.retryOnEmpty && streamMetadata !== null && !streamMetadata.finishReason && isEmptyCompletion(streamMetadata)) {
+              const emptyError = new EmptyCompletionError({
+                iteration,
+                finishReason: streamMetadata.finishReason
+              });
+              if (streamAttempt < maxStreamAttempts) {
+                await this.backoffBeforeRetry(
+                  emptyError,
+                  streamAttempt,
+                  maxStreamAttempts,
+                  iteration,
+                  llmNodeId
+                );
+                streamMetadata = null;
+                gadgetCallCount = 0;
+                textOutputs.length = 0;
+                gadgetResults.length = 0;
+                continue;
+              }
+              emptyFailure = emptyError;
+              break;
+            }
+            if (streamMetadata !== null) {
+              yield streamMetadata;
+            }
             break;
           } catch (streamError) {
             const error = streamError;
             const canRetry = this.retryConfig.enabled && streamAttempt < maxStreamAttempts;
             const shouldRetryError = this.retryConfig.shouldRetry ? this.retryConfig.shouldRetry(error) : isRetryableError(error);
             if (canRetry && shouldRetryError) {
-              const retryAfterMs = this.retryConfig.respectRetryAfter ? extractRetryAfterMs(error) : null;
-              const baseDelay = this.retryConfig.minTimeout * this.retryConfig.factor ** (streamAttempt - 1);
-              const cappedBaseDelay = Math.min(baseDelay, this.retryConfig.maxTimeout);
-              const delay = retryAfterMs !== null ? Math.min(retryAfterMs, this.retryConfig.maxRetryAfterMs) : cappedBaseDelay;
-              const finalDelay = this.retryConfig.randomize ? delay * (0.5 + Math.random()) : delay;
-              this.logger.warn(
-                `Stream iteration failed (attempt ${streamAttempt}/${maxStreamAttempts}), retrying...`,
-                {
-                  error: error.message,
-                  retriesLeft: maxStreamAttempts - streamAttempt,
-                  delayMs: Math.round(finalDelay),
-                  retryAfterMs
-                }
+              await this.backoffBeforeRetry(
+                error,
+                streamAttempt,
+                maxStreamAttempts,
+                iteration,
+                llmNodeId
               );
-              this.retryConfig.onRetry?.(error, streamAttempt);
-              await safeObserve(async () => {
-                if (this.hooks.observers?.onRetryAttempt) {
-                  const subagentContext = getSubagentContextForNode(this.tree, llmNodeId);
-                  const hookContext = {
-                    iteration,
-                    attemptNumber: streamAttempt,
-                    retriesLeft: maxStreamAttempts - streamAttempt,
-                    error,
-                    retryAfterMs: retryAfterMs ?? void 0,
-                    logger: this.logger,
-                    subagentContext
-                  };
-                  await this.hooks.observers.onRetryAttempt(hookContext);
-                }
-              }, this.logger);
-              await this.sleep(finalDelay);
               streamMetadata = null;
               gadgetCallCount = 0;
               textOutputs.length = 0;
@@ -3925,8 +3982,55 @@ var init_retry_orchestrator = __esm({
             throw error;
           }
         }
+        if (emptyFailure !== null) {
+          this.logger.error(`LLM returned empty completions on all ${streamAttempt} attempts`, {
+            iteration
+          });
+          this.retryConfig.onRetriesExhausted?.(emptyFailure, streamAttempt);
+          throw emptyFailure;
+        }
         return streamMetadata !== null ? { streamMetadata, textOutputs, gadgetResults, gadgetCallCount } : null;
       }
+      /**
+       * Apply the configured backoff before a retry attempt: compute the delay
+       * (Retry-After hint or exponential backoff, with optional jitter), emit the
+       * retry log, fire the `onRetry` callback and `onRetryAttempt` observer, then
+       * sleep. Shared by the error-retry and empty-completion-retry paths so both
+       * honour identical backoff and observer semantics.
+       */
+      async backoffBeforeRetry(error, streamAttempt, maxStreamAttempts, iteration, llmNodeId) {
+        const retryAfterMs = this.retryConfig.respectRetryAfter ? extractRetryAfterMs(error) : null;
+        const baseDelay = this.retryConfig.minTimeout * this.retryConfig.factor ** (streamAttempt - 1);
+        const cappedBaseDelay = Math.min(baseDelay, this.retryConfig.maxTimeout);
+        const delay = retryAfterMs !== null ? Math.min(retryAfterMs, this.retryConfig.maxRetryAfterMs) : cappedBaseDelay;
+        const finalDelay = this.retryConfig.randomize ? delay * (0.5 + Math.random()) : delay;
+        this.logger.warn(
+          `Stream iteration failed (attempt ${streamAttempt}/${maxStreamAttempts}), retrying...`,
+          {
+            error: error.message,
+            retriesLeft: maxStreamAttempts - streamAttempt,
+            delayMs: Math.round(finalDelay),
+            retryAfterMs
+          }
+        );
+        this.retryConfig.onRetry?.(error, streamAttempt);
+        await safeObserve(async () => {
+          if (this.hooks.observers?.onRetryAttempt) {
+            const subagentContext = getSubagentContextForNode(this.tree, llmNodeId);
+            const hookContext = {
+              iteration,
+              attemptNumber: streamAttempt,
+              retriesLeft: maxStreamAttempts - streamAttempt,
+              error,
+              retryAfterMs: retryAfterMs ?? void 0,
+              logger: this.logger,
+              subagentContext
+            };
+            await this.hooks.observers.onRetryAttempt(hookContext);
+          }
+        }, this.logger);
+        await this.sleep(finalDelay);
+      }
     };
   }
 });
@@ -11067,7 +11171,7 @@ var init_model_registry = __esm({
        * Register a provider and collect its model specifications
        */
       registerProvider(provider) {
-        const specs = provider.getModelSpecs?.() ?? [];
+        const specs = [...provider.getModelSpecs?.() ?? []];
         if (specs.length > 0) {
           this.modelSpecs.push(...specs);
           this.providerMap.set(provider.providerId, specs);
@@ -11161,7 +11265,7 @@ var init_model_registry = __esm({
         if (!providerId) {
           return [...this.modelSpecs];
         }
-        return this.providerMap.get(providerId) ?? [];
+        return [...this.providerMap.get(providerId) ?? []];
       }
       /**
        * Get context window and output limits for a model
@@ -13062,13 +13166,22 @@ var init_parser2 = __esm({
     GadgetCallParser = class {
       buffer = "";
       lastEmittedTextOffset = 0;
+      /** Non-null only while a single trailing gadget block is mid-stream. */
+      currentPartial = null;
       startPrefix;
       endPrefix;
       argPrefix;
+      /** Length of the longest marker; `maxMarkerLength - 1` is the scan-resume overlap. */
+      maxMarkerLength;
       constructor(options = {}) {
         this.startPrefix = options.startPrefix ?? GADGET_START_PREFIX;
         this.endPrefix = options.endPrefix ?? GADGET_END_PREFIX;
         this.argPrefix = options.argPrefix ?? GADGET_ARG_PREFIX;
+        this.maxMarkerLength = Math.max(
+          this.startPrefix.length,
+          this.endPrefix.length,
+          this.argPrefix.length
+        );
       }
       /**
        * Extract and consume text up to the given index.
@@ -13155,12 +13268,13 @@ var init_parser2 = __esm({
           const metadataEndIndex = this.buffer.indexOf("\n", metadataStartIndex);
           if (metadataEndIndex === -1) break;
           const headerLine = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
-          const { gadgetName, invocationId, dependencies } = this.parseInvocationMetadata(headerLine);
+          const { gadgetName, invocationId, dependencies } = this.currentPartial ? this.currentPartial : this.parseInvocationMetadata(headerLine);
           const contentStartIndex = metadataEndIndex + 1;
           let partEndIndex;
           let endMarkerLength = 0;
-          const nextStartPos = this.buffer.indexOf(this.startPrefix, contentStartIndex);
-          const endPos = this.buffer.indexOf(this.endPrefix, contentStartIndex);
+          const bodySearchStart = this.currentPartial ? contentStartIndex + Math.max(0, this.currentPartial.bodyScannedLen - (this.maxMarkerLength - 1)) : contentStartIndex;
+          const nextStartPos = this.buffer.indexOf(this.startPrefix, bodySearchStart);
+          const endPos = this.buffer.indexOf(this.endPrefix, bodySearchStart);
           if (nextStartPos !== -1 && (endPos === -1 || nextStartPos < endPos)) {
             partEndIndex = nextStartPos;
             endMarkerLength = 0;
@@ -13168,9 +13282,22 @@ var init_parser2 = __esm({
             partEndIndex = endPos;
             endMarkerLength = this.endPrefix.length;
           } else {
+            if (!this.currentPartial) {
+              this.currentPartial = this.newPartialState(gadgetName, invocationId, dependencies);
+            }
+            yield* this.emitArgPartials(
+              this.currentPartial,
+              contentStartIndex,
+              this.buffer.length,
+              false
+            );
             break;
           }
-          const parametersRaw = this.buffer.substring(contentStartIndex, partEndIndex).trim();
+          const rawSlice = this.buffer.substring(contentStartIndex, partEndIndex);
+          if (this.currentPartial) {
+            yield* this.emitArgPartials(this.currentPartial, contentStartIndex, partEndIndex, true);
+          }
+          const parametersRaw = rawSlice.trim();
           const { parameters, parseError } = this.parseParameters(parametersRaw);
           yield {
             type: "gadget_call",
@@ -13183,6 +13310,7 @@ var init_parser2 = __esm({
               dependencies
             }
           };
+          this.currentPartial = null;
           startIndex = partEndIndex + endMarkerLength;
           this.lastEmittedTextOffset = startIndex;
         }
@@ -13191,6 +13319,117 @@ var init_parser2 = __esm({
           this.lastEmittedTextOffset = 0;
         }
       }
+      /** Create fresh partial-tracking state for a newly-started streaming gadget. */
+      newPartialState(gadgetName, invocationId, dependencies) {
+        return {
+          gadgetName,
+          invocationId,
+          dependencies,
+          emittedFieldLengths: /* @__PURE__ */ new Map(),
+          completedFields: /* @__PURE__ */ new Set(),
+          bodyScannedLen: 0,
+          lastArgRelOffset: -1
+        };
+      }
+      /**
+       * Emit per-field "growing value" partials for an in-progress (or, when
+       * `allComplete`, a just-completed) gadget body delimited by [bodyStart, bodyEnd).
+       *
+       * Incremental by design: each call resumes the `!!!ARG:` scan near where the last
+       * one stopped (backing off by one marker's worth so a marker split across a chunk
+       * boundary is still found) and only re-touches the in-progress field, so a long
+       * streamed body costs O(new bytes) per feed instead of O(body). Every field except
+       * the in-progress (last) one is complete — a following `!!!ARG:` terminated it; the
+       * last field is tentative unless `allComplete`. The tentative field holds back any
+       * suffix that is a partial prefix of a gadget marker so it never leaks into a value.
+       *
+       * We deliberately do NOT run stripMarkdownFences here: an unbalanced opening fence
+       * sits before the first `!!!ARG:` (never emitted) and the authoritative gadget_call
+       * still strips fences from the full raw parameters.
+       */
+      *emitArgPartials(state, bodyStart, bodyEnd, allComplete) {
+        const argLen = this.argPrefix.length;
+        let searchAbs = bodyStart + Math.max(0, state.bodyScannedLen - (this.maxMarkerLength - 1));
+        if (state.lastArgRelOffset >= 0) {
+          searchAbs = Math.max(searchAbs, bodyStart + state.lastArgRelOffset + argLen);
+        }
+        while (true) {
+          const argAbs = this.buffer.indexOf(this.argPrefix, searchAbs);
+          if (argAbs === -1 || argAbs >= bodyEnd) break;
+          if (state.lastArgRelOffset >= 0) {
+            yield* this.emitFieldRange(state, bodyStart + state.lastArgRelOffset, argAbs, true);
+          }
+          state.lastArgRelOffset = argAbs - bodyStart;
+          searchAbs = argAbs + argLen;
+        }
+        if (state.lastArgRelOffset >= 0) {
+          yield* this.emitFieldRange(state, bodyStart + state.lastArgRelOffset, bodyEnd, allComplete);
+        }
+        state.bodyScannedLen = bodyEnd - bodyStart;
+      }
+      /**
+       * Emit a single field whose `!!!ARG:` marker starts at `markerAbs` and whose value
+       * runs to `valueEndAbs` (the next marker, or the body end). Mirrors the per-field
+       * semantics of the old split-based emitter: field-path line, hold-back for a
+       * tentative value, single trailing-newline strip.
+       */
+      *emitFieldRange(state, markerAbs, valueEndAbs, complete2) {
+        const pathStart = markerAbs + this.argPrefix.length;
+        const newlineAbs = this.buffer.indexOf("\n", pathStart);
+        if (newlineAbs === -1 || newlineAbs >= valueEndAbs) {
+          if (!complete2) return;
+          const pointer = this.buffer.substring(pathStart, valueEndAbs).trim();
+          if (pointer) yield* this.emitFieldDelta(state, pointer, "", true);
+          return;
+        }
+        const fieldPath = this.buffer.substring(pathStart, newlineAbs).trim();
+        if (!fieldPath) return;
+        let value = this.buffer.substring(newlineAbs + 1, valueEndAbs);
+        if (!complete2) {
+          const hold = this.trailingPartialMarkerLength(value);
+          if (hold > 0) value = value.slice(0, value.length - hold);
+        }
+        if (value.endsWith("\n")) value = value.slice(0, -1);
+        yield* this.emitFieldDelta(state, fieldPath, value, complete2);
+      }
+      /**
+       * Emit a single partial for a field, but only when its value grew or it newly
+       * completed — keeping event volume proportional to field growth, not characters.
+       */
+      *emitFieldDelta(state, fieldPath, value, fieldComplete) {
+        const previousLength = state.emittedFieldLengths.get(fieldPath) ?? -1;
+        const grew = value.length > previousLength;
+        const newlyComplete = fieldComplete && !state.completedFields.has(fieldPath);
+        if (!grew && !newlyComplete) return;
+        const delta = previousLength < 0 ? value : value.slice(Math.min(previousLength, value.length));
+        state.emittedFieldLengths.set(fieldPath, value.length);
+        if (fieldComplete) state.completedFields.add(fieldPath);
+        yield {
+          type: "gadget_args_partial",
+          invocationId: state.invocationId,
+          gadgetName: state.gadgetName,
+          fieldPath,
+          value,
+          delta,
+          isFieldComplete: fieldComplete
+        };
+      }
+      /**
+       * Length of the longest suffix of `value` that is a proper prefix of any gadget
+       * marker (start/end/arg). Used to hold back the beginning of an incoming marker
+       * so it never appears inside a streamed value.
+       */
+      trailingPartialMarkerLength(value) {
+        const markers = [this.startPrefix, this.endPrefix, this.argPrefix];
+        const limit = Math.min(this.maxMarkerLength - 1, value.length);
+        for (let len = limit; len >= 1; len--) {
+          const suffix = value.slice(value.length - len);
+          for (const marker of markers) {
+            if (suffix.length < marker.length && marker.startsWith(suffix)) return len;
+          }
+        }
+        return 0;
+      }
       // Finalize parsing and return remaining text or incomplete gadgets
       *finalize() {
         const startIndex = this.buffer.indexOf(this.startPrefix, this.lastEmittedTextOffset);
@@ -13203,9 +13442,18 @@ var init_parser2 = __esm({
           const metadataEndIndex = this.buffer.indexOf("\n", metadataStartIndex);
           if (metadataEndIndex !== -1) {
             const headerLine = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
-            const { gadgetName, invocationId, dependencies } = this.parseInvocationMetadata(headerLine);
+            const { gadgetName, invocationId, dependencies } = this.currentPartial ? this.currentPartial : this.parseInvocationMetadata(headerLine);
             const contentStartIndex = metadataEndIndex + 1;
-            const parametersRaw = this.buffer.substring(contentStartIndex).trim();
+            const contentRaw = this.buffer.substring(contentStartIndex);
+            if (this.currentPartial) {
+              yield* this.emitArgPartials(
+                this.currentPartial,
+                contentStartIndex,
+                this.buffer.length,
+                true
+              );
+            }
+            const parametersRaw = contentRaw.trim();
             const { parameters, parseError } = this.parseParameters(parametersRaw);
             yield {
               type: "gadget_call",
@@ -13218,6 +13466,7 @@ var init_parser2 = __esm({
                 dependencies
               }
             };
+            this.currentPartial = null;
             return;
           }
         }
@@ -13230,6 +13479,7 @@ var init_parser2 = __esm({
       reset() {
         this.buffer = "";
         this.lastEmittedTextOffset = 0;
+        this.currentPartial = null;
       }
     };
   }
@@ -14155,6 +14405,29 @@ async function notifyGadgetStart(ctx) {
     await safeObserve(() => hookFn(context), ctx.logger);
   }
 }
+async function notifyGadgetArgsPartial(ctx) {
+  if (!ctx.hooks?.onGadgetArgsPartial && !ctx.parentObservers?.onGadgetArgsPartial) return;
+  const subagentContext = ctx.tree && ctx.parentNodeId ? getSubagentContextForNode(ctx.tree, ctx.parentNodeId) : void 0;
+  const context = {
+    iteration: ctx.iteration,
+    invocationId: ctx.event.invocationId,
+    gadgetName: ctx.event.gadgetName,
+    fieldPath: ctx.event.fieldPath,
+    value: ctx.event.value,
+    delta: ctx.event.delta,
+    isFieldComplete: ctx.event.isFieldComplete,
+    logger: ctx.logger,
+    subagentContext
+  };
+  if (ctx.hooks?.onGadgetArgsPartial) {
+    const hookFn = ctx.hooks.onGadgetArgsPartial;
+    await safeObserve(() => hookFn(context), ctx.logger);
+  }
+  if (ctx.parentObservers?.onGadgetArgsPartial) {
+    const hookFn = ctx.parentObservers.onGadgetArgsPartial;
+    await safeObserve(() => hookFn(context), ctx.logger);
+  }
+}
 async function notifyGadgetComplete(ctx) {
   const gadgetNode = ctx.tree?.getNodeByInvocationId(ctx.invocationId);
   const subagentContext = ctx.tree && gadgetNode ? getSubagentContextForNode(ctx.tree, gadgetNode.id) : void 0;
@@ -14963,6 +15236,7 @@ var init_stream_processor = __esm({
     init_gadget_dispatcher();
     init_gadget_hook_lifecycle();
     init_gadget_limit_guard();
+    init_observer_notifier();
     init_safe_observe();
     StreamProcessor = class {
       iteration;
@@ -14971,6 +15245,10 @@ var init_stream_processor = __esm({
       parser;
       // Execution Tree context
       tree;
+      /** LLM-call node these gadgets hang off; used to derive subagentContext for partials. */
+      parentNodeId;
+      /** Parent agent observers (subagent visibility) — also notified for arg partials. */
+      parentObservers;
       responseText = "";
       // Dependency resolution is delegated to GadgetDependencyResolver
       dependencyResolver;
@@ -14984,6 +15262,8 @@ var init_stream_processor = __esm({
         this.hooks = options.hooks ?? {};
         this.logger = options.logger ?? createLogger({ name: "llmist:stream-processor" });
         this.tree = options.tree;
+        this.parentNodeId = options.parentNodeId;
+        this.parentObservers = options.parentObservers;
         this.dependencyResolver = new GadgetDependencyResolver({
           priorCompletedInvocations: options.priorCompletedInvocations,
           priorFailedInvocations: options.priorFailedInvocations
@@ -15185,6 +15465,17 @@ var init_stream_processor = __esm({
           for await (const e of this.dispatcher.dispatch(event.call)) {
             yield e;
           }
+        } else if (event.type === "gadget_args_partial") {
+          await notifyGadgetArgsPartial({
+            tree: this.tree,
+            hooks: this.hooks.observers,
+            parentObservers: this.parentObservers,
+            logger: this.logger,
+            iteration: this.iteration,
+            parentNodeId: this.parentNodeId,
+            event
+          });
+          yield event;
         } else {
           yield event;
         }
@@ -16279,19 +16570,7 @@ init_stream_processor();
 // src/index.ts
 init_client2();
 init_constants();
-
-// src/core/errors.ts
-function isAbortError(error) {
-  if (!(error instanceof Error)) return false;
-  if (error.name === "AbortError") return true;
-  if (error.name === "APIConnectionAbortedError") return true;
-  if (error.name === "APIUserAbortError") return true;
-  const message = error.message.toLowerCase();
-  if (message.includes("abort")) return true;
-  if (message.includes("cancelled")) return true;
-  if (message.includes("canceled")) return true;
-  return false;
-}
+init_errors2();
 
 // src/core/execution-events.ts
 function isLLMEvent(event) {
@@ -17000,6 +17279,7 @@ export {
   DEFAULT_RATE_LIMIT_CONFIG,
   DEFAULT_RETRY_CONFIG,
   DEFAULT_SUMMARIZATION_PROMPT,
+  EmptyCompletionError,
   ExecutionTree,
   FALLBACK_CHARS_PER_TOKEN,
   GADGET_ARG_PREFIX,