@upstash/workflow 0.3.0-rc → 0.3.0-rc1

package/{types-DESkn7K9.d.mts → types-pEje3VEB.d.ts}

@@ -1,4 +1,4 @@
-import { QstashError, PublishRequest, FlowControl, HTTPMethods as HTTPMethods$1, Client, Receiver } from '@upstash/qstash';
+import { QstashError, PublishRequest, HTTPMethods as HTTPMethods$1, FlowControl, Client, Receiver } from '@upstash/qstash';
 import { z } from 'zod';
 
 /**
@@ -8,23 +8,17 @@ declare class WorkflowError extends QstashError {
     constructor(message: string);
 }
 /**
- * Raised when the workflow executes a function successfully
- * and aborts to end the execution
+ * Base error for workflow abort scenarios
+ * Raised when a workflow step executes successfully.
  */
 declare class WorkflowAbort extends Error {
-    stepInfo?: Step;
     stepName: string;
+    stepInfo?: Step;
     /**
-     * whether workflow is to be canceled on abort
-     */
-    cancelWorkflow: boolean;
-    /**
-     *
      * @param stepName name of the aborting step
      * @param stepInfo step information
-     * @param cancelWorkflow
      */
-    constructor(stepName: string, stepInfo?: Step, cancelWorkflow?: boolean);
+    constructor(stepName: string, stepInfo?: Step);
 }
 /**
  * Raised when the workflow is failed due to a non-retryable error
@@ -38,35 +32,134 @@ declare class WorkflowNonRetryableError extends WorkflowAbort {
 declare class WorkflowRetryAfterError extends WorkflowAbort {
     retryAfter: number | Duration;
     /**
-     * @param retryAfter time in seconds after which the workflow should be retried
      * @param message error message to be displayed
+     * @param retryAfter time in seconds after which the workflow should be retried
      */
     constructor(message: string, retryAfter: number | Duration);
 }
 
-declare const LOG_LEVELS: readonly ["DEBUG", "INFO", "SUBMIT", "WARN", "ERROR"];
-type LogLevel = (typeof LOG_LEVELS)[number];
-type ChatLogEntry = {
-    timestamp: number;
-    workflowRunId: string;
-    logLevel: LogLevel;
-    eventType: "ENDPOINT_START" | "SUBMIT_THIRD_PARTY_RESULT" | "CREATE_CONTEXT" | "SUBMIT_FIRST_INVOCATION" | "RUN_SINGLE" | "RUN_PARALLEL" | "SUBMIT_STEP" | "SUBMIT_CLEANUP" | "RESPONSE_WORKFLOW" | "RESPONSE_DEFAULT" | "ERROR";
-    details: unknown;
+type LifeCycleEvent = "beforeExecution" | "afterExecution" | "runStarted" | "runCompleted";
+type DebugEvent = "onError" | "onWarning" | "onInfo";
+type LifeCycleEventParameters<TResult> = {
+    beforeExecution: {
+        stepName: string;
+    };
+    afterExecution: {
+        stepName: string;
+        result: unknown;
+    };
+    runStarted: {};
+    runCompleted: {
+        result: TResult;
+    };
+};
+type DebugEventParameters = {
+    onError: {
+        error: Error;
+    };
+    onWarning: {
+        warning: string;
+    };
+    onInfo: {
+        info: string;
+    };
 };
-type WorkflowLoggerOptions = {
-    logLevel: LogLevel;
-    logOutput: "console";
+type MiddlewareCallbacks<TInitialPayload, TResult> = Partial<{
+    [K in LifeCycleEvent]: (params: LifeCycleEventParameters<TResult>[K] & {
+        context: WorkflowContext<TInitialPayload>;
+    }) => Promise<void> | void;
+} & {
+    [K in DebugEvent]: (params: DebugEventParameters[K] & {
+        workflowRunId?: string;
+    }) => Promise<void> | void;
+}>;
+type MiddlewareInitCallbacks<TInitialPayload, TResult> = () => Promise<MiddlewareCallbacks<TInitialPayload, TResult>> | MiddlewareCallbacks<TInitialPayload, TResult>;
+type MiddlewareCallbackConfig<TInitialPayload, TResult> = {
+    init: MiddlewareInitCallbacks<TInitialPayload, TResult>;
+} | {
+    callbacks: MiddlewareCallbacks<TInitialPayload, TResult>;
 };
-declare class WorkflowLogger {
-    private logs;
-    private options;
-    private workflowRunId?;
-    constructor(options: WorkflowLoggerOptions);
-    log(level: LogLevel, eventType: ChatLogEntry["eventType"], details?: unknown): Promise<void>;
-    setWorkflowRunId(workflowRunId: string): void;
-    private writeToConsole;
-    private shouldLog;
-    static getLogger(verbose?: boolean | WorkflowLogger): WorkflowLogger | undefined;
+type MiddlewareParameters<TInitialPayload, TResult> = {
+    name: string;
+} & MiddlewareCallbackConfig<TInitialPayload, TResult>;
+/**
+ * Type for the dispatch debug method that can be passed to helper functions
+ * without needing to pass generics everywhere
+ */
+type DispatchDebug = <K extends DebugEvent>(event: K, params: DebugEventParameters[K]) => Promise<void>;
+/**
+ * Type for the dispatch lifecycle method
+ */
+type DispatchLifecycle<TResult = unknown> = <K extends LifeCycleEvent>(event: K, params: LifeCycleEventParameters<TResult>[K]) => Promise<void>;
+
+declare class WorkflowMiddleware<TInitialPayload = unknown, TResult = unknown> {
+    readonly name: string;
+    private initCallbacks?;
+    /**
+     * Callback functions
+     *
+     * Initially set to undefined, will be populated after init is called
+     */
+    private middlewareCallbacks?;
+    constructor(parameters: MiddlewareParameters<TInitialPayload, TResult>);
+    ensureInit(): Promise<void>;
+    /**
+     * Gets a callback function by name.
+     *
+     * @param callback name of the callback to retrieve
+     */
+    getCallback<K extends keyof MiddlewareCallbacks<TInitialPayload, TResult>>(callback: K): MiddlewareCallbacks<TInitialPayload, TResult>[K] | undefined;
+}
+
+/**
+ * MiddlewareManager - Simplified middleware dispatcher
+ *
+ * This class manages middleware execution without requiring generics everywhere.
+ * Once created, you can export dispatch methods that handle both lifecycle and debug events.
+ */
+declare class MiddlewareManager<TInitialPayload = any, TResult = any> {
+    private middlewares;
+    private workflowRunId;
+    private context;
+    /**
+     * @param middlewares list of workflow middlewares
+     */
+    constructor(middlewares?: WorkflowMiddleware<TInitialPayload, TResult>[]);
+    /**
+     * Assign workflow run ID - will be passed to debug events
+     *
+     * @param workflowRunId workflow run id to assign
+     */
+    assignWorkflowRunId(workflowRunId: string): void;
+    /**
+     * Assign context - required for lifecycle events
+     *
+     * also assigns workflowRunId from context
+     *
+     * @param context workflow context to assign
+     */
+    assignContext(context: WorkflowContext<TInitialPayload>): void;
+    /**
+     * Internal method to execute middlewares with common error handling logic
+     *
+     * @param event event name to dispatch
+     * @param params event parameters
+     */
+    private executeMiddlewares;
+    /**
+     * Dispatch a debug event (onError, onWarning, onInfo)
+     *
+     * @param event debug event name
+     * @param params event parameters
+     */
+    dispatchDebug<K extends DebugEvent>(event: K, params: DebugEventParameters[K]): Promise<void>;
+    /**
+     * Dispatch a lifecycle event (beforeExecution, afterExecution, runStarted, runCompleted)
+     *
+     * @param event lifecycle event name
+     * @param params event parameters
+     */
+    dispatchLifecycle<K extends LifeCycleEvent>(event: K, params: LifeCycleEventParameters<TResult>[K]): Promise<void>;
 }
 
 type HeadersResponse = {
@@ -94,7 +187,8 @@ declare abstract class BaseLazyStep<TResult = unknown> {
     readonly stepName: string;
     abstract readonly stepType: StepType;
     protected abstract readonly allowUndefinedOut: boolean;
-    constructor(stepName: string);
+    protected readonly context: WorkflowContext;
+    constructor(context: WorkflowContext, stepName: string);
     /**
      * plan step to submit when step will run parallel with other
      * steps (parallel call state `first`)
@@ -117,11 +211,12 @@ declare abstract class BaseLazyStep<TResult = unknown> {
      *
      * will be called when returning the steps to the context from auto executor
      *
-     * @param out field of the step
+     * @param step step
      * @returns parsed out field
      */
-    parseOut(out: unknown): TResult;
-    protected safeParseOut(out: string): TResult;
+    parseOut(step: Step): TResult;
+    protected safeParseOut(out: string, step: Step): TResult;
+    protected handleUndefinedOut(step: Step): TResult;
     protected static tryParsing(stepOut: unknown): any;
     getBody({ step }: GetBodyParams): string;
     getHeaders({ context, telemetry, invokeCount, step }: GetHeaderParams): HeadersResponse;
@@ -129,21 +224,41 @@ declare abstract class BaseLazyStep<TResult = unknown> {
         messageId: string;
     }[]>;
 }
+type Webhook = {
+    webhookUrl: string;
+    eventId: string;
+};
+type WaitForWebhookResponse = {
+    timeout: false;
+    request: Request;
+} | {
+    timeout: true;
+    request: undefined;
+};
 
 declare class AutoExecutor {
     private context;
     private promises;
     private activeLazyStepList?;
-    private debug?;
     private readonly nonPlanStepCount;
     private readonly steps;
     private indexInCurrentList;
-    private invokeCount;
-    private telemetry?;
+    private readonly invokeCount;
+    private readonly telemetry?;
+    private readonly dispatchDebug;
+    private readonly dispatchLifecycle;
     stepCount: number;
     planStepCount: number;
     protected executingStep: string | false;
-    constructor(context: WorkflowContext, steps: Step[], telemetry?: Telemetry, invokeCount?: number, debug?: WorkflowLogger);
+    /**
+     * @param context workflow context
+     * @param steps list of steps
+     * @param dispatchDebug debug event dispatcher
+     * @param dispatchLifecycle lifecycle event dispatcher
+     * @param telemetry optional telemetry information
+     * @param invokeCount optional invoke count
+     */
+    constructor(context: WorkflowContext, steps: Step[], dispatchDebug: DispatchDebug, dispatchLifecycle: DispatchLifecycle, telemetry?: Telemetry, invokeCount?: number);
     /**
      * Adds the step function to the list of step functions to run in
      * parallel. After adding the function, defers the execution, so
@@ -178,7 +293,7 @@ declare class AutoExecutor {
     /**
      * Executes a step:
      * - If the step result is available in the steps, returns the result
-     * - If the result is not avaiable, runs the function
+     * - If the result is not available, runs the function
      * - Sends the result to QStash
      *
      * @param lazyStep lazy step to execute
@@ -188,8 +303,7 @@ declare class AutoExecutor {
     /**
      * Runs steps in parallel.
      *
-     * @param stepName parallel step name
-     * @param stepFunctions list of async functions to run in parallel
+     * @param parallelSteps list of lazy steps to run in parallel
      * @returns results of the functions run in parallel
      */
     protected runParallel<TResults extends unknown[]>(parallelSteps: {
@@ -275,22 +389,27 @@ type LLMOwner = "upstash" | "openai" | "anthropic" | "custom";
  * copies and updates the request by removing the api field and adding url & headers.
  *
  * @param api api field of PublishRequest
- * @returns updated request
+ * @returns updated request with provider info
  */
 declare const getProviderInfo: (api: Required<PublishRequest>["api"]) => ProviderInfo;
 
-type ApiCallSettings<TBody = unknown, TFields extends object = object> = Omit<CallSettings<TBody>, "url"> & TFields;
+type ApiCallSettings<TBody = unknown, TFields extends object = object> = Omit<CallSettings, "url" | "body"> & {
+    body: TBody;
+} & TFields;
 declare abstract class BaseWorkflowApi {
     protected context: WorkflowContext;
+    /**
+     * @param context workflow context
+     */
     constructor({ context }: {
         context: WorkflowContext;
     });
     /**
      * context.call which uses a QStash API
      *
-     * @param stepName
-     * @param settings
-     * @returns
+     * @param stepName name of the step
+     * @param settings call settings including api configuration
+     * @returns call response
      */
     protected callApi<TResult = unknown, TBody = unknown>(stepName: string, settings: ApiCallSettings<TBody, {
         api: Parameters<typeof getProviderInfo>[0];
@@ -506,25 +625,6 @@ declare class WorkflowContext<TInitialPayload = unknown> {
      * ```
      */
     readonly url: string;
-    /**
-     * URL to call in case of workflow failure with QStash failure callback
-     *
-     * https://upstash.com/docs/qstash/features/callbacks#what-is-a-failure-callback
-     *
-     * Can be overwritten by passing a `failureUrl` parameter in `serve`:
-     *
-     * ```ts
-     * export const POST = serve(
-     *   async (context) => {
-     *     ...
-     *   },
-     *   {
-     *     failureUrl: "new-url-value"
-     *   }
-     * )
-     * ```
-     */
-    readonly failureUrl?: string;
     /**
      * Payload of the request which started the workflow.
      *
@@ -580,46 +680,6 @@ declare class WorkflowContext<TInitialPayload = unknown> {
      * Default value is set to `process.env`.
      */
     readonly env: Record<string, string | undefined>;
-    /**
-     * Number of retries
-     */
-    readonly retries: number;
-    /**
-     * Delay between retries.
-     *
-     * By default, the `retryDelay` is exponential backoff.
-     * More details can be found in: https://upstash.com/docs/qstash/features/retry.
-     *
-     * The `retryDelay` option allows you to customize the delay (in milliseconds) between retry attempts when message delivery fails.
-     *
-     * You can use mathematical expressions and the following built-in functions to calculate the delay dynamically.
-     * The special variable `retried` represents the current retry attempt count (starting from 0).
-     *
-     * Supported functions:
-     * - `pow`
-     * - `sqrt`
-     * - `abs`
-     * - `exp`
-     * - `floor`
-     * - `ceil`
-     * - `round`
-     * - `min`
-     * - `max`
-     *
-     * Examples of valid `retryDelay` values:
-     * ```ts
-     * 1000 // 1 second
-     * 1000 * (1 + retried)  // 1 second multiplied by the current retry attempt
-     * pow(2, retried) // 2 to the power of the current retry attempt
-     * max(10, pow(2, retried)) // The greater of 10 or 2^retried
-     * ```
-     */
-    readonly retryDelay?: string;
-    /**
-     * Settings for controlling the number of active requests
-     * and number of requests per second with the same key.
-     */
-    readonly flowControl?: FlowControl;
     /**
      * Label to apply to the workflow run.
      *
@@ -636,22 +696,18 @@ declare class WorkflowContext<TInitialPayload = unknown> {
      * ```
      */
     readonly label?: string;
-    constructor({ qstashClient, workflowRunId, headers, steps, url, failureUrl, debug, initialPayload, env, retries, retryDelay, telemetry, invokeCount, flowControl, label, }: {
+    constructor({ qstashClient, workflowRunId, headers, steps, url, initialPayload, env, telemetry, invokeCount, label, middlewareManager, }: {
         qstashClient: WorkflowClient;
         workflowRunId: string;
         headers: Headers;
         steps: Step[];
         url: string;
-        failureUrl?: string;
-        debug?: WorkflowLogger;
         initialPayload: TInitialPayload;
         env?: Record<string, string | undefined>;
-        retries?: number;
-        retryDelay?: string;
         telemetry?: Telemetry;
         invokeCount?: number;
-        flowControl?: FlowControl;
         label?: string;
+        middlewareManager?: MiddlewareManager<TInitialPayload>;
     });
     /**
      * Executes a workflow step
@@ -739,7 +795,7 @@ declare class WorkflowContext<TInitialPayload = unknown> {
      *     header: Record<string, string[]>
      *   }
      */
-    call<TResult = unknown, TBody = unknown>(stepName: string, settings: CallSettings<TBody>): Promise<CallResponse<TResult>>;
+    call<TResult = unknown>(stepName: string, settings: CallSettings): Promise<CallResponse<TResult>>;
     call<TResult extends {
         workflowRunId: string;
     } = {
@@ -803,10 +859,12 @@ declare class WorkflowContext<TInitialPayload = unknown> {
      */
     notify(stepName: string, eventId: string, eventData: unknown): Promise<NotifyStepResponse>;
     invoke<TInitialPayload, TResult>(stepName: string, settings: LazyInvokeStepParams<TInitialPayload, TResult>): Promise<InvokeStepResponse<TResult>>;
+    createWebhook(stepName: string): Promise<Webhook>;
+    waitForWebhook(stepName: string, webhook: Webhook, timeout: Duration): Promise<WaitForWebhookResponse>;
     /**
      * Cancel the current workflow run
      *
-     * Will throw WorkflowAbort to stop workflow execution.
+     * Will throw WorkflowCancelAbort to stop workflow execution.
      * Shouldn't be inside try/catch.
      */
     cancel(): Promise<void>;
@@ -838,7 +896,7 @@ type WorkflowClient = {
 type WorkflowReceiver = {
     verify: InstanceType<typeof Receiver>["verify"];
 };
-declare const StepTypes: readonly ["Initial", "Run", "SleepFor", "SleepUntil", "Call", "Wait", "Notify", "Invoke"];
+declare const StepTypes: readonly ["Initial", "Run", "SleepFor", "SleepUntil", "Call", "Wait", "Notify", "Invoke", "CreateWebhook", "WaitForWebhook"];
 type StepType = (typeof StepTypes)[number];
 type ThirdPartyCallFields<TBody = unknown> = {
     /**
@@ -922,9 +980,9 @@ type AsyncStepFunction<TResult> = () => Promise<TResult>;
 type StepFunction<TResult> = AsyncStepFunction<TResult> | SyncStepFunction<TResult>;
 type ParallelCallState = "first" | "partial" | "discard" | "last";
 type RouteFunction<TInitialPayload, TResult = unknown> = (context: WorkflowContext<TInitialPayload>) => Promise<TResult>;
-type FinishCondition = "success" | "duplicate-step" | "fromCallback" | "auth-fail" | "failure-callback" | "workflow-already-ended" | WorkflowNonRetryableError;
+type FinishCondition = "success" | "duplicate-step" | "fromCallback" | "auth-fail" | "failure-callback-executed" | "failure-callback-undefined" | "workflow-already-ended" | WorkflowNonRetryableError;
 type DetailedFinishCondition = {
-    condition: Exclude<FinishCondition, WorkflowNonRetryableError | "failure-callback">;
+    condition: Exclude<FinishCondition, WorkflowNonRetryableError | "failure-callback-executed">;
     result?: never;
 } | {
     condition: "non-retryable-error";
@@ -933,35 +991,26 @@ type DetailedFinishCondition = {
     condition: "retry-after-error";
     result: WorkflowRetryAfterError;
 } | {
-    condition: "failure-callback";
+    condition: "failure-callback-executed";
     result: string | void;
 };
-type WorkflowServeOptions<TResponse extends Response = Response, TInitialPayload = unknown> = ValidationOptions<TInitialPayload> & {
-    /**
-     * QStash client
-     */
-    qstashClient?: WorkflowClient;
+type WorkflowContextWithoutMethods<TInitialPayload> = Omit<WorkflowContext<TInitialPayload>, "run" | "sleepUntil" | "sleep" | "call" | "waitForEvent" | "notify" | "cancel" | "api" | "invoke" | "createWebhook" | "waitForWebhook">;
+type QStashClientExtraConfig = Omit<NonNullable<ConstructorParameters<typeof Client>[0]>, "baseUrl" | "token">;
+type WorkflowServeOptions<TInitialPayload = unknown, TResult = unknown> = {
     /**
-     * Function called to return a response after each step execution
+     * QStash client or client configuration
      *
-     * @param workflowRunId
-     * @returns response
+     * Can be either:
+     * - A WorkflowClient instance
+     * - Client configuration options (omitting baseUrl and token, which will be read from env vars)
      */
-    onStepFinish?: (workflowRunId: string, finishCondition: FinishCondition, detailedFinishCondition?: DetailedFinishCondition) => TResponse;
+    qstashClient?: WorkflowClient | QStashClientExtraConfig;
     /**
      * Url of the endpoint where the workflow is set up.
      *
      * If not set, url will be inferred from the request.
      */
     url?: string;
-    /**
-     * Verbose mode
-     *
-     * Disabled if not set. If set to true, a logger is created automatically.
-     *
-     * Alternatively, a WorkflowLogger can be passed.
-     */
-    verbose?: WorkflowLogger | true;
     /**
      * Receiver to verify *all* requests by checking if they come from QStash
      *
@@ -969,21 +1018,9 @@ type WorkflowServeOptions<TResponse extends Response = Response, TInitialPayload
      * QSTASH_CURRENT_SIGNING_KEY and QSTASH_NEXT_SIGNING_KEY if they are set.
      */
     receiver?: WorkflowReceiver;
-    /**
-     * Url to call if QStash retries are exhausted while executing the workflow
-     */
-    failureUrl?: string;
-    /**
-     * Error handler called when an error occurs in the workflow. This is
-     * different from `failureFunction` in that it is called when an error
-     * occurs in the workflow, while `failureFunction` is called when QStash
-     * retries are exhausted.
-     */
-    onError?: (error: Error) => void;
     /**
      * Failure function called when QStash retries are exhausted while executing
-     * the workflow. Will overwrite `failureUrl` parameter with the workflow
-     * endpoint if passed.
+     * the workflow.
      *
      * @param context workflow context at the moment of error
      * @param failStatus error status
@@ -991,7 +1028,7 @@ type WorkflowServeOptions<TResponse extends Response = Response, TInitialPayload
      * @returns void
      */
     failureFunction?: (failureData: {
-        context: Omit<WorkflowContext<TInitialPayload>, "run" | "sleepUntil" | "sleep" | "call" | "waitForEvent" | "notify" | "cancel" | "api" | "invoke">;
+        context: WorkflowContextWithoutMethods<TInitialPayload>;
         failStatus: number;
         failResponse: string;
         failHeaders: Record<string, string[]>;
@@ -1017,50 +1054,6 @@ type WorkflowServeOptions<TResponse extends Response = Response, TInitialPayload
      * Useful in cases like cloudflare with hono.
      */
     env?: Record<string, string | undefined>;
-    /**
-     * Number of retries to use in workflow requests
-     *
-     * @default 3
-     */
-    retries?: number;
-    /**
-     * Delay between retries.
-     *
-     * By default, the `retryDelay` is exponential backoff.
-     * More details can be found in: https://upstash.com/docs/qstash/features/retry.
-     *
-     * The `retryDelay` option allows you to customize the delay (in milliseconds) between retry attempts when message delivery fails.
-     *
-     * You can use mathematical expressions and the following built-in functions to calculate the delay dynamically.
-     * The special variable `retried` represents the current retry attempt count (starting from 0).
-     *
-     * Supported functions:
-     * - `pow`
-     * - `sqrt`
-     * - `abs`
-     * - `exp`
-     * - `floor`
-     * - `ceil`
-     * - `round`
-     * - `min`
-     * - `max`
-     *
-     * Examples of valid `retryDelay` values:
-     * ```ts
-     * 1000 // 1 second
-     * 1000 * (1 + retried)  // 1 second multiplied by the current retry attempt
-     * pow(2, retried) // 2 to the power of the current retry attempt
-     * max(10, pow(2, retried)) // The greater of 10 or 2^retried
-     * ```
-     */
-    retryDelay?: string;
-    /**
-     * Whether the framework should use `content-type: application/json`
-     * in `triggerFirstInvocation`.
-     *
-     * Not part of the public API. Only available in serveBase, which is not exported.
-     */
-    useJSONContent?: boolean;
     /**
      * By default, Workflow SDK sends telemetry about SDK version, framework or runtime.
      *
@@ -1070,11 +1063,14 @@ type WorkflowServeOptions<TResponse extends Response = Response, TInitialPayload
      */
     disableTelemetry?: boolean;
     /**
-     * Settings for controlling the number of active requests
-     * and number of requests per second with the same key.
+     * List of workflow middlewares to use
      */
-    flowControl?: FlowControl;
-} & ValidationOptions<TInitialPayload>;
+    middlewares?: WorkflowMiddleware<TInitialPayload, TResult>[];
+    /**
+     * Whether to enable verbose logging for debugging purposes
+     */
+    verbose?: boolean;
+} & ExclusiveValidationOptions<TInitialPayload>;
 type ValidationOptions<TInitialPayload> = {
     schema?: z.ZodType<TInitialPayload>;
     initialPayloadParser?: (initialPayload: string) => TInitialPayload;
@@ -1100,7 +1096,6 @@ type Telemetry = {
      */
     runtime?: string;
 };
-type PublicServeOptions<TInitialPayload = unknown, TResponse extends Response = Response> = Omit<WorkflowServeOptions<TResponse, TInitialPayload>, "onStepFinish" | "useJSONContent" | "schema" | "initialPayloadParser"> & ExclusiveValidationOptions<TInitialPayload>;
 /**
  * Payload passed as body in failureFunction
  */
@@ -1190,29 +1185,15 @@ interface WaitEventOptions {
      */
     timeout?: number | Duration;
 }
-type StringifyBody<TBody = unknown> = TBody extends string ? boolean : true;
-type CallSettings<TBody = unknown> = {
+type CallSettings = {
     url: string;
     method?: HTTPMethods$1;
-    /**
-     * Request body.
-     *
-     * By default, the body is stringified with `JSON.stringify`. If you want
-     * to send a string body without stringifying it, you need to set
-     * `stringifyBody` to false.
-     */
-    body?: TBody;
+    body?: string;
     headers?: Record<string, string>;
     retries?: number;
     retryDelay?: string;
     timeout?: Duration | number;
     flowControl?: FlowControl;
-    /**
-     * Whether the body field should be stringified when making the request.
-     *
-     * @default true
-     */
-    stringifyBody?: StringifyBody<TBody>;
 };
 type HeaderParams = {
     /**
@@ -1231,18 +1212,6 @@ type HeaderParams = {
      * user headers which will be forwarded in the request
      */
     userHeaders?: Headers;
-    /**
-     * failure url to call incase of failure
-     */
-    failureUrl?: WorkflowServeOptions["failureUrl"];
-    /**
-     * retry setting of requests except context.call
-     */
-    retries?: number;
-    /**
-     * retry delay to include in headers.
-     */
-    retryDelay?: string;
     /**
      * telemetry to include in timeoutHeaders.
      *
@@ -1253,11 +1222,6 @@ type HeaderParams = {
      * invoke count to include in headers
      */
     invokeCount?: number;
-    /**
-     * Settings for controlling the number of active requests
-     * and number of requests per second with the same key.
-     */
-    flowControl?: FlowControl;
 } & ({
     /**
      * step to generate headers for
@@ -1319,13 +1283,16 @@ type InvokeWorkflowRequest = {
     workflowRunId: string;
     headers: Record<string, string[]>;
     step: Step;
-    body: string;
+    body?: string;
 };
 type LazyInvokeStepParams<TInitiaPayload, TResult> = {
-    workflow: Pick<InvokableWorkflow<TInitiaPayload, TResult>, "routeFunction" | "workflowId" | "options">;
-    body: TInitiaPayload;
+    workflow: InvokableWorkflow<TInitiaPayload, TResult>;
     workflowRunId?: string;
-} & Pick<CallSettings<TInitiaPayload>, "retries" | "headers" | "flowControl" | "retryDelay" | "stringifyBody">;
+} & Pick<CallSettings, "retries" | "headers" | "flowControl" | "retryDelay"> & (TInitiaPayload extends undefined ? {
+    body?: undefined;
+} : {
+    body: TInitiaPayload;
+});
 type InvokeStepResponse<TBody> = {
     body: TBody;
     isCanceled?: boolean;
@@ -1333,8 +1300,14 @@ type InvokeStepResponse<TBody> = {
 };
 type InvokableWorkflow<TInitialPayload, TResult> = {
     routeFunction: RouteFunction<TInitialPayload, TResult>;
-    options: WorkflowServeOptions<Response, TInitialPayload>;
+    options: WorkflowServeOptions<TInitialPayload, TResult>;
     workflowId?: string;
+    /**
+     * whether the invoked workflow should use JSON content type for initial trigger
+     *
+     * this is set by platform createWorkflow helpers and is not part of public serve options
+     */
+    useJSONContent?: boolean;
 };
 
-export { type AsyncStepFunction as A, type WorkflowLoggerOptions as B, type CallResponse as C, type DetailedFinishCondition as D, type ExclusiveValidationOptions as E, type FinishCondition as F, WorkflowLogger as G, type HeaderParams as H, type InvokeWorkflowRequest as I, type LazyInvokeStepParams as L, type NotifyResponse as N, type ParallelCallState as P, type RouteFunction as R, type StepType as S, type Telemetry as T, type WorkflowServeOptions as W, type RawStep as a, type Waiter as b, WorkflowError as c, WorkflowAbort as d, WorkflowNonRetryableError as e, WorkflowRetryAfterError as f, WorkflowContext as g, type WorkflowClient as h, type WorkflowReceiver as i, StepTypes as j, type Step as k, type SyncStepFunction as l, type StepFunction as m, type PublicServeOptions as n, type FailureFunctionPayload as o, type RequiredExceptFields as p, type WaitRequest as q, type WaitStepResponse as r, type NotifyStepResponse as s, type Duration as t, type WaitEventOptions as u, type StringifyBody as v, type CallSettings as w, type InvokeStepResponse as x, type InvokableWorkflow as y, type LogLevel as z };
+export { type AsyncStepFunction as A, type CallResponse as C, type DetailedFinishCondition as D, type ExclusiveValidationOptions as E, type FinishCondition as F, type HeaderParams as H, type InvokeWorkflowRequest as I, type LazyInvokeStepParams as L, type NotifyResponse as N, type ParallelCallState as P, type QStashClientExtraConfig as Q, type RawStep as R, type StepType as S, type Telemetry as T, WorkflowMiddleware as W, type WorkflowClient as a, type WorkflowReceiver as b, type RouteFunction as c, type WorkflowServeOptions as d, type Waiter as e, WorkflowError as f, WorkflowAbort as g, WorkflowNonRetryableError as h, WorkflowRetryAfterError as i, WorkflowContext as j, StepTypes as k, type Step as l, type SyncStepFunction as m, type StepFunction as n, type FailureFunctionPayload as o, type RequiredExceptFields as p, type WaitRequest as q, type WaitStepResponse as r, type NotifyStepResponse as s, type Duration as t, type WaitEventOptions as u, type CallSettings as v, type InvokeStepResponse as w, type InvokableWorkflow as x };