@workglow/task-graph 0.0.99 → 0.0.100

package/dist/node.js

@@ -47,10 +47,8 @@ class Dataflow {
     if (!this.stream)
       return;
     const reader = this.stream.getReader();
-    const accumulatedPorts = new Map;
     let lastSnapshotData = undefined;
     let finishData = undefined;
-    let hasTextDelta = false;
     let streamError;
     try {
       while (true) {
@@ -58,16 +56,6 @@ class Dataflow {
         if (done)
           break;
         switch (event.type) {
-          case "text-delta": {
-            if (this.sourceTaskPortId !== DATAFLOW_ALL_PORTS && event.port !== this.sourceTaskPortId) {
-              break;
-            }
-            hasTextDelta = true;
-            accumulatedPorts.set(event.port, (accumulatedPorts.get(event.port) ?? "") + event.textDelta);
-            break;
-          }
-          case "object-delta":
-            break;
           case "snapshot":
             lastSnapshotData = event.data;
             break;
@@ -90,19 +78,8 @@ class Dataflow {
     }
     if (lastSnapshotData !== undefined) {
       this.setPortData(lastSnapshotData);
-    } else if (finishData && Object.keys(finishData).length > 0) {
+    } else if (finishData !== undefined) {
       this.setPortData(finishData);
-    } else if (hasTextDelta) {
-      if (this.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
-        const obj = {};
-        for (const [port, text] of accumulatedPorts) {
-          obj[port] = text;
-        }
-        this.value = obj;
-      } else {
-        const text = accumulatedPorts.values().next().value ?? "";
-        this.value = text;
-      }
     }
   }
   reset() {
@@ -548,6 +525,7 @@ class TaskRunner {
   outputCache;
   registry = globalServiceRegistry;
   inputStreams;
+  shouldAccumulate = true;
   constructor(task) {
     this.task = task;
     this.own = this.own.bind(this);
@@ -656,7 +634,7 @@ class TaskRunner {
         throw new TaskError(`Task ${this.task.type} declares append streaming but no output port has x-stream: "append"`);
       }
     }
-    const accumulated = new Map;
+    const accumulated = this.shouldAccumulate ? new Map : undefined;
     let chunkCount = 0;
     let finalOutput;
     this.task.emit("stream_start");
@@ -676,33 +654,40 @@ class TaskRunner {
       if (event.type === "snapshot") {
         this.task.runOutputData = event.data;
       }
-      this.task.emit("stream_chunk", event);
       switch (event.type) {
         case "text-delta": {
-          accumulated.set(event.port, (accumulated.get(event.port) ?? "") + event.textDelta);
+          if (accumulated) {
+            accumulated.set(event.port, (accumulated.get(event.port) ?? "") + event.textDelta);
+          }
+          this.task.emit("stream_chunk", event);
           const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
           await this.handleProgress(progress);
           break;
         }
         case "object-delta": {
+          this.task.emit("stream_chunk", event);
           const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
           await this.handleProgress(progress);
           break;
         }
         case "snapshot": {
+          this.task.emit("stream_chunk", event);
           const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
           await this.handleProgress(progress);
           break;
         }
         case "finish": {
-          if (streamMode === "append") {
+          if (accumulated) {
             const merged = { ...event.data || {} };
             for (const [port, text] of accumulated) {
-              merged[port] = text.length > 0 ? text : event.data?.[port] ?? "";
+              if (text.length > 0)
+                merged[port] = text;
             }
             finalOutput = merged;
-          } else if (streamMode === "replace") {
+            this.task.emit("stream_chunk", { type: "finish", data: merged });
+          } else {
             finalOutput = event.data;
+            this.task.emit("stream_chunk", event);
           }
           break;
         }
@@ -741,6 +726,7 @@ class TaskRunner {
     } else if (cache instanceof TaskOutputRepository) {
       this.outputCache = cache;
     }
+    this.shouldAccumulate = config.shouldAccumulate !== false;
     if (config.updateProgress) {
       this.updateProgress = config.updateProgress;
     }
@@ -1552,6 +1538,7 @@ class TaskGraphRunner {
   reactiveRunning = false;
   graph;
   outputCache;
+  accumulateLeafOutputs = true;
   registry = globalServiceRegistry2;
   abortController;
   inProgressTasks = new Map;
@@ -1771,6 +1758,29 @@ class TaskGraphRunner {
       }
     }
   }
+  taskNeedsAccumulation(task) {
+    if (this.outputCache)
+      return true;
+    const outEdges = this.graph.getTargetDataflows(task.config.id);
+    if (outEdges.length === 0)
+      return this.accumulateLeafOutputs;
+    const outSchema = task.outputSchema();
+    for (const df of outEdges) {
+      if (df.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
+        if (getStreamingPorts(outSchema).length > 0)
+          return true;
+        continue;
+      }
+      const targetTask = this.graph.getTask(df.targetTaskId);
+      if (!targetTask)
+        continue;
+      const inSchema = targetTask.inputSchema();
+      if (edgeNeedsAccumulation(outSchema, df.sourceTaskPortId, inSchema, df.targetTaskPortId)) {
+        return true;
+      }
+    }
+    return false;
+  }
   async runTask(task, input) {
     const isStreamable = isTaskStreamable(task);
     if (isStreamable) {
@@ -1793,7 +1803,7 @@ class TaskGraphRunner {
       return this.runStreamingTask(task, input);
     }
     const results = await task.runner.run(input, {
-      outputCache: this.outputCache,
+      outputCache: this.outputCache ?? false,
       updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
       registry: this.registry
     });
@@ -1813,6 +1823,7 @@ class TaskGraphRunner {
   }
   async runStreamingTask(task, input) {
     const streamMode = getOutputStreamMode(task.outputSchema());
+    const shouldAccumulate = this.taskNeedsAccumulation(task);
     let streamingNotified = false;
     const onStatus = (status) => {
       if (status === TaskStatus.STREAMING && !streamingNotified) {
@@ -1837,7 +1848,8 @@ class TaskGraphRunner {
     task.on("stream_end", onStreamEnd);
     try {
       const results = await task.runner.run(input, {
-        outputCache: this.outputCache,
+        outputCache: this.outputCache ?? false,
+        shouldAccumulate,
         updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
         registry: this.registry
       });
@@ -1945,6 +1957,7 @@ class TaskGraphRunner {
     } else {
       this.registry = new ServiceRegistry2(globalServiceRegistry2.container.createChildContainer());
     }
+    this.accumulateLeafOutputs = config?.accumulateLeafOutputs !== false;
     if (config?.outputCache !== undefined) {
       if (typeof config.outputCache === "boolean") {
         if (config.outputCache === true) {
@@ -2276,7 +2289,7 @@ class GraphAsTask extends Task {
           }
         }
       });
-      const runPromise = this.subGraph.run(input, { parentSignal: context.signal }).then((results2) => {
+      const runPromise = this.subGraph.run(input, { parentSignal: context.signal, accumulateLeafOutputs: false }).then((results2) => {
         subgraphDone = true;
         resolveWaiting?.();
         return results2;
@@ -3083,7 +3096,8 @@ class TaskGraph {
   run(input = {}, config = {}) {
     return this.runner.runGraph(input, {
       outputCache: config?.outputCache || this.outputCache,
-      parentSignal: config?.parentSignal || undefined
+      parentSignal: config?.parentSignal || undefined,
+      accumulateLeafOutputs: config?.accumulateLeafOutputs
     });
   }
   runReactive(input = {}) {
@@ -5187,4 +5201,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=D1D0735E2B61108764756E2164756E21
+//# debugId=58638F6F12E25A3464756E2164756E21