@upstash/workflow 0.2.2 → 0.2.4

package/{types-APRap-aV.d.mts → types-Bt4-paRy.d.mts}

@@ -1,4 +1,4 @@
-import { HTTPMethods, Client, Receiver } from '@upstash/qstash';
+import { PublishRequest, Client, Receiver, HTTPMethods as HTTPMethods$1 } from '@upstash/qstash';
 
 /**
  * Base class outlining steps. Basically, each step kind (run/sleep/sleepUntil)
@@ -63,10 +63,11 @@ declare class AutoExecutor {
     private readonly nonPlanStepCount;
     private readonly steps;
     private indexInCurrentList;
+    private telemetry?;
     stepCount: number;
     planStepCount: number;
     protected executingStep: string | false;
-    constructor(context: WorkflowContext, steps: Step[], debug?: WorkflowLogger);
+    constructor(context: WorkflowContext, steps: Step[], telemetry?: Telemetry, debug?: WorkflowLogger);
     /**
      * Adds the step function to the list of step functions to run in
      * parallel. After adding the function, defers the execution, so
@@ -162,6 +163,230 @@ declare class AutoExecutor {
     private deferExecution;
 }
 
+type HTTPMethods = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+
+type ProviderInfo = {
+    /**
+     * full url used for request
+     */
+    url: string;
+    /**
+     * base url of the request
+     */
+    baseUrl: string;
+    /**
+     * route elements which will follow the baseUrl
+     */
+    route: string[];
+    /**
+     * headers to include in the request
+     */
+    appendHeaders: Record<string, string>;
+    /**
+     * provider owner
+     */
+    owner: Owner;
+    /**
+     * method to use in the request
+     */
+    method: HTTPMethods;
+};
+type Owner = EmailOwner | LLMOwner;
+/**
+ * Email
+ */
+type EmailOwner = "resend";
+/**
+ * LLM
+ */
+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
+ */
+declare const getProviderInfo: (api: Required<PublishRequest>["api"]) => ProviderInfo;
+
+type ApiCallSettings<TBody = unknown, TFields extends object = object> = Omit<CallSettings<TBody>, "url"> & TFields;
+declare abstract class BaseWorkflowApi {
+    protected context: WorkflowContext;
+    constructor({ context }: {
+        context: WorkflowContext;
+    });
+    /**
+     * context.call which uses a QStash API
+     *
+     * @param stepName
+     * @param settings
+     * @returns
+     */
+    protected callApi<TResult = unknown, TBody = unknown>(stepName: string, settings: ApiCallSettings<TBody, {
+        api: Parameters<typeof getProviderInfo>[0];
+    }>): Promise<CallResponse<TResult>>;
+}
+
+type CreateChatCompletion$1 = {
+    model: string;
+    messages: {
+        role: "user" | "assistant";
+        content: unknown;
+    }[];
+    max_tokens: number;
+    metadata?: object;
+    stop_sequences?: string[];
+    /**
+     * streaming is not possible Upstash Workflow.
+     */
+    stream?: false;
+    system?: string;
+    temparature?: number;
+    top_k?: number;
+    top_p?: number;
+};
+type ChatCompletion$1 = {
+    id: string;
+    type: "message";
+    role: "assistant";
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    model: string;
+    stop_reasong: string;
+    stop_sequence: string[];
+    usage: unknown;
+};
+declare class AnthropicAPI extends BaseWorkflowApi {
+    call<TResult = ChatCompletion$1, TBody = CreateChatCompletion$1>(stepName: string, settings: ApiCallSettings<TBody, {
+        token: string;
+        operation: "messages.create";
+    }>): Promise<CallResponse<TResult>>;
+}
+
+type Messages = {
+    content: string;
+    role: "developer" | "system";
+    name?: string;
+} | {
+    content: unknown;
+    role: "user";
+    name?: string;
+} | {
+    content: unknown;
+    refusal?: string;
+    role: "assistant";
+    name?: string;
+    audio?: unknown;
+    tool_calls?: unknown;
+} | {
+    role: "tool";
+    content: string | unknown;
+    tool_call_id: string;
+} | {
+    role: "function";
+    content: string | undefined;
+    name: string;
+};
+type CreateChatCompletion = {
+    messages: Messages[];
+    model: string;
+    store?: boolean;
+    reasoning_effort?: string;
+    metadata?: unknown;
+    frequency_penalty?: number;
+    logit_bias?: Record<string, number>;
+    logprobs?: boolean;
+    top_logprobs?: number;
+    max_completion_tokens?: number;
+    n?: number;
+    modalities?: string[];
+    prediction?: unknown;
+    audio?: unknown;
+    presence_penalty?: number;
+    response_format?: unknown;
+    seed?: number;
+    service_tier?: string;
+    stop?: string | string[];
+    /**
+     * streaming is not supported in Upstash Workflow.
+     */
+    stream?: false;
+    temperature?: number;
+    top_p?: number;
+    tools?: unknown;
+    tool_choice?: string;
+    parallel_tool_calls?: boolean;
+    user?: string;
+};
+type ChatCompletion = {
+    id: string;
+    choices: ChatCompletionChoice[];
+    created: number;
+    model: string;
+    object: "chat.completion";
+    service_tier?: "scale" | "default" | null;
+    system_fingerprint?: string;
+    usage?: unknown;
+};
+type ChatCompletionChoice = {
+    finish_reason: "stop" | "length" | "tool_calls" | "content_filter" | "function_call";
+    index: number;
+    logprobs: unknown;
+    message: {
+        content: string | null;
+        refusal: string | null;
+        role: "assistant";
+        audio?: unknown;
+        tool_calls?: unknown;
+    };
+};
+declare class OpenAIAPI extends BaseWorkflowApi {
+    call<TResult = ChatCompletion, TBody = CreateChatCompletion>(stepName: string, settings: ApiCallSettings<TBody, {
+        token: string;
+        organization?: string;
+        operation: "chat.completions.create";
+    }>): Promise<CallResponse<TResult>>;
+}
+
+type SendEmail = {
+    from: string;
+    to: string;
+    subject: string;
+    bcc?: string | string[];
+    cc?: string | string[];
+    scheduled_at?: string;
+    reply_to?: string | string[];
+    html?: string;
+    text?: string;
+    headers: unknown;
+    attachments: unknown;
+    tags: {
+        name: string;
+        value: string;
+    }[];
+};
+type SendEmailResponse = {
+    id: string;
+};
+type SendBatchEmail = SendEmail[];
+type SendBatchEmailResponse = {
+    data: SendEmailResponse[];
+};
+declare class ResendAPI extends BaseWorkflowApi {
+    call<TBatch extends boolean = false, TResult = TBatch extends true ? SendBatchEmailResponse : SendEmailResponse, TBody = TBatch extends true ? SendBatchEmail : SendEmail>(stepName: string, settings: ApiCallSettings<TBody, {
+        token: string;
+        batch?: TBatch;
+    }>): Promise<CallResponse<TResult>>;
+}
+
+declare class WorkflowApi extends BaseWorkflowApi {
+    get openai(): OpenAIAPI;
+    get resend(): ResendAPI;
+    get anthropic(): AnthropicAPI;
+}
+
 /**
  * Upstash Workflow context
  *
@@ -288,7 +513,7 @@ declare class WorkflowContext<TInitialPayload = unknown> {
      * Number of retries
      */
     readonly retries: number;
-    constructor({ qstashClient, workflowRunId, headers, steps, url, failureUrl, debug, initialPayload, env, retries, }: {
+    constructor({ qstashClient, workflowRunId, headers, steps, url, failureUrl, debug, initialPayload, env, retries, telemetry, }: {
         qstashClient: WorkflowClient;
         workflowRunId: string;
         headers: Headers;
@@ -299,6 +524,7 @@ declare class WorkflowContext<TInitialPayload = unknown> {
         initialPayload: TInitialPayload;
         env?: Record<string, string | undefined>;
         retries?: number;
+        telemetry?: Telemetry;
     });
     /**
      * Executes a workflow step
@@ -385,14 +611,7 @@ declare class WorkflowContext<TInitialPayload = unknown> {
      *     header: Record<string, string[]>
      *   }
      */
-    call<TResult = unknown>(stepName: string, settings: {
-        url: string;
-        method?: HTTPMethods;
-        body?: unknown;
-        headers?: Record<string, string>;
-        retries?: number;
-        timeout?: Duration | number;
-    }): Promise<CallResponse<TResult>>;
+    call<TResult = unknown, TBody = unknown>(stepName: string, settings: CallSettings<TBody>): Promise<CallResponse<TResult>>;
     /**
      * Pauses workflow execution until a specific event occurs or a timeout is reached.
      *
@@ -462,6 +681,7 @@ declare class WorkflowContext<TInitialPayload = unknown> {
      * DisabledWorkflowContext.
      */
     protected addStep<TResult = unknown>(step: BaseLazyStep<TResult>): Promise<TResult>;
+    get api(): WorkflowApi;
 }
 
 /**
@@ -493,7 +713,7 @@ type ThirdPartyCallFields<TBody = unknown> = {
     /**
      * Third party call method. Set when context.call is used.
      */
-    callMethod: HTTPMethods;
+    callMethod: HTTPMethods$1;
     /**
      * Third party call body. Set when context.call is used.
      */
@@ -620,7 +840,7 @@ type WorkflowServeOptions<TResponse extends Response = Response, TInitialPayload
      * @returns void
      */
     failureFunction?: (failureData: {
-        context: Omit<WorkflowContext<TInitialPayload>, "run" | "sleepUntil" | "sleep" | "call" | "waitForEvent" | "notify">;
+        context: Omit<WorkflowContext<TInitialPayload>, "run" | "sleepUntil" | "sleep" | "call" | "waitForEvent" | "notify" | "cancel" | "api">;
         failStatus: number;
         failResponse: string;
         failHeaders: Record<string, string[]>;
@@ -658,6 +878,26 @@ type WorkflowServeOptions<TResponse extends Response = Response, TInitialPayload
      * 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.
+     *
+     * Set `disableTelemetry` to disable this behavior.
+     */
+    disableTelemetry?: boolean;
+};
+type Telemetry = {
+    /**
+     * sdk version
+     */
+    sdk: string;
+    /**
+     * platform (such as nextjs/cloudflare)
+     */
+    framework: string;
+    /**
+     * node version
+     */
+    runtime?: string;
 };
 type PublicServeOptions<TInitialPayload = unknown, TResponse extends Response = Response> = Omit<WorkflowServeOptions<TResponse, TInitialPayload>, "onStepFinish" | "useJSONContent">;
 /**
@@ -745,5 +985,76 @@ interface WaitEventOptions {
      */
     timeout?: number | Duration;
 }
+type CallSettings<TBody = unknown> = {
+    url: string;
+    method?: HTTPMethods$1;
+    body?: TBody;
+    headers?: Record<string, string>;
+    retries?: number;
+    timeout?: Duration | number;
+};
+type HeaderParams = {
+    /**
+     * whether the request is a first invocation request.
+     */
+    initHeaderValue: "true" | "false";
+    /**
+     * run id of the workflow
+     */
+    workflowRunId: string;
+    /**
+     * url where the workflow is hosted
+     */
+    workflowUrl: string;
+    /**
+     * 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;
+    /**
+     * telemetry to include in timeoutHeaders.
+     *
+     * Only needed/used when the step is a waitForEvent step
+     */
+    telemetry?: Telemetry;
+} & ({
+    /**
+     * step to generate headers for
+     */
+    step: Step;
+    /**
+     * number of retries in context.call
+     */
+    callRetries?: number;
+    /**
+     * timeout duration in context.call
+     */
+    callTimeout?: number | Duration;
+} | {
+    /**
+     * step not passed. Either first invocation or simply getting headers for
+     * third party callack.
+     */
+    step?: never;
+    /**
+     * number of retries in context.call
+     *
+     * set to never because this is not a context.call step
+     */
+    callRetries?: never;
+    /**
+     * timeout duration in context.call
+     *
+     * set to never because this is not a context.call step
+     */
+    callTimeout?: never;
+});
 
-export { type AsyncStepFunction as A, type CallResponse as C, type Duration as D, type FinishCondition as F, type LogLevel as L, type NotifyResponse as N, type ParallelCallState as P, type RouteFunction as R, type Step as S, type WorkflowServeOptions as W, type Waiter as a, WorkflowContext as b, type WorkflowClient as c, type WorkflowReceiver as d, StepTypes as e, type StepType as f, type RawStep as g, type SyncStepFunction as h, type StepFunction as i, type PublicServeOptions as j, type FailureFunctionPayload as k, type RequiredExceptFields as l, type WaitRequest as m, type WaitStepResponse as n, type NotifyStepResponse as o, type WaitEventOptions as p, type WorkflowLoggerOptions as q, WorkflowLogger as r };
+export { type AsyncStepFunction as A, type CallResponse as C, type Duration as D, type FinishCondition as F, type HeaderParams as H, type LogLevel as L, type NotifyResponse as N, type ParallelCallState as P, type RouteFunction as R, type Step as S, type Telemetry as T, type WorkflowServeOptions as W, type Waiter as a, WorkflowContext as b, type WorkflowClient as c, type WorkflowReceiver as d, StepTypes as e, type StepType as f, type RawStep as g, type SyncStepFunction as h, type StepFunction as i, type PublicServeOptions as j, type FailureFunctionPayload as k, type RequiredExceptFields as l, type WaitRequest as m, type WaitStepResponse as n, type NotifyStepResponse as o, type WaitEventOptions as p, type CallSettings as q, type WorkflowLoggerOptions as r, WorkflowLogger as s };