@voltagent/core 0.1.57 → 0.1.59

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import { z } from 'zod';
 import { Span } from '@opentelemetry/api';
+import * as TF from 'type-fest';
 import { Simplify, LiteralUnion, MergeDeep } from 'type-fest';
 import { Context } from 'hono';
 import { SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { DangerouslyAllowAny, PlainObject } from '@voltagent/internal/types';
 import { ClientCapabilities } from '@modelcontextprotocol/sdk/types.js';
 import { EventEmitter } from 'node:events';
 
@@ -1133,6 +1135,64 @@ interface PromptContent {
     };
 }
 
+interface OnStartHookArgs {
+    agent: Agent<any>;
+    context: OperationContext;
+}
+interface OnEndHookArgs {
+    /**
+     * The conversation ID.
+     */
+    conversationId: string;
+    /**
+     * The agent that generated the output.
+     */
+    agent: Agent<any>;
+    /** The standardized successful output object. Undefined on error. */
+    output: AgentOperationOutput | undefined;
+    /** The VoltAgentError object if the operation failed. Undefined on success. */
+    error: VoltAgentError | undefined;
+    /** The complete conversation messages including user input and assistant responses (Vercel AI SDK compatible) */
+    context: OperationContext;
+}
+interface OnHandoffHookArgs {
+    agent: Agent<any>;
+    source: Agent<any>;
+}
+interface OnToolStartHookArgs {
+    agent: Agent<any>;
+    tool: AgentTool;
+    context: OperationContext;
+}
+interface OnToolEndHookArgs {
+    agent: Agent<any>;
+    tool: AgentTool;
+    /** The successful output from the tool. Undefined on error. */
+    output: unknown | undefined;
+    /** The VoltAgentError if the tool execution failed. Undefined on success. */
+    error: VoltAgentError | undefined;
+    context: OperationContext;
+}
+type AgentHookOnStart = (args: OnStartHookArgs) => Promise<void> | void;
+type AgentHookOnEnd = (args: OnEndHookArgs) => Promise<void> | void;
+type AgentHookOnHandoff = (args: OnHandoffHookArgs) => Promise<void> | void;
+type AgentHookOnToolStart = (args: OnToolStartHookArgs) => Promise<void> | void;
+type AgentHookOnToolEnd = (args: OnToolEndHookArgs) => Promise<void> | void;
+/**
+ * Type definition for agent hooks using single argument objects.
+ */
+type AgentHooks = {
+    onStart?: AgentHookOnStart;
+    onEnd?: AgentHookOnEnd;
+    onHandoff?: AgentHookOnHandoff;
+    onToolStart?: AgentHookOnToolStart;
+    onToolEnd?: AgentHookOnToolEnd;
+};
+/**
+ * Create hooks from an object literal.
+ */
+declare function createHooks(hooks?: Partial<AgentHooks>): AgentHooks;
+
 /**
  * Enhanced dynamic value for instructions that supports prompt management
  */
@@ -1231,7 +1291,7 @@ type AgentOptions = {
     /**
      * Optional user-defined context to be passed around
      */
-    userContext?: Map<string | symbol, unknown>;
+    userContext?: UserContext;
     /**
      * @deprecated Use `voltOpsClient` instead. Will be removed in a future version.
      *
@@ -1352,7 +1412,8 @@ interface CommonGenerateOptions {
     signal?: AbortSignal;
     historyEntryId?: string;
     operationContext?: OperationContext;
-    userContext?: Map<string | symbol, unknown>;
+    userContext?: UserContext;
+    hooks?: AgentHooks;
 }
 /**
  * Public-facing generate options for external users
@@ -1575,6 +1636,7 @@ interface VoltAgentError {
  * Providers must pass an error conforming to the VoltAgentError structure.
  */
 type StreamOnErrorCallback = (error: VoltAgentError) => Promise<void> | void;
+type UserContext = Map<string | symbol, unknown>;
 /**
  * Standardized object structure passed to the onFinish callback
  * when streamText completes successfully.
@@ -1591,7 +1653,7 @@ interface StreamTextFinishResult {
     /** Any warnings generated during the completion (if available). */
     warnings?: unknown[];
     /** User context containing any custom metadata from the operation. */
-    userContext?: Map<string | symbol, unknown>;
+    userContext?: UserContext;
 }
 /**
  * Type for the onFinish callback function for streamText.
@@ -1614,7 +1676,7 @@ interface StreamObjectFinishResult<TObject> {
     /** The reason the stream finished (if available). Although less common for object streams. */
     finishReason?: string;
     /** User context containing any custom metadata from the operation. */
-    userContext?: Map<string | symbol, unknown>;
+    userContext?: UserContext;
 }
 /**
  * Type for the onFinish callback function for streamObject.
@@ -1636,7 +1698,7 @@ interface StandardizedTextResult {
     /** Warnings (if available from provider). */
     warnings?: unknown[];
     /** User context containing any custom metadata from the operation. */
-    userContext?: Map<string | symbol, unknown>;
+    userContext?: UserContext;
 }
 /**
  * Standardized success result structure for generateObject.
@@ -1654,7 +1716,7 @@ interface StandardizedObjectResult<TObject> {
     /** Warnings (if available from provider). */
     warnings?: unknown[];
     /** User context containing any custom metadata from the operation. */
-    userContext?: Map<string | symbol, unknown>;
+    userContext?: UserContext;
 }
 /**
  * Unified output type for the onEnd hook, representing the successful result
@@ -1677,7 +1739,7 @@ type GenerateTextResponse<TProvider extends {
 type StreamTextResponse<TProvider extends {
     llm: LLMProvider<any>;
 }> = InferStreamTextResponseFromProvider<TProvider> & {
-    userContext?: Map<string | symbol, unknown>;
+    userContext?: UserContext;
 };
 type GenerateObjectResponse<TProvider extends {
     llm: LLMProvider<any>;
@@ -1687,7 +1749,7 @@ type GenerateObjectResponse<TProvider extends {
 type StreamObjectResponse<TProvider extends {
     llm: LLMProvider<any>;
 }, TSchema extends z.ZodType> = InferStreamObjectResponseFromProvider<TProvider, TSchema> & {
-    userContext?: Map<string | symbol, unknown>;
+    userContext?: UserContext;
 };
 
 /**
@@ -3088,65 +3150,6 @@ declare abstract class BaseRetriever {
     abstract retrieve(input: string | BaseMessage[], options: RetrieveOptions): Promise<string>;
 }
 
-/**
- * Main VoltOps client class that provides unified access to both
- * telemetry export and prompt management functionality.
- */
-declare class VoltOpsClient implements VoltOpsClient$1 {
-    readonly options: VoltOpsClientOptions & {
-        baseUrl: string;
-    };
-    readonly observability?: VoltAgentExporter;
-    readonly prompts?: VoltOpsPromptManager;
-    constructor(options: VoltOpsClientOptions);
-    /**
-     * Create a prompt helper for agent instructions
-     */
-    createPromptHelper(_agentId: string): PromptHelper;
-    get exportHistoryEntry(): ((historyEntryData: ExportAgentHistoryPayload) => Promise<{
-        historyEntryId: string;
-    }>) | undefined;
-    get exportHistoryEntryAsync(): ((historyEntryData: ExportAgentHistoryPayload) => void) | undefined;
-    get exportTimelineEvent(): ((timelineEventData: ExportTimelineEventPayload) => Promise<{
-        timelineEventId: string;
-    }>) | undefined;
-    get exportTimelineEventAsync(): ((timelineEventData: ExportTimelineEventPayload) => void) | undefined;
-    /**
-     * Check if observability is enabled and configured
-     */
-    isObservabilityEnabled(): boolean;
-    /**
-     * Check if prompt management is enabled and configured
-     */
-    isPromptManagementEnabled(): boolean;
-    /**
-     * Get observability exporter for backward compatibility
-     * @deprecated Use observability property directly
-     */
-    getObservabilityExporter(): VoltAgentExporter | undefined;
-    /**
-     * Get prompt manager for direct access
-     */
-    getPromptManager(): VoltOpsPromptManager | undefined;
-    /**
-     * Static method to create prompt helper with priority-based fallback
-     * Priority: Agent VoltOpsClient > Global VoltOpsClient > Fallback instructions
-     */
-    static createPromptHelperWithFallback(agentId: string, agentName: string, fallbackInstructions: string, agentVoltOpsClient?: VoltOpsClient): PromptHelper;
-    /**
-     * Validate API keys and provide helpful error messages
-     */
-    private validateApiKeys;
-    /**
-     * Cleanup resources when client is no longer needed
-     */
-    dispose(): Promise<void>;
-}
-/**
- * Factory function to create VoltOps client
- */
-declare const createVoltOpsClient: (options: VoltOpsClientOptions) => VoltOpsClient;
-
 /**
  * ReadableStream type for voice responses
  */
@@ -3255,63 +3258,64 @@ type Voice = {
     getVoices(): Promise<VoiceMetadata[]>;
 };
 
-interface OnStartHookArgs {
-    agent: Agent<any>;
-    context: OperationContext;
-}
-interface OnEndHookArgs {
+/**
+ * Main VoltOps client class that provides unified access to both
+ * telemetry export and prompt management functionality.
+ */
+declare class VoltOpsClient implements VoltOpsClient$1 {
+    readonly options: VoltOpsClientOptions & {
+        baseUrl: string;
+    };
+    readonly observability?: VoltAgentExporter;
+    readonly prompts?: VoltOpsPromptManager;
+    constructor(options: VoltOpsClientOptions);
     /**
-     * The conversation ID.
+     * Create a prompt helper for agent instructions
      */
-    conversationId: string;
+    createPromptHelper(_agentId: string): PromptHelper;
+    get exportHistoryEntry(): ((historyEntryData: ExportAgentHistoryPayload) => Promise<{
+        historyEntryId: string;
+    }>) | undefined;
+    get exportHistoryEntryAsync(): ((historyEntryData: ExportAgentHistoryPayload) => void) | undefined;
+    get exportTimelineEvent(): ((timelineEventData: ExportTimelineEventPayload) => Promise<{
+        timelineEventId: string;
+    }>) | undefined;
+    get exportTimelineEventAsync(): ((timelineEventData: ExportTimelineEventPayload) => void) | undefined;
     /**
-     * The agent that generated the output.
+     * Check if observability is enabled and configured
      */
-    agent: Agent<any>;
-    /** The standardized successful output object. Undefined on error. */
-    output: AgentOperationOutput | undefined;
-    /** The VoltAgentError object if the operation failed. Undefined on success. */
-    error: VoltAgentError | undefined;
-    /** The complete conversation messages including user input and assistant responses (Vercel AI SDK compatible) */
-    context: OperationContext;
-}
-interface OnHandoffHookArgs {
-    agent: Agent<any>;
-    source: Agent<any>;
-}
-interface OnToolStartHookArgs {
-    agent: Agent<any>;
-    tool: AgentTool;
-    context: OperationContext;
-}
-interface OnToolEndHookArgs {
-    agent: Agent<any>;
-    tool: AgentTool;
-    /** The successful output from the tool. Undefined on error. */
-    output: unknown | undefined;
-    /** The VoltAgentError if the tool execution failed. Undefined on success. */
-    error: VoltAgentError | undefined;
-    context: OperationContext;
+    isObservabilityEnabled(): boolean;
+    /**
+     * Check if prompt management is enabled and configured
+     */
+    isPromptManagementEnabled(): boolean;
+    /**
+     * Get observability exporter for backward compatibility
+     * @deprecated Use observability property directly
+     */
+    getObservabilityExporter(): VoltAgentExporter | undefined;
+    /**
+     * Get prompt manager for direct access
+     */
+    getPromptManager(): VoltOpsPromptManager | undefined;
+    /**
+     * Static method to create prompt helper with priority-based fallback
+     * Priority: Agent VoltOpsClient > Global VoltOpsClient > Fallback instructions
+     */
+    static createPromptHelperWithFallback(agentId: string, agentName: string, fallbackInstructions: string, agentVoltOpsClient?: VoltOpsClient): PromptHelper;
+    /**
+     * Validate API keys and provide helpful error messages
+     */
+    private validateApiKeys;
+    /**
+     * Cleanup resources when client is no longer needed
+     */
+    dispose(): Promise<void>;
 }
-type AgentHookOnStart = (args: OnStartHookArgs) => Promise<void> | void;
-type AgentHookOnEnd = (args: OnEndHookArgs) => Promise<void> | void;
-type AgentHookOnHandoff = (args: OnHandoffHookArgs) => Promise<void> | void;
-type AgentHookOnToolStart = (args: OnToolStartHookArgs) => Promise<void> | void;
-type AgentHookOnToolEnd = (args: OnToolEndHookArgs) => Promise<void> | void;
 /**
- * Type definition for agent hooks using single argument objects.
- */
-type AgentHooks = {
-    onStart?: AgentHookOnStart;
-    onEnd?: AgentHookOnEnd;
-    onHandoff?: AgentHookOnHandoff;
-    onToolStart?: AgentHookOnToolStart;
-    onToolEnd?: AgentHookOnToolEnd;
-};
-/**
- * Create hooks from an object literal.
+ * Factory function to create VoltOps client
  */
-declare function createHooks(hooks?: Partial<AgentHooks>): AgentHooks;
+declare const createVoltOpsClient: (options: VoltOpsClientOptions) => VoltOpsClient;
 
 /**
  * SubAgentManager - Manages sub-agents and delegation functionality for an Agent
@@ -3707,6 +3711,12 @@ declare class Agent<TProvider extends {
      * This is typically called by the main VoltAgent instance after it has initialized its exporter.
      */
     _INTERNAL_setVoltAgentExporter(exporter: VoltAgentExporter): void;
+    /**
+     * Helper method to merge the agent's hooks with the ones passed in the options
+     * @param options - The options passed to the generate method
+     * @returns The merged hooks
+     */
+    private getMergedHooks;
     /**
      * Helper method to get retriever context with event handling
      */
@@ -3822,6 +3832,771 @@ type VoltAgentOptions = {
     enableSwaggerUI?: boolean;
 };
 
+interface WorkflowRunOptions {
+    /**
+     * The active step, this can be used to track the current step in a workflow
+     * @default 0
+     */
+    active?: number;
+    /**
+     * The execution ID, this can be used to track the current execution in a workflow
+     * @default uuidv4
+     */
+    executionId?: string;
+    /**
+     * The conversation ID, this can be used to track the current conversation in a workflow
+     */
+    conversationId?: string;
+    /**
+     * The user ID, this can be used to track the current user in a workflow
+     */
+    userId?: string;
+    /**
+     * The user context, this can be used to track the current user context in a workflow
+     */
+    userContext?: UserContext;
+}
+/**
+ * Hooks for the workflow
+ * @param DATA - The type of the data
+ * @param RESULT - The type of the result
+ */
+type WorkflowHooks<DATA, RESULT> = {
+    /**
+     * Called when the workflow starts
+     * @param state - The current state of the workflow
+     * @returns void
+     */
+    onStart?: (state: WorkflowState<DATA, RESULT>) => Promise<void>;
+    /**
+     * Called when a step starts
+     * @param state - The current state of the workflow
+     * @returns void
+     */
+    onStepStart?: (state: WorkflowState<DATA, RESULT>) => Promise<void>;
+    /**
+     * Called when a step ends
+     * @param state - The current state of the workflow
+     * @returns void
+     */
+    onStepEnd?: (state: WorkflowState<DATA, RESULT>) => Promise<void>;
+    /**
+     * Called when the workflow ends
+     * @param state - The current state of the workflow
+     * @returns void
+     */
+    onEnd?: (state: WorkflowState<DATA, RESULT>) => Promise<void>;
+};
+type WorkflowInput<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema> = TF.IsUnknown<INPUT_SCHEMA> extends true ? BaseMessage | BaseMessage[] | string : INPUT_SCHEMA extends z.ZodTypeAny ? z.infer<INPUT_SCHEMA> : undefined;
+type WorkflowResult<RESULT_SCHEMA extends z.ZodTypeAny> = RESULT_SCHEMA extends z.ZodTypeAny ? z.infer<RESULT_SCHEMA> : RESULT_SCHEMA;
+type WorkflowConfig<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny> = {
+    /**
+     * Unique identifier for the workflow
+     */
+    id: string;
+    /**
+     * Human-readable name for the workflow
+     */
+    name: string;
+    /**
+     * Description of what the workflow does
+     */
+    purpose?: string;
+    /**
+     * Schema for the input data
+     */
+    input?: INPUT_SCHEMA;
+    /**
+     * Schema for the result data
+     */
+    result: RESULT_SCHEMA;
+    /**
+     * Hooks for the workflow
+     */
+    hooks?: WorkflowHooks<WorkflowInput<INPUT_SCHEMA>, WorkflowResult<RESULT_SCHEMA>>;
+};
+/**
+ * A workflow instance that can be executed
+ */
+type Workflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny> = {
+    /**
+     * Unique identifier for the workflow
+     */
+    id: string;
+    /**
+     * Human-readable name for the workflow
+     */
+    name: string;
+    /**
+     * Description of what the workflow does
+     * @default "No purpose provided"
+     */
+    purpose: string;
+    /**
+     * Array of steps to execute in order
+     */
+    steps: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, DangerouslyAllowAny, DangerouslyAllowAny>[];
+    /**
+     * Execute the workflow with the given input
+     * @param input - The input to the workflow
+     * @returns The result of the workflow
+     */
+    run: (input: WorkflowInput<INPUT_SCHEMA>, options?: WorkflowRunOptions) => Promise<{
+        executionId: string;
+        startAt: Date;
+        endAt: Date;
+        status: "completed";
+        result: z.infer<RESULT_SCHEMA>;
+    }>;
+};
+
+type WorkflowStateStatus = "pending" | "running" | "completed" | "failed";
+type WorkflowState<INPUT, RESULT> = {
+    executionId: string;
+    conversationId?: string;
+    userId?: string;
+    userContext?: UserContext;
+    active: number;
+    startAt: Date;
+    endAt: Date | null;
+    status: WorkflowStateStatus;
+    /** the initial input data to the workflow */
+    input: InternalExtractWorkflowInputData<INPUT>;
+    /** current data being processed */
+    data: DangerouslyAllowAny;
+    /** the result of workflow execution, null until execution is complete */
+    result: RESULT | null;
+    error: Error | null;
+};
+
+/**
+ * The base input type for the workflow
+ * @private - INTERNAL USE ONLY
+ */
+type InternalBaseWorkflowInputSchema = z.ZodTypeAny | BaseMessage | BaseMessage[] | string;
+/**
+ * The state parameter for the workflow, used to pass the state to a step or other function (i.e. hooks)
+ * @private - INTERNAL USE ONLY
+ */
+type InternalWorkflowStateParam<INPUT> = Omit<WorkflowState<INPUT, DangerouslyAllowAny>, "data" | "result">;
+/**
+ * A function that can be executed by the workflow
+ * @private - INTERNAL USE ONLY
+ */
+type InternalWorkflowFunc<INPUT, DATA, RESULT> = (data: InternalExtractWorkflowInputData<DATA>, state: InternalWorkflowStateParam<INPUT>) => Promise<RESULT>;
+type InternalWorkflowStepConfig<T extends PlainObject = PlainObject> = {
+    /**
+     * Unique identifier for the step
+     * @default uuidv4
+     */
+    id?: string;
+    /**
+     * Human-readable name for the step
+     */
+    name?: string;
+    /**
+     * Description of what the step does
+     */
+    purpose?: string;
+} & T;
+/**
+ * Base step interface for building new steps
+ * @private - INTERNAL USE ONLY
+ */
+interface InternalBaseWorkflowStep<INPUT, DATA, RESULT> {
+    /**
+     * Unique identifier for the step
+     */
+    id: string;
+    /**
+     * Human-readable name for the step
+     */
+    name: string | null;
+    /**
+     * Description of what the step does
+     */
+    purpose: string | null;
+    /**
+     * Type identifier for the step
+     */
+    type: string;
+    /**
+     * Execute the step with the given data
+     * @param data - The data to execute the step with
+     * @param state - The state of the workflow
+     * @returns The result of the step
+     */
+    execute: (data: InternalExtractWorkflowInputData<DATA>, state: InternalWorkflowStateParam<INPUT>) => Promise<RESULT>;
+}
+/**
+ * Any step that can be accepted by the workflow
+ * @private - INTERNAL USE ONLY
+ */
+type InternalAnyWorkflowStep<INPUT, DATA = DangerouslyAllowAny, RESULT = DangerouslyAllowAny> = InternalBaseWorkflowStep<INPUT, DATA, RESULT> | Omit<InternalBaseWorkflowStep<INPUT, DATA, RESULT>, "type">;
+/**
+ * Infer the result type from a list of steps
+ * @private - INTERNAL USE ONLY
+ */
+type InternalInferWorkflowStepsResult<STEPS extends ReadonlyArray<InternalAnyWorkflowStep<DangerouslyAllowAny, DangerouslyAllowAny, DangerouslyAllowAny>>> = {
+    [K in keyof STEPS]: Awaited<ReturnType<STEPS[K]["execute"]>>;
+};
+type InternalExtractWorkflowInputData<T> = TF.IsUnknown<T> extends true ? BaseMessage | BaseMessage[] | string : TF.IsAny<T> extends true ? BaseMessage | BaseMessage[] | string : T extends z.ZodType ? z.infer<T> : T;
+
+type AgentConfig$1<SCHEMA extends z.ZodTypeAny> = PublicGenerateOptions & {
+    schema: SCHEMA;
+};
+/**
+ * Creates an agent step for a workflow
+ *
+ * @example
+ * ```ts
+ * const w = createWorkflow(
+ *   andAgent(
+ *     (data) => `Generate a greeting for the user ${data.name}`,
+ *     agent,
+ *    { schema: z.object({ greeting: z.string() }) }
+ *   ),
+ *   andThen(async (data) => data.greeting)
+ * );
+ * ```
+ *
+ * @param task - The task (prompt) to execute for the agent, can be a string or a function that returns a string
+ * @param agent - The agent to execute the task using `generateObject`
+ * @param config - The config for the agent (schema) `generateObject` call
+ * @returns A workflow step that executes the agent with the task
+ */
+declare function andAgent<INPUT, DATA, SCHEMA extends z.ZodTypeAny>(task: BaseMessage[] | string | InternalWorkflowFunc<INPUT, DATA, BaseMessage[] | string>, agent: Agent<{
+    llm: DangerouslyAllowAny;
+}>, config: AgentConfig$1<SCHEMA>): {
+    type: "agent";
+    id: string;
+    name: string;
+    purpose: string | null;
+    agent: Agent<{
+        llm: DangerouslyAllowAny;
+    }>;
+    execute: (data: InternalExtractWorkflowInputData<DATA>, state: InternalWorkflowStateParam<INPUT>) => Promise<z.TypeOf<SCHEMA>>;
+};
+
+interface WorkflowStepAgent<INPUT, DATA, RESULT> extends InternalBaseWorkflowStep<INPUT, DATA, RESULT> {
+    type: "agent";
+    agent: Agent<{
+        llm: DangerouslyAllowAny;
+    }>;
+}
+type WorkflowStepFuncConfig<INPUT, DATA, RESULT> = InternalWorkflowStepConfig<{
+    execute: InternalWorkflowFunc<INPUT, DATA, RESULT>;
+}>;
+interface WorkflowStepFunc<INPUT, DATA, RESULT> extends InternalBaseWorkflowStep<INPUT, DATA, RESULT> {
+    type: "func";
+}
+type WorkflowStepTapConfig<INPUT, DATA, _RESULT> = InternalWorkflowStepConfig<{
+    execute: InternalWorkflowFunc<INPUT, DATA, DangerouslyAllowAny>;
+}>;
+interface WorkflowStepTap<INPUT, DATA, _RESULT> extends InternalBaseWorkflowStep<INPUT, DATA, DATA> {
+    type: "tap";
+}
+type WorkflowStepConditionalWhenConfig<INPUT, DATA, RESULT> = InternalWorkflowStepConfig<{
+    condition: InternalWorkflowFunc<INPUT, DATA, boolean>;
+    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+}>;
+interface WorkflowStepConditionalWhen<INPUT, DATA, RESULT> extends InternalBaseWorkflowStep<INPUT, DATA, InternalExtractWorkflowInputData<DATA> | RESULT> {
+    type: "conditional-when";
+    condition: InternalWorkflowFunc<INPUT, DATA, boolean>;
+}
+type WorkflowStepParallelRaceConfig<INPUT, DATA, RESULT> = InternalWorkflowStepConfig<{
+    steps: ReadonlyArray<InternalAnyWorkflowStep<INPUT, DATA, RESULT>>;
+}>;
+interface WorkflowStepParallelRace<INPUT, DATA, RESULT> extends InternalBaseWorkflowStep<INPUT, DATA, RESULT> {
+    type: "parallel-race";
+    steps: ReadonlyArray<InternalAnyWorkflowStep<INPUT, DATA, RESULT>>;
+}
+type WorkflowStepParallelAllConfig<STEPS extends ReadonlyArray<InternalAnyWorkflowStep<DangerouslyAllowAny, DangerouslyAllowAny>>> = InternalWorkflowStepConfig<{
+    steps: STEPS;
+}>;
+interface WorkflowStepParallelAll<INPUT, DATA, RESULT> extends InternalBaseWorkflowStep<INPUT, DATA, RESULT> {
+    type: "parallel-all";
+    steps: ReadonlyArray<InternalAnyWorkflowStep<INPUT, DATA, RESULT>>;
+}
+type WorkflowStep<INPUT, DATA, RESULT> = WorkflowStepAgent<INPUT, DATA, RESULT> | WorkflowStepFunc<INPUT, DATA, RESULT> | WorkflowStepConditionalWhen<INPUT, DATA, RESULT> | WorkflowStepParallelAll<INPUT, DATA, RESULT> | WorkflowStepTap<INPUT, DATA, RESULT> | WorkflowStepParallelRace<INPUT, DATA, RESULT>;
+
+/**
+ * Creates an async function step for the workflow
+ *
+ * @example
+ * ```ts
+ * const w = createWorkflow(
+ *   andThen(async (data) => {
+ *     const processed = await someAsyncOperation(data.value);
+ *     return { ...data, processed };
+ *   }),
+ *   andThen(async (data) => {
+ *     return { result: `Processed: ${data.processed}` };
+ *   })
+ * );
+ * ```
+ *
+ * @param fn - The async function to execute with the workflow data
+ * @returns A workflow step that executes the function and returns the result
+ */
+declare function andThen<INPUT, DATA, RESULT>({ execute, ...config }: WorkflowStepFuncConfig<INPUT, DATA, RESULT>): {
+    type: "func";
+    execute: InternalWorkflowFunc<INPUT, DATA, RESULT>;
+    id: string;
+    name: string;
+    purpose: string;
+};
+
+/**
+ * Creates a conditional step for the workflow that executes only when a condition is met
+ *
+ * @example
+ * ```ts
+ * const w = createWorkflow(
+ *   andWhen({
+ *     condition: (data) => data.userType === "admin",
+ *     stepOrFunc: andThen(async (data) => {
+ *       return { ...data, permissions: ["read", "write", "delete"] };
+ *     })
+ *   }),
+ *   andWhen({
+ *       condition: (data) => data.value > 100,
+ *     andAgent(
+ *       (data) => `Process high value transaction: ${data.value}`,
+ *       agent,
+ *       { schema: z.object({ processed: z.boolean() }) }
+ *     )
+ *   )
+ * );
+ * ```
+ *
+ * @param condition - Function that determines if the step should execute based on the input data
+ * @param stepOrFunc - Either a workflow step or an agent to execute when the condition is true
+ * @returns A conditional workflow step that executes the step only when the condition evaluates to true
+ */
+declare function andWhen<INPUT, DATA, RESULT>({ condition, step, ...config }: WorkflowStepConditionalWhenConfig<INPUT, DATA, RESULT>): {
+    type: "conditional-when";
+    condition: InternalWorkflowFunc<INPUT, DATA, boolean>;
+    execute: (data: InternalExtractWorkflowInputData<DATA>, state: InternalWorkflowStateParam<INPUT>) => Promise<RESULT | InternalExtractWorkflowInputData<DATA>>;
+    id: string;
+    name: string;
+    purpose: string;
+};
+
+/**
+ * Creates a parallel execution step that runs multiple steps simultaneously and waits for all to complete
+ *
+ * @example
+ * ```ts
+ * const w = createWorkflow(
+ *   andAll([
+ *     andThen(async (data) => {
+ *       const userInfo = await fetchUserInfo(data.userId);
+ *       return { userInfo };
+ *     }),
+ *     andThen(async (data) => {
+ *       const permissions = await fetchPermissions(data.userId);
+ *       return { permissions };
+ *     }),
+ *     andAgent(
+ *       (data) => `Generate recommendations for user ${data.userId}`,
+ *       agent,
+ *       { schema: z.object({ recommendations: z.array(z.string()) }) }
+ *     )
+ *   ]),
+ *   andThen(async (data) => {
+ *     // data is now an array: [{ userInfo }, { permissions }, { recommendations }]
+ *     return { combined: data.flat() };
+ *   })
+ * );
+ * ```
+ *
+ * @param steps - Array of workflow steps to execute in parallel
+ * @returns A workflow step that executes all steps simultaneously and returns their results as an array
+ */
+declare function andAll<INPUT, DATA, RESULT, STEPS extends ReadonlyArray<InternalAnyWorkflowStep<INPUT, DATA, RESULT>>, INFERRED_RESULT = InternalInferWorkflowStepsResult<STEPS>>({ steps, ...config }: WorkflowStepParallelAllConfig<STEPS>): {
+    type: "parallel-all";
+    steps: InternalAnyWorkflowStep<INPUT, DATA, INFERRED_RESULT>[];
+    execute: (data: InternalExtractWorkflowInputData<DATA>, state: InternalWorkflowStateParam<INPUT>) => Promise<INFERRED_RESULT>;
+    id: string;
+    name: string;
+    purpose: string;
+};
+
+/**
+ * Creates a race execution step that runs multiple steps simultaneously and returns the first completed result
+ *
+ * @example
+ * ```ts
+ * const w = createWorkflow(
+ *   andRace([
+ *     andThen(async (data) => {
+ *       // Fast operation
+ *       const cacheResult = await checkCache(data.query);
+ *       return { source: "cache", result: cacheResult };
+ *     }),
+ *     andThen(async (data) => {
+ *       // Slower operation
+ *       const dbResult = await queryDatabase(data.query);
+ *       return { source: "database", result: dbResult };
+ *     }),
+ *     andAgent(
+ *       (data) => `Generate fallback response for: ${data.query}`,
+ *       agent,
+ *       { schema: z.object({ source: z.literal("ai"), result: z.string() }) }
+ *     )
+ *   ]),
+ *   andThen(async (data) => {
+ *     // data is the result from whichever step completed first
+ *     return { finalResult: data.result, source: data.source };
+ *   })
+ * );
+ * ```
+ *
+ * @param steps - Array of workflow steps to execute in parallel
+ * @returns A workflow step that executes all steps simultaneously and returns the result from the first step to complete
+ */
+declare function andRace<INPUT, DATA, RESULT, STEPS extends ReadonlyArray<InternalAnyWorkflowStep<INPUT, DATA, RESULT>>, INFERRED_RESULT = InternalInferWorkflowStepsResult<STEPS>[number]>({ steps, ...config }: InternalWorkflowStepConfig<{
+    steps: STEPS;
+}>): {
+    type: "parallel-race";
+    steps: InternalAnyWorkflowStep<INPUT, DATA, INFERRED_RESULT>[];
+    execute: (data: InternalExtractWorkflowInputData<DATA>, state: InternalWorkflowStateParam<INPUT>) => Promise<INFERRED_RESULT>;
+    id: string;
+    name: string;
+    purpose: string;
+};
+
+/**
+ * A safe way to tap into the workflow state without affecting the result.
+ * @param fn - The async function to execute
+ * @returns A workflow step that executes the function
+ */
+declare function andTap<INPUT, DATA, RESULT>({ execute, ...config }: WorkflowStepTapConfig<INPUT, DATA, RESULT>): {
+    type: "tap";
+    execute: (data: InternalExtractWorkflowInputData<DATA>, context: InternalWorkflowStateParam<INPUT>) => Promise<DATA>;
+    id: string;
+    name: string;
+    purpose: string;
+};
+
+/**
+ * Creates a workflow from multiple and* functions
+ * @param config - The workflow configuration
+ * @param steps - Variable number of and* functions to execute
+ * @returns A configured workflow instance
+ */
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, S10>, s11: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S10, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, S10>, s11: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S10, S11>, s12: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S11, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, S10>, s11: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S10, S11>, s12: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S11, S12>, s13: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S12, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, S10>, s11: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S10, S11>, s12: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S11, S12>, s13: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S12, S13>, s14: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S13, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, S10>, s11: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S10, S11>, s12: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S11, S12>, s13: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S12, S13>, s14: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S13, S14>, s15: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S14, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, S10>, s11: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S10, S11>, s12: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S11, S12>, s13: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S12, S13>, s14: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S13, S14>, s15: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S14, S15>, s16: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S15, WorkflowResult<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, S10>, s11: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S10, S11>, s12: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S11, S12>, s13: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S12, S13>, s14: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S13, S14>, s15: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S14, S15>, s16: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S15, S16>, s17: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S16, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, S10>, s11: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S10, S11>, s12: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S11, S12>, s13: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S12, S13>, s14: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S13, S14>, s15: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S14, S15>, s16: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S15, S16>, s17: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S16, S17>, s18: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S17, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, S10>, s11: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S10, S11>, s12: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S11, S12>, s13: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S12, S13>, s14: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S13, S14>, s15: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S14, S15>, s16: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S15, S16>, s17: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S16, S17>, s18: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S17, S18>, s19: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S18, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+declare function createWorkflow<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15, S16, S17, S18, S19>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>, s1: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, WorkflowInput<INPUT_SCHEMA>, S1>, s2: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S1, S2>, s3: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S2, S3>, s4: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S3, S4>, s5: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S4, S5>, s6: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S5, S6>, s7: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S6, S7>, s8: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S7, S8>, s9: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S8, S9>, s10: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S9, S10>, s11: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S10, S11>, s12: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S11, S12>, s13: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S12, S13>, s14: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S13, S14>, s15: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S14, S15>, s16: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S15, S16>, s17: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S16, S17>, s18: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S17, S18>, s19: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S18, S19>, s20: WorkflowStep<WorkflowInput<INPUT_SCHEMA>, S19, z.infer<RESULT_SCHEMA>>): Workflow<INPUT_SCHEMA, RESULT_SCHEMA>;
+
+/**
+ * Agent configuration for the chain
+ */
+type AgentConfig<SCHEMA extends z.ZodTypeAny> = {
+    schema: SCHEMA;
+};
+/**
+ * A workflow chain that provides a fluent API for building workflows
+ *
+ * @example
+ * ```ts
+ * const workflow = createWorkflowChain({
+ *   id: "user-processing",
+ *   name: "User Processing Workflow",
+ *   purpose: "Process user data and generate personalized content",
+ *   input: z.object({ userId: z.string(), userType: z.enum(["admin", "user"]) }),
+ *   result: z.object({ processed: z.boolean(), content: z.string() })
+ * })
+ *   .andThen(async (data) => {
+ *     const userInfo = await fetchUserInfo(data.userId);
+ *     return { ...data, userInfo };
+ *   })
+ *   .andWhen(
+ *     (data) => data.userType === "admin",
+ *     async (data) => ({ ...data, permissions: ["read", "write", "delete"] })
+ *   )
+ *   .andAgent(
+ *     (data) => `Generate personalized content for ${data.userInfo.name}`,
+ *     agent,
+ *     { schema: z.object({ content: z.string() }) }
+ *   )
+ *   .andThen(async (data) => ({
+ *     processed: true,
+ *     content: data.content
+ *   }));
+ *
+ * const result = await workflow.run({ userId: "123", userType: "admin" });
+ * ```
+ */
+declare class WorkflowChain<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny, CURRENT_DATA = WorkflowInput<INPUT_SCHEMA>> {
+    private steps;
+    private config;
+    constructor(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>);
+    /**
+     * Creates an agent step for a workflow
+     *
+     * @example
+     * ```ts
+     * const w = createWorkflowChain<{ name: string }>()
+     *   .andAgent(
+     *     (data) => `Generate a greeting for the user ${data.name}`,
+     *     agent,
+     *     { schema: z.object({ greeting: z.string() }) }
+     *   )
+     *   .andThen(async (data) => data.greeting)
+     * ```
+     *
+     * @param task - The task (prompt) to execute for the agent, can be a string or a function that returns a string
+     * @param agent - The agent to execute the task using `generateObject`
+     * @param config - The config for the agent (schema) `generateObject` call
+     * @returns A workflow step that executes the agent with the task
+     */
+    andAgent<SCHEMA extends z.ZodTypeAny>(task: string | InternalWorkflowFunc<INPUT_SCHEMA, CURRENT_DATA, string>, agent: Agent<{
+        llm: DangerouslyAllowAny;
+    }>, config: AgentConfig<SCHEMA>): WorkflowChain<INPUT_SCHEMA, RESULT_SCHEMA, z.infer<SCHEMA>>;
+    /**
+     * Add a function step to the workflow
+     *
+     * @example
+     * ```ts
+     * const workflow = createWorkflowChain(config)
+     *   .andThen(async (data) => {
+     *     const processed = await someAsyncOperation(data.value);
+     *     return { ...data, processed };
+     *   })
+     *   .andThen(async (data) => {
+     *     const enriched = await enrichData(data.processed);
+     *     return { ...data, enriched };
+     *   });
+     * ```
+     *
+     * @param fn - The async function to execute with the current workflow data
+     * @returns A new chain with the function step added
+     */
+    andThen<NEW_DATA>({ execute, ...config }: WorkflowStepFuncConfig<WorkflowInput<INPUT_SCHEMA>, CURRENT_DATA, NEW_DATA>): WorkflowChain<INPUT_SCHEMA, RESULT_SCHEMA, NEW_DATA>;
+    /**
+     * Add a conditional step that executes when a condition is true
+     *
+     * @example
+     * ```ts
+     * const workflow = createWorkflowChain(config)
+     *   .andWhen(
+     *     (data) => data.userType === "admin",
+     *     async (data) => ({ ...data, permissions: ["read", "write", "delete"] })
+     *   )
+     *   .andWhen(
+     *     (data) => data.value > 1000,
+     *     async (data) => ({ ...data, flagged: true, requiresReview: true })
+     *   )
+     *   .andWhen(
+     *     (data) => data.status === "pending",
+     *     (data) => andAgent(
+     *       `Process pending request for ${data.userId}`,
+     *       agent,
+     *       { schema: z.object({ processed: z.boolean() }) }
+     *     )
+     *   );
+     * ```
+     *
+     * @param condition - Function that determines if the step should execute based on the current data
+     * @param stepInput - Either a workflow step or an agent to execute when the condition is true
+     * @returns A new chain with the conditional step added
+     */
+    andWhen<NEW_DATA>({ condition, step, ...config }: WorkflowStepConditionalWhenConfig<WorkflowInput<INPUT_SCHEMA>, CURRENT_DATA, NEW_DATA>): WorkflowChain<INPUT_SCHEMA, RESULT_SCHEMA, NEW_DATA | CURRENT_DATA>;
+    /**
+     * Add a tap step to the workflow
+     *
+     * @example
+     * ```ts
+     * const workflow = createWorkflowChain(config)
+     *   .andTap({
+     *     execute: async (data) => {
+     *       console.log("🔄 Translating text:", data);
+     *     }
+     *   })
+     *   .andThen({
+     *     // the input data is still the same as the andTap ONLY executes, it doesn't return anything
+     *     execute: async (data) => {
+     *       return { ...data, translatedText: data.translatedText };
+     *     }
+     *   });
+     * ```
+     *
+     * @param fn - The async function to execute with the current workflow data
+     * @returns A new chain with the tap step added
+     */
+    andTap<NEW_DATA>({ execute, ...config }: WorkflowStepTapConfig<WorkflowInput<INPUT_SCHEMA>, CURRENT_DATA, NEW_DATA>): WorkflowChain<INPUT_SCHEMA, RESULT_SCHEMA, CURRENT_DATA>;
+    /**
+     * Add a parallel execution step that runs multiple steps simultaneously and waits for all to complete
+     *
+     * @example
+     * ```ts
+     * const workflow = createWorkflowChain(config)
+     *   .andAll([
+     *     async (data) => {
+     *       const userInfo = await fetchUserInfo(data.userId);
+     *       return { userInfo };
+     *     },
+     *     async (data) => {
+     *       const permissions = await fetchPermissions(data.userId);
+     *       return { permissions };
+     *     },
+     *     (data) => andAgent(
+     *       `Generate recommendations for user ${data.userId}`,
+     *       agent,
+     *       { schema: z.object({ recommendations: z.array(z.string()) }) }
+     *     )
+     *   ])
+     *   .andThen(async (data) => {
+     *     // data is now an array: [{ userInfo }, { permissions }, { recommendations }]
+     *     return { combined: data.flat() };
+     *   });
+     * ```
+     *
+     * @param steps - Array of workflow steps to execute in parallel
+     * @returns A new chain with the parallel step added
+     */
+    andAll<NEW_DATA, STEPS extends ReadonlyArray<InternalAnyWorkflowStep<WorkflowInput<INPUT_SCHEMA>, CURRENT_DATA, NEW_DATA>>, INFERRED_RESULT = InternalInferWorkflowStepsResult<STEPS>>({ steps, ...config }: WorkflowStepParallelAllConfig<STEPS>): WorkflowChain<INPUT_SCHEMA, RESULT_SCHEMA, INFERRED_RESULT>;
+    /**
+     * Add a race execution step that runs multiple steps simultaneously and returns the first completed result
+     *
+     * @example
+     * ```ts
+     * const workflow = createWorkflowChain(config)
+     *   .andRace([
+     *     async (data) => {
+     *       // Fast operation
+     *       const cacheResult = await checkCache(data.query);
+     *       return { source: "cache", result: cacheResult };
+     *     },
+     *     async (data) => {
+     *       // Slower operation
+     *       const dbResult = await queryDatabase(data.query);
+     *       return { source: "database", result: dbResult };
+     *     },
+     *     (data) => andAgent(
+     *       `Generate fallback response for: ${data.query}`,
+     *       agent,
+     *       { schema: z.object({ source: z.literal("ai"), result: z.string() }) }
+     *     )
+     *   ])
+     *   .andThen(async (data) => {
+     *     // data is the result from whichever step completed first
+     *     return { finalResult: data.result, source: data.source };
+     *   });
+     * ```
+     *
+     * @param steps - Array of workflow steps to execute in parallel
+     * @returns A new chain with the race step added
+     */
+    andRace<NEW_DATA, STEPS extends ReadonlyArray<InternalAnyWorkflowStep<WorkflowInput<INPUT_SCHEMA>, CURRENT_DATA, NEW_DATA>>, INFERRED_RESULT = InternalInferWorkflowStepsResult<STEPS>[number]>({ steps, ...config }: WorkflowStepParallelRaceConfig<STEPS, CURRENT_DATA, NEW_DATA>): WorkflowChain<INPUT_SCHEMA, RESULT_SCHEMA, INFERRED_RESULT>;
+    /**
+     * Execute the workflow with the given input
+     *
+     * @example
+     * ```ts
+     * const workflow = createWorkflowChain({
+     *   id: "user-processing",
+     *   name: "User Processing Workflow",
+     *   purpose: "Process user data and generate personalized content",
+     *   input: z.object({ userId: z.string(), userType: z.enum(["admin", "user"]) }),
+     *   result: z.object({ processed: z.boolean(), content: z.string() })
+     * })
+     *   .andThen(async (data) => {
+     *     const userInfo = await fetchUserInfo(data.userId);
+     *     return { ...data, userInfo };
+     *   })
+     *   .andAgent(
+     *     (data) => `Generate personalized content for ${data.userInfo.name}`,
+     *     agent,
+     *     { schema: z.object({ content: z.string() }) }
+     *   )
+     *   .andThen(async (data) => ({
+     *     processed: true,
+     *     content: data.content
+     *   }));
+     *
+     * const result = await workflow.run({ userId: "123", userType: "admin" });
+     * console.log(result); // { processed: true, content: "Hello John, here's your personalized content..." }
+     * ```
+     *
+     * @param input - The input data for the workflow that matches the input schema
+     * @returns The workflow execution result that matches the result schema
+     */
+    run(input: WorkflowInput<INPUT_SCHEMA>, options?: WorkflowRunOptions): Promise<{
+        executionId: string;
+        startAt: Date;
+        endAt: Date;
+        status: "completed";
+        result: z.TypeOf<RESULT_SCHEMA>;
+    }>;
+}
+/**
+ * Creates a new workflow chain with the given configuration
+ *
+ * @example
+ * ```ts
+ * const workflow = createWorkflowChain({
+ *   id: "data-processing",
+ *   name: "Data Processing Pipeline",
+ *   purpose: "Process and analyze user data with AI insights",
+ *   input: z.object({
+ *     userId: z.string(),
+ *     data: z.array(z.number()),
+ *     options: z.object({
+ *       includeAnalysis: z.boolean().default(true)
+ *     }).optional()
+ *   }),
+ *   result: z.object({
+ *     processed: z.boolean(),
+ *     summary: z.string(),
+ *     insights: z.array(z.string()).optional()
+ *   })
+ * })
+ *   .andThen(async (data) => {
+ *     const processed = await processData(data.data);
+ *     return { ...data, processed };
+ *   })
+ *   .andWhen(
+ *     (data) => data.options?.includeAnalysis ?? true,
+ *     (data) => andAgent(
+ *       `Analyze the processed data: ${JSON.stringify(data.processed)}`,
+ *       agent,
+ *       { schema: z.object({ insights: z.array(z.string()) }) }
+ *     )
+ *   )
+ *   .andThen(async (data) => ({
+ *     processed: true,
+ *     summary: `Processed ${data.data.length} items for user ${data.userId}`,
+ *     insights: data.insights
+ *   }));
+ *
+ * const result = await workflow.run(...);
+ * ```
+ *
+ * @param config - The workflow configuration including schemas and metadata
+ * @returns A new workflow chain instance ready for building steps
+ */
+declare function createWorkflowChain<INPUT_SCHEMA extends InternalBaseWorkflowInputSchema, RESULT_SCHEMA extends z.ZodTypeAny>(config: WorkflowConfig<INPUT_SCHEMA, RESULT_SCHEMA>): WorkflowChain<INPUT_SCHEMA, RESULT_SCHEMA, WorkflowInput<INPUT_SCHEMA>>;
+
 /**
  * Enum defining the next action to take after a reasoning step.
  */
@@ -4151,6 +4926,11 @@ type HTTPServerConfig = {
      * Event source initialization options (used for SSE fallback)
      */
     eventSourceInit?: EventSourceInit;
+    /**
+     * Optional maximum request timeout in milliseconds.
+     * If provided, passed to MCPClient as the per-request timeout.
+     */
+    timeout?: number;
 };
 /**
  * SSE-based MCP server configuration (explicit SSE transport)
@@ -4172,6 +4952,11 @@ type SSEServerConfig = {
      * Event source initialization options
      */
     eventSourceInit?: EventSourceInit;
+    /**
+     * Optional maximum request timeout in milliseconds.
+     * If provided, passed to MCPClient as the per-request timeout.
+     */
+    timeout?: number;
 };
 /**
  * Streamable HTTP-based MCP server configuration (no fallback)
@@ -4193,6 +4978,11 @@ type StreamableHTTPServerConfig = {
      * Session ID for the connection
      */
     sessionId?: string;
+    /**
+     * Optional maximum request timeout in milliseconds.
+     * If provided, passed to MCPClient as the per-request timeout.
+     */
+    timeout?: number;
 };
 /**
  * Stdio-based MCP server configuration
@@ -4218,6 +5008,11 @@ type StdioServerConfig = {
      * Working directory for the MCP server process
      */
     cwd?: string;
+    /**
+     * Optional maximum request timeout in milliseconds.
+     * If provided, passed to MCPClient as the per-request timeout.
+     */
+    timeout?: number;
 };
 /**
  * Tool call request
@@ -4746,4 +5541,4 @@ declare class VoltAgent {
     shutdownTelemetry(): Promise<void>;
 }
 
-export { Agent, AgentErrorEvent, AgentHistoryEntry, AgentHookOnEnd, AgentHookOnHandoff, AgentHookOnStart, AgentHookOnToolEnd, AgentHookOnToolStart, AgentHooks, AgentOptions, AgentRegistry, AgentResponse, AgentStartEvent, AgentStartEventMetadata, AgentSuccessEvent, AgentSuccessEventMetadata, AgentTool, AllowedVariableValue, AnyToolConfig, AsyncIterableStream, BaseEventMetadata, BaseLLMOptions, BaseMessage, BaseRetriever, BaseTimelineEvent, BaseTool, BaseToolCall, CachedPrompt, ChatMessage, ClientInfo, Conversation, ConversationQueryOptions, CreateConversationInput, CreateReasoningToolsOptions, CustomEndpointDefinition, CustomEndpointError, CustomEndpointHandler, DEFAULT_INSTRUCTIONS, DataContent, DynamicValue, DynamicValueOptions, ErrorStreamPart, EventStatus, ExtractVariableNames, FEW_SHOT_EXAMPLES, FilePart, FinishStreamPart, GenerateObjectOptions, GenerateTextOptions, HTTPServerConfig, HistoryStatus, HttpMethod, VoltOpsClient$1 as IVoltOpsClient, ImagePart, InMemoryStorage, InferGenerateObjectResponse, InferGenerateTextResponse, InferMessage, InferModel, InferProviderParams, InferStreamResponse, InferTool, LLMProvider, LibSQLStorage, MCPClient, MCPClientConfig, MCPClientEvents, MCPConfiguration, MCPOptions, MCPServerConfig, MCPToolCall, MCPToolResult, Memory, MemoryEventMetadata, MemoryManager, MemoryMessage, MemoryOptions, MemoryReadErrorEvent, MemoryReadStartEvent, MemoryReadSuccessEvent, MemoryWriteErrorEvent, MemoryWriteStartEvent, MemoryWriteSuccessEvent, MessageContent, MessageFilterOptions, MessageRole, ModelToolCall, NewTimelineEvent, NextAction, NodeType, ObjectSubAgentConfig, OnEndHookArgs, OnHandoffHookArgs, OnStartHookArgs, OnToolEndHookArgs, OnToolStartHookArgs, OperationContext, PackageUpdateInfo, PromptApiClient, PromptApiResponse, PromptContent, PromptCreator, PromptHelper, PromptReference, PromptTemplate, ProviderObjectResponse, ProviderObjectStreamResponse, ProviderParams, ProviderResponse, ProviderTextResponse, ProviderTextStreamResponse, ReadableStreamType, ReasoningStep, ReasoningStepSchema, ReasoningStreamPart, ReasoningToolExecuteOptions, RetrieveOptions, Retriever, RetrieverErrorEvent, RetrieverOptions, RetrieverStartEvent, RetrieverSuccessEvent, SSEServerConfig, ServerOptions, SourceStreamPart, StandardEventData, StandardTimelineEvent, StdioServerConfig, StepChunkCallback, StepFinishCallback, StepWithContent, StreamEventForwarderOptions, StreamObjectFinishResult, StreamObjectOnFinishCallback, StreamObjectOptions, StreamPart, StreamTextFinishResult, StreamTextOnFinishCallback, StreamTextOptions, StreamableHTTPServerConfig, SubAgentConfig, SubAgentConfigObject, SubAgentMethod, TemplateVariables, TextDeltaStreamPart, TextPart, TextSubAgentConfig, TimelineEventCoreLevel, TimelineEventCoreStatus, TimelineEventCoreType, Tool, ToolCall, ToolCallStreamPart, ToolErrorEvent, ToolErrorInfo, ToolExecuteOptions, ToolExecutionContext, ToolManager, ToolOptions, ToolResultStreamPart, ToolSchema, ToolStartEvent, ToolStatus, ToolStatusInfo, ToolSuccessEvent, Toolkit, ToolsetMap, ToolsetWithTools, TransportError, Usage, UsageInfo, Voice, VoiceEventData, VoiceEventType, VoiceMetadata, VoiceOptions, VoltAgent, VoltAgentError, VoltAgentExporter, VoltAgentExporterOptions, VoltAgentOptions, VoltOpsClient, VoltOpsClientOptions, VoltOpsPromptApiClient, VoltOpsPromptManager, VoltOpsPromptManagerImpl, checkForUpdates, createAsyncIterableStream, createHooks, createNodeId, createPrompt, createReasoningTools, createRetrieverTool, createSimpleTemplateEngine, createStreamEventForwarder, createSubagent, createTool, createToolkit, createVoltOpsClient, VoltAgent as default, getNodeTypeFromNodeId, registerCustomEndpoint, registerCustomEndpoints, safeJsonParse, serializeValueForDebug, streamEventForwarder, tool, updateAllPackages, updateSinglePackage, zodSchemaToJsonUI };
+export { Agent, AgentErrorEvent, AgentHistoryEntry, AgentHookOnEnd, AgentHookOnHandoff, AgentHookOnStart, AgentHookOnToolEnd, AgentHookOnToolStart, AgentHooks, AgentOptions, AgentRegistry, AgentResponse, AgentStartEvent, AgentStartEventMetadata, AgentSuccessEvent, AgentSuccessEventMetadata, AgentTool, AllowedVariableValue, AnyToolConfig, AsyncIterableStream, BaseEventMetadata, BaseLLMOptions, BaseMessage, BaseRetriever, BaseTimelineEvent, BaseTool, BaseToolCall, CachedPrompt, ChatMessage, ClientInfo, Conversation, ConversationQueryOptions, CreateConversationInput, CreateReasoningToolsOptions, CustomEndpointDefinition, CustomEndpointError, CustomEndpointHandler, DEFAULT_INSTRUCTIONS, DataContent, DynamicValue, DynamicValueOptions, ErrorStreamPart, EventStatus, ExtractVariableNames, FEW_SHOT_EXAMPLES, FilePart, FinishStreamPart, GenerateObjectOptions, GenerateTextOptions, HTTPServerConfig, HistoryStatus, HttpMethod, VoltOpsClient$1 as IVoltOpsClient, ImagePart, InMemoryStorage, InferGenerateObjectResponse, InferGenerateTextResponse, InferMessage, InferModel, InferProviderParams, InferStreamResponse, InferTool, LLMProvider, LibSQLStorage, MCPClient, MCPClientConfig, MCPClientEvents, MCPConfiguration, MCPOptions, MCPServerConfig, MCPToolCall, MCPToolResult, Memory, MemoryEventMetadata, MemoryManager, MemoryMessage, MemoryOptions, MemoryReadErrorEvent, MemoryReadStartEvent, MemoryReadSuccessEvent, MemoryWriteErrorEvent, MemoryWriteStartEvent, MemoryWriteSuccessEvent, MessageContent, MessageFilterOptions, MessageRole, ModelToolCall, NewTimelineEvent, NextAction, NodeType, ObjectSubAgentConfig, OnEndHookArgs, OnHandoffHookArgs, OnStartHookArgs, OnToolEndHookArgs, OnToolStartHookArgs, OperationContext, PackageUpdateInfo, PromptApiClient, PromptApiResponse, PromptContent, PromptCreator, PromptHelper, PromptReference, PromptTemplate, ProviderObjectResponse, ProviderObjectStreamResponse, ProviderParams, ProviderResponse, ProviderTextResponse, ProviderTextStreamResponse, ReadableStreamType, ReasoningStep, ReasoningStepSchema, ReasoningStreamPart, ReasoningToolExecuteOptions, RetrieveOptions, Retriever, RetrieverErrorEvent, RetrieverOptions, RetrieverStartEvent, RetrieverSuccessEvent, SSEServerConfig, ServerOptions, SourceStreamPart, StandardEventData, StandardTimelineEvent, StdioServerConfig, StepChunkCallback, StepFinishCallback, StepWithContent, StreamEventForwarderOptions, StreamObjectFinishResult, StreamObjectOnFinishCallback, StreamObjectOptions, StreamPart, StreamTextFinishResult, StreamTextOnFinishCallback, StreamTextOptions, StreamableHTTPServerConfig, SubAgentConfig, SubAgentConfigObject, SubAgentMethod, TemplateVariables, TextDeltaStreamPart, TextPart, TextSubAgentConfig, TimelineEventCoreLevel, TimelineEventCoreStatus, TimelineEventCoreType, Tool, ToolCall, ToolCallStreamPart, ToolErrorEvent, ToolErrorInfo, ToolExecuteOptions, ToolExecutionContext, ToolManager, ToolOptions, ToolResultStreamPart, ToolSchema, ToolStartEvent, ToolStatus, ToolStatusInfo, ToolSuccessEvent, Toolkit, ToolsetMap, ToolsetWithTools, TransportError, Usage, UsageInfo, Voice, VoiceEventData, VoiceEventType, VoiceMetadata, VoiceOptions, VoltAgent, VoltAgentError, VoltAgentExporter, VoltAgentExporterOptions, VoltAgentOptions, VoltOpsClient, VoltOpsClientOptions, VoltOpsPromptApiClient, VoltOpsPromptManager, VoltOpsPromptManagerImpl, Workflow, WorkflowConfig, andAgent, andAll, andRace, andTap, andThen, andWhen, checkForUpdates, createAsyncIterableStream, createHooks, createNodeId, createPrompt, createReasoningTools, createRetrieverTool, createSimpleTemplateEngine, createStreamEventForwarder, createSubagent, createTool, createToolkit, createVoltOpsClient, createWorkflow, createWorkflowChain, VoltAgent as default, getNodeTypeFromNodeId, registerCustomEndpoint, registerCustomEndpoints, safeJsonParse, serializeValueForDebug, streamEventForwarder, tool, updateAllPackages, updateSinglePackage, zodSchemaToJsonUI };