llmist 18.2.0 → 18.3.0

package/dist/index.js

@@ -2467,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);
@@ -13154,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.
@@ -13247,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;
@@ -13260,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",
@@ -13275,6 +13310,7 @@ var init_parser2 = __esm({
               dependencies
             }
           };
+          this.currentPartial = null;
           startIndex = partEndIndex + endMarkerLength;
           this.lastEmittedTextOffset = startIndex;
         }
@@ -13283,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);
@@ -13295,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",
@@ -13310,6 +13466,7 @@ var init_parser2 = __esm({
                 dependencies
               }
             };
+            this.currentPartial = null;
             return;
           }
         }
@@ -13322,6 +13479,7 @@ var init_parser2 = __esm({
       reset() {
         this.buffer = "";
         this.lastEmittedTextOffset = 0;
+        this.currentPartial = null;
       }
     };
   }
@@ -14247,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;
@@ -15055,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;
@@ -15063,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;
@@ -15076,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
@@ -15277,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;
         }