@upstash/qstash 2.7.14 → 2.7.15

package/{chunk-2OTIVTGG.mjs → chunk-LSYJT55T.mjs}

@@ -1,7 +1,7 @@
 import {
   Receiver,
   serve
-} from "./chunk-Q2AGFQYM.mjs";
+} from "./chunk-Y52A3KZT.mjs";
 
 // node_modules/defu/dist/defu.mjs
 function isPlainObject(value) {

package/chunk-X4MWA7DF.mjs

@@ -0,0 +1,34 @@
+import {
+  BaseProvider
+} from "./chunk-Y52A3KZT.mjs";
+
+// src/client/api/email.ts
+var EmailProvider = class extends BaseProvider {
+  apiKind = "email";
+  batch;
+  constructor(baseUrl, token, owner, batch) {
+    super(baseUrl, token, owner);
+    this.batch = batch;
+  }
+  getRoute() {
+    return this.batch ? ["emails", "batch"] : ["emails"];
+  }
+  getHeaders(_options) {
+    return {
+      "upstash-forward-authorization": `Bearer ${this.token}`
+    };
+  }
+  onFinish(providerInfo, _options) {
+    return providerInfo;
+  }
+};
+var resend = ({
+  token,
+  batch = false
+}) => {
+  return new EmailProvider("https://api.resend.com", token, "resend", batch);
+};
+
+export {
+  resend
+};

package/{chunk-Q2AGFQYM.mjs → chunk-Y52A3KZT.mjs}

@@ -58,14 +58,6 @@ var Receiver = class {
   }
 };
 
-// src/client/api/utils.ts
-var appendAPIOptions = (request, headers) => {
-  if (request.api?.name === "email") {
-    headers.set("Authorization", request.api.provider.token);
-    request.method = request.method ?? "POST";
-  }
-};
-
 // src/client/dlq.ts
 var DLQ = class {
   http;
@@ -213,7 +205,7 @@ var HttpClient = class {
       attempts: 1,
       backoff: () => 0
     } : {
-      attempts: config.retry?.retries ? config.retry.retries + 1 : 5,
+      attempts: config.retry?.retries ?? 5,
       backoff: config.retry?.backoff ?? ((retryCount) => Math.exp(retryCount) * 50)
     };
   }
@@ -258,13 +250,15 @@ var HttpClient = class {
     const [url, requestOptions] = this.processRequest(request);
     let response = void 0;
     let error = void 0;
-    for (let index = 0; index < this.retry.attempts; index++) {
+    for (let index = 0; index <= this.retry.attempts; index++) {
       try {
         response = await fetch(url.toString(), requestOptions);
         break;
       } catch (error_) {
         error = error_;
-        await new Promise((r) => setTimeout(r, this.retry.backoff(index)));
+        if (index < this.retry.attempts) {
+          await new Promise((r) => setTimeout(r, this.retry.backoff(index)));
+        }
       }
     }
     if (!response) {
@@ -361,37 +355,6 @@ var setupAnalytics = (analytics, providerApiKey, providerBaseUrl, provider) => {
     }
   }
 };
-var upstash = () => {
-  return {
-    owner: "upstash",
-    baseUrl: "https://qstash.upstash.io/llm",
-    token: "",
-    organization: void 0
-  };
-};
-var openai = ({
-  token,
-  organization
-}) => {
-  return {
-    token,
-    owner: "openai",
-    baseUrl: "https://api.openai.com",
-    organization
-  };
-};
-var custom = ({
-  baseUrl,
-  token
-}) => {
-  const trimmedBaseUrl = baseUrl.replace(/\/(v1\/)?chat\/completions$/, "");
-  return {
-    token,
-    owner: "custom",
-    baseUrl: trimmedBaseUrl,
-    organization: void 0
-  };
-};
 
 // src/client/llm/chat.ts
 var Chat = class _Chat {
@@ -467,7 +430,6 @@ var Chat = class _Chat {
    * @param request ChatRequest with messages
    * @returns Chat completion or stream
    */
-  // eslint-disable-next-line @typescript-eslint/require-await
   createThirdParty = async (request) => {
     const { baseUrl, token, owner, organization } = request.provider;
     if (owner === "upstash")
@@ -528,63 +490,6 @@ var Chat = class _Chat {
   };
 };
 
-// src/client/llm/utils.ts
-function appendLLMOptionsIfNeeded(request, headers, http) {
-  if (request.api?.name === "email" || !request.api)
-    return;
-  const provider = request.api.provider;
-  const analytics = request.api.analytics;
-  if (provider?.owner === "upstash") {
-    handleUpstashProvider(request, headers, http, analytics);
-    return;
-  }
-  if (!("provider" in request.api))
-    return;
-  const { baseUrl, token } = validateProviderConfig(provider);
-  const analyticsConfig = analytics ? setupAnalytics({ name: analytics.name, token: analytics.token }, token, baseUrl, "custom") : void 0;
-  if (analyticsConfig) {
-    setAnalyticsHeaders(headers, analyticsConfig);
-    request.url = analyticsConfig.baseURL;
-  } else {
-    request.url = `${baseUrl}/v1/chat/completions`;
-    headers.set("Authorization", `Bearer ${token}`);
-  }
-}
-function handleUpstashProvider(request, headers, http, analytics) {
-  if (analytics) {
-    const analyticsConfig = setupAnalytics(
-      { name: analytics.name, token: analytics.token },
-      //@ts-expect-error hacky way to get bearer token
-      String(http.authorization).split("Bearer ")[1],
-      request.api?.provider?.baseUrl,
-      "upstash"
-    );
-    setAnalyticsHeaders(headers, analyticsConfig);
-    request.url = analyticsConfig.baseURL;
-  } else {
-    request.api = { name: "llm" };
-  }
-}
-function validateProviderConfig(provider) {
-  if (!provider?.baseUrl)
-    throw new Error("baseUrl cannot be empty or undefined!");
-  if (!provider.token)
-    throw new Error("token cannot be empty or undefined!");
-  return { baseUrl: provider.baseUrl, token: provider.token };
-}
-function setAnalyticsHeaders(headers, analyticsConfig) {
-  headers.set("Helicone-Auth", analyticsConfig.defaultHeaders?.["Helicone-Auth"] ?? "");
-  headers.set("Authorization", analyticsConfig.defaultHeaders?.Authorization ?? "");
-  if (analyticsConfig.defaultHeaders?.["Helicone-Target-Url"]) {
-    headers.set("Helicone-Target-Url", analyticsConfig.defaultHeaders["Helicone-Target-Url"]);
-  }
-}
-function ensureCallbackPresent(request) {
-  if (request.api?.name === "llm" && !request.callback) {
-    throw new TypeError("Callback cannot be undefined when using LLM");
-  }
-}
-
 // src/client/messages.ts
 var Messages = class {
   http;
@@ -633,6 +538,160 @@ var Messages = class {
   }
 };
 
+// src/client/api/base.ts
+var BaseProvider = class {
+  baseUrl;
+  token;
+  owner;
+  constructor(baseUrl, token, owner) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+    this.owner = owner;
+  }
+  getUrl() {
+    return `${this.baseUrl}/${this.getRoute().join("/")}`;
+  }
+};
+
+// src/client/api/llm.ts
+var LLMProvider = class extends BaseProvider {
+  apiKind = "llm";
+  organization;
+  constructor(baseUrl, token, owner, organization) {
+    super(baseUrl, token, owner);
+    this.organization = organization;
+  }
+  getRoute() {
+    return this.owner === "anthropic" ? ["v1", "messages"] : ["v1", "chat", "completions"];
+  }
+  getHeaders(options) {
+    if (this.owner === "upstash" && !options.analytics) {
+      return {};
+    }
+    const header = this.owner === "anthropic" ? "x-api-key" : "authorization";
+    const headerValue = this.owner === "anthropic" ? this.token : `Bearer ${this.token}`;
+    const headers = { [header]: headerValue };
+    if (this.owner === "openai" && this.organization) {
+      headers["OpenAI-Organization"] = this.organization;
+    }
+    return headers;
+  }
+  /**
+   * Checks if callback exists and adds analytics in place if it's set.
+   *
+   * @param request
+   * @param options
+   */
+  onFinish(providerInfo, options) {
+    if (options.analytics) {
+      return updateWithAnalytics(providerInfo, options.analytics);
+    }
+    return providerInfo;
+  }
+};
+var upstash = () => {
+  return new LLMProvider("https://qstash.upstash.io/llm", "", "upstash");
+};
+var openai = ({
+  token,
+  organization
+}) => {
+  return new LLMProvider("https://api.openai.com", token, "openai", organization);
+};
+var anthropic = ({ token }) => {
+  return new LLMProvider("https://api.anthropic.com", token, "anthropic");
+};
+var custom = ({
+  baseUrl,
+  token
+}) => {
+  const trimmedBaseUrl = baseUrl.replace(/\/(v1\/)?chat\/completions$/, "");
+  return new LLMProvider(trimmedBaseUrl, token, "custom");
+};
+
+// src/client/api/utils.ts
+var getProviderInfo = (api, upstashToken) => {
+  const { name, provider, ...parameters } = api;
+  const finalProvider = provider ?? upstash();
+  if (finalProvider.owner === "upstash" && !finalProvider.token) {
+    finalProvider.token = upstashToken;
+  }
+  if (!finalProvider.baseUrl)
+    throw new TypeError("baseUrl cannot be empty or undefined!");
+  if (!finalProvider.token)
+    throw new TypeError("token cannot be empty or undefined!");
+  if (finalProvider.apiKind !== name) {
+    throw new TypeError(
+      `Unexpected api name. Expected '${finalProvider.apiKind}', received ${name}`
+    );
+  }
+  const providerInfo = {
+    url: finalProvider.getUrl(),
+    baseUrl: finalProvider.baseUrl,
+    route: finalProvider.getRoute(),
+    appendHeaders: finalProvider.getHeaders(parameters),
+    owner: finalProvider.owner
+  };
+  return finalProvider.onFinish(providerInfo, parameters);
+};
+var processApi = (request, upstashToken) => {
+  if (!request.api) {
+    return request;
+  }
+  const { url, appendHeaders, owner } = getProviderInfo(request.api, upstashToken);
+  if (request.api.name === "llm") {
+    const callback = request.callback;
+    if (!callback) {
+      throw new TypeError("Callback cannot be undefined when using LLM api.");
+    }
+    return {
+      ...request,
+      // @ts-expect-error undici header conflict
+      headers: new Headers({
+        ...request.headers,
+        ...appendHeaders
+      }),
+      ...owner === "upstash" && !request.api.analytics ? { api: { name: "llm" }, url: void 0, callback } : { url, api: void 0 }
+    };
+  } else {
+    return {
+      ...request,
+      // @ts-expect-error undici header conflict
+      headers: new Headers({
+        ...request.headers,
+        ...appendHeaders
+      }),
+      url,
+      api: void 0
+    };
+  }
+};
+function updateWithAnalytics(providerInfo, analytics) {
+  switch (analytics.name) {
+    case "helicone": {
+      providerInfo.appendHeaders["Helicone-Auth"] = `Bearer ${analytics.token}`;
+      if (providerInfo.owner === "upstash") {
+        updateProviderInfo(providerInfo, "https://qstash.helicone.ai", [
+          "llm",
+          ...providerInfo.route
+        ]);
+      } else {
+        providerInfo.appendHeaders["Helicone-Target-Url"] = providerInfo.baseUrl;
+        updateProviderInfo(providerInfo, "https://gateway.helicone.ai", providerInfo.route);
+      }
+      return providerInfo;
+    }
+    default: {
+      throw new Error("Unknown analytics provider");
+    }
+  }
+}
+function updateProviderInfo(providerInfo, baseUrl, route) {
+  providerInfo.baseUrl = baseUrl;
+  providerInfo.route = route;
+  providerInfo.url = `${baseUrl}/${route.join("/")}`;
+}
+
 // src/client/utils.ts
 var isIgnoredHeader = (header) => {
   const lowerCaseHeader = header.toLowerCase();
@@ -665,7 +724,7 @@ function processHeaders(request) {
   if (request.deduplicationId !== void 0) {
     headers.set("Upstash-Deduplication-Id", request.deduplicationId);
   }
-  if (request.contentBasedDeduplication !== void 0) {
+  if (request.contentBasedDeduplication) {
     headers.set("Upstash-Content-Based-Deduplication", "true");
   }
   if (request.retries !== void 0) {
@@ -691,9 +750,10 @@ function getRequestPath(request) {
   if (nonApiPath)
     return nonApiPath;
   if (request.api?.name === "llm")
-    return `api/${request.api.name}`;
+    return `api/llm`;
   if (request.api?.name === "email") {
-    return request.api.provider.baseUrl;
+    const providerInfo = getProviderInfo(request.api, "not-needed");
+    return providerInfo.baseUrl;
   }
   throw new QstashError(`Failed to infer request path for ${JSON.stringify(request)}`);
 }
@@ -810,12 +870,12 @@ var Queue = class {
   async enqueueJSON(request) {
     const headers = prefixHeaders(new Headers(request.headers));
     headers.set("Content-Type", "application/json");
-    ensureCallbackPresent(request);
-    appendLLMOptionsIfNeeded(request, headers, this.http);
-    appendAPIOptions(request, headers);
+    request.headers = headers;
+    const upstashToken = String(this.http.authorization).split("Bearer ")[1];
+    const nonApiRequest = processApi(request, upstashToken);
     const response = await this.enqueue({
-      ...request,
-      body: JSON.stringify(request.body),
+      ...nonApiRequest,
+      body: JSON.stringify(nonApiRequest.body),
       headers
     });
     return response;
@@ -1113,13 +1173,12 @@ var Client = class {
   async publishJSON(request) {
     const headers = prefixHeaders(new Headers(request.headers));
     headers.set("Content-Type", "application/json");
-    ensureCallbackPresent(request);
-    appendLLMOptionsIfNeeded(request, headers, this.http);
-    appendAPIOptions(request, headers);
+    request.headers = headers;
+    const upstashToken = String(this.http.authorization).split("Bearer ")[1];
+    const nonApiRequest = processApi(request, upstashToken);
     const response = await this.publish({
-      ...request,
-      headers,
-      body: JSON.stringify(request.body)
+      ...nonApiRequest,
+      body: JSON.stringify(nonApiRequest.body)
     });
     return response;
   }
@@ -1153,17 +1212,17 @@ var Client = class {
    * Batch publish messages to QStash, serializing each body to JSON.
    */
   async batchJSON(request) {
-    for (const message of request) {
+    const batchPayload = request.map((message) => {
       if ("body" in message) {
         message.body = JSON.stringify(message.body);
       }
       message.headers = new Headers(message.headers);
-      ensureCallbackPresent(message);
-      appendLLMOptionsIfNeeded(message, message.headers, this.http);
-      appendAPIOptions(message, message.headers);
-      message.headers.set("Content-Type", "application/json");
-    }
-    const response = await this.batch(request);
+      const upstashToken = String(this.http.authorization).split("Bearer ")[1];
+      const nonApiMessage = processApi(message, upstashToken);
+      nonApiMessage.headers.set("Content-Type", "application/json");
+      return nonApiMessage;
+    });
+    const response = await this.batch(batchPayload);
     return response;
   }
   /**
@@ -2616,11 +2675,13 @@ export {
   QStashWorkflowAbort,
   formatWorkflowError,
   setupAnalytics,
+  Chat,
+  Messages,
+  BaseProvider,
   upstash,
   openai,
+  anthropic,
   custom,
-  Chat,
-  Messages,
   decodeBase64,
   Schedules,
   UrlGroups,

package/{client-kxUsvnWj.d.ts → client-RORrka04.d.mts}

@@ -62,16 +62,6 @@ declare class Receiver {
     private verifyBodyAndUrl;
 }
 
-type EmailProviderReturnType = {
-    owner: "resend";
-    baseUrl: "https://api.resend.com/emails" | "https://api.resend.com/emails/batch";
-    token: string;
-};
-declare const resend: ({ token, batch, }: {
-    token: string;
-    batch?: boolean;
-}) => EmailProviderReturnType;
-
 type State = "CREATED" | "ACTIVE" | "DELIVERED" | "ERROR" | "RETRY" | "FAILED";
 type HTTPMethods = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
 type Event = {
@@ -116,31 +106,94 @@ type RateLimit = {
     reset: string | null;
 };
 
-type Owner = "upstash" | "openai" | "custom";
-type ProviderReturnType<TOwner extends Owner = Owner, TBaseUrl extends string = string, TToken extends string = string, TOrganization extends string | undefined = string | undefined> = {
-    owner: TOwner;
-    baseUrl: TBaseUrl;
-    token: TToken;
-    organization: TOrganization;
+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;
 };
-type AnalyticsConfig = {
-    name: "helicone";
-    token: string;
+type ApiKind = "llm" | "email";
+type Owner = EmailOwner | LLMOwner;
+type PublishApi<TName extends ApiKind, TProvider extends BaseProvider<TName>> = {
+    name: TName;
+    provider?: TProvider;
 };
-type AnalyticsSetup = {
-    baseURL?: string;
-    defaultHeaders?: Record<string, string | undefined>;
+/**
+ * Email
+ */
+type EmailOwner = "resend";
+type PublishEmailApi = Required<PublishApi<"email", BaseProvider<"email", EmailOwner>>>;
+/**
+ * LLM
+ */
+type LLMOwner = "upstash" | "openai" | "anthropic" | "custom";
+type LLMOptions = {
+    analytics?: {
+        name: "helicone";
+        token: string;
+    };
 };
-declare const setupAnalytics: (analytics: AnalyticsConfig | undefined, providerApiKey: string, providerBaseUrl?: string, provider?: "openai" | "upstash" | "custom") => AnalyticsSetup;
-declare const upstash: () => ProviderReturnType<"upstash", "https://qstash.upstash.io/llm", "">;
-declare const openai: <TToken extends string = string, TOrganization extends string | undefined = undefined>({ token, organization, }: {
-    token: TToken;
-    organization?: TOrganization;
-}) => ProviderReturnType<"openai", "https://api.openai.com", TToken, TOrganization extends string ? TOrganization : undefined>;
-declare const custom: <TToken extends string = string>({ baseUrl, token, }: {
+type PublishLLMApi = PublishApi<"llm", BaseProvider<"llm", LLMOwner>> & LLMOptions;
+
+declare abstract class BaseProvider<TName extends ApiKind, TOwner = Owner> {
+    abstract readonly apiKind: TName;
+    readonly baseUrl: string;
+    token: string;
+    readonly owner: TOwner;
+    constructor(baseUrl: string, token: string, owner: TOwner);
+    /**
+     * called before returning the final request
+     *
+     * @param request
+     */
+    abstract onFinish(request: ProviderInfo, options: unknown): ProviderInfo;
+    abstract getRoute(): string[];
+    abstract getHeaders(options: unknown): Record<string, string>;
+    getUrl(): string;
+}
+
+declare class LLMProvider<TOwner extends LLMOwner> extends BaseProvider<"llm", LLMOwner> {
+    readonly apiKind = "llm";
+    readonly organization?: string;
+    constructor(baseUrl: string, token: string, owner: TOwner, organization?: string);
+    getRoute(): string[];
+    getHeaders(options: LLMOptions): Record<string, string>;
+    /**
+     * Checks if callback exists and adds analytics in place if it's set.
+     *
+     * @param request
+     * @param options
+     */
+    onFinish(providerInfo: ProviderInfo, options: LLMOptions): ProviderInfo;
+}
+declare const upstash: () => LLMProvider<"upstash">;
+declare const openai: ({ token, organization, }: {
+    token: string;
+    organization?: string;
+}) => LLMProvider<"openai">;
+declare const anthropic: ({ token }: {
+    token: string;
+}) => LLMProvider<"anthropic">;
+declare const custom: ({ baseUrl, token, }: {
     baseUrl: string;
-    token: TToken;
-}) => ProviderReturnType<"custom", string, TToken>;
+    token: string;
+}) => LLMProvider<"custom">;
 
 type ChatCompletionMessage = {
     role: "system" | "assistant" | "user";
@@ -229,21 +282,21 @@ type ChatRequestFields = ChatRequestCommonFields & {
     messages: ChatCompletionMessage[];
 };
 type ChatRequestProviders = {
-    provider: ProviderReturnType<"openai">;
+    provider: LLMProvider<"openai">;
     model: OpenAIChatModel;
     analytics?: {
         name: "helicone";
         token: string;
     };
 } | {
-    provider: ProviderReturnType<"custom">;
+    provider: LLMProvider<"custom">;
     model: string;
     analytics?: {
         name: "helicone";
         token: string;
     };
 } | {
-    provider: ProviderReturnType<"upstash">;
+    provider: LLMProvider<"upstash">;
     model: ChatModel;
     analytics?: {
         name: "helicone";
@@ -282,6 +335,11 @@ type UpstashRequest = {
      * @default true
      */
     parseResponseAsJson?: boolean;
+    /**
+     * optionally overwrite the baseUrl of the http.
+     *
+     * default value of the http is base qstash url.
+     */
     baseUrl?: string;
 };
 type UpstashResponse<TResult> = TResult & {
@@ -1633,14 +1691,7 @@ type PublishRequest<TBody = BodyInit> = {
     /**
      * The api endpoint the request should be sent to.
      */
-    api: {
-        name: "llm";
-        provider?: ProviderReturnType;
-        analytics?: {
-            name: "helicone";
-            token: string;
-        };
-    };
+    api: PublishLLMApi;
     topic?: never;
     /**
      * Use a callback url to forward the response of your destination server to your callback url.
@@ -1656,10 +1707,7 @@ type PublishRequest<TBody = BodyInit> = {
     /**
      * The api endpoint the request should be sent to.
      */
-    api: {
-        name: "email";
-        provider: EmailProviderReturnType;
-    };
+    api: PublishEmailApi;
     topic?: never;
     callback?: string;
 } | {
@@ -1815,4 +1863,4 @@ type PublishResponse<TRequest> = TRequest extends {
     urlGroup: string;
 } ? PublishToUrlGroupsResponse : PublishToApiResponse;
 
-export { type AnalyticsConfig as $, type AddEndpointsRequest as A, type BodyInit as B, type ChatRateLimit as C, type ChatCompletion as D, type EventsRequest as E, type FailureFunctionPayload as F, type GetEventsResponse as G, type HTTPMethods as H, type ChatCompletionChunk as I, type StreamEnabled as J, type StreamDisabled as K, type StreamParameter as L, type Message as M, type PromptChatRequest as N, type OpenAIChatModel as O, type PublishBatchRequest as P, type QueueRequest as Q, type RateLimit as R, type Step as S, type ChatRequest as T, type UrlGroup as U, type VerifyRequest as V, type WithCursor as W, custom as X, openai as Y, upstash as Z, type ProviderReturnType as _, type ReceiverConfig as a, type AnalyticsSetup as a0, setupAnalytics as a1, resend as a2, type RouteFunction as a3, type WorkflowServeOptions as a4, Workflow as a5, processOptions as a6, serve as a7, WorkflowContext as a8, DisabledWorkflowContext as a9, type WorkflowClient as aa, type WorkflowReceiver as ab, StepTypes as ac, type StepType as ad, type RawStep as ae, type SyncStepFunction as af, type AsyncStepFunction as ag, type StepFunction as ah, type ParallelCallState as ai, type FinishCondition as aj, type RequiredExceptFields as ak, type LogLevel as al, type WorkflowLoggerOptions as am, WorkflowLogger as an, SignatureError as b, Receiver as c, type PublishRequest as d, type PublishJsonRequest as e, Client as f, type PublishToApiResponse as g, type PublishToUrlResponse as h, type PublishToUrlGroupsResponse as i, type PublishResponse as j, type MessagePayload as k, Messages as l, type Schedule as m, type CreateScheduleRequest as n, Schedules as o, type Endpoint as p, type RemoveEndpointsRequest as q, UrlGroups as r, type State as s, type Event as t, type EventPayload as u, type GetEventsPayload as v, type HeadersInit as w, type RequestOptions as x, Chat as y, type ChatCompletionMessage as z };
+export { upstash as $, type AddEndpointsRequest as A, BaseProvider as B, type ChatRateLimit as C, type RequestOptions as D, type EmailOwner as E, type FailureFunctionPayload as F, type GetEventsResponse as G, type HTTPMethods as H, Chat as I, type ChatCompletionMessage as J, type ChatCompletion as K, type LLMOwner as L, type Message as M, type ChatCompletionChunk as N, type StreamEnabled as O, type ProviderInfo as P, type QueueRequest as Q, type RateLimit as R, type Step as S, type StreamDisabled as T, type UrlGroup as U, type VerifyRequest as V, type WithCursor as W, type StreamParameter as X, type OpenAIChatModel as Y, type PromptChatRequest as Z, type ChatRequest as _, type ReceiverConfig as a, openai as a0, anthropic as a1, custom as a2, type RouteFunction as a3, type WorkflowServeOptions as a4, Workflow as a5, processOptions as a6, serve as a7, WorkflowContext as a8, DisabledWorkflowContext as a9, type WorkflowClient as aa, type WorkflowReceiver as ab, StepTypes as ac, type StepType as ad, type RawStep as ae, type SyncStepFunction as af, type AsyncStepFunction as ag, type StepFunction as ah, type ParallelCallState as ai, type FinishCondition as aj, type RequiredExceptFields as ak, type LogLevel as al, type WorkflowLoggerOptions as am, WorkflowLogger as an, SignatureError as b, Receiver as c, type PublishBatchRequest as d, type PublishRequest as e, type PublishJsonRequest as f, type EventsRequest as g, Client as h, type PublishToApiResponse as i, type PublishToUrlResponse as j, type PublishToUrlGroupsResponse as k, type PublishResponse as l, type MessagePayload as m, Messages as n, type Schedule as o, type CreateScheduleRequest as p, Schedules as q, type Endpoint as r, type RemoveEndpointsRequest as s, UrlGroups as t, type State as u, type Event as v, type EventPayload as w, type GetEventsPayload as x, type BodyInit as y, type HeadersInit as z };