@ai-sdk/workflow 2.0.54 → 2.0.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "2.0.54",
+  "version": "2.0.57",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -36,9 +36,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.20",
-    "@ai-sdk/provider-utils": "5.0.52",
-    "ai": "7.0.123",
+    "@ai-sdk/provider": "4.0.21",
+    "@ai-sdk/provider-utils": "5.0.53",
+    "ai": "7.0.126",
     "ajv": "^8.20.0"
   },
   "devDependencies": {

package/src/do-stream-step.ts

@@ -3,12 +3,14 @@ import type {
   LanguageModelV4CallOptions,
   LanguageModelV4Prompt,
   LanguageModelV4Source,
+  LanguageModelV4StreamPart,
   SharedV4ProviderMetadata,
 } from '@ai-sdk/provider';
-import { isAbortError } from '@ai-sdk/provider-utils';
+import { asArray, isAbortError } from '@ai-sdk/provider-utils';
 import {
   experimental_streamLanguageModelCall as streamModelCall,
   gateway,
+  wrapLanguageModel,
   type Experimental_LanguageModelStreamPart,
   type FinishReason,
   type LanguageModel,
@@ -20,7 +22,7 @@ import {
   type ToolSet,
 } from 'ai';
 import { prepareRetries } from 'ai/internal';
-import type { ProviderOptions } from './workflow-agent.js';
+import type { ProviderOptions, StreamTextTransform } from './workflow-agent.js';
 import {
   resolveSerializableTools,
   type SerializableToolDef,
@@ -72,6 +74,9 @@ export interface DoStreamStepOptions {
   includeRawChunks?: boolean;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
   responseFormat?: LanguageModelV4CallOptions['responseFormat'];
+  experimental_transform?:
+    | StreamTextTransform<ToolSet>
+    | Array<StreamTextTransform<ToolSet>>;
 }
 
 /**
@@ -201,7 +206,7 @@ export async function doStreamStep(
         : AbortSignal.any([options.abortSignal, AbortSignal.timeout(timeout)]);
 
   // Resolve model inside step (must happen here for serialization boundary)
-  const model: LanguageModel =
+  const model =
     typeof modelInit === 'string'
       ? gateway.languageModel(modelInit)
       : modelInit;
@@ -213,6 +218,27 @@ export async function doStreamStep(
   const tools = serializedTools
     ? resolveSerializableTools(serializedTools)
     : undefined;
+  const modelWithTransforms =
+    options?.experimental_transform == null
+      ? model
+      : wrapLanguageModel({
+          model,
+          middleware: {
+            specificationVersion: 'v4',
+            wrapStream: async ({ doStream }) => {
+              const { stream, ...result } = await doStream();
+
+              return {
+                ...result,
+                stream: applyStreamTransforms({
+                  stream,
+                  transforms: asArray(options.experimental_transform!),
+                  tools: tools ?? {},
+                }),
+              };
+            },
+          },
+        });
 
   // streamModelCall derives the model responseFormat from its output spec.
   // WorkflowAgent parses output outside the model-call helper, so this minimal
@@ -247,7 +273,7 @@ export async function doStreamStep(
     try {
       const { stream } = await retry(() =>
         streamModelCall({
-          model,
+          model: modelWithTransforms,
           // streamModelCall expects Prompt (ModelMessage[]) but we pass the
           // pre-converted LanguageModelV4Prompt. standardizePrompt inside
           // streamModelCall handles both formats.
@@ -556,6 +582,61 @@ export async function doStreamStep(
 // another retry layer around the durable step.
 doStreamStep.maxRetries = 0;
 
+function applyStreamTransforms({
+  stream,
+  transforms,
+  tools,
+}: {
+  stream: ReadableStream<LanguageModelV4StreamPart>;
+  transforms: Array<StreamTextTransform<ToolSet>>;
+  tools: ToolSet;
+}): ReadableStream<LanguageModelV4StreamPart> {
+  const sourceReader = stream.getReader();
+  let stopped = false;
+
+  const stopStream = () => {
+    if (stopped) {
+      return;
+    }
+
+    stopped = true;
+    void sourceReader.cancel().catch(() => {});
+  };
+
+  let transformedStream = new ReadableStream<LanguageModelV4StreamPart>(
+    {
+      async pull(controller) {
+        if (stopped) {
+          controller.close();
+          return;
+        }
+
+        const { done, value } = await sourceReader.read();
+
+        if (done || stopped) {
+          controller.close();
+          return;
+        }
+
+        controller.enqueue(value);
+      },
+      cancel(reason) {
+        stopped = true;
+        return sourceReader.cancel(reason);
+      },
+    },
+    { highWaterMark: 0 },
+  );
+
+  for (const transform of transforms) {
+    transformedStream = transformedStream.pipeThrough(
+      transform({ tools, stopStream }),
+    );
+  }
+
+  return transformedStream;
+}
+
 function upsertTextContentPart({
   content,
   textPartIndexes,

package/src/stream-text-iterator.ts

@@ -47,6 +47,7 @@ import type {
   WorkflowAgentOnStepFinishCallback,
   TelemetryOptions,
   WorkflowAgentOnStepStartCallback,
+  StreamTextTransform,
 } from './workflow-agent.js';
 
 // Re-export for consumers
@@ -140,6 +141,7 @@ export async function* streamTextIterator({
   timeoutAt,
   repairToolCall,
   responseFormat,
+  experimental_transform,
   experimental_sandbox: sandbox,
 }: {
   prompt: LanguageModelV4Prompt;
@@ -164,6 +166,9 @@ export async function* streamTextIterator({
   timeoutAt?: number;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
   responseFormat?: LanguageModelV4CallOptions['responseFormat'];
+  experimental_transform?:
+    | StreamTextTransform<ToolSet>
+    | Array<StreamTextTransform<ToolSet>>;
   experimental_sandbox?: SandboxSession;
 }): AsyncGenerator<
   StreamTextIteratorYieldValue,
@@ -370,6 +375,7 @@ export async function* streamTextIterator({
           timeoutAt,
           repairToolCall,
           responseFormat,
+          experimental_transform,
         },
       );
 

package/src/workflow-agent.ts

@@ -2325,6 +2325,10 @@ export class WorkflowAgent<
         options.experimental_repairToolCall ??
         this.repairToolCall) as ToolCallRepairFunction<ToolSet> | undefined,
       responseFormat: await (options.output ?? this.output)?.responseFormat,
+      experimental_transform: options.experimental_transform as
+        | StreamTextTransform<ToolSet>
+        | Array<StreamTextTransform<ToolSet>>
+        | undefined,
       experimental_sandbox: sandbox,
     });