@ai-sdk/workflow 2.0.70 → 2.0.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "2.0.70",
+  "version": "2.0.72",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -38,11 +38,11 @@
   "dependencies": {
     "@ai-sdk/provider": "4.0.27",
     "@ai-sdk/provider-utils": "5.0.59",
-    "ai": "7.0.138",
+    "ai": "7.0.140",
     "ajv": "^8.20.0"
   },
   "devDependencies": {
-    "@ai-sdk/otel": "1.0.138",
+    "@ai-sdk/otel": "1.0.140",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",

package/src/do-generate-step.ts

@@ -7,6 +7,7 @@ import {
 } from 'ai';
 import {
   asLanguageModelUsage,
+  convertToLanguageModelPrompt,
   parseToolCall,
   prepareLanguageModelCallOptions,
   prepareRetries,
@@ -14,6 +15,7 @@ import {
   prepareTools,
   resolveLanguageModel,
 } from 'ai/internal';
+import { languageModelPromptToModelMessages } from './language-model-prompt-to-model-messages.js';
 import type {
   ModelCallOptions,
   ModelCallRawContentPart,
@@ -90,6 +92,16 @@ async function generateModelCall(
           AbortSignal.timeout(remaining),
         ]);
   const model = resolveLanguageModel(modelInit);
+  const modelPrompt = await convertToLanguageModelPrompt({
+    prompt: {
+      instructions: undefined,
+      messages: languageModelPromptToModelMessages(prompt),
+    },
+    supportedUrls: await model.supportedUrls,
+    download: options.download,
+    abortSignal,
+    provider: model.provider.split('.')[0],
+  });
   const tools = resolveSerializableTools(serializedTools);
   const toolChoice = prepareToolChoice({ toolChoice: options.toolChoice });
   const modelTools = await prepareTools({ tools });
@@ -125,7 +137,7 @@ async function generateModelCall(
       execute: () =>
         model.doGenerate({
           ...settings,
-          prompt: [...prompt],
+          prompt: modelPrompt,
           tools: modelTools,
           toolChoice,
           responseFormat: options.responseFormat,
@@ -159,7 +171,7 @@ async function generateModelCall(
           tools,
           repairToolCall: options.repairToolCall,
           instructions:
-            prompt
+            modelPrompt
               .filter(message => message.role === 'system')
               .map(message => message.content)
               .join('\n') || undefined,

package/src/do-stream-step.ts

@@ -10,10 +10,10 @@ import {
   NoOutputGeneratedError,
   wrapLanguageModel,
   type LanguageModel,
-  type ModelMessage,
   type ToolSet,
 } from 'ai';
 import { isOutputChunk, prepareRetries } from 'ai/internal';
+import { languageModelPromptToModelMessages } from './language-model-prompt-to-model-messages.js';
 import type { StreamTextTransform } from './workflow-agent.js';
 import {
   resolveSerializableTools,
@@ -178,21 +178,7 @@ async function streamModelStep(
           // streamModelCall expects Prompt (ModelMessage[]) but we pass the
           // pre-converted LanguageModelV4Prompt. standardizePrompt inside
           // streamModelCall handles both formats.
-          messages: conversationPrompt.map(message =>
-            message.role !== 'tool'
-              ? message
-              : {
-                  ...message,
-                  // Provider prompt approval responses have already been filtered by
-                  // convertToLanguageModelPrompt. Restore the marker expected by the
-                  // model-call helper when it converts these messages again.
-                  content: message.content.map(part =>
-                    part.type === 'tool-approval-response'
-                      ? { ...part, providerExecuted: true }
-                      : part,
-                  ),
-                },
-          ) as unknown as ModelMessage[],
+          messages: languageModelPromptToModelMessages(conversationPrompt),
           allowSystemInMessages: true,
           tools,
           toolChoice: options?.toolChoice,
@@ -211,6 +197,7 @@ async function streamModelStep(
           stopSequences: options?.stopSequences,
           seed: options?.seed,
           repairToolCall: options?.repairToolCall,
+          download: options?.download,
           ...languageModelCallTelemetry,
         }),
       );

package/src/language-model-prompt-to-model-messages.ts

@@ -0,0 +1,28 @@
+import type { LanguageModelV4Prompt } from '@ai-sdk/provider';
+import type { ModelMessage } from 'ai';
+
+/**
+ * Prepares a workflow-side `LanguageModelV4Prompt` for a second, model-aware
+ * `convertToLanguageModelPrompt` pass inside a model step.
+ *
+ * The workflow-side conversion preserves URLs (it cannot download them) and
+ * filters out approval responses for tools that are not provider-executed.
+ * The remaining approval responses are restored with the `providerExecuted`
+ * marker that the second conversion expects.
+ */
+export function languageModelPromptToModelMessages(
+  prompt: LanguageModelV4Prompt,
+): ModelMessage[] {
+  return prompt.map(message =>
+    message.role !== 'tool'
+      ? message
+      : {
+          ...message,
+          content: message.content.map(part =>
+            part.type === 'tool-approval-response'
+              ? { ...part, providerExecuted: true }
+              : part,
+          ),
+        },
+  ) as unknown as ModelMessage[];
+}

package/src/model-call-iterator.ts

@@ -143,6 +143,7 @@ export async function* modelCallIterator({
   includeRawChunks = false,
   timeoutAt,
   repairToolCall,
+  download,
   responseFormat,
   experimental_transform,
   experimental_sandbox: sandbox,
@@ -170,6 +171,7 @@ export async function* modelCallIterator({
   includeRawChunks?: boolean;
   timeoutAt?: number;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
+  download?: ModelCallOptions['download'];
   responseFormat?: LanguageModelV4CallOptions['responseFormat'];
   experimental_transform?:
     | StreamTextTransform<ToolSet>
@@ -380,6 +382,7 @@ export async function* modelCallIterator({
         includeRawChunks,
         timeoutAt,
         repairToolCall,
+        download,
         responseFormat,
         include,
         experimental_transform,

package/src/model-call.ts

@@ -15,7 +15,11 @@ import type {
   ToolChoice,
   ToolSet,
 } from 'ai';
-import type { ProviderOptions, StreamTextTransform } from './workflow-agent.js';
+import type {
+  DownloadFunction,
+  ProviderOptions,
+  StreamTextTransform,
+} from './workflow-agent.js';
 
 export type ModelCallStreamPart<TTools extends ToolSet = ToolSet> =
   | Experimental_LanguageModelStreamPart<TTools>
@@ -62,6 +66,7 @@ export interface ModelCallOptions {
   toolChoice?: ToolChoice<ToolSet>;
   includeRawChunks?: boolean;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
+  download?: DownloadFunction;
   include?: {
     requestBody?: boolean;
     responseBody?: boolean;

package/src/test/concurrency-workflows.ts

@@ -0,0 +1,66 @@
+import { tool, type ModelMessage } from 'ai';
+import { createHook } from 'workflow';
+import { z } from 'zod/v4';
+import { mockTextModel } from '../providers/mock.js';
+import { WorkflowAgent } from '../workflow-agent.js';
+
+async function completeAction(id: string) {
+  'use step';
+  return id;
+}
+
+export async function resumeSequentialApprovals(mode: 'generate' | 'stream') {
+  'use workflow';
+  const events: string[] = [];
+  const agent = new WorkflowAgent({
+    model: mockTextModel('Done.'),
+    toolCallConcurrency: 1,
+    tools: {
+      action: tool({
+        inputSchema: z.object({ id: z.string() }),
+        needsApproval: true,
+        execute: async ({ id }) => {
+          events.push(`start:${id}`);
+          if (id === 'first') {
+            using hook = createHook<string>();
+            await hook;
+          }
+          const result = await completeAction(id);
+          events.push(`end:${id}`);
+          return result;
+        },
+      }),
+    },
+  });
+  const ids = ['first', 'second'];
+  const messages: ModelMessage[] = [
+    { role: 'user', content: 'Run the tools.' },
+    {
+      role: 'assistant',
+      content: ids.flatMap(id => [
+        {
+          type: 'tool-call' as const,
+          toolCallId: id,
+          toolName: 'action',
+          input: { id },
+        },
+        {
+          type: 'tool-approval-request' as const,
+          toolCallId: id,
+          approvalId: `approval-${id}`,
+        },
+      ]),
+    },
+    {
+      role: 'tool',
+      content: [...ids].reverse().map(id => ({
+        type: 'tool-approval-response' as const,
+        approvalId: `approval-${id}`,
+        approved: true,
+      })),
+    },
+  ];
+  if (mode === 'generate') await agent.generate({ messages });
+  else await agent.stream({ messages });
+  return events;
+}