@upstash/workflow 0.2.14 → 0.2.16

package/index.d.ts

@@ -1,6 +1,6 @@
-import { R as RouteFunction, W as WorkflowServeOptions, E as ExclusiveValidationOptions, T as Telemetry, S as StepType, a as RawStep, N as NotifyResponse, b as Waiter, c as Step } from './types-C1WIgVLA.js';
-export { A as AsyncStepFunction, C as CallResponse, r as CallSettings, D as Duration, l as FailureFunctionPayload, F as FinishCondition, H as HeaderParams, t as InvokableWorkflow, s as InvokeStepResponse, I as InvokeWorkflowRequest, L as LazyInvokeStepParams, u as LogLevel, p as NotifyStepResponse, P as ParallelCallState, k as PublicServeOptions, m as RequiredExceptFields, j as StepFunction, h as StepTypes, i as SyncStepFunction, q as WaitEventOptions, n as WaitRequest, o as WaitStepResponse, f as WorkflowClient, e as WorkflowContext, w as WorkflowLogger, v as WorkflowLoggerOptions, g as WorkflowReceiver, d as WorkflowTool } from './types-C1WIgVLA.js';
-import { FlowControl, PublishRequest, HTTPMethods, State, Client as Client$1, QstashError } from '@upstash/qstash';
+import { R as RouteFunction, W as WorkflowServeOptions, E as ExclusiveValidationOptions, T as Telemetry, S as StepType, a as RawStep, N as NotifyResponse, b as Waiter } from './types-Dd-3bPoU.js';
+export { A as AsyncStepFunction, C as CallResponse, u as CallSettings, D as Duration, o as FailureFunctionPayload, F as FinishCondition, H as HeaderParams, w as InvokableWorkflow, v as InvokeStepResponse, I as InvokeWorkflowRequest, L as LazyInvokeStepParams, x as LogLevel, s as NotifyStepResponse, P as ParallelCallState, n as PublicServeOptions, p as RequiredExceptFields, k as Step, m as StepFunction, j as StepTypes, l as SyncStepFunction, t as WaitEventOptions, q as WaitRequest, r as WaitStepResponse, d as WorkflowAbort, h as WorkflowClient, g as WorkflowContext, c as WorkflowError, z as WorkflowLogger, y as WorkflowLoggerOptions, e as WorkflowNonRetryableError, i as WorkflowReceiver, f as WorkflowTool } from './types-Dd-3bPoU.js';
+import { FlowControl, PublishRequest, HTTPMethods, State, Client as Client$1 } from '@upstash/qstash';
 import 'zod';
 import 'ai';
 import '@ai-sdk/openai';
@@ -60,6 +60,10 @@ type BaseStepLog = {
      * will be undefined for an unfinished parallel step.
      */
     out: unknown;
+    /**
+     * number of retries for the step
+     */
+    retries: number;
     /**
      * number of parallel steps
      *
@@ -78,10 +82,6 @@ type BaseStepLog = {
      * headers
      */
     headers: Record<string, string[]>;
-    /**
-     * retries
-     */
-    retries: number;
 };
 type CallUrlGroup = {
     /**
@@ -368,6 +368,156 @@ type TriggerOptions = {
      */
     useFailureFunction?: never;
 });
+type DLQResumeRestartOptions<TDLQId extends string | string[] = string | string[]> = {
+    dlqId: TDLQId;
+} & Pick<TriggerOptions, "flowControl" | "retries">;
+type DLQResumeRestartResponse = {
+    /**
+     * id of the workflow run created to resume or restart the DLQ message
+     */
+    workflowRunId: string;
+    /**
+     * Time when the new workflow run was created
+     */
+    workflowCreatedAt: string;
+};
+
+type QStashDLQFilterOptions = NonNullable<Required<Parameters<Client$1["dlq"]["listMessages"]>[0]>>["filter"];
+type DLQFilterOptions = Pick<QStashDLQFilterOptions, "fromDate" | "toDate" | "url" | "responseStatus">;
+type DLQMessage = {
+    messageId: string;
+    url: string;
+    method: string;
+    header: Record<string, string[]>;
+    body: string;
+    maxRetries: number;
+    notBefore: number;
+    createdAt: number;
+    callerIP: string;
+    workflowRunId: string;
+    workflowCreatedAt: number;
+    workflowUrl: string;
+    responseStatus: number;
+    responseHeader: Record<string, string[]>;
+    responseBody: string;
+    dlqId: string;
+};
+type PublicDLQMessage = Pick<DLQMessage, "header" | "body" | "maxRetries" | "notBefore" | "createdAt" | "callerIP" | "workflowRunId" | "workflowCreatedAt" | "workflowUrl" | "responseStatus" | "responseHeader" | "responseBody" | "dlqId">;
+declare class DLQ {
+    private client;
+    constructor(client: Client$1);
+    /**
+     * list the items in the DLQ
+     *
+     * @param cursor - Optional cursor for pagination.
+     * @param count - Optional number of items to return.
+     * @param filter - Optional filter options to apply to the DLQ items.
+     *    The available filter options are:
+     *    - `fromDate`: Filter items which entered the DLQ after this date.
+     *    - `toDate`: Filter items which entered the DLQ before this date.
+     *    - `url`: Filter items by the URL they were sent to.
+     *    - `responseStatus`: Filter items by the response status code.
+     * @returns
+     */
+    list(parameters?: {
+        cursor?: string;
+        count?: number;
+        filter?: DLQFilterOptions;
+    }): Promise<{
+        messages: PublicDLQMessage[];
+        cursor?: string;
+    }>;
+    /**
+     * Resumes the workflow run for the given DLQ message(s).
+     *
+     * Resuming means that the new workflow run will start executing from where
+     * the original workflow run failed, using the same input and context.
+     *
+     * If you want to restart the workflow run from the beginning, use
+     * `restart` method instead.
+     *
+     * Example with a single DLQ ID:
+     * ```ts
+     * const response = await client.dlq.resume({
+     *   dlqId: "dlq-12345",
+     *   flowControl: {
+     *     key: "my-flow-control-key",
+     *     value: "my-flow-control-value",
+     *   },
+     *   retries: 3,
+     * });
+     *
+     * console.log(response.workflowRunId); // ID of the new workflow run
+     * ```
+     *
+     * Example with multiple DLQ IDs:
+     * ```ts
+     * const response = await client.dlq.resume({
+     *  dlqId: ["dlq-12345", "dlq-67890"],
+     *  // other parameters...
+     * });
+     * console.log(response[0].workflowRunId); // ID of the first workflow run
+     * console.log(response[1].workflowRunId); // ID of the second workflow run
+     * ```
+     *
+     * if the dlqId is not found, throws an error.
+     *
+     * @param dlqId - The ID(s) of the DLQ message(s) to resume.
+     * @param flowControl - Optional flow control parameters. If not passed, flow
+     *     control of the failing workflow will be used
+     * @param retries - Optional number of retries to perform if the request fails.
+     *     If not passed, retries settings of the failing workflow will be used.
+     * @returns run id and creation time of the new workflow run(s).
+     */
+    resume(parameters: DLQResumeRestartOptions<string>): Promise<DLQResumeRestartResponse>;
+    resume(parameters: DLQResumeRestartOptions<string[]>): Promise<DLQResumeRestartResponse[]>;
+    /**
+     * Restarts the workflow run for the given DLQ message(s).
+     *
+     * Restarting means that the new workflow run will start executing from the
+     * beginning with the same initial payload and configuration.
+     *
+     * If you want to resume the workflow run from where it failed, use
+     * `resume` method instead.
+     *
+     * Example with a single DLQ ID:
+     * ```ts
+     * const response = await client.dlq.restart({
+     *   dlqId: "dlq-12345",
+     *   flowControl: {
+     *     key: "my-flow-control-key",
+     *     value: "my-flow-control-value",
+     *   },
+     *   retries: 3,
+     * });
+     *
+     * console.log(response.workflowRunId); // ID of the new workflow run
+     * ```
+     *
+     * Example with multiple DLQ IDs:
+     * ```ts
+     * const response = await client.dlq.restart({
+     *  dlqId: ["dlq-12345", "dlq-67890"],
+     *  // other parameters...
+     * });
+     * console.log(response[0].workflowRunId); // ID of the first workflow run
+     * console.log(response[1].workflowRunId); // ID of the second workflow run
+     * ```
+     *
+     * if the dlqId is not found, throws an error.
+     *
+     * @param dlqId - The ID(s) of the DLQ message(s) to restart.
+     * @param flowControl - Optional flow control parameters. If not passed, flow
+     *     control of the failing workflow will be used
+     * @param retries - Optional number of retries to perform if the request fails.
+     *     If not passed, retries settings of the failing workflow will be used.
+     * @returns run id and creation time of the new workflow run(s).
+     */
+    restart(parameters: DLQResumeRestartOptions<string>): Promise<DLQResumeRestartResponse>;
+    restart(parameters: DLQResumeRestartOptions<string[]>): Promise<DLQResumeRestartResponse[]>;
+    private static handleDLQOptions;
+    private static getDlqIdQueryParameter;
+}
 
 type ClientConfig = ConstructorParameters<typeof Client$1>[0];
 /**
@@ -579,32 +729,7 @@ declare class Client {
         workflowUrl?: WorkflowRunLog["workflowUrl"];
         workflowCreatedAt?: WorkflowRunLog["workflowRunCreatedAt"];
     }): Promise<WorkflowRunLogs>;
+    get dlq(): DLQ;
 }
 
-/**
- * Error raised during Workflow execution
- */
-declare class WorkflowError extends QstashError {
-    constructor(message: string);
-}
-/**
- * Raised when the workflow executes a function successfully
- * and aborts to end the execution
- */
-declare class WorkflowAbort extends Error {
-    stepInfo?: Step;
-    stepName: string;
-    /**
-     * 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);
-}
-
-export { Client, ExclusiveValidationOptions, NotifyResponse, RawStep, RouteFunction, Step, type StepLog, StepType, Telemetry, type TriggerOptions, Waiter, WorkflowAbort, WorkflowError, type WorkflowRunLog, type WorkflowRunLogs, WorkflowServeOptions, serve };
+export { Client, type DLQResumeRestartOptions, type DLQResumeRestartResponse, ExclusiveValidationOptions, NotifyResponse, RawStep, RouteFunction, type StepLog, StepType, Telemetry, type TriggerOptions, Waiter, type WorkflowRunLog, type WorkflowRunLogs, WorkflowServeOptions, serve };

package/index.js

@@ -26,6 +26,7 @@ __export(src_exports, {
   WorkflowContext: () => WorkflowContext,
   WorkflowError: () => WorkflowError,
   WorkflowLogger: () => WorkflowLogger,
+  WorkflowNonRetryableError: () => WorkflowNonRetryableError,
   WorkflowTool: () => WorkflowTool,
   serve: () => serve
 });
@@ -103,7 +104,7 @@ var WORKFLOW_PROTOCOL_VERSION_HEADER = "Upstash-Workflow-Sdk-Version";
 var DEFAULT_CONTENT_TYPE = "application/json";
 var NO_CONCURRENCY = 1;
 var DEFAULT_RETRIES = 3;
-var VERSION = "v0.2.14";
+var VERSION = "v0.2.15";
 var SDK_TELEMETRY = `@upstash/workflow@${VERSION}`;
 var TELEMETRY_HEADER_SDK = "Upstash-Telemetry-Sdk";
 var TELEMETRY_HEADER_FRAMEWORK = "Upstash-Telemetry-Framework";
@@ -141,6 +142,16 @@ var WorkflowAbort = class extends Error {
     this.cancelWorkflow = cancelWorkflow;
   }
 };
+var WorkflowNonRetryableError = class extends WorkflowAbort {
+  /**
+   * @param message error message to be displayed
+   */
+  constructor(message) {
+    super("fail", void 0, false);
+    this.name = "WorkflowNonRetryableError";
+    if (message) this.message = message;
+  }
+};
 var formatWorkflowError = (error) => {
   return error instanceof Error ? {
     error: error.name,
@@ -705,6 +716,8 @@ var triggerRouteFunction = async ({
       return ok("workflow-was-finished");
     } else if (!(error_ instanceof WorkflowAbort)) {
       return err(error_);
+    } else if (error_ instanceof WorkflowNonRetryableError) {
+      return ok(error_);
     } else if (error_.cancelWorkflow) {
       await onCancel();
       return ok("workflow-finished");
@@ -866,7 +879,7 @@ ${atob(callbackMessage.body ?? "")}`
 var getTelemetryHeaders = (telemetry) => {
   return {
     [TELEMETRY_HEADER_SDK]: telemetry.sdk,
-    [TELEMETRY_HEADER_FRAMEWORK]: telemetry.framework,
+    [TELEMETRY_HEADER_FRAMEWORK]: telemetry.framework ?? "unknown",
     [TELEMETRY_HEADER_RUNTIME]: telemetry.runtime ?? "unknown"
   };
 };
@@ -2948,10 +2961,10 @@ var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowCon
     throw new WorkflowAbort(_DisabledWorkflowContext.disabledMessage);
   }
   /**
-   * overwrite cancel method to do nothing
+   * overwrite cancel method to throw WorkflowAbort with the disabledMessage
    */
   async cancel() {
-    return;
+    throw new WorkflowAbort(_DisabledWorkflowContext.disabledMessage);
   }
   /**
    * copies the passed context to create a DisabledWorkflowContext. Then, runs the
@@ -2983,7 +2996,7 @@ var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowCon
     try {
       await routeFunction(disabledContext);
     } catch (error) {
-      if (error instanceof WorkflowAbort && error.stepName === this.disabledMessage) {
+      if (error instanceof WorkflowAbort && error.stepName === this.disabledMessage || error instanceof WorkflowNonRetryableError) {
         return ok("step-found");
       }
       return err(error);
@@ -3141,7 +3154,17 @@ var handleFailure = async (request, requestPayload, qstashClient, initialPayload
   try {
     const { status, header, body, url, sourceBody, workflowRunId } = JSON.parse(requestPayload);
     const decodedBody = body ? decodeBase64(body) : "{}";
-    const errorPayload = JSON.parse(decodedBody);
+    let errorMessage = "";
+    try {
+      const errorPayload = JSON.parse(decodedBody);
+      if (errorPayload.message) {
+        errorMessage = errorPayload.message;
+      }
+    } catch {
+    }
+    if (!errorMessage) {
+      errorMessage = `Couldn't parse 'failResponse' in 'failureFunction', received: '${decodedBody}'`;
+    }
     const workflowContext = new WorkflowContext({
       qstashClient,
       workflowRunId,
@@ -3170,7 +3193,7 @@ var handleFailure = async (request, requestPayload, qstashClient, initialPayload
     await failureFunction({
       context: workflowContext,
       failStatus: status,
-      failResponse: errorPayload.message,
+      failResponse: errorMessage,
       failHeaders: header
     });
   } catch (error) {
@@ -3204,6 +3227,13 @@ var processOptions = (options) => {
             status: 400
           }
         );
+      } else if (finishCondition instanceof WorkflowNonRetryableError) {
+        return new Response(JSON.stringify(formatWorkflowError(finishCondition)), {
+          headers: {
+            "Upstash-NonRetryable-Error": "true"
+          },
+          status: 489
+        });
       }
       return new Response(JSON.stringify({ workflowRunId }), {
         status: 200
@@ -3396,6 +3426,9 @@ var serveBase = (routeFunction, telemetry, options) => {
         },
         debug
       });
+      if (result.isOk() && result.value instanceof WorkflowNonRetryableError) {
+        return onStepFinish(workflowRunId, result.value);
+      }
       if (result.isErr()) {
         await debug?.log("ERROR", "ERROR", { error: result.error.message });
         throw result.error;
@@ -3444,6 +3477,86 @@ var serve = (routeFunction, options) => {
 
 // src/client/index.ts
 var import_qstash12 = require("@upstash/qstash");
+
+// src/client/dlq.ts
+var DLQ = class _DLQ {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * list the items in the DLQ
+   *
+   * @param cursor - Optional cursor for pagination.
+   * @param count - Optional number of items to return.
+   * @param filter - Optional filter options to apply to the DLQ items.
+   *    The available filter options are:
+   *    - `fromDate`: Filter items which entered the DLQ after this date.
+   *    - `toDate`: Filter items which entered the DLQ before this date.
+   *    - `url`: Filter items by the URL they were sent to.
+   *    - `responseStatus`: Filter items by the response status code.
+   * @returns
+   */
+  async list(parameters) {
+    const { cursor, count, filter } = parameters || {};
+    return await this.client.http.request({
+      path: ["v2", "dlq"],
+      method: "GET",
+      query: {
+        cursor,
+        count,
+        ...filter,
+        source: "workflow"
+      }
+    });
+  }
+  async resume(parameters) {
+    const { headers, queryParams } = _DLQ.handleDLQOptions(parameters);
+    const { workflowRuns } = await this.client.http.request({
+      path: ["v2", "workflows", "dlq", `resume?${queryParams}`],
+      headers,
+      method: "POST"
+    });
+    if (Array.isArray(parameters.dlqId)) {
+      return workflowRuns;
+    }
+    return workflowRuns[0];
+  }
+  async restart(parameters) {
+    const { headers, queryParams } = _DLQ.handleDLQOptions(parameters);
+    const { workflowRuns } = await this.client.http.request({
+      path: ["v2", "workflows", "dlq", `restart?${queryParams}`],
+      headers,
+      method: "POST"
+    });
+    if (Array.isArray(parameters.dlqId)) {
+      return workflowRuns;
+    }
+    return workflowRuns[0];
+  }
+  static handleDLQOptions(options) {
+    const { dlqId, flowControl, retries } = options;
+    const headers = {};
+    if (flowControl) {
+      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
+      headers["Upstash-Flow-Control-Key"] = flowControlKey;
+      headers["Upstash-Flow-Control-Value"] = flowControlValue;
+    }
+    if (retries !== void 0) {
+      headers["Upstash-Retries"] = retries.toString();
+    }
+    return {
+      queryParams: _DLQ.getDlqIdQueryParameter(dlqId),
+      headers
+    };
+  }
+  static getDlqIdQueryParameter(dlqId) {
+    const dlqIds = Array.isArray(dlqId) ? dlqId : [dlqId];
+    const paramsArray = dlqIds.map((id) => ["dlqIds", id]);
+    return new URLSearchParams(paramsArray).toString();
+  }
+};
+
+// src/client/index.ts
 var Client4 = class {
   client;
   constructor(clientConfig) {
@@ -3585,15 +3698,13 @@ var Client4 = class {
         url: option.url,
         workflowRunId: finalWorkflowRunId,
         retries: option.retries,
-        telemetry: void 0,
-        // can't know workflow telemetry here
+        telemetry: { sdk: SDK_TELEMETRY },
         flowControl: option.flowControl,
         failureUrl
       });
       return {
         workflowContext: context,
-        telemetry: void 0,
-        // can't know workflow telemetry here
+        telemetry: { sdk: SDK_TELEMETRY },
         delay: option.delay
       };
     });
@@ -3660,6 +3771,9 @@ var Client4 = class {
     });
     return result;
   }
+  get dlq() {
+    return new DLQ(this.client);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -3669,6 +3783,7 @@ var Client4 = class {
   WorkflowContext,
   WorkflowError,
   WorkflowLogger,
+  WorkflowNonRetryableError,
   WorkflowTool,
   serve
 });

package/index.mjs

@@ -1,19 +1,102 @@
 import {
+  SDK_TELEMETRY,
   StepTypes,
   WorkflowAbort,
   WorkflowContext,
   WorkflowError,
   WorkflowLogger,
+  WorkflowNonRetryableError,
   WorkflowTool,
   getWorkflowRunId,
   makeGetWaitersRequest,
   makeNotifyRequest,
+  prepareFlowControl,
   serve,
   triggerFirstInvocation
-} from "./chunk-RMS2NQ3K.mjs";
+} from "./chunk-TGEGSOSN.mjs";
 
 // src/client/index.ts
 import { Client as QStashClient } from "@upstash/qstash";
+
+// src/client/dlq.ts
+var DLQ = class _DLQ {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * list the items in the DLQ
+   *
+   * @param cursor - Optional cursor for pagination.
+   * @param count - Optional number of items to return.
+   * @param filter - Optional filter options to apply to the DLQ items.
+   *    The available filter options are:
+   *    - `fromDate`: Filter items which entered the DLQ after this date.
+   *    - `toDate`: Filter items which entered the DLQ before this date.
+   *    - `url`: Filter items by the URL they were sent to.
+   *    - `responseStatus`: Filter items by the response status code.
+   * @returns
+   */
+  async list(parameters) {
+    const { cursor, count, filter } = parameters || {};
+    return await this.client.http.request({
+      path: ["v2", "dlq"],
+      method: "GET",
+      query: {
+        cursor,
+        count,
+        ...filter,
+        source: "workflow"
+      }
+    });
+  }
+  async resume(parameters) {
+    const { headers, queryParams } = _DLQ.handleDLQOptions(parameters);
+    const { workflowRuns } = await this.client.http.request({
+      path: ["v2", "workflows", "dlq", `resume?${queryParams}`],
+      headers,
+      method: "POST"
+    });
+    if (Array.isArray(parameters.dlqId)) {
+      return workflowRuns;
+    }
+    return workflowRuns[0];
+  }
+  async restart(parameters) {
+    const { headers, queryParams } = _DLQ.handleDLQOptions(parameters);
+    const { workflowRuns } = await this.client.http.request({
+      path: ["v2", "workflows", "dlq", `restart?${queryParams}`],
+      headers,
+      method: "POST"
+    });
+    if (Array.isArray(parameters.dlqId)) {
+      return workflowRuns;
+    }
+    return workflowRuns[0];
+  }
+  static handleDLQOptions(options) {
+    const { dlqId, flowControl, retries } = options;
+    const headers = {};
+    if (flowControl) {
+      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
+      headers["Upstash-Flow-Control-Key"] = flowControlKey;
+      headers["Upstash-Flow-Control-Value"] = flowControlValue;
+    }
+    if (retries !== void 0) {
+      headers["Upstash-Retries"] = retries.toString();
+    }
+    return {
+      queryParams: _DLQ.getDlqIdQueryParameter(dlqId),
+      headers
+    };
+  }
+  static getDlqIdQueryParameter(dlqId) {
+    const dlqIds = Array.isArray(dlqId) ? dlqId : [dlqId];
+    const paramsArray = dlqIds.map((id) => ["dlqIds", id]);
+    return new URLSearchParams(paramsArray).toString();
+  }
+};
+
+// src/client/index.ts
 var Client = class {
   client;
   constructor(clientConfig) {
@@ -155,15 +238,13 @@ var Client = class {
         url: option.url,
         workflowRunId: finalWorkflowRunId,
         retries: option.retries,
-        telemetry: void 0,
-        // can't know workflow telemetry here
+        telemetry: { sdk: SDK_TELEMETRY },
         flowControl: option.flowControl,
         failureUrl
       });
       return {
         workflowContext: context,
-        telemetry: void 0,
-        // can't know workflow telemetry here
+        telemetry: { sdk: SDK_TELEMETRY },
         delay: option.delay
       };
     });
@@ -230,6 +311,9 @@ var Client = class {
     });
     return result;
   }
+  get dlq() {
+    return new DLQ(this.client);
+  }
 };
 export {
   Client,
@@ -238,6 +322,7 @@ export {
   WorkflowContext,
   WorkflowError,
   WorkflowLogger,
+  WorkflowNonRetryableError,
   WorkflowTool,
   serve
 };

package/nextjs.d.mts

@@ -1,6 +1,6 @@
 import { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
-import { R as RouteFunction, k as PublicServeOptions, t as InvokableWorkflow } from './types-C1WIgVLA.mjs';
-import { s as serveManyBase } from './serve-many-BF71QZHQ.mjs';
+import { R as RouteFunction, n as PublicServeOptions, w as InvokableWorkflow } from './types-Dd-3bPoU.mjs';
+import { s as serveManyBase } from './serve-many-AFwJPR3S.mjs';
 import '@upstash/qstash';
 import 'zod';
 import 'ai';

package/nextjs.d.ts

@@ -1,6 +1,6 @@
 import { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
-import { R as RouteFunction, k as PublicServeOptions, t as InvokableWorkflow } from './types-C1WIgVLA.js';
-import { s as serveManyBase } from './serve-many-BMlN2PAB.js';
+import { R as RouteFunction, n as PublicServeOptions, w as InvokableWorkflow } from './types-Dd-3bPoU.js';
+import { s as serveManyBase } from './serve-many-AaKSQyi7.js';
 import '@upstash/qstash';
 import 'zod';
 import 'ai';