@ai-sdk/workflow 0.0.0-bf6e4b15-20260402200305

package/dist/index.d.mts

@@ -0,0 +1,739 @@
+import { LanguageModelV4, SharedV4ProviderOptions, LanguageModelV4Prompt, LanguageModelV4CallOptions, LanguageModelV4StreamPart } from '@ai-sdk/provider';
+import { ToolSet, SystemModelMessage, ToolChoice, StepResult, StreamTextOnStepFinishCallback, ModelMessage, FinishReason, LanguageModelUsage, Experimental_ModelCallStreamPart, StopCondition, LanguageModelResponseMetadata, ToolCallRepairFunction, UIMessage, UIMessageChunk } from 'ai';
+export { Experimental_ModelCallStreamPart as ModelCallStreamPart, Output, ToolCallRepairFunction } from 'ai';
+
+/**
+ * Shared types for AI SDK V4.
+ */
+
+/**
+ * Language model type for AI SDK V4.
+ *
+ * This is a simple alias for LanguageModelV4 from @ai-sdk/provider.
+ */
+type CompatibleLanguageModel = LanguageModelV4;
+
+/**
+ * Infer the type of the tools of a workflow agent.
+ */
+type InferWorkflowAgentTools<WORKFLOW_AGENT> = WORKFLOW_AGENT extends WorkflowAgent<infer TOOLS> ? TOOLS : never;
+/**
+ * Infer the UI message type of a workflow agent.
+ */
+type InferWorkflowAgentUIMessage<WORKFLOW_AGENT, MESSAGE_METADATA = unknown> = UIMessage<MESSAGE_METADATA>;
+
+/**
+ * Output specification interface for structured outputs.
+ * Use `Output.object({ schema })` or `Output.text()` to create an output specification.
+ */
+interface OutputSpecification<OUTPUT, PARTIAL> {
+    readonly name: string;
+    responseFormat: PromiseLike<LanguageModelV4CallOptions['responseFormat']>;
+    parsePartialOutput(options: {
+        text: string;
+    }): Promise<{
+        partial: PARTIAL;
+    } | undefined>;
+    parseCompleteOutput(options: {
+        text: string;
+    }, context: {
+        response: LanguageModelResponseMetadata;
+        usage: LanguageModelUsage;
+        finishReason: FinishReason;
+    }): Promise<OUTPUT>;
+}
+/**
+ * Provider-specific options type. This is equivalent to SharedV4ProviderOptions from @ai-sdk/provider.
+ */
+type ProviderOptions = SharedV4ProviderOptions;
+/**
+ * Telemetry settings for observability.
+ */
+interface TelemetrySettings {
+    /**
+     * Enable or disable telemetry. Defaults to true.
+     */
+    isEnabled?: boolean;
+    /**
+     * Identifier for this function. Used to group telemetry data by function.
+     */
+    functionId?: string;
+    /**
+     * Additional information to include in the telemetry data.
+     */
+    metadata?: Record<string, string | number | boolean | Array<string | number | boolean> | null | undefined>;
+    /**
+     * Enable or disable input recording. Enabled by default.
+     *
+     * You might want to disable input recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordInputs?: boolean;
+    /**
+     * Enable or disable output recording. Enabled by default.
+     *
+     * You might want to disable output recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordOutputs?: boolean;
+    /**
+     * Custom tracer for the telemetry.
+     */
+    tracer?: unknown;
+}
+/**
+ * A transformation that is applied to the stream.
+ */
+type StreamTextTransform<TTools extends ToolSet> = (options: {
+    tools: TTools;
+    stopStream: () => void;
+}) => TransformStream<LanguageModelV4StreamPart, LanguageModelV4StreamPart>;
+
+/**
+ * Custom download function for URLs.
+ * The function receives an array of URLs with information about whether
+ * the model supports them directly.
+ */
+type DownloadFunction = (options: {
+    url: URL;
+    isUrlSupportedByModel: boolean;
+}[]) => PromiseLike<({
+    data: Uint8Array;
+    mediaType: string | undefined;
+} | null)[]>;
+/**
+ * Generation settings that can be passed to the model.
+ * These map directly to LanguageModelV4CallOptions.
+ */
+interface GenerationSettings {
+    /**
+     * Maximum number of tokens to generate.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Temperature setting. The range depends on the provider and model.
+     * It is recommended to set either `temperature` or `topP`, but not both.
+     */
+    temperature?: number;
+    /**
+     * Nucleus sampling. This is a number between 0 and 1.
+     * E.g. 0.1 would mean that only tokens with the top 10% probability mass are considered.
+     * It is recommended to set either `temperature` or `topP`, but not both.
+     */
+    topP?: number;
+    /**
+     * Only sample from the top K options for each subsequent token.
+     * Used to remove "long tail" low probability responses.
+     * Recommended for advanced use cases only. You usually only need to use temperature.
+     */
+    topK?: number;
+    /**
+     * Presence penalty setting. It affects the likelihood of the model to
+     * repeat information that is already in the prompt.
+     * The presence penalty is a number between -1 (increase repetition)
+     * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+     */
+    presencePenalty?: number;
+    /**
+     * Frequency penalty setting. It affects the likelihood of the model
+     * to repeatedly use the same words or phrases.
+     * The frequency penalty is a number between -1 (increase repetition)
+     * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+     */
+    frequencyPenalty?: number;
+    /**
+     * Stop sequences. If set, the model will stop generating text when one of the stop sequences is generated.
+     * Providers may have limits on the number of stop sequences.
+     */
+    stopSequences?: string[];
+    /**
+     * The seed (integer) to use for random sampling. If set and supported
+     * by the model, calls will generate deterministic results.
+     */
+    seed?: number;
+    /**
+     * Maximum number of retries. Set to 0 to disable retries.
+     * Note: In workflow context, retries are typically handled by the workflow step mechanism.
+     * @default 2
+     */
+    maxRetries?: number;
+    /**
+     * Abort signal for cancelling the operation.
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * Additional HTTP headers to be sent with the request.
+     * Only applicable for HTTP-based providers.
+     */
+    headers?: Record<string, string | undefined>;
+    /**
+     * Additional provider-specific options. They are passed through
+     * to the provider from the AI SDK and enable provider-specific
+     * functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+}
+/**
+ * Information passed to the prepareStep callback.
+ */
+interface PrepareStepInfo<TTools extends ToolSet = ToolSet> {
+    /**
+     * The current model configuration (string or function).
+     * The function should return a LanguageModelV4 instance.
+     */
+    model: string | (() => Promise<CompatibleLanguageModel>);
+    /**
+     * The current step number (0-indexed).
+     */
+    stepNumber: number;
+    /**
+     * All previous steps with their results.
+     */
+    steps: StepResult<TTools, any>[];
+    /**
+     * The messages that will be sent to the model.
+     * This is the LanguageModelV4Prompt format used internally.
+     */
+    messages: LanguageModelV4Prompt;
+    /**
+     * The context passed via the experimental_context setting (experimental).
+     */
+    experimental_context: unknown;
+}
+/**
+ * Return type from the prepareStep callback.
+ * All properties are optional - only return the ones you want to override.
+ */
+interface PrepareStepResult extends Partial<GenerationSettings> {
+    /**
+     * Override the model for this step.
+     * The function should return a LanguageModelV4 instance.
+     */
+    model?: string | (() => Promise<CompatibleLanguageModel>);
+    /**
+     * Override the system message for this step.
+     */
+    system?: string;
+    /**
+     * Override the messages for this step.
+     * Use this for context management or message injection.
+     */
+    messages?: LanguageModelV4Prompt;
+    /**
+     * Override the tool choice for this step.
+     */
+    toolChoice?: ToolChoice<ToolSet>;
+    /**
+     * Override the active tools for this step.
+     * Limits the tools that are available for the model to call.
+     */
+    activeTools?: string[];
+    /**
+     * Context that is passed into tool execution. Experimental.
+     * Changing the context will affect the context in this step and all subsequent steps.
+     */
+    experimental_context?: unknown;
+}
+/**
+ * Callback function called before each step in the agent loop.
+ * Use this to modify settings, manage context, or implement dynamic behavior.
+ */
+type PrepareStepCallback<TTools extends ToolSet = ToolSet> = (info: PrepareStepInfo<TTools>) => PrepareStepResult | Promise<PrepareStepResult>;
+/**
+ * Options passed to the prepareCall callback.
+ */
+interface PrepareCallOptions<TTools extends ToolSet = ToolSet> extends Partial<GenerationSettings> {
+    model: string | (() => Promise<CompatibleLanguageModel>);
+    tools: TTools;
+    instructions?: string | SystemModelMessage | Array<SystemModelMessage>;
+    toolChoice?: ToolChoice<TTools>;
+    experimental_telemetry?: TelemetrySettings;
+    experimental_context?: unknown;
+    messages: ModelMessage[];
+}
+/**
+ * Result of the prepareCall callback. All fields are optional —
+ * only returned fields override the defaults.
+ * Note: `tools` cannot be overridden via prepareCall because they are
+ * bound at construction time for type safety.
+ */
+type PrepareCallResult<TTools extends ToolSet = ToolSet> = Partial<Omit<PrepareCallOptions<TTools>, 'tools'>>;
+/**
+ * Callback called once before the agent loop starts to transform call parameters.
+ */
+type PrepareCallCallback<TTools extends ToolSet = ToolSet> = (options: PrepareCallOptions<TTools>) => PrepareCallResult<TTools> | Promise<PrepareCallResult<TTools>>;
+/**
+ * Configuration options for creating a {@link WorkflowAgent} instance.
+ */
+interface WorkflowAgentOptions<TTools extends ToolSet = ToolSet> extends GenerationSettings {
+    /**
+     * The model provider to use for the agent.
+     *
+     * This should be a string compatible with the Vercel AI Gateway (e.g., 'anthropic/claude-opus'),
+     * or a step function that returns a LanguageModelV4 instance.
+     */
+    model: string | (() => Promise<CompatibleLanguageModel>);
+    /**
+     * A set of tools available to the agent.
+     * Tools can be implemented as workflow steps for automatic retries and persistence,
+     * or as regular workflow-level logic using core library features like sleep() and Hooks.
+     */
+    tools?: TTools;
+    /**
+     * Agent instructions. Can be a string, a SystemModelMessage, or an array of SystemModelMessages.
+     * Supports provider-specific options (e.g., caching) when using the SystemModelMessage form.
+     */
+    instructions?: string | SystemModelMessage | Array<SystemModelMessage>;
+    /**
+     * Optional system prompt to guide the agent's behavior.
+     * @deprecated Use `instructions` instead.
+     */
+    system?: string;
+    /**
+     * The tool choice strategy. Default: 'auto'.
+     */
+    toolChoice?: ToolChoice<TTools>;
+    /**
+     * Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+     * Default context that is passed into tool execution for every stream call on this agent.
+     *
+     * Per-stream `experimental_context` values passed to `stream()` override this default.
+     * Experimental (can break in patch releases).
+     * @default undefined
+     */
+    experimental_context?: unknown;
+    /**
+     * Default callback function called before each step in the agent loop.
+     * Use this to modify settings, manage context, or inject messages dynamically
+     * for every stream call on this agent instance.
+     *
+     * Per-stream `prepareStep` values passed to `stream()` override this default.
+     */
+    prepareStep?: PrepareStepCallback<TTools>;
+    /**
+     * Callback function to be called after each step completes.
+     */
+    onStepFinish?: StreamTextOnStepFinishCallback<ToolSet, any>;
+    /**
+     * Callback that is called when the LLM response and all request tool executions are finished.
+     */
+    onFinish?: StreamTextOnFinishCallback<ToolSet>;
+    /**
+     * Callback called when the agent starts streaming, before any LLM calls.
+     */
+    experimental_onStart?: WorkflowAgentOnStartCallback;
+    /**
+     * Callback called before each step (LLM call) begins.
+     */
+    experimental_onStepStart?: WorkflowAgentOnStepStartCallback;
+    /**
+     * Callback called before a tool's execute function runs.
+     */
+    experimental_onToolCallStart?: WorkflowAgentOnToolCallStartCallback;
+    /**
+     * Callback called after a tool execution completes.
+     */
+    experimental_onToolCallFinish?: WorkflowAgentOnToolCallFinishCallback;
+    /**
+     * Prepare the parameters for the stream call.
+     * Called once before the agent loop starts. Use this to transform
+     * model, tools, instructions, or other settings based on runtime context.
+     */
+    prepareCall?: PrepareCallCallback<TTools>;
+}
+/**
+ * Callback that is called when the LLM response and all request tool executions are finished.
+ */
+type StreamTextOnFinishCallback<TTools extends ToolSet = ToolSet, OUTPUT = never> = (event: {
+    /**
+     * Details for all steps.
+     */
+    readonly steps: StepResult<TTools, any>[];
+    /**
+     * The final messages including all tool calls and results.
+     */
+    readonly messages: ModelMessage[];
+    /**
+     * The text output from the last step.
+     */
+    readonly text: string;
+    /**
+     * The finish reason from the last step.
+     */
+    readonly finishReason: FinishReason;
+    /**
+     * The total token usage across all steps.
+     */
+    readonly totalUsage: LanguageModelUsage;
+    /**
+     * Context that is passed into tool execution.
+     */
+    readonly experimental_context: unknown;
+    /**
+     * The generated structured output. It uses the `experimental_output` specification.
+     * Only available when `experimental_output` is specified.
+     */
+    readonly experimental_output: OUTPUT;
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is invoked when an error occurs during streaming.
+ */
+type StreamTextOnErrorCallback = (event: {
+    error: unknown;
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is set using the `onAbort` option.
+ */
+type StreamTextOnAbortCallback<TTools extends ToolSet = ToolSet> = (event: {
+    /**
+     * Details for all previously finished steps.
+     */
+    readonly steps: StepResult<TTools, any>[];
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is called when the agent starts streaming, before any LLM calls.
+ */
+type WorkflowAgentOnStartCallback = (event: {
+    /** The model being used */
+    readonly model: string | (() => Promise<CompatibleLanguageModel>);
+    /** The messages being sent */
+    readonly messages: ModelMessage[];
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is called before each step (LLM call) begins.
+ */
+type WorkflowAgentOnStepStartCallback = (event: {
+    /** The current step number (0-based) */
+    readonly stepNumber: number;
+    /** The model being used for this step */
+    readonly model: string | (() => Promise<CompatibleLanguageModel>);
+    /** The messages being sent for this step */
+    readonly messages: ModelMessage[];
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is called before a tool's execute function runs.
+ */
+type WorkflowAgentOnToolCallStartCallback = (event: {
+    /** The tool call being executed */
+    readonly toolCall: ToolCall;
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is called after a tool execution completes.
+ */
+type WorkflowAgentOnToolCallFinishCallback = (event: {
+    /** The tool call that was executed */
+    readonly toolCall: ToolCall;
+    /** The tool result (undefined if execution failed) */
+    readonly result?: unknown;
+    /** The error if execution failed */
+    readonly error?: unknown;
+}) => PromiseLike<void> | void;
+/**
+ * Options for the {@link WorkflowAgent.stream} method.
+ */
+interface WorkflowAgentStreamOptions<TTools extends ToolSet = ToolSet, OUTPUT = never, PARTIAL_OUTPUT = never> extends Partial<GenerationSettings> {
+    /**
+     * The conversation messages to process. Should follow the AI SDK's ModelMessage format.
+     */
+    messages: ModelMessage[];
+    /**
+     * Optional system prompt override. If provided, overrides the system prompt from the constructor.
+     */
+    system?: string;
+    /**
+     * A WritableStream that receives raw LanguageModelV4StreamPart chunks in real-time
+     * as the model generates them. This enables streaming to the client without
+     * coupling WorkflowAgent to UIMessageChunk format.
+     *
+     * Convert to UIMessageChunks at the response boundary using
+     * `createUIMessageChunkTransform()` from `@ai-sdk/workflow`.
+     *
+     * @example
+     * ```typescript
+     * // In the workflow:
+     * await agent.stream({
+     *   messages,
+     *   writable: getWritable<ModelCallStreamPart>(),
+     * });
+     *
+     * // In the route handler:
+     * return createUIMessageStreamResponse({
+     *   stream: run.readable.pipeThrough(createModelCallToUIChunkTransform()),
+     * });
+     * ```
+     */
+    writable?: WritableStream<Experimental_ModelCallStreamPart<ToolSet>>;
+    /**
+     * Condition for stopping the generation when there are tool results in the last step.
+     * When the condition is an array, any of the conditions can be met to stop the generation.
+     */
+    stopWhen?: StopCondition<NoInfer<ToolSet>, any> | Array<StopCondition<NoInfer<ToolSet>, any>>;
+    /**
+     * Maximum number of sequential LLM calls (steps), e.g. when you use tool calls.
+     * A maximum number can be set to prevent infinite loops in the case of misconfigured tools.
+     * By default, it's unlimited (the agent loops until completion).
+     */
+    maxSteps?: number;
+    /**
+     * The tool choice strategy. Default: 'auto'.
+     * Overrides the toolChoice from the constructor if provided.
+     */
+    toolChoice?: ToolChoice<TTools>;
+    /**
+     * 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>>;
+    /**
+     * Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+     * Context that is passed into tool execution.
+     * Experimental (can break in patch releases).
+     * @default undefined
+     */
+    experimental_context?: unknown;
+    /**
+     * Optional specification for parsing structured outputs from the LLM response.
+     * Use `Output.object({ schema })` for structured output or `Output.text()` for text output.
+     *
+     * @example
+     * ```typescript
+     * import { Output } from '@workflow/ai';
+     * import { z } from 'zod';
+     *
+     * const result = await agent.stream({
+     *   messages: [...],
+     *   writable: getWritable(),
+     *   experimental_output: Output.object({
+     *     schema: z.object({
+     *       sentiment: z.enum(['positive', 'negative', 'neutral']),
+     *       confidence: z.number(),
+     *     }),
+     *   }),
+     * });
+     *
+     * console.log(result.experimental_output); // { sentiment: 'positive', confidence: 0.95 }
+     * ```
+     */
+    experimental_output?: OutputSpecification<OUTPUT, PARTIAL_OUTPUT>;
+    /**
+     * Whether to include raw chunks from the provider in the stream.
+     * When enabled, you will receive raw chunks with type 'raw' that contain the unprocessed data from the provider.
+     * This allows access to cutting-edge provider features not yet wrapped by the AI SDK.
+     * Defaults to false.
+     */
+    includeRawChunks?: boolean;
+    /**
+     * A function that attempts to repair a tool call that failed to parse.
+     */
+    experimental_repairToolCall?: ToolCallRepairFunction<TTools>;
+    /**
+     * Optional stream transformations.
+     * They are applied in the order they are provided.
+     * The stream transformations must maintain the stream structure for streamText to work correctly.
+     */
+    experimental_transform?: StreamTextTransform<TTools> | Array<StreamTextTransform<TTools>>;
+    /**
+     * Custom download function to use for URLs.
+     * By default, files are downloaded if the model does not support the URL for the given media type.
+     */
+    experimental_download?: DownloadFunction;
+    /**
+     * Callback function to be called after each step completes.
+     */
+    onStepFinish?: StreamTextOnStepFinishCallback<TTools, any>;
+    /**
+     * Callback that is invoked when an error occurs during streaming.
+     * You can use it to log errors.
+     */
+    onError?: StreamTextOnErrorCallback;
+    /**
+     * Callback that is called when the LLM response and all request tool executions
+     * (for tools that have an `execute` function) are finished.
+     */
+    onFinish?: StreamTextOnFinishCallback<TTools, OUTPUT>;
+    /**
+     * Callback that is called when the operation is aborted.
+     */
+    onAbort?: StreamTextOnAbortCallback<TTools>;
+    /**
+     * Callback called when the agent starts streaming, before any LLM calls.
+     */
+    experimental_onStart?: WorkflowAgentOnStartCallback;
+    /**
+     * Callback called before each step (LLM call) begins.
+     */
+    experimental_onStepStart?: WorkflowAgentOnStepStartCallback;
+    /**
+     * Callback called before a tool's execute function runs.
+     */
+    experimental_onToolCallStart?: WorkflowAgentOnToolCallStartCallback;
+    /**
+     * Callback called after a tool execution completes.
+     */
+    experimental_onToolCallFinish?: WorkflowAgentOnToolCallFinishCallback;
+    /**
+     * Callback function called before each step in the agent loop.
+     * Use this to modify settings, manage context, or inject messages dynamically.
+     *
+     * @example
+     * ```typescript
+     * prepareStep: async ({ messages, stepNumber }) => {
+     *   // Inject messages from a queue
+     *   const queuedMessages = await getQueuedMessages();
+     *   if (queuedMessages.length > 0) {
+     *     return {
+     *       messages: [...messages, ...queuedMessages],
+     *     };
+     *   }
+     *   return {};
+     * }
+     * ```
+     */
+    prepareStep?: PrepareStepCallback<TTools>;
+    /**
+     * Timeout in milliseconds for the stream operation.
+     * When specified, creates an AbortSignal that will abort the operation after the given time.
+     * If both `timeout` and `abortSignal` are provided, whichever triggers first will abort.
+     */
+    timeout?: number;
+}
+/**
+ * A tool call made by the model. Matches the AI SDK's tool call shape.
+ */
+interface ToolCall {
+    /** Discriminator for content part arrays */
+    type: 'tool-call';
+    /** The unique identifier of the tool call */
+    toolCallId: string;
+    /** The name of the tool that was called */
+    toolName: string;
+    /** The parsed input arguments for the tool call */
+    input: unknown;
+}
+/**
+ * A tool result from executing a tool. Matches the AI SDK's tool result shape.
+ */
+interface ToolResult {
+    /** Discriminator for content part arrays */
+    type: 'tool-result';
+    /** The tool call ID this result corresponds to */
+    toolCallId: string;
+    /** The name of the tool that was executed */
+    toolName: string;
+    /** The parsed input arguments that were passed to the tool */
+    input: unknown;
+    /** The output produced by the tool */
+    output: unknown;
+}
+/**
+ * Result of the WorkflowAgent.stream method.
+ */
+interface WorkflowAgentStreamResult<TTools extends ToolSet = ToolSet, OUTPUT = never> {
+    /**
+     * The final messages including all tool calls and results.
+     */
+    messages: ModelMessage[];
+    /**
+     * Details for all steps.
+     */
+    steps: StepResult<TTools, any>[];
+    /**
+     * The tool calls from the last step.
+     * Includes all tool calls regardless of whether they were executed.
+     *
+     * When the agent stops because a tool without an `execute` function was called,
+     * this array will contain those calls. Compare with `toolResults` to find
+     * unresolved tool calls that need client-side handling:
+     *
+     * ```ts
+     * const unresolved = result.toolCalls.filter(
+     *   tc => !result.toolResults.some(tr => tr.toolCallId === tc.toolCallId)
+     * );
+     * ```
+     *
+     * This matches the AI SDK's `GenerateTextResult.toolCalls` behavior.
+     */
+    toolCalls: ToolCall[];
+    /**
+     * The tool results from the last step.
+     * Only includes results for tools that were actually executed (server-side or provider-executed).
+     * Tools without an `execute` function will NOT have entries here.
+     *
+     * This matches the AI SDK's `GenerateTextResult.toolResults` behavior.
+     */
+    toolResults: ToolResult[];
+    /**
+     * The generated structured output. It uses the `experimental_output` specification.
+     * Only available when `experimental_output` is specified.
+     */
+    experimental_output: OUTPUT;
+}
+/**
+ * A class for building durable AI agents within workflows.
+ *
+ * WorkflowAgent enables you to create AI-powered agents that can maintain state
+ * across workflow steps, call tools, and gracefully handle interruptions and resumptions.
+ * It integrates seamlessly with the AI SDK and the Workflow DevKit for
+ * production-grade reliability.
+ *
+ * @example
+ * ```typescript
+ * const agent = new WorkflowAgent({
+ *   model: 'anthropic/claude-opus',
+ *   tools: {
+ *     getWeather: {
+ *       description: 'Get weather for a location',
+ *       inputSchema: z.object({ location: z.string() }),
+ *       execute: getWeatherStep,
+ *     },
+ *   },
+ *   instructions: 'You are a helpful weather assistant.',
+ * });
+ *
+ * const result = await agent.stream({
+ *   messages: [{ role: 'user', content: 'What is the weather?' }],
+ * });
+ * ```
+ */
+declare class WorkflowAgent<TBaseTools extends ToolSet = ToolSet> {
+    private model;
+    /**
+     * The tool set configured for this agent.
+     */
+    readonly tools: TBaseTools;
+    private instructions?;
+    private generationSettings;
+    private toolChoice?;
+    private telemetry?;
+    private experimentalContext;
+    private prepareStep?;
+    private constructorOnStepFinish?;
+    private constructorOnFinish?;
+    private constructorOnStart?;
+    private constructorOnStepStart?;
+    private constructorOnToolCallStart?;
+    private constructorOnToolCallFinish?;
+    private prepareCall?;
+    constructor(options: WorkflowAgentOptions<TBaseTools>);
+    generate(): void;
+    stream<TTools extends TBaseTools = TBaseTools, OUTPUT = never, PARTIAL_OUTPUT = never>(options: WorkflowAgentStreamOptions<TTools, OUTPUT, PARTIAL_OUTPUT>): Promise<WorkflowAgentStreamResult<TTools, OUTPUT>>;
+}
+
+/**
+ * Convert a single ModelCallStreamPart to a UIMessageChunk.
+ * Returns undefined for parts that don't map to UI chunks.
+ */
+declare function toUIMessageChunk(part: Experimental_ModelCallStreamPart<ToolSet>): UIMessageChunk | undefined;
+/**
+ * Create a TransformStream that converts ModelCallStreamPart to UIMessageChunk.
+ * Wraps toUIMessageChunk with start/start-step/finish-step lifecycle chunks.
+ */
+declare function createModelCallToUIChunkTransform(): TransformStream<Experimental_ModelCallStreamPart<ToolSet>, UIMessageChunk>;
+
+export { type CompatibleLanguageModel, type DownloadFunction, 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, WorkflowAgent, type WorkflowAgentOnStartCallback, type WorkflowAgentOnStepStartCallback, type WorkflowAgentOnToolCallFinishCallback, type WorkflowAgentOnToolCallStartCallback, type WorkflowAgentOptions, type WorkflowAgentStreamOptions, type WorkflowAgentStreamResult, createModelCallToUIChunkTransform, toUIMessageChunk };