@ai-sdk/workflow 1.0.0-beta.26 → 1.0.0-beta.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "1.0.0-beta.26",
+  "version": "1.0.0-beta.28",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "ajv": "^8.18.0",
-    "@ai-sdk/provider": "4.0.0-beta.12",
-    "@ai-sdk/provider-utils": "5.0.0-beta.26",
-    "ai": "7.0.0-beta.111"
+    "@ai-sdk/provider": "4.0.0-beta.13",
+    "@ai-sdk/provider-utils": "5.0.0-beta.28",
+    "ai": "7.0.0-beta.113"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
@@ -47,12 +47,14 @@
     "node": ">=18"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "homepage": "https://ai-sdk.dev/docs",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vercel/ai.git"
+    "url": "https://github.com/vercel/ai",
+    "directory": "packages/workflow"
   },
   "bugs": {
     "url": "https://github.com/vercel/ai/issues"

package/src/do-stream-step.ts

@@ -115,6 +115,7 @@ export async function doStreamStep(
     // pre-converted LanguageModelV4Prompt. standardizePrompt inside
     // streamModelCall handles both formats.
     messages: conversationPrompt as unknown as ModelMessage[],
+    allowSystemInMessages: true,
     tools,
     toolChoice: options?.toolChoice,
     includeRawChunks: options?.includeRawChunks,

package/src/serializable-schema.ts

@@ -23,6 +23,8 @@ export type SerializableToolDef = {
   inputSchema: JSONSchema7;
   /** Present on provider tools (e.g. anthropic.tools.webSearch). */
   type?: 'provider';
+  /** Provider tool is executed by the provider. */
+  isProviderExecuted?: boolean;
   /** Provider tool ID, e.g. 'anthropic.web_search_20250305'. */
   id?: `${string}.${string}`;
   /** Provider tool configuration args (maxUses, allowedDomains, etc.). */
@@ -49,6 +51,7 @@ export function serializeToolSet(
       // them as provider-executed tools (e.g. anthropic webSearch).
       if ((t as any).type === 'provider') {
         def.type = 'provider';
+        def.isProviderExecuted = (t as any).isProviderExecuted ?? false;
         def.id = (t as any).id;
         def.args = (t as any).args;
       }
@@ -81,6 +84,7 @@ export function resolveSerializableTools(
             type: 'provider' as const,
             id: t.id!,
             args: t.args ?? {},
+            isProviderExecuted: t.isProviderExecuted ?? false,
             inputSchema: jsonSchema(t.inputSchema),
           }),
         ];

package/src/workflow-agent.ts

@@ -14,10 +14,12 @@ import {
   type Experimental_LanguageModelStreamPart as ModelCallStreamPart,
   type ModelMessage,
   Output,
+  Prompt,
   type StepResult,
   type StopCondition,
-  type StreamTextOnStepFinishCallback,
+  type GenerateTextOnStepFinishCallback,
   type SystemModelMessage,
+  type ActiveTools,
   type ToolCallRepairFunction,
   type ToolChoice,
   type ToolSet,
@@ -37,12 +39,12 @@ export type { CompatibleLanguageModel } from './types.js';
 
 /**
  * Callback function to be called after each step completes.
- * Alias for the AI SDK's StreamTextOnStepFinishCallback, using
+ * Alias for the AI SDK's GenerateTextOnStepFinishCallback, using
  * WorkflowAgent-consistent naming.
  */
 export type WorkflowAgentOnStepFinishCallback<
   TTools extends ToolSet = ToolSet,
-> = StreamTextOnStepFinishCallback<TTools, any>;
+> = GenerateTextOnStepFinishCallback<TTools, any>;
 
 /**
  * Infer the type of the tools of a workflow agent.
@@ -445,7 +447,7 @@ export interface WorkflowAgentOptions<
    *
    * Per-stream `activeTools` values passed to `stream()` override this default.
    */
-  activeTools?: Array<keyof NoInfer<TTools>>;
+  activeTools?: ActiveTools<NoInfer<TTools>>;
 
   /**
    * Default output specification for structured outputs.
@@ -735,7 +737,7 @@ export type WorkflowAgentStreamOptions<
      * Limits the tools that are available for the model to call without
      * changing the tool call and result types in the result.
      */
-    activeTools?: Array<keyof NoInfer<TTools>>;
+    activeTools?: ActiveTools<NoInfer<TTools>>;
 
     /**
      * Optional telemetry configuration.
@@ -1021,7 +1023,7 @@ export class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
   private stopWhen?:
     | StopCondition<ToolSet, any>
     | Array<StopCondition<ToolSet, any>>;
-  private activeTools?: Array<keyof TBaseTools>;
+  private activeTools?: ActiveTools<TBaseTools>;
   private output?: OutputSpecification<any, any>;
   private experimentalRepairToolCall?: ToolCallRepairFunction<TBaseTools>;
   private experimentalDownload?: DownloadFunction;
@@ -1162,10 +1164,11 @@ export class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
 
     const prompt = await standardizePrompt({
       system: effectiveInstructions,
+      allowSystemInMessages: true, // TODO: consider exposing this as a parameter
       ...(effectivePrompt != null
         ? { prompt: effectivePrompt }
         : { messages: effectiveMessages! }),
-    });
+    } as Prompt);
 
     // Process tool approval responses before starting the agent loop.
     // This mirrors how stream-text.ts handles tool-approval-response parts:
@@ -1376,7 +1379,7 @@ export class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
       effectiveActiveTools && effectiveActiveTools.length > 0
         ? (filterActiveTools({
             tools: this.tools,
-            activeTools: effectiveActiveTools as string[],
+            activeTools: effectiveActiveTools,
           }) ?? this.tools)
         : this.tools;
 
@@ -1542,11 +1545,16 @@ export class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
 
         // Only execute tools if there are tool calls
         if (toolCalls.length > 0) {
+          const invalidToolCalls = toolCalls.filter(tc => tc.invalid === true);
+          const validToolCalls = toolCalls.filter(tc => tc.invalid !== true);
+
           // Separate provider-executed tool calls from client-executed ones
-          const nonProviderToolCalls = toolCalls.filter(
+          const nonProviderToolCalls = validToolCalls.filter(
             tc => !tc.providerExecuted,
           );
-          const providerToolCalls = toolCalls.filter(tc => tc.providerExecuted);
+          const providerToolCalls = validToolCalls.filter(
+            tc => tc.providerExecuted,
+          );
 
           // Check which tools need approval (can be async)
           const approvalNeeded = await Promise.all(
@@ -1610,7 +1618,15 @@ export class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
                 ),
               );
 
-            const resolvedResults = [...executableResults, ...providerResults];
+            const continuationInvalidResults = invalidToolCalls.map(
+              createInvalidToolResult,
+            );
+            const resolvedResults = [
+              ...executableResults,
+              ...providerResults,
+              ...continuationInvalidResults,
+            ];
+            const executedResults = [...executableResults, ...providerResults];
 
             const allToolCalls: ToolCall[] = toolCalls.map(tc => ({
               type: 'tool-call' as const,
@@ -1619,7 +1635,7 @@ export class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
               input: tc.input,
             }));
 
-            const allToolResults: ToolResult[] = resolvedResults.map(r => ({
+            const allToolResults: ToolResult[] = executedResults.map(r => ({
               type: 'tool-result' as const,
               toolCallId: r.toolCallId,
               toolName: r.toolName,
@@ -1707,25 +1723,32 @@ export class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
             providerToolCalls.map(toolCall =>
               resolveProviderToolResult(toolCall, providerExecutedToolResults),
             );
+          const continuationInvalidToolResults = invalidToolCalls.map(
+            createInvalidToolResult,
+          );
 
-          // Combine results in the original order
-          const toolResults = toolCalls.map(tc => {
+          // Combine executable/provider results in the original order,
+          // while preserving invalid tool calls as error results for the
+          // next model step without emitting them as synthetic UI success.
+          const continuationToolResults = toolCalls.flatMap(tc => {
+            const invalidResult = continuationInvalidToolResults.find(
+              r => r.toolCallId === tc.toolCallId,
+            );
+            if (invalidResult) return [invalidResult];
             const clientResult = clientToolResults.find(
               r => r.toolCallId === tc.toolCallId,
             );
-            if (clientResult) return clientResult;
+            if (clientResult) return [clientResult];
             const providerResult = providerToolResults.find(
               r => r.toolCallId === tc.toolCallId,
             );
-            if (providerResult) return providerResult;
-            // This should never happen, but return empty result as fallback
-            return {
-              type: 'tool-result' as const,
-              toolCallId: tc.toolCallId,
-              toolName: tc.toolName,
-              output: { type: 'text' as const, value: '' },
-            };
+            if (providerResult) return [providerResult];
+            return [];
           });
+          const executedToolResults = continuationToolResults.filter(
+            result =>
+              !invalidToolCalls.some(tc => tc.toolCallId === result.toolCallId),
+          );
 
           // Write tool results and step boundaries to the stream so the
           // UI can transition tool parts to output-available state and
@@ -1733,7 +1756,7 @@ export class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
           if (options.writable) {
             await writeToolResultsWithStepBoundary(
               options.writable,
-              toolResults.map(r => ({
+              executedToolResults.map(r => ({
                 toolCallId: r.toolCallId,
                 toolName: r.toolName,
                 input: toolCalls.find(tc => tc.toolCallId === r.toolCallId)
@@ -1750,7 +1773,7 @@ export class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
             toolName: tc.toolName,
             input: tc.input,
           }));
-          lastStepToolResults = toolResults.map(r => ({
+          lastStepToolResults = executedToolResults.map(r => ({
             type: 'tool-result' as const,
             toolCallId: r.toolCallId,
             toolName: r.toolName,
@@ -1758,7 +1781,7 @@ export class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
             output: 'value' in r.output ? r.output.value : undefined,
           }));
 
-          result = await iterator.next(toolResults);
+          result = await iterator.next(continuationToolResults);
         } else {
           // Final step with no tool calls - reset tracking
           lastStepToolCalls = [];
@@ -2060,6 +2083,22 @@ function resolveProviderToolResult(
   };
 }
 
+function createInvalidToolResult(toolCall: {
+  toolCallId: string;
+  toolName: string;
+  error?: unknown;
+}): LanguageModelV4ToolResultPart {
+  return {
+    type: 'tool-result' as const,
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    output: {
+      type: 'error-text' as const,
+      value: getErrorMessage(toolCall.error),
+    },
+  };
+}
+
 async function executeTool(
   toolCall: { toolCallId: string; toolName: string; input: unknown },
   tools: ToolSet,