@ai-sdk/workflow 0.0.0-bf6e4b15-20260402200305

package/src/do-stream-step.ts

@@ -0,0 +1,329 @@
+import type {
+  LanguageModelV4CallOptions,
+  LanguageModelV4Prompt,
+} from '@ai-sdk/provider';
+import {
+  type Experimental_ModelCallStreamPart as ModelCallStreamPart,
+  experimental_streamModelCall as streamModelCall,
+  type FinishReason,
+  type LanguageModel,
+  type LanguageModelUsage,
+  type ModelMessage,
+  type StepResult,
+  type StopCondition,
+  type ToolCallRepairFunction,
+  type ToolChoice,
+  type ToolSet,
+} from 'ai';
+import { gateway } from 'ai';
+import type { ProviderOptions, TelemetrySettings } from './workflow-agent.js';
+import {
+  resolveSerializableTools,
+  type SerializableToolDef,
+} from './serializable-schema.js';
+import type { CompatibleLanguageModel } from './types.js';
+
+export type { Experimental_ModelCallStreamPart as ModelCallStreamPart } from 'ai';
+
+export type ModelStopCondition = StopCondition<NoInfer<ToolSet>, any>;
+
+/**
+ * Provider-executed tool result captured from the stream.
+ */
+export interface ProviderExecutedToolResult {
+  toolCallId: string;
+  toolName: string;
+  result: unknown;
+  isError?: boolean;
+}
+
+/**
+ * Options for the doStreamStep function.
+ */
+export interface DoStreamStepOptions {
+  maxOutputTokens?: number;
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  presencePenalty?: number;
+  frequencyPenalty?: number;
+  stopSequences?: string[];
+  seed?: number;
+  maxRetries?: number;
+  abortSignal?: AbortSignal;
+  headers?: Record<string, string | undefined>;
+  providerOptions?: ProviderOptions;
+  toolChoice?: ToolChoice<ToolSet>;
+  includeRawChunks?: boolean;
+  experimental_telemetry?: TelemetrySettings;
+  repairToolCall?: ToolCallRepairFunction<ToolSet>;
+  responseFormat?: LanguageModelV4CallOptions['responseFormat'];
+}
+
+/**
+ * Parsed tool call from the stream (parsed by streamModelCall's transform).
+ */
+export interface ParsedToolCall {
+  type: 'tool-call';
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  providerExecuted?: boolean;
+  providerMetadata?: Record<string, unknown>;
+  dynamic?: boolean;
+  invalid?: boolean;
+  error?: unknown;
+}
+
+/**
+ * Finish metadata from the stream.
+ */
+export interface StreamFinish {
+  finishReason: FinishReason;
+  rawFinishReason: string | undefined;
+  usage: LanguageModelUsage;
+  providerMetadata?: Record<string, unknown>;
+}
+
+export async function doStreamStep(
+  conversationPrompt: LanguageModelV4Prompt,
+  modelInit: string | (() => Promise<CompatibleLanguageModel>),
+  writable?: WritableStream<ModelCallStreamPart<ToolSet>>,
+  serializedTools?: Record<string, SerializableToolDef>,
+  options?: DoStreamStepOptions,
+) {
+  'use step';
+
+  // Resolve model inside step (must happen here for serialization boundary)
+  let model: CompatibleLanguageModel;
+  if (typeof modelInit === 'string') {
+    model = gateway.languageModel(modelInit) as CompatibleLanguageModel;
+  } else if (typeof modelInit === 'function') {
+    model = await modelInit();
+  } else {
+    throw new Error(
+      'Invalid "model initialization" argument. Must be a string or a function that returns a LanguageModel instance.',
+    );
+  }
+
+  // Reconstruct tools from serializable definitions with Ajv validation.
+  // Tools are serialized before crossing the step boundary because zod schemas
+  // contain functions that can't be serialized by the workflow runtime.
+  const tools = serializedTools
+    ? resolveSerializableTools(serializedTools)
+    : undefined;
+
+  // streamModelCall handles: prompt standardization, tool preparation,
+  // model.doStream(), retry logic, and stream part transformation
+  // (tool call parsing, finish reason mapping, file wrapping).
+  const { stream: modelStream } = await streamModelCall({
+    model: model as LanguageModel,
+    // streamModelCall expects Prompt (ModelMessage[]) but we pass the
+    // pre-converted LanguageModelV4Prompt. standardizePrompt inside
+    // streamModelCall handles both formats.
+    messages: conversationPrompt as unknown as ModelMessage[],
+    tools,
+    toolChoice: options?.toolChoice,
+    includeRawChunks: options?.includeRawChunks,
+    providerOptions: options?.providerOptions,
+    abortSignal: options?.abortSignal,
+    headers: options?.headers,
+    maxOutputTokens: options?.maxOutputTokens,
+    temperature: options?.temperature,
+    topP: options?.topP,
+    topK: options?.topK,
+    presencePenalty: options?.presencePenalty,
+    frequencyPenalty: options?.frequencyPenalty,
+    stopSequences: options?.stopSequences,
+    seed: options?.seed,
+    repairToolCall: options?.repairToolCall,
+  });
+
+  // Consume the stream: capture data and write to writable in real-time
+  const toolCalls: ParsedToolCall[] = [];
+  const providerExecutedToolResults = new Map<
+    string,
+    ProviderExecutedToolResult
+  >();
+  let finish: StreamFinish | undefined;
+
+  // Aggregation for StepResult
+  let text = '';
+  const reasoningParts: Array<{ text: string }> = [];
+  let responseMetadata:
+    | { id?: string; timestamp?: Date; modelId?: string }
+    | undefined;
+  let warnings: unknown[] | undefined;
+
+  // Acquire writer once before the loop to avoid per-chunk lock overhead
+  const writer = writable?.getWriter();
+
+  try {
+    for await (const part of modelStream) {
+      switch (part.type) {
+        case 'text-delta':
+          text += part.text;
+          break;
+        case 'reasoning-delta':
+          reasoningParts.push({ text: part.text });
+          break;
+        case 'tool-call': {
+          // parseToolCall adds dynamic/invalid/error at runtime
+          const toolCallPart = part as typeof part & Partial<ParsedToolCall>;
+          toolCalls.push({
+            type: 'tool-call',
+            toolCallId: toolCallPart.toolCallId,
+            toolName: toolCallPart.toolName,
+            input: toolCallPart.input,
+            providerExecuted: toolCallPart.providerExecuted,
+            providerMetadata: toolCallPart.providerMetadata as
+              | Record<string, unknown>
+              | undefined,
+            dynamic: toolCallPart.dynamic,
+            invalid: toolCallPart.invalid,
+            error: toolCallPart.error,
+          });
+          break;
+        }
+        case 'tool-result':
+          if (part.providerExecuted) {
+            providerExecutedToolResults.set(part.toolCallId, {
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              result: part.output,
+              isError: false,
+            });
+          }
+          break;
+        case 'tool-error': {
+          const errorPart = part as typeof part & {
+            providerExecuted?: boolean;
+          };
+          if (errorPart.providerExecuted) {
+            providerExecutedToolResults.set(errorPart.toolCallId, {
+              toolCallId: errorPart.toolCallId,
+              toolName: errorPart.toolName,
+              result: errorPart.error,
+              isError: true,
+            });
+          }
+          break;
+        }
+        case 'model-call-end':
+          finish = {
+            finishReason: part.finishReason,
+            rawFinishReason: part.rawFinishReason,
+            usage: part.usage,
+            providerMetadata: part.providerMetadata as
+              | Record<string, unknown>
+              | undefined,
+          };
+          break;
+        case 'model-call-start':
+          warnings = part.warnings;
+          break;
+        case 'model-call-response-metadata':
+          responseMetadata = part;
+          break;
+      }
+
+      // Write to writable in real-time
+      if (writer) {
+        await writer.write(part);
+      }
+    }
+  } finally {
+    writer?.releaseLock();
+  }
+
+  // Build StepResult
+  const reasoningText = reasoningParts.map(r => r.text).join('') || undefined;
+
+  const step: StepResult<ToolSet, any> = {
+    callId: 'workflow-agent',
+    stepNumber: 0,
+    model: {
+      provider: responseMetadata?.modelId?.split(':')[0] ?? 'unknown',
+      modelId: responseMetadata?.modelId ?? 'unknown',
+    },
+    functionId: undefined,
+    metadata: undefined,
+    experimental_context: undefined,
+    content: [
+      ...(text ? [{ type: 'text' as const, text }] : []),
+      ...toolCalls
+        .filter(tc => !tc.invalid)
+        .map(tc => ({
+          type: 'tool-call' as const,
+          toolCallId: tc.toolCallId,
+          toolName: tc.toolName,
+          input: tc.input,
+          ...(tc.dynamic ? { dynamic: true as const } : {}),
+        })),
+    ],
+    text,
+    reasoning: reasoningParts.map(r => ({
+      type: 'reasoning' as const,
+      text: r.text,
+    })),
+    reasoningText,
+    files: [],
+    sources: [],
+    toolCalls: toolCalls
+      .filter(tc => !tc.invalid)
+      .map(tc => ({
+        type: 'tool-call' as const,
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        input: tc.input,
+        ...(tc.dynamic ? { dynamic: true as const } : {}),
+      })),
+    staticToolCalls: [],
+    dynamicToolCalls: toolCalls
+      .filter(tc => !tc.invalid && tc.dynamic)
+      .map(tc => ({
+        type: 'tool-call' as const,
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        input: tc.input,
+        dynamic: true as const,
+      })),
+    toolResults: [],
+    staticToolResults: [],
+    dynamicToolResults: [],
+    finishReason: finish?.finishReason ?? 'other',
+    rawFinishReason: finish?.rawFinishReason,
+    usage:
+      finish?.usage ??
+      ({
+        inputTokens: 0,
+        inputTokenDetails: {
+          noCacheTokens: undefined,
+          cacheReadTokens: undefined,
+          cacheWriteTokens: undefined,
+        },
+        outputTokens: 0,
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+        totalTokens: 0,
+      } as LanguageModelUsage),
+    warnings,
+    request: { body: '' },
+    response: {
+      id: responseMetadata?.id ?? 'unknown',
+      timestamp: responseMetadata?.timestamp ?? new Date(),
+      modelId: responseMetadata?.modelId ?? 'unknown',
+      messages: [],
+    },
+    providerMetadata: finish?.providerMetadata ?? {},
+  } as StepResult<ToolSet, any>;
+
+  return {
+    toolCalls,
+    finish,
+    step,
+    providerExecutedToolResults,
+  };
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+export {
+  WorkflowAgent,
+  Output,
+  type CompatibleLanguageModel,
+  type DownloadFunction,
+  type WorkflowAgentOptions,
+  type WorkflowAgentStreamOptions,
+  type WorkflowAgentStreamResult,
+  type GenerationSettings,
+  type InferWorkflowAgentTools,
+  type InferWorkflowAgentUIMessage,
+  type OutputSpecification,
+  type PrepareCallCallback,
+  type PrepareCallOptions,
+  type PrepareCallResult,
+  type PrepareStepCallback,
+  type PrepareStepInfo,
+  type PrepareStepResult,
+  type ProviderOptions,
+  type StreamTextOnAbortCallback,
+  type StreamTextOnErrorCallback,
+  type StreamTextOnFinishCallback,
+  type StreamTextTransform,
+  type TelemetrySettings,
+  type ToolCallRepairFunction,
+  type WorkflowAgentOnStartCallback,
+  type WorkflowAgentOnStepStartCallback,
+  type WorkflowAgentOnToolCallStartCallback,
+  type WorkflowAgentOnToolCallFinishCallback,
+} from './workflow-agent.js';
+
+export {
+  createModelCallToUIChunkTransform,
+  toUIMessageChunk,
+} from './to-ui-message-chunk.js';
+
+export type { ModelCallStreamPart } from './do-stream-step.js';

package/src/providers/mock-function-wrapper.ts

@@ -0,0 +1,11 @@
+import { MockLanguageModelV4 } from 'ai/test';
+
+// Workaround for SWC plugin bug (https://github.com/vercel/workflow/issues/1365):
+// `new ClassName(...)` in a step closure doesn't get closure vars hoisted
+// correctly. Wrapping the constructor call in a plain function (imported
+// from a separate file) fixes it.
+export function mockProvider(
+  ...args: ConstructorParameters<typeof MockLanguageModelV4>
+) {
+  return new MockLanguageModelV4(...args);
+}

package/src/providers/mock.ts

@@ -0,0 +1,123 @@
+import { mockProvider } from './mock-function-wrapper.js';
+
+export type MockResponseDescriptor =
+  | { type: 'text'; text: string }
+  | { type: 'tool-call'; toolName: string; input: string };
+
+/**
+ * Mock model that returns a fixed text response.
+ * Same 'use step' pattern as real providers (anthropic, openai, etc.).
+ * Only captures `text` (string) — fully serializable across step boundary.
+ */
+export function mockTextModel(text: string) {
+  return async () => {
+    'use step';
+    // Bind closure var at step body level so SWC plugin detects it
+    const _text = text;
+    return mockProvider({
+      doStream: async () => ({
+        stream: new ReadableStream({
+          start(c) {
+            for (const v of [
+              { type: 'stream-start', warnings: [] },
+              {
+                type: 'response-metadata',
+                id: 'r',
+                modelId: 'mock',
+                timestamp: new Date(),
+              },
+              { type: 'text-start', id: '1' },
+              { type: 'text-delta', id: '1', delta: _text },
+              { type: 'text-end', id: '1' },
+              {
+                type: 'finish',
+                finishReason: { unified: 'stop', raw: 'stop' },
+                usage: {
+                  inputTokens: { total: 5, noCache: 5 },
+                  outputTokens: { total: 10, text: 10 },
+                },
+              },
+            ] as any[])
+              c.enqueue(v);
+            c.close();
+          },
+        }),
+      }),
+    });
+  };
+}
+
+/**
+ * Mock model that plays through a sequence of responses.
+ * Determines which response to return by counting assistant messages in the prompt.
+ * Only captures `responses` (array of plain objects) — fully serializable.
+ */
+export function mockSequenceModel(responses: MockResponseDescriptor[]) {
+  return async () => {
+    'use step';
+    // Bind closure var at step body level so SWC plugin detects it
+    const _responses = responses;
+    return mockProvider({
+      doStream: async (options: any) => {
+        const idx = Math.min(
+          options.prompt.filter((m: any) => m.role === 'assistant').length,
+          _responses.length - 1,
+        );
+        const r = _responses[idx];
+        const parts =
+          r.type === 'text'
+            ? [
+                { type: 'stream-start', warnings: [] },
+                {
+                  type: 'response-metadata',
+                  id: 'r',
+                  modelId: 'mock',
+                  timestamp: new Date(),
+                },
+                { type: 'text-start', id: '1' },
+                { type: 'text-delta', id: '1', delta: r.text },
+                { type: 'text-end', id: '1' },
+                {
+                  type: 'finish',
+                  finishReason: { unified: 'stop', raw: 'stop' },
+                  usage: {
+                    inputTokens: { total: 5, noCache: 5 },
+                    outputTokens: { total: 10, text: 10 },
+                  },
+                },
+              ]
+            : [
+                { type: 'stream-start', warnings: [] },
+                {
+                  type: 'response-metadata',
+                  id: 'r',
+                  modelId: 'mock',
+                  timestamp: new Date(),
+                },
+                {
+                  type: 'tool-call',
+                  toolCallId: `call-${idx + 1}`,
+                  toolName: r.toolName,
+                  input: r.input,
+                },
+                {
+                  type: 'finish',
+                  finishReason: { unified: 'tool-calls', raw: undefined },
+                  usage: {
+                    inputTokens: { total: 5, noCache: 5 },
+                    outputTokens: { total: 10, text: 10 },
+                  },
+                },
+              ];
+        return {
+          stream: new ReadableStream({
+            start(c) {
+              for (const p of parts as any[]) c.enqueue(p);
+              c.close();
+            },
+          }),
+        };
+      },
+    });
+  };
+}

package/src/serializable-schema.ts

@@ -0,0 +1,81 @@
+/**
+ * Helpers for passing tool schemas across workflow step boundaries.
+ *
+ * Tool schemas (zod, valibot, arktype, etc.) contain functions that can't be
+ * serialized by the workflow runtime. These helpers extract JSON Schema from
+ * schemas, then reconstruct tools with Ajv validation inside step functions.
+ *
+ * Uses `asSchema()` from `@ai-sdk/provider-utils` for JSON Schema extraction,
+ * which supports Standard Schema compatible libraries. When libraries adopt
+ * `~standard.jsonSchema` (Standard Schema v2), extraction can be simplified
+ * to use that interface directly.
+ */
+import type { JSONSchema7 } from '@ai-sdk/provider';
+import { asSchema, jsonSchema } from '@ai-sdk/provider-utils';
+import { tool, type ToolSet } from 'ai';
+import Ajv from 'ajv';
+
+/**
+ * Serializable tool definition — plain objects only, safe for workflow steps.
+ */
+export type SerializableToolDef = {
+  description?: string;
+  inputSchema: JSONSchema7;
+};
+
+/**
+ * Converts a ToolSet (with zod/standard schemas and execute functions) to a
+ * serializable record of tool definitions. Only description and inputSchema
+ * (as JSON Schema) are preserved — execute functions are stripped since they
+ * run outside the step.
+ */
+export function serializeToolSet(
+  tools: ToolSet,
+): Record<string, SerializableToolDef> {
+  return Object.fromEntries(
+    Object.entries(tools).map(([name, t]) => [
+      name,
+      {
+        description: t.description,
+        inputSchema: asSchema(t.inputSchema).jsonSchema as JSONSchema7,
+      },
+    ]),
+  );
+}
+
+/**
+ * Reconstructs tool objects from serializable tool definitions inside a step.
+ *
+ * Wraps each tool's JSON Schema with `jsonSchema()` and validates tool call
+ * arguments against the schema using Ajv. This provides runtime type safety
+ * equivalent to using zod schemas directly with the AI SDK.
+ */
+export function resolveSerializableTools(
+  tools: Record<string, SerializableToolDef>,
+): ToolSet {
+  const ajv = new Ajv();
+
+  return Object.fromEntries(
+    Object.entries(tools).map(([name, t]) => {
+      const validateFn = ajv.compile(t.inputSchema);
+
+      return [
+        name,
+        tool({
+          description: t.description,
+          inputSchema: jsonSchema(t.inputSchema, {
+            validate: value => {
+              if (validateFn(value)) {
+                return { success: true, value: value as any };
+              }
+              return {
+                success: false,
+                error: new Error(ajv.errorsText(validateFn.errors)),
+              };
+            },
+          }),
+        }),
+      ];
+    }),
+  );
+}

package/src/stream-iterator.ts

@@ -0,0 +1,46 @@
+/**
+ * Converts an AsyncGenerator to a ReadableStream.
+ */
+export function iteratorToStream<T>(
+  iterator: AsyncGenerator<T>,
+  options?: { signal?: AbortSignal },
+): ReadableStream<T> {
+  return new ReadableStream<T>({
+    async pull(controller) {
+      if (options?.signal?.aborted) {
+        controller.close();
+        return;
+      }
+
+      const { value, done } = await iterator.next();
+      if (done) {
+        controller.close();
+      } else {
+        controller.enqueue(value);
+      }
+    },
+    cancel() {
+      iterator.return(undefined as any);
+    },
+  });
+}
+
+/**
+ * Converts a ReadableStream to an AsyncIterable.
+ *
+ * @yields Items from the stream.
+ */
+export async function* streamToIterator<T>(
+  stream: ReadableStream<T>,
+): AsyncGenerator<T> {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}