@ai-sdk/workflow 0.0.0-6b196531-20260710185421

package/dist/index.d.ts

@@ -0,0 +1,1188 @@
+import { LanguageModelV4, LanguageModelV4CallOptions, SharedV4ProviderOptions, LanguageModelV4Prompt, LanguageModelV4StreamPart } from '@ai-sdk/provider';
+import { Context, HasRequiredKey, InferToolSetContext } from '@ai-sdk/provider-utils';
+import { ToolSet, LanguageModel, Instructions, ToolChoice, TelemetryOptions as TelemetryOptions$1, StopCondition, ActiveTools, LanguageModelResponseMetadata, LanguageModelUsage, FinishReason, ToolCallRepairFunction, Experimental_SandboxSession, StepResult, GenerateTextOnStepEndCallback, ModelMessage, Experimental_LanguageModelStreamPart, UIMessage, UIMessageChunk, ChatTransport, PrepareSendMessagesRequest, PrepareReconnectToStreamRequest, ChatRequestOptions } from 'ai';
+export { Experimental_LanguageModelStreamPart 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;
+
+/**
+ * Callback function to be called after each step completes.
+ * Alias for the AI SDK's GenerateTextOnStepEndCallback, using
+ * WorkflowAgent-consistent naming.
+ */
+type WorkflowAgentOnStepEndCallback<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context> = GenerateTextOnStepEndCallback<TTools, TRuntimeContext>;
+/**
+ * Callback function to be called after each step completes.
+ * Deprecated alias for `WorkflowAgentOnStepEndCallback`.
+ *
+ * @deprecated Use `WorkflowAgentOnStepEndCallback` instead.
+ */
+type WorkflowAgentOnStepFinishCallback<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context> = WorkflowAgentOnStepEndCallback<TTools, TRuntimeContext>;
+/**
+ * Infer the type of the tools of a workflow agent.
+ */
+type InferWorkflowAgentTools<WORKFLOW_AGENT> = WORKFLOW_AGENT extends WorkflowAgent<infer TOOLS, any> ? 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;
+type WorkflowAgentToolsContextParameter<TTools extends ToolSet> = HasRequiredKey<InferToolSetContext<TTools>> extends true ? {
+    toolsContext: InferToolSetContext<TTools>;
+} : {
+    toolsContext?: never;
+};
+type TelemetryOptions<TRuntimeContext extends Context = Context, TTools extends ToolSet = ToolSet> = TelemetryOptions$1<TRuntimeContext, TTools>;
+/**
+ * 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>;
+    /**
+     * Reasoning effort level for the model. Controls how much reasoning
+     * the model performs before generating a response.
+     */
+    reasoning?: LanguageModelV4CallOptions['reasoning'];
+    /**
+     * 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, TRuntimeContext extends Context = Context> {
+    /**
+     * The current model configuration (string or function).
+     * The function should return a LanguageModelV4 instance.
+     */
+    model: LanguageModel;
+    /**
+     * The current step number (0-indexed).
+     */
+    stepNumber: number;
+    /**
+     * All previous steps with their results.
+     */
+    steps: StepResult<TTools, TRuntimeContext>[];
+    /**
+     * The messages that will be sent to the model.
+     * This is the LanguageModelV4Prompt format used internally.
+     */
+    messages: LanguageModelV4Prompt;
+    /**
+     * The runtime context that flows through the agent loop.
+     * Treat the value as immutable; return a new `runtimeContext` from
+     * `prepareStep` to update it for the current and subsequent steps.
+     */
+    runtimeContext: TRuntimeContext;
+    /**
+     * Per-tool context, keyed by tool name. Each tool receives only its own
+     * validated entry as `context` during execution.
+     * Treat the value as immutable; return a new `toolsContext` from
+     * `prepareStep` to update it for the current and subsequent steps.
+     */
+    toolsContext: InferToolSetContext<TTools>;
+    /**
+     * The sandbox environment that the step is operating in.
+     */
+    experimental_sandbox?: Experimental_SandboxSession;
+}
+/**
+ * Return type from the prepareStep callback.
+ * All properties are optional - only return the ones you want to override.
+ */
+interface PrepareStepResult<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context> extends Partial<GenerationSettings> {
+    /**
+     * Override the model for this step.
+     */
+    model?: LanguageModel;
+    /**
+     * 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[];
+    /**
+     * Updated runtime context for the current and subsequent steps.
+     * Returning a value replaces the agent's runtime context.
+     */
+    runtimeContext?: TRuntimeContext;
+    /**
+     * Updated per-tool context for the current and subsequent steps.
+     * Returning a value replaces the agent's tools context.
+     */
+    toolsContext?: InferToolSetContext<TTools>;
+    /**
+     * Override the sandbox environment for this step.
+     */
+    experimental_sandbox?: Experimental_SandboxSession;
+}
+/**
+ * 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, TRuntimeContext extends Context = Context> = (info: PrepareStepInfo<TTools, TRuntimeContext>) => PrepareStepResult<TTools, TRuntimeContext> | undefined | Promise<PrepareStepResult<TTools, TRuntimeContext> | undefined>;
+/**
+ * Options passed to the prepareCall callback.
+ */
+interface PrepareCallOptions<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context> extends Partial<GenerationSettings> {
+    model: LanguageModel;
+    tools: TTools;
+    instructions?: Instructions;
+    toolChoice?: ToolChoice<TTools>;
+    telemetry?: TelemetryOptions<TRuntimeContext, TTools>;
+    /**
+     * Runtime context that flows through the agent loop.
+     * Treat as immutable; return a new `runtimeContext` to update it for the call.
+     */
+    runtimeContext?: TRuntimeContext;
+    /**
+     * Per-tool context, keyed by tool name.
+     */
+    toolsContext?: InferToolSetContext<TTools>;
+    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, TRuntimeContext extends Context = Context> = Partial<Omit<PrepareCallOptions<TTools, TRuntimeContext>, 'tools'>>;
+/**
+ * Callback called once before the agent loop starts to transform call parameters.
+ */
+type PrepareCallCallback<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context> = (options: PrepareCallOptions<TTools, TRuntimeContext>) => PrepareCallResult<TTools, TRuntimeContext> | Promise<PrepareCallResult<TTools, TRuntimeContext>>;
+/**
+ * Configuration options for creating a {@link WorkflowAgent} instance.
+ */
+type WorkflowAgentOptions<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context> = GenerationSettings & WorkflowAgentToolsContextParameter<TTools> & {
+    /**
+     * The id of the agent.
+     */
+    id?: string;
+    /**
+     * 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 LanguageModelV4 instance from a provider.
+     */
+    model: LanguageModel;
+    /**
+     * 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?: Instructions;
+    /**
+     * 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.
+     */
+    telemetry?: TelemetryOptions<TRuntimeContext, TTools>;
+    /**
+     * Default runtime context for every stream call on this agent.
+     *
+     * The runtime context flows through `prepareStep`, lifecycle callbacks,
+     * and step results.
+     * Treat as immutable; return a new `runtimeContext` from `prepareStep`
+     * to update it between steps.
+     *
+     * In workflow context, keep values serializable so they can cross workflow
+     * and step boundaries.
+     *
+     * Per-stream `runtimeContext` values passed to `stream()` override this default.
+     */
+    runtimeContext?: TRuntimeContext;
+    /**
+     * Default stop condition for the agent loop. When the condition is an array,
+     * any of the conditions can be met to stop the generation.
+     *
+     * Per-stream `stopWhen` values passed to `stream()` override this default.
+     */
+    stopWhen?: StopCondition<NoInfer<ToolSet>, any> | Array<StopCondition<NoInfer<ToolSet>, any>>;
+    /**
+     * Default set of active tools that limits which tools the model can call,
+     * without changing the tool call and result types in the result.
+     *
+     * Per-stream `activeTools` values passed to `stream()` override this default.
+     */
+    activeTools?: ActiveTools<NoInfer<TTools>>;
+    /**
+     * Default output specification for structured outputs.
+     * Use `Output.object({ schema })` for structured output or `Output.text()` for text output.
+     *
+     * Per-stream `output` values passed to `stream()` override this default.
+     */
+    output?: OutputSpecification<any, any>;
+    /**
+     * Default function that attempts to repair a tool call that failed to parse.
+     *
+     * Per-stream `repairToolCall` values passed to `stream()` override this default.
+     */
+    repairToolCall?: ToolCallRepairFunction<TTools>;
+    /**
+     * Default function that attempts to repair a tool call that failed to parse.
+     *
+     * Per-stream `repairToolCall` values passed to `stream()` override this default.
+     *
+     * @deprecated Use `repairToolCall` instead.
+     */
+    experimental_repairToolCall?: ToolCallRepairFunction<TTools>;
+    /**
+     * Default custom download function to use for URLs.
+     *
+     * Per-stream `experimental_download` values passed to `stream()` override this default.
+     */
+    experimental_download?: DownloadFunction;
+    /**
+     * Default sandbox environment passed through to tool execution as
+     * `experimental_sandbox`.
+     *
+     * Per-stream `experimental_sandbox` values passed to `stream()` override this default.
+     */
+    experimental_sandbox?: Experimental_SandboxSession;
+    /**
+     * 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, TRuntimeContext>;
+    /**
+     * Callback function to be called after each step completes.
+     */
+    onStepEnd?: WorkflowAgentOnStepEndCallback<TTools, TRuntimeContext>;
+    /**
+     * Callback function to be called after each step completes.
+     *
+     * @deprecated Use `onStepEnd` instead.
+     */
+    onStepFinish?: WorkflowAgentOnStepFinishCallback<TTools, TRuntimeContext>;
+    /**
+     * Callback that is called when the LLM response and all request tool executions are finished.
+     */
+    onEnd?: WorkflowAgentOnEndCallback<TTools, TRuntimeContext>;
+    /**
+     * Callback that is called when the LLM response and all request tool executions are finished.
+     *
+     * @deprecated Use `onEnd` instead.
+     */
+    onFinish?: WorkflowAgentOnFinishCallback<TTools, TRuntimeContext>;
+    /**
+     * Callback called when the agent starts streaming, before any LLM calls.
+     */
+    experimental_onStart?: WorkflowAgentOnStartCallback<TTools, TRuntimeContext>;
+    /**
+     * Callback called before each step (LLM call) begins.
+     */
+    experimental_onStepStart?: WorkflowAgentOnStepStartCallback<TTools, TRuntimeContext>;
+    /**
+     * Callback called before a tool's execute function runs.
+     */
+    onToolExecutionStart?: WorkflowAgentOnToolExecutionStartCallback<TTools>;
+    /**
+     * Callback called after a tool execution completes.
+     */
+    onToolExecutionEnd?: WorkflowAgentOnToolExecutionEndCallback<TTools>;
+    /**
+     * 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, TRuntimeContext>;
+    /**
+     * Whether to allow system messages inside the `prompt` or `messages` fields.
+     * When `false` (the default), system messages in `prompt` or `messages` are
+     * rejected to prevent prompt-injection attacks. Set to `true` only when you
+     * intentionally interleave system messages with user messages.
+     *
+     * @default false
+     */
+    allowSystemInMessages?: boolean;
+};
+/**
+ * Callback that is called when the LLM response and all request tool executions are finished.
+ */
+type WorkflowAgentOnEndCallback<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context, OUTPUT = never> = (event: {
+    /**
+     * Details for all steps.
+     */
+    readonly steps: StepResult<TTools, TRuntimeContext>[];
+    /**
+     * 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 usage: LanguageModelUsage;
+    /**
+     * The total token usage across all steps.
+     */
+    readonly totalUsage: LanguageModelUsage;
+    /**
+     * The runtime context at the end of the agent loop.
+     */
+    readonly runtimeContext: TRuntimeContext;
+    /**
+     * The per-tool context at the end of the agent loop.
+     */
+    readonly toolsContext: InferToolSetContext<TTools>;
+    /**
+     * The generated structured output. It uses the `output` specification.
+     * Only available when `output` is specified.
+     */
+    readonly output: OUTPUT;
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is called when the LLM response and all request tool executions are finished.
+ *
+ * @deprecated Use `WorkflowAgentOnEndCallback` instead.
+ */
+type WorkflowAgentOnFinishCallback<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context, OUTPUT = never> = WorkflowAgentOnEndCallback<TTools, TRuntimeContext, OUTPUT>;
+/**
+ * Callback that is invoked when an error occurs during streaming.
+ */
+type WorkflowAgentOnErrorCallback = (event: {
+    error: unknown;
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is set using the `onAbort` option.
+ */
+type WorkflowAgentOnAbortCallback<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<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context> = (event: {
+    /** The model being used */
+    readonly model: LanguageModel;
+    /** The messages being sent */
+    readonly messages: ModelMessage[];
+    /** Shared runtime context for this agent loop */
+    readonly runtimeContext: TRuntimeContext;
+    /** Per-tool context map for this agent loop */
+    readonly toolsContext: InferToolSetContext<TTools>;
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is called before each step (LLM call) begins.
+ */
+type WorkflowAgentOnStepStartCallback<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context> = (event: {
+    /** The current step number (0-based) */
+    readonly stepNumber: number;
+    /** The model being used for this step */
+    readonly model: LanguageModel;
+    /** The messages being sent for this step */
+    readonly messages: ModelMessage[];
+    /** Results from all previously finished steps */
+    readonly steps: ReadonlyArray<StepResult<TTools, TRuntimeContext>>;
+    /** Shared runtime context for this step */
+    readonly runtimeContext: TRuntimeContext;
+    /** Per-tool context map for this step */
+    readonly toolsContext: InferToolSetContext<TTools>;
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is called before a tool's execute function runs.
+ */
+type WorkflowAgentOnToolExecutionStartCallback<TTools extends ToolSet = ToolSet> = (event: {
+    /** The tool call being executed */
+    readonly toolCall: ToolCall;
+    /** The current step number (0-based) */
+    readonly stepNumber: number;
+    /** Messages sent to the language model for the step that produced the call */
+    readonly messages: ModelMessage[];
+    /** Tool-specific context passed to the tool */
+    readonly toolContext: InferToolSetContext<TTools>[keyof InferToolSetContext<TTools>] | undefined;
+}) => PromiseLike<void> | void;
+/**
+ * Callback that is called after a tool execution completes.
+ * Uses a discriminated union pattern: check `success` to determine
+ * whether `output` or `error` is available.
+ */
+type WorkflowAgentOnToolExecutionEndCallback<TTools extends ToolSet = ToolSet> = (event: {
+    /** The tool call that was executed */
+    readonly toolCall: ToolCall;
+    /** The current step number (0-based) */
+    readonly stepNumber: number;
+    /** Execution time in milliseconds */
+    readonly durationMs: number;
+    /** Messages sent to the language model for the step that produced the call */
+    readonly messages: ModelMessage[];
+    /** Tool-specific context passed to the tool */
+    readonly toolContext: InferToolSetContext<TTools>[keyof InferToolSetContext<TTools>] | undefined;
+    /** Whether the tool call succeeded */
+    readonly success: true;
+    /** The tool result */
+    readonly output: unknown;
+    readonly error?: never;
+} | {
+    /** The tool call that was executed */
+    readonly toolCall: ToolCall;
+    /** The current step number (0-based) */
+    readonly stepNumber: number;
+    /** Execution time in milliseconds */
+    readonly durationMs: number;
+    /** Messages sent to the language model for the step that produced the call */
+    readonly messages: ModelMessage[];
+    /** Tool-specific context passed to the tool */
+    readonly toolContext: InferToolSetContext<TTools>[keyof InferToolSetContext<TTools>] | undefined;
+    /** Whether the tool call succeeded */
+    readonly success: false;
+    /** The error that occurred */
+    readonly error: unknown;
+    readonly output?: never;
+}) => PromiseLike<void> | void;
+/**
+ * Options for the {@link WorkflowAgent.stream} method.
+ */
+type WorkflowAgentStreamOptions<TTools extends ToolSet = ToolSet, TRuntimeContext extends Context = Context, OUTPUT = never, PARTIAL_OUTPUT = never> = Partial<GenerationSettings> & ({
+    /**
+     * A prompt. It can be either a text prompt or a list of messages.
+     *
+     * You can either use `prompt` or `messages` but not both.
+     */
+    prompt: string | Array<ModelMessage>;
+    /**
+     * A list of messages.
+     *
+     * You can either use `prompt` or `messages` but not both.
+     */
+    messages?: never;
+} | {
+    /**
+     * The conversation messages to process. Should follow the AI SDK's ModelMessage format.
+     *
+     * You can either use `prompt` or `messages` but not both.
+     */
+    messages: Array<ModelMessage>;
+    /**
+     * A prompt. It can be either a text prompt or a list of messages.
+     *
+     * You can either use `prompt` or `messages` but not both.
+     */
+    prompt?: never;
+}) & {
+    /**
+     * 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_LanguageModelStreamPart<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>>;
+    /**
+     * 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?: ActiveTools<NoInfer<TTools>>;
+    /**
+     * Optional telemetry configuration.
+     */
+    telemetry?: TelemetryOptions<TRuntimeContext, TTools>;
+    /**
+     * Runtime context that flows through the agent loop.
+     *
+     * Treat as immutable; return a new `runtimeContext` from `prepareStep`
+     * to update it between steps.
+     *
+     * In workflow context, keep values serializable so they can cross workflow
+     * and step boundaries.
+     *
+     * Overrides the constructor-level `runtimeContext` if provided.
+     */
+    runtimeContext?: TRuntimeContext;
+    /**
+     * Per-tool context, keyed by tool name. Each tool receives only its own
+     * validated entry as `context` during execution. Tools that declare a
+     * `contextSchema` validate their entry against the schema.
+     *
+     * In workflow context, keep values serializable so they can cross workflow
+     * and step boundaries.
+     *
+     * Overrides the constructor-level `toolsContext` if provided.
+     */
+    toolsContext?: InferToolSetContext<TTools>;
+    /**
+     * 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(),
+     *   output: Output.object({
+     *     schema: z.object({
+     *       sentiment: z.enum(['positive', 'negative', 'neutral']),
+     *       confidence: z.number(),
+     *     }),
+     *   }),
+     * });
+     *
+     * console.log(result.output); // { sentiment: 'positive', confidence: 0.95 }
+     * ```
+     */
+    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.
+     */
+    repairToolCall?: ToolCallRepairFunction<TTools>;
+    /**
+     * A function that attempts to repair a tool call that failed to parse.
+     *
+     * @deprecated Use `repairToolCall` instead.
+     */
+    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;
+    /**
+     * Sandbox environment passed through to tool execution as
+     * `experimental_sandbox`. Overrides the constructor-level value if provided.
+     */
+    experimental_sandbox?: Experimental_SandboxSession;
+    /**
+     * Callback function to be called after each step completes.
+     */
+    onStepEnd?: WorkflowAgentOnStepEndCallback<TTools, TRuntimeContext>;
+    /**
+     * Callback function to be called after each step completes.
+     *
+     * @deprecated Use `onStepEnd` instead.
+     */
+    onStepFinish?: WorkflowAgentOnStepFinishCallback<TTools, TRuntimeContext>;
+    /**
+     * Callback that is invoked when an error occurs during streaming.
+     * You can use it to log errors.
+     */
+    onError?: WorkflowAgentOnErrorCallback;
+    /**
+     * Callback that is called when the LLM response and all request tool executions
+     * (for tools that have an `execute` function) are finished.
+     */
+    onEnd?: WorkflowAgentOnEndCallback<TTools, TRuntimeContext, OUTPUT>;
+    /**
+     * Callback that is called when the LLM response and all request tool executions
+     * (for tools that have an `execute` function) are finished.
+     *
+     * @deprecated Use `onEnd` instead.
+     */
+    onFinish?: WorkflowAgentOnFinishCallback<TTools, TRuntimeContext, OUTPUT>;
+    /**
+     * Callback that is called when the operation is aborted.
+     */
+    onAbort?: WorkflowAgentOnAbortCallback<TTools>;
+    /**
+     * Callback called when the agent starts streaming, before any LLM calls.
+     */
+    experimental_onStart?: WorkflowAgentOnStartCallback<TTools, TRuntimeContext>;
+    /**
+     * Callback called before each step (LLM call) begins.
+     */
+    experimental_onStepStart?: WorkflowAgentOnStepStartCallback<TTools, TRuntimeContext>;
+    /**
+     * Callback called before a tool's execute function runs.
+     */
+    onToolExecutionStart?: WorkflowAgentOnToolExecutionStartCallback<TTools>;
+    /**
+     * Callback called after a tool execution completes.
+     */
+    onToolExecutionEnd?: WorkflowAgentOnToolExecutionEndCallback<TTools>;
+    /**
+     * 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, TRuntimeContext>;
+    /**
+     * 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;
+    /**
+     * Whether to send a 'finish' chunk to the writable stream when streaming completes.
+     * @default true
+     */
+    sendFinish?: boolean;
+    /**
+     * Whether to prevent the writable stream from being closed after streaming completes.
+     * @default false
+     */
+    preventClose?: boolean;
+};
+/**
+ * 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 finish reason from the last step.
+     */
+    finishReason: FinishReason;
+    /**
+     * The total token usage across all steps.
+     */
+    totalUsage: LanguageModelUsage;
+    /**
+     * The generated structured output. It uses the `output` specification.
+     * Only available when `output` is specified.
+     */
+    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, TRuntimeContext extends Context = Context> {
+    /**
+     * The id of the agent.
+     */
+    readonly id: string | undefined;
+    private model;
+    /**
+     * The tool set configured for this agent.
+     */
+    readonly tools: TBaseTools;
+    private instructions?;
+    private generationSettings;
+    private toolChoice?;
+    private telemetry?;
+    private runtimeContext?;
+    private toolsContext?;
+    private stopWhen?;
+    private activeTools?;
+    private output?;
+    private repairToolCall?;
+    private experimentalDownload?;
+    private experimentalSandbox?;
+    private prepareStep?;
+    private allowSystemInMessages;
+    private constructorOnStepEnd?;
+    private constructorOnEnd?;
+    private constructorOnStart?;
+    private constructorOnStepStart?;
+    private constructorOnToolExecutionStart?;
+    private constructorOnToolExecutionEnd?;
+    private prepareCall?;
+    constructor(options: WorkflowAgentOptions<TBaseTools, TRuntimeContext>);
+    generate(): void;
+    stream<TTools extends TBaseTools = TBaseTools, OUTPUT = never, PARTIAL_OUTPUT = never>(options: WorkflowAgentStreamOptions<TTools, TRuntimeContext, 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_LanguageModelStreamPart<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_LanguageModelStreamPart<ToolSet>, UIMessageChunk>;
+
+interface SendMessagesOptions<UI_MESSAGE extends UIMessage> {
+    trigger: 'submit-message' | 'regenerate-message';
+    chatId: string;
+    messageId?: string;
+    messages: UI_MESSAGE[];
+    abortSignal?: AbortSignal;
+}
+interface ReconnectToStreamOptions {
+    chatId: string;
+    abortSignal?: AbortSignal;
+    /**
+     * Override the `startIndex` for this reconnection.
+     * Negative values read from the end of the stream.
+     * When omitted, falls back to the constructor's `initialStartIndex`.
+     */
+    startIndex?: number;
+}
+type OnChatSendMessage<UI_MESSAGE extends UIMessage> = (response: Response, options: SendMessagesOptions<UI_MESSAGE>) => void | Promise<void>;
+type OnChatEnd = ({ chatId, chunkIndex, }: {
+    chatId: string;
+    chunkIndex: number;
+}) => void | Promise<void>;
+/**
+ * Configuration options for the WorkflowChatTransport.
+ *
+ * @template UI_MESSAGE - The type of UI messages being sent and received,
+ *                        must extend the UIMessage interface from the AI SDK.
+ */
+interface WorkflowChatTransportOptions<UI_MESSAGE extends UIMessage> {
+    /**
+     * API endpoint for chat requests
+     * Defaults to /api/chat if not provided
+     */
+    api?: string;
+    /**
+     * Custom fetch implementation to use for HTTP requests.
+     * Defaults to the global fetch function if not provided.
+     */
+    fetch?: typeof fetch;
+    /**
+     * Callback invoked after successfully sending messages to the chat endpoint.
+     * Useful for tracking chat history and inspecting response headers.
+     *
+     * @param response - The HTTP response object from the chat endpoint
+     * @param options - The original options passed to sendMessages
+     */
+    onChatSendMessage?: OnChatSendMessage<UI_MESSAGE>;
+    /**
+     * Callback invoked when a chat stream ends (receives a "finish" chunk).
+     * Useful for cleanup operations or state updates.
+     *
+     * @param chatId - The ID of the chat that ended
+     * @param chunkIndex - The total number of chunks received
+     */
+    onChatEnd?: OnChatEnd;
+    /**
+     * Maximum number of consecutive errors allowed during reconnection attempts.
+     * Defaults to 3 if not provided.
+     */
+    maxConsecutiveErrors?: number;
+    /**
+     * Default `startIndex` to use when reconnecting to a stream without a known
+     * chunk position (i.e. the initial reconnection, not a retry).
+     * Negative values read from the end of the stream (e.g. `-10` fetches the
+     * last 10 chunks), which is useful for resuming a chat UI after a page
+     * refresh without replaying the full conversation.
+     *
+     * Can be overridden per-call via `ReconnectToStreamOptions.startIndex`.
+     *
+     * Defaults to `0` (replay from the beginning).
+     */
+    initialStartIndex?: number;
+    /**
+     * Function to prepare the request for sending messages.
+     * Allows customizing the API endpoint, headers, credentials, and body.
+     */
+    prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
+    /**
+     * Function to prepare the request for reconnecting to a stream.
+     * Allows customizing the API endpoint, headers, and credentials.
+     */
+    prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
+}
+/**
+ * A transport implementation for managing chat workflows with support for
+ * streaming responses and automatic reconnection to interrupted streams.
+ *
+ * This class implements the ChatTransport interface from the AI SDK and provides
+ * reliable message streaming with automatic recovery from network interruptions
+ * or function timeouts.
+ *
+ * @template UI_MESSAGE - The type of UI messages being sent and received,
+ *                        must extend the UIMessage interface from the AI SDK.
+ *
+ * @implements {ChatTransport<UI_MESSAGE>}
+ */
+declare class WorkflowChatTransport<UI_MESSAGE extends UIMessage> implements ChatTransport<UI_MESSAGE> {
+    private readonly api;
+    private readonly fetch;
+    private readonly onChatSendMessage?;
+    private readonly onChatEnd?;
+    private readonly maxConsecutiveErrors;
+    private readonly initialStartIndex;
+    private readonly prepareSendMessagesRequest?;
+    private readonly prepareReconnectToStreamRequest?;
+    /**
+     * Creates a new WorkflowChatTransport instance.
+     *
+     * @param options - Configuration options for the transport
+     * @param options.api - API endpoint for chat requests (defaults to '/api/chat')
+     * @param options.fetch - Custom fetch implementation (defaults to global fetch)
+     * @param options.onChatSendMessage - Callback after sending messages
+     * @param options.onChatEnd - Callback when chat stream ends
+     * @param options.maxConsecutiveErrors - Maximum consecutive errors for reconnection
+     * @param options.prepareSendMessagesRequest - Function to prepare send messages request
+     * @param options.prepareReconnectToStreamRequest - Function to prepare reconnect request
+     */
+    constructor(options?: WorkflowChatTransportOptions<UI_MESSAGE>);
+    /**
+     * Sends messages to the chat endpoint and returns a stream of response chunks.
+     *
+     * This method handles the entire chat lifecycle including:
+     * - Sending messages to the /api/chat endpoint
+     * - Streaming response chunks
+     * - Automatic reconnection if the stream is interrupted
+     *
+     * @param options - Options for sending messages
+     * @param options.trigger - The type of message submission ('submit-message' or 'regenerate-message')
+     * @param options.chatId - Unique identifier for this chat session
+     * @param options.messageId - Optional message ID for tracking specific messages
+     * @param options.messages - Array of UI messages to send
+     * @param options.abortSignal - Optional AbortSignal to cancel the request
+     *
+     * @returns A ReadableStream of UIMessageChunk objects containing the response
+     * @throws Error if the fetch request fails or returns a non-OK status
+     */
+    sendMessages(options: SendMessagesOptions<UI_MESSAGE> & ChatRequestOptions): Promise<ReadableStream<UIMessageChunk>>;
+    private sendMessagesIterator;
+    /**
+     * Reconnects to an existing chat stream that was previously interrupted.
+     *
+     * This method is useful for resuming a chat session after network issues,
+     * page refreshes, or Vercel Function timeouts.
+     *
+     * @param options - Options for reconnecting to the stream
+     * @param options.chatId - The chat ID to reconnect to
+     *
+     * @returns A ReadableStream of UIMessageChunk objects
+     * @throws Error if the reconnection request fails or returns a non-OK status
+     */
+    reconnectToStream(options: ReconnectToStreamOptions & ChatRequestOptions): Promise<ReadableStream<UIMessageChunk> | null>;
+    private reconnectToStreamIterator;
+    private onFinish;
+}
+
+/**
+ * Normalizes the part framing of a UI message stream so it is always
+ * well-formed for the AI SDK's stream consumer (`processUIMessageStream`,
+ * which backs `useChat`/`readUIMessageStream`).
+ *
+ * ## Why this exists
+ *
+ * The consumer maintains a map of "active" text/reasoning parts keyed by id.
+ * A `text-delta`/`text-end` for an id that has no open part is a fatal error
+ * (`Received text-delta for missing text part with ID "0" ...`) that kills the
+ * whole turn. Two properties of the durable streaming model make that error
+ * reachable:
+ *
+ * - A workflow run owns a single shared stream, and the consumer resets its
+ *   active-part maps on every `finish-step`. Multi-step turns reuse the same
+ *   part id (commonly `"0"`) in each step, so a single dropped or duplicated
+ *   `*-start` across a step boundary orphans the rest of that step's content.
+ * - The same stream is read across reconnects, and a stream-producing step can
+ *   run more than once (retry/redelivery, or the concurrent-worker duplication
+ *   tracked in vercel/workflow#2331 and #2039). Either can interleave or
+ *   duplicate chunks on the shared stream — e.g. a `finish-step` landing in the
+ *   middle of another execution's text part.
+ *
+ * Since the content is still flowing and only the framing is damaged, repairing
+ * the framing here degrades the worst case to "text begins slightly into the
+ * step" or "a duplicated tail is dropped" instead of a dead turn.
+ *
+ * ## What it does
+ *
+ * Mirrors the consumer's part-lifetime state machine, per part type, per step:
+ * - resets tracking on `finish-step` (exactly where the consumer resets);
+ * - synthesizes a missing `*-start` when an orphaned `*-delta`/`*-end` arrives;
+ * - drops a re-delivered `*-start`/`*-delta`/`*-end` for a part already
+ *   open or ended in the current step (reconnect/replay overlap).
+ *
+ * A well-formed stream passes through unchanged.
+ *
+ * ## Scope: text and reasoning only
+ *
+ * `tool-input-delta` raises the same class of fatal error (`Received
+ * tool-input-delta for missing tool call ...`), but tool parts are deliberately
+ * left untouched: the consumer does not reset its tool-call map on `finish-step`
+ * and tool-call ids are unique, so the step-boundary id-reuse orphaning that
+ * makes text/reasoning fragile does not apply to them. If a future duplication
+ * mode is found to orphan tool-input parts, extend the same machine to that
+ * family rather than special-casing it.
+ *
+ * @param source the raw UI message chunk stream to normalize.
+ * @yields the framing-corrected UI message chunks.
+ */
+declare function normalizeUIMessageStreamParts(source: AsyncIterable<UIMessageChunk>): AsyncGenerator<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 ReconnectToStreamOptions, type SendMessagesOptions, type StreamTextTransform, type TelemetryOptions, WorkflowAgent, type WorkflowAgentOnAbortCallback, type WorkflowAgentOnEndCallback, type WorkflowAgentOnErrorCallback, type WorkflowAgentOnFinishCallback, type WorkflowAgentOnStartCallback, type WorkflowAgentOnStepEndCallback, type WorkflowAgentOnStepFinishCallback, type WorkflowAgentOnStepStartCallback, type WorkflowAgentOnToolExecutionEndCallback, type WorkflowAgentOnToolExecutionStartCallback, type WorkflowAgentOptions, type WorkflowAgentStreamOptions, type WorkflowAgentStreamResult, WorkflowChatTransport, type WorkflowChatTransportOptions, createModelCallToUIChunkTransform, normalizeUIMessageStreamParts, toUIMessageChunk };