@ai-sdk/workflow 2.0.0 → 2.0.3

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @ai-sdk/workflow
 
+## 2.0.3
+
+### Patch Changes
+
+- ai@7.0.73
+
+## 2.0.2
+
+### Patch Changes
+
+- ai@7.0.72
+
+## 2.0.1
+
+### Patch Changes
+
+- 4233a40: Resume transformed WorkflowAgent streams using UI message chunk indexes.
+- Updated dependencies [9a37469]
+  - ai@7.0.71
+
 ## 2.0.0
 
 ### Major Changes

package/dist/index.d.ts

@@ -1003,8 +1003,20 @@ declare function toUIMessageChunk(part: ModelCallStreamPart<ToolSet>): UIMessage
 /**
  * Create a TransformStream that converts ModelCallStreamPart to UIMessageChunk.
  * Wraps toUIMessageChunk with start/start-step/finish-step lifecycle chunks.
+ *
+ * When resuming a stream, provide `uiStartIndex` and replay the source
+ * ModelCallStreamPart stream from index 0. The transform will omit the UI
+ * chunks that the client has already received. Raw model stream parts and UI
+ * message chunks do not have a one-to-one relationship, so a UI chunk index
+ * must not be used as the source stream's start index.
  */
-declare function createModelCallToUIChunkTransform(): TransformStream<ModelCallStreamPart<ToolSet>, UIMessageChunk>;
+declare function createModelCallToUIChunkTransform({ uiStartIndex, }?: {
+    /**
+     * Number of transformed UIMessageChunks to omit from the output.
+     * Must be a non-negative safe integer.
+     */
+    uiStartIndex?: number;
+}): TransformStream<ModelCallStreamPart<ToolSet>, UIMessageChunk>;
 
 interface SendMessagesOptions<UI_MESSAGE extends UIMessage> {
     trigger: 'submit-message' | 'regenerate-message';
@@ -1018,7 +1030,8 @@ interface ReconnectToStreamOptions {
     abortSignal?: AbortSignal;
     /**
      * Override the `startIndex` for this reconnection.
-     * Negative values read from the end of the stream.
+     * Negative values read from the end when the server's durable stream and
+     * tail-index header use the same UIMessageChunk index space.
      * When omitted, falls back to the constructor's `initialStartIndex`.
      */
     startIndex?: number;
@@ -1069,9 +1082,10 @@ interface WorkflowChatTransportOptions<UI_MESSAGE extends UIMessage> {
     /**
      * Default `startIndex` to use when reconnecting to a stream without a known
      * chunk position (i.e. the initial reconnection, not a retry).
-     * Negative values read from the end of the stream (e.g. `-10` fetches the
-     * last 10 chunks), which is useful for resuming a chat UI after a page
-     * refresh without replaying the full conversation.
+     * Negative values read from the end of a durable UIMessageChunk stream (e.g.
+     * `-10` fetches the last 10 chunks), which is useful for resuming a chat UI
+     * after a page refresh without replaying the full conversation. Raw
+     * ModelCallStreamPart streams do not support negative UI chunk indexes.
      *
      * Can be overridden per-call via `ReconnectToStreamOptions.startIndex`.
      *

package/dist/index.js

@@ -2265,20 +2265,31 @@ function toUIMessageChunk(part) {
     }
   }
 }
-function createModelCallToUIChunkTransform() {
+function createModelCallToUIChunkTransform({
+  uiStartIndex = 0
+} = {}) {
+  if (!Number.isSafeInteger(uiStartIndex) || uiStartIndex < 0) {
+    throw new RangeError("uiStartIndex must be a non-negative safe integer");
+  }
+  let uiChunkIndex = 0;
+  const enqueue = (controller, chunk) => {
+    if (uiChunkIndex++ >= uiStartIndex) {
+      controller.enqueue(chunk);
+    }
+  };
   return new TransformStream({
     start: (controller) => {
-      controller.enqueue({ type: "start" });
-      controller.enqueue({ type: "start-step" });
+      enqueue(controller, { type: "start" });
+      enqueue(controller, { type: "start-step" });
     },
     flush: (controller) => {
-      controller.enqueue({ type: "finish-step" });
-      controller.enqueue({ type: "finish" });
+      enqueue(controller, { type: "finish-step" });
+      enqueue(controller, { type: "finish" });
     },
     transform: (part, controller) => {
       const uiChunk = toUIMessageChunk(part);
       if (uiChunk) {
-        controller.enqueue(uiChunk);
+        enqueue(controller, uiChunk);
       }
     }
   });