@upstash/qstash 2.7.9 → 2.7.11-canary

package/index.js

@@ -1,43 +1,1639 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./chunk-VN7YQ2UN.js');
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Chat: () => Chat,
+  Client: () => Client,
+  Messages: () => Messages,
+  QStashWorkflowAbort: () => QStashWorkflowAbort,
+  QStashWorkflowError: () => QStashWorkflowError,
+  QstashChatRatelimitError: () => QstashChatRatelimitError,
+  QstashDailyRatelimitError: () => QstashDailyRatelimitError,
+  QstashError: () => QstashError,
+  QstashRatelimitError: () => QstashRatelimitError,
+  Receiver: () => Receiver,
+  Schedules: () => Schedules,
+  SignatureError: () => SignatureError,
+  UrlGroups: () => UrlGroups,
+  custom: () => custom,
+  decodeBase64: () => decodeBase64,
+  formatWorkflowError: () => formatWorkflowError,
+  openai: () => openai,
+  setupAnalytics: () => setupAnalytics,
+  upstash: () => upstash
+});
+module.exports = __toCommonJS(src_exports);
 
+// src/receiver.ts
+var jose = __toESM(require("jose"));
+var import_crypto_js = __toESM(require("crypto-js"));
+var SignatureError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SignatureError";
+  }
+};
+var Receiver = class {
+  currentSigningKey;
+  nextSigningKey;
+  constructor(config) {
+    this.currentSigningKey = config.currentSigningKey;
+    this.nextSigningKey = config.nextSigningKey;
+  }
+  /**
+   * Verify the signature of a request.
+   *
+   * Tries to verify the signature with the current signing key.
+   * If that fails, maybe because you have rotated the keys recently, it will
+   * try to verify the signature with the next signing key.
+   *
+   * If that fails, the signature is invalid and a `SignatureError` is thrown.
+   */
+  async verify(request) {
+    const isValid = await this.verifyWithKey(this.currentSigningKey, request);
+    if (isValid) {
+      return true;
+    }
+    return this.verifyWithKey(this.nextSigningKey, request);
+  }
+  /**
+   * Verify signature with a specific signing key
+   */
+  async verifyWithKey(key, request) {
+    const jwt = await jose.jwtVerify(request.signature, new TextEncoder().encode(key), {
+      issuer: "Upstash",
+      clockTolerance: request.clockTolerance
+    }).catch((error) => {
+      throw new SignatureError(error.message);
+    });
+    const p = jwt.payload;
+    if (request.url !== void 0 && p.sub !== request.url) {
+      throw new SignatureError(`invalid subject: ${p.sub}, want: ${request.url}`);
+    }
+    const bodyHash = import_crypto_js.default.SHA256(request.body).toString(import_crypto_js.default.enc.Base64url);
+    const padding = new RegExp(/=+$/);
+    if (p.body.replace(padding, "") !== bodyHash.replace(padding, "")) {
+      throw new SignatureError(`body hash does not match, want: ${p.body}, got: ${bodyHash}`);
+    }
+    return true;
+  }
+};
 
+// src/client/dlq.ts
+var DLQ = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List messages in the dlq
+   */
+  async listMessages(options) {
+    const filterPayload = {
+      ...options?.filter,
+      topicName: options?.filter?.urlGroup
+    };
+    const messagesPayload = await this.http.request({
+      method: "GET",
+      path: ["v2", "dlq"],
+      query: {
+        cursor: options?.cursor,
+        count: options?.count,
+        ...filterPayload
+      }
+    });
+    return {
+      messages: messagesPayload.messages.map((message) => {
+        return {
+          ...message,
+          urlGroup: message.topicName
+        };
+      }),
+      cursor: messagesPayload.cursor
+    };
+  }
+  /**
+   * Remove a message from the dlq using it's `dlqId`
+   */
+  async delete(dlqMessageId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "dlq", dlqMessageId],
+      parseResponseAsJson: false
+      // there is no response
+    });
+  }
+  /**
+   * Remove multiple messages from the dlq using their `dlqId`s
+   */
+  async deleteMany(request) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "dlq"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ dlqIds: request.dlqIds })
+    });
+  }
+};
 
+// src/client/error.ts
+var QstashError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "QstashError";
+  }
+};
+var QstashRatelimitError = class extends QstashError {
+  limit;
+  remaining;
+  reset;
+  constructor(args) {
+    super(`Exceeded burst rate limit. ${JSON.stringify(args)} `);
+    this.name = "QstashRatelimitError";
+    this.limit = args.limit;
+    this.remaining = args.remaining;
+    this.reset = args.reset;
+  }
+};
+var QstashChatRatelimitError = class extends QstashError {
+  limitRequests;
+  limitTokens;
+  remainingRequests;
+  remainingTokens;
+  resetRequests;
+  resetTokens;
+  constructor(args) {
+    super(`Exceeded chat rate limit. ${JSON.stringify(args)} `);
+    this.limitRequests = args["limit-requests"];
+    this.limitTokens = args["limit-tokens"];
+    this.remainingRequests = args["remaining-requests"];
+    this.remainingTokens = args["remaining-tokens"];
+    this.resetRequests = args["reset-requests"];
+    this.resetTokens = args["reset-tokens"];
+  }
+};
+var QstashDailyRatelimitError = class extends QstashError {
+  limit;
+  remaining;
+  reset;
+  constructor(args) {
+    super(`Exceeded daily rate limit. ${JSON.stringify(args)} `);
+    this.limit = args.limit;
+    this.remaining = args.remaining;
+    this.reset = args.reset;
+    this.name = "QstashChatRatelimitError";
+  }
+};
+var QStashWorkflowError = class extends QstashError {
+  constructor(message) {
+    super(message);
+    this.name = "QStashWorkflowError";
+  }
+};
+var QStashWorkflowAbort = class extends Error {
+  stepInfo;
+  stepName;
+  constructor(stepName, stepInfo) {
+    super(
+      `This is an QStash Workflow error thrown after a step executes. It is expected to be raised. Make sure that you await for each step. Also, if you are using try/catch blocks, you should not wrap context.run/sleep/sleepUntil/call methods with try/catch. Aborting workflow after executing step '${stepName}'.`
+    );
+    this.name = "QStashWorkflowAbort";
+    this.stepName = stepName;
+    this.stepInfo = stepInfo;
+  }
+};
+var formatWorkflowError = (error) => {
+  return error instanceof Error ? {
+    error: error.name,
+    message: error.message
+  } : {
+    error: "Error",
+    message: "An error occured while executing workflow."
+  };
+};
 
+// src/client/http.ts
+var HttpClient = class {
+  baseUrl;
+  authorization;
+  options;
+  retry;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.authorization = config.authorization;
+    this.retry = // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typeof config.retry === "boolean" && !config.retry ? {
+      attempts: 1,
+      backoff: () => 0
+    } : {
+      attempts: config.retry?.retries ? config.retry.retries + 1 : 5,
+      backoff: config.retry?.backoff ?? ((retryCount) => Math.exp(retryCount) * 50)
+    };
+  }
+  async request(request) {
+    const { response } = await this.requestWithBackoff(request);
+    if (request.parseResponseAsJson === false) {
+      return void 0;
+    }
+    return await response.json();
+  }
+  async *requestStream(request) {
+    const { response } = await this.requestWithBackoff(request);
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const body = response.body;
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        const chunkText = decoder.decode(value, { stream: true });
+        const chunks = chunkText.split("\n").filter(Boolean);
+        for (const chunk of chunks) {
+          if (chunk.startsWith("data: ")) {
+            const data = chunk.slice(6);
+            if (data === "[DONE]") {
+              break;
+            }
+            yield JSON.parse(data);
+          }
+        }
+      }
+    } finally {
+      await reader.cancel();
+    }
+  }
+  requestWithBackoff = async (request) => {
+    const [url, requestOptions] = this.processRequest(request);
+    let response = void 0;
+    let error = void 0;
+    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 (!response) {
+      throw error ?? new Error("Exhausted all retries");
+    }
+    await this.checkResponse(response);
+    return {
+      response,
+      error
+    };
+  };
+  processRequest = (request) => {
+    const headers = new Headers(request.headers);
+    if (!headers.has("Authorization")) {
+      headers.set("Authorization", this.authorization);
+    }
+    const requestOptions = {
+      method: request.method,
+      headers,
+      body: request.body,
+      keepalive: request.keepalive
+    };
+    const url = new URL([request.baseUrl ?? this.baseUrl, ...request.path].join("/"));
+    if (request.query) {
+      for (const [key, value] of Object.entries(request.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, value.toString());
+        }
+      }
+    }
+    return [url.toString(), requestOptions];
+  };
+  async checkResponse(response) {
+    if (response.status === 429) {
+      if (response.headers.get("x-ratelimit-limit-requests")) {
+        throw new QstashChatRatelimitError({
+          "limit-requests": response.headers.get("x-ratelimit-limit-requests"),
+          "limit-tokens": response.headers.get("x-ratelimit-limit-tokens"),
+          "remaining-requests": response.headers.get("x-ratelimit-remaining-requests"),
+          "remaining-tokens": response.headers.get("x-ratelimit-remaining-tokens"),
+          "reset-requests": response.headers.get("x-ratelimit-reset-requests"),
+          "reset-tokens": response.headers.get("x-ratelimit-reset-tokens")
+        });
+      } else if (response.headers.get("RateLimit-Limit")) {
+        throw new QstashDailyRatelimitError({
+          limit: response.headers.get("RateLimit-Limit"),
+          remaining: response.headers.get("RateLimit-Remaining"),
+          reset: response.headers.get("RateLimit-Reset")
+        });
+      }
+      throw new QstashRatelimitError({
+        limit: response.headers.get("Burst-RateLimit-Limit"),
+        remaining: response.headers.get("Burst-RateLimit-Remaining"),
+        reset: response.headers.get("Burst-RateLimit-Reset")
+      });
+    }
+    if (response.status < 200 || response.status >= 300) {
+      const body = await response.text();
+      throw new QstashError(body.length > 0 ? body : `Error: status=${response.status}`);
+    }
+  }
+};
 
+// src/client/llm/providers.ts
+var setupAnalytics = (analytics, providerApiKey, providerBaseUrl, provider) => {
+  if (!analytics)
+    return {};
+  switch (analytics.name) {
+    case "helicone": {
+      switch (provider) {
+        case "upstash": {
+          return {
+            baseURL: "https://qstash.helicone.ai/llm/v1/chat/completions",
+            defaultHeaders: {
+              "Helicone-Auth": `Bearer ${analytics.token}`,
+              Authorization: `Bearer ${providerApiKey}`
+            }
+          };
+        }
+        default: {
+          return {
+            baseURL: "https://gateway.helicone.ai/v1/chat/completions",
+            defaultHeaders: {
+              "Helicone-Auth": `Bearer ${analytics.token}`,
+              "Helicone-Target-Url": providerBaseUrl,
+              Authorization: `Bearer ${providerApiKey}`
+            }
+          };
+        }
+      }
+    }
+    default: {
+      throw new Error("Unknown analytics provider");
+    }
+  }
+};
+var upstash = () => {
+  return {
+    owner: "upstash",
+    baseUrl: "https://qstash.upstash.io/llm",
+    token: ""
+  };
+};
+var openai = ({
+  token
+}) => {
+  return { token, owner: "openai", baseUrl: "https://api.openai.com" };
+};
+var custom = ({
+  baseUrl,
+  token
+}) => {
+  const trimmedBaseUrl = baseUrl.replace(/\/(v1\/)?chat\/completions$/, "");
+  return {
+    token,
+    owner: "custom",
+    baseUrl: trimmedBaseUrl
+  };
+};
 
+// src/client/llm/chat.ts
+var Chat = class _Chat {
+  http;
+  token;
+  constructor(http, token) {
+    this.http = http;
+    this.token = token;
+  }
+  static toChatRequest(request) {
+    const messages = [];
+    messages.push(
+      { role: "system", content: request.system },
+      { role: "user", content: request.user }
+    );
+    const chatRequest = { ...request, messages };
+    return chatRequest;
+  }
+  /**
+   * Calls the Upstash completions api given a ChatRequest.
+   *
+   * Returns a ChatCompletion or a stream of ChatCompletionChunks
+   * if stream is enabled.
+   *
+   * @param request ChatRequest with messages
+   * @returns Chat completion or stream
+   */
+  create = async (request) => {
+    if (request.provider.owner != "upstash")
+      return this.createThirdParty(request);
+    const body = JSON.stringify(request);
+    let baseUrl = void 0;
+    let headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.token}`,
+      ..."stream" in request && request.stream ? {
+        Connection: "keep-alive",
+        Accept: "text/event-stream",
+        "Cache-Control": "no-cache"
+      } : {}
+    };
+    if (request.analytics) {
+      const { baseURL, defaultHeaders } = setupAnalytics(
+        { name: "helicone", token: request.analytics.token },
+        this.getAuthorizationToken(),
+        request.provider.baseUrl,
+        "upstash"
+      );
+      headers = { ...headers, ...defaultHeaders };
+      baseUrl = baseURL;
+    }
+    const path = request.analytics ? [] : ["llm", "v1", "chat", "completions"];
+    return "stream" in request && request.stream ? this.http.requestStream({
+      path,
+      method: "POST",
+      headers,
+      baseUrl,
+      body
+    }) : this.http.request({
+      path,
+      method: "POST",
+      headers,
+      baseUrl,
+      body
+    });
+  };
+  /**
+   * Calls the Upstash completions api given a ChatRequest.
+   *
+   * Returns a ChatCompletion or a stream of ChatCompletionChunks
+   * if stream is enabled.
+   *
+   * @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 } = request.provider;
+    if (owner === "upstash")
+      throw new Error("Upstash is not 3rd party provider!");
+    delete request.provider;
+    delete request.system;
+    const analytics = request.analytics;
+    delete request.analytics;
+    const body = JSON.stringify(request);
+    const isAnalyticsEnabled = analytics?.name && analytics.token;
+    const analyticsConfig = analytics?.name && analytics.token ? setupAnalytics({ name: analytics.name, token: analytics.token }, token, baseUrl, owner) : { defaultHeaders: void 0, baseURL: baseUrl };
+    const isStream = "stream" in request && request.stream;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+      ...isStream ? {
+        Connection: "keep-alive",
+        Accept: "text/event-stream",
+        "Cache-Control": "no-cache"
+      } : {},
+      ...analyticsConfig.defaultHeaders
+    };
+    const response = await this.http[isStream ? "requestStream" : "request"]({
+      path: isAnalyticsEnabled ? [] : ["v1", "chat", "completions"],
+      method: "POST",
+      headers,
+      body,
+      baseUrl: analyticsConfig.baseURL
+    });
+    return response;
+  };
+  // Helper method to get the authorization token
+  getAuthorizationToken() {
+    const authHeader = String(this.http.authorization);
+    const match = /Bearer (.+)/.exec(authHeader);
+    if (!match) {
+      throw new Error("Invalid authorization header format");
+    }
+    return match[1];
+  }
+  /**
+   * Calls the Upstash completions api given a PromptRequest.
+   *
+   * Returns a ChatCompletion or a stream of ChatCompletionChunks
+   * if stream is enabled.
+   *
+   * @param request PromptRequest with system and user messages.
+   *    Note that system parameter shouldn't be passed in the case of
+   *    mistralai/Mistral-7B-Instruct-v0.2 model.
+   * @returns Chat completion or stream
+   */
+  prompt = async (request) => {
+    const chatRequest = _Chat.toChatRequest(request);
+    return this.create(chatRequest);
+  };
+};
 
+// src/client/llm/utils.ts
+function appendLLMOptionsIfNeeded(request, headers, http) {
+  if (!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;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get a message
+   */
+  async get(messageId) {
+    const messagePayload = await this.http.request({
+      method: "GET",
+      path: ["v2", "messages", messageId]
+    });
+    const message = {
+      ...messagePayload,
+      urlGroup: messagePayload.topicName
+    };
+    return message;
+  }
+  /**
+   * Cancel a message
+   */
+  async delete(messageId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages", messageId],
+      parseResponseAsJson: false
+    });
+  }
+  async deleteMany(messageIds) {
+    const result = await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ messageIds })
+    });
+    return result.cancelled;
+  }
+  async deleteAll() {
+    const result = await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages"]
+    });
+    return result.cancelled;
+  }
+};
 
+// src/client/utils.ts
+var isIgnoredHeader = (header) => {
+  const lowerCaseHeader = header.toLowerCase();
+  return lowerCaseHeader.startsWith("content-type") || lowerCaseHeader.startsWith("upstash-");
+};
+function prefixHeaders(headers) {
+  const keysToBePrefixed = [...headers.keys()].filter((key) => !isIgnoredHeader(key));
+  for (const key of keysToBePrefixed) {
+    const value = headers.get(key);
+    if (value !== null) {
+      headers.set(`Upstash-Forward-${key}`, value);
+    }
+    headers.delete(key);
+  }
+  return headers;
+}
+function processHeaders(request) {
+  const headers = prefixHeaders(new Headers(request.headers));
+  headers.set("Upstash-Method", request.method ?? "POST");
+  if (request.delay !== void 0) {
+    if (typeof request.delay === "string") {
+      headers.set("Upstash-Delay", request.delay);
+    } else {
+      headers.set("Upstash-Delay", `${request.delay.toFixed(0)}s`);
+    }
+  }
+  if (request.notBefore !== void 0) {
+    headers.set("Upstash-Not-Before", request.notBefore.toFixed(0));
+  }
+  if (request.deduplicationId !== void 0) {
+    headers.set("Upstash-Deduplication-Id", request.deduplicationId);
+  }
+  if (request.contentBasedDeduplication !== void 0) {
+    headers.set("Upstash-Content-Based-Deduplication", "true");
+  }
+  if (request.retries !== void 0) {
+    headers.set("Upstash-Retries", request.retries.toFixed(0));
+  }
+  if (request.callback !== void 0) {
+    headers.set("Upstash-Callback", request.callback);
+  }
+  if (request.failureCallback !== void 0) {
+    headers.set("Upstash-Failure-Callback", request.failureCallback);
+  }
+  if (request.timeout !== void 0) {
+    if (typeof request.timeout === "string") {
+      headers.set("Upstash-Timeout", request.timeout);
+    } else {
+      headers.set("Upstash-Timeout", `${request.timeout}s`);
+    }
+  }
+  return headers;
+}
+function getRequestPath(request) {
+  return request.url ?? request.urlGroup ?? request.topic ?? `api/${request.api?.name}`;
+}
+function decodeBase64(base64) {
+  try {
+    const binString = atob(base64);
+    const intArray = Uint8Array.from(binString, (m) => m.codePointAt(0));
+    return new TextDecoder().decode(intArray);
+  } catch (error) {
+    console.warn(
+      `Upstash Qstash: Failed while decoding base64 "${base64}". Decoding with atob and returning it instead. Error: ${error}`
+    );
+    return atob(base64);
+  }
+}
 
+// src/client/queue.ts
+var Queue = class {
+  http;
+  queueName;
+  constructor(http, queueName) {
+    this.http = http;
+    this.queueName = queueName;
+  }
+  /**
+   * Create or update the queue
+   */
+  async upsert(request) {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    const body = {
+      queueName: this.queueName,
+      parallelism: request.parallelism ?? 1,
+      paused: request.paused ?? false
+    };
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "queues"],
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Get the queue details
+   */
+  async get() {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "queues", this.queueName]
+    });
+  }
+  /**
+   * List queues
+   */
+  async list() {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "queues"]
+    });
+  }
+  /**
+   * Delete the queue
+   */
+  async delete() {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    await this.http.request({
+      method: "DELETE",
+      path: ["v2", "queues", this.queueName],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Enqueue a message to a queue.
+   */
+  async enqueue(request) {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    const headers = processHeaders(request);
+    const destination = getRequestPath(request);
+    const response = await this.http.request({
+      path: ["v2", "enqueue", this.queueName, destination],
+      body: request.body,
+      headers,
+      method: "POST"
+    });
+    return response;
+  }
+  /**
+   * Enqueue a message to a queue, serializing the body to JSON.
+   */
+  async enqueueJSON(request) {
+    const headers = prefixHeaders(new Headers(request.headers));
+    headers.set("Content-Type", "application/json");
+    ensureCallbackPresent(request);
+    appendLLMOptionsIfNeeded(request, headers, this.http);
+    const response = await this.enqueue({
+      ...request,
+      body: JSON.stringify(request.body),
+      headers
+    });
+    return response;
+  }
+  /**
+   * Pauses the queue.
+   *
+   * A paused queue will not deliver messages until
+   * it is resumed.
+   */
+  async pause() {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "queues", this.queueName, "pause"],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Resumes the queue.
+   */
+  async resume() {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "queues", this.queueName, "resume"],
+      parseResponseAsJson: false
+    });
+  }
+};
 
+// src/client/schedules.ts
+var Schedules = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a schedule
+   */
+  async create(request) {
+    const headers = prefixHeaders(new Headers(request.headers));
+    if (!headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    headers.set("Upstash-Cron", request.cron);
+    if (request.method !== void 0) {
+      headers.set("Upstash-Method", request.method);
+    }
+    if (request.delay !== void 0) {
+      if (typeof request.delay === "string") {
+        headers.set("Upstash-Delay", request.delay);
+      } else {
+        headers.set("Upstash-Delay", `${request.delay.toFixed(0)}s`);
+      }
+    }
+    if (request.retries !== void 0) {
+      headers.set("Upstash-Retries", request.retries.toFixed(0));
+    }
+    if (request.callback !== void 0) {
+      headers.set("Upstash-Callback", request.callback);
+    }
+    if (request.failureCallback !== void 0) {
+      headers.set("Upstash-Failure-Callback", request.failureCallback);
+    }
+    if (request.timeout !== void 0) {
+      if (typeof request.timeout === "string") {
+        headers.set("Upstash-Timeout", request.timeout);
+      } else {
+        headers.set("Upstash-Timeout", `${request.timeout}s`);
+      }
+    }
+    if (request.scheduleId !== void 0) {
+      headers.set("Upstash-Schedule-Id", request.scheduleId);
+    }
+    return await this.http.request({
+      method: "POST",
+      headers,
+      path: ["v2", "schedules", request.destination],
+      body: request.body
+    });
+  }
+  /**
+   * Get a schedule
+   */
+  async get(scheduleId) {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "schedules", scheduleId]
+    });
+  }
+  /**
+   * List your schedules
+   */
+  async list() {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "schedules"]
+    });
+  }
+  /**
+   * Delete a schedule
+   */
+  async delete(scheduleId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "schedules", scheduleId],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Pauses the schedule.
+   *
+   * A paused schedule will not deliver messages until
+   * it is resumed.
+   */
+  async pause({ schedule }) {
+    await this.http.request({
+      method: "PATCH",
+      path: ["v2", "schedules", schedule, "pause"],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Resumes the schedule.
+   */
+  async resume({ schedule }) {
+    await this.http.request({
+      method: "PATCH",
+      path: ["v2", "schedules", schedule, "resume"],
+      parseResponseAsJson: false
+    });
+  }
+};
 
+// src/client/url-groups.ts
+var UrlGroups = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new url group with the given name and endpoints
+   */
+  async addEndpoints(request) {
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "topics", request.name, "endpoints"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoints: request.endpoints }),
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Remove endpoints from a url group.
+   */
+  async removeEndpoints(request) {
+    await this.http.request({
+      method: "DELETE",
+      path: ["v2", "topics", request.name, "endpoints"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoints: request.endpoints }),
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Get a list of all url groups.
+   */
+  async list() {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "topics"]
+    });
+  }
+  /**
+   * Get a single url group
+   */
+  async get(name) {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "topics", name]
+    });
+  }
+  /**
+   * Delete a url group
+   */
+  async delete(name) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "topics", name],
+      parseResponseAsJson: false
+    });
+  }
+};
 
+// node_modules/neverthrow/dist/index.es.js
+var defaultErrorConfig = {
+  withStackTrace: false
+};
+var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+  const maybeStack = config.withStackTrace ? new Error().stack : void 0;
+  return {
+    data,
+    message,
+    stack: maybeStack
+  };
+};
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m)
+    return m.call(o);
+  if (o && typeof o.length === "number")
+    return {
+      next: function() {
+        if (o && i >= o.length)
+          o = void 0;
+        return { value: o && o[i++], done: !o };
+      }
+    };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function verb(n) {
+    if (g[n])
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length)
+      resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+var ResultAsync = class _ResultAsync {
+  constructor(res) {
+    this._promise = res;
+  }
+  static fromSafePromise(promise) {
+    const newPromise = promise.then((value) => new Ok(value));
+    return new _ResultAsync(newPromise);
+  }
+  static fromPromise(promise, errorFn) {
+    const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+    return new _ResultAsync(newPromise);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromThrowable(fn, errorFn) {
+    return (...args) => {
+      return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
+        try {
+          return new Ok(yield fn(...args));
+        } catch (error) {
+          return new Err(errorFn ? errorFn(error) : error);
+        }
+      }))());
+    };
+  }
+  static combine(asyncResultList) {
+    return combineResultAsyncList(asyncResultList);
+  }
+  static combineWithAllErrors(asyncResultList) {
+    return combineResultAsyncListWithAllErrors(asyncResultList);
+  }
+  map(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      return new Ok(yield f(res.value));
+    })));
+  }
+  mapErr(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      return new Err(yield f(res.error));
+    })));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return new _ResultAsync(this._promise.then((res) => {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newValue = f(res.value);
+      return newValue instanceof _ResultAsync ? newValue._promise : newValue;
+    }));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return f(res.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  match(ok2, _err) {
+    return this._promise.then((res) => res.match(ok2, _err));
+  }
+  unwrapOr(t) {
+    return this._promise.then((res) => res.unwrapOr(t));
+  }
+  /**
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  safeUnwrap() {
+    return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+    });
+  }
+  // Makes ResultAsync implement PromiseLike<Result>
+  then(successCallback, failureCallback) {
+    return this._promise.then(successCallback, failureCallback);
+  }
+};
+var errAsync = (err2) => new ResultAsync(Promise.resolve(new Err(err2)));
+var fromPromise = ResultAsync.fromPromise;
+var fromSafePromise = ResultAsync.fromSafePromise;
+var fromAsyncThrowable = ResultAsync.fromThrowable;
+var combineResultList = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr()) {
+      acc = err(result.error);
+      break;
+    } else {
+      acc.map((list) => list.push(result.value));
+    }
+  }
+  return acc;
+};
+var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+var combineResultListWithAllErrors = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr() && acc.isErr()) {
+      acc.error.push(result.error);
+    } else if (result.isErr() && acc.isOk()) {
+      acc = err([result.error]);
+    } else if (result.isOk() && acc.isOk()) {
+      acc.value.push(result.value);
+    }
+  }
+  return acc;
+};
+var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+var Result;
+(function(Result2) {
+  function fromThrowable2(fn, errorFn) {
+    return (...args) => {
+      try {
+        const result = fn(...args);
+        return ok(result);
+      } catch (e) {
+        return err(errorFn ? errorFn(e) : e);
+      }
+    };
+  }
+  Result2.fromThrowable = fromThrowable2;
+  function combine(resultList) {
+    return combineResultList(resultList);
+  }
+  Result2.combine = combine;
+  function combineWithAllErrors(resultList) {
+    return combineResultListWithAllErrors(resultList);
+  }
+  Result2.combineWithAllErrors = combineWithAllErrors;
+})(Result || (Result = {}));
+var ok = (value) => new Ok(value);
+var err = (err2) => new Err(err2);
+var Ok = class {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  map(f) {
+    return ok(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  mapErr(_f) {
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(_f) {
+    return ok(this.value);
+  }
+  asyncAndThen(f) {
+    return f(this.value);
+  }
+  asyncMap(f) {
+    return ResultAsync.fromSafePromise(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  unwrapOr(_v) {
+    return this.value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  match(ok2, _err) {
+    return ok2(this.value);
+  }
+  safeUnwrap() {
+    const value = this.value;
+    return function* () {
+      return value;
+    }();
+  }
+  _unsafeUnwrap(_) {
+    return this.value;
+  }
+  _unsafeUnwrapErr(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+  }
+};
+var Err = class {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  map(_f) {
+    return err(this.error);
+  }
+  mapErr(f) {
+    return err(f(this.error));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(_f) {
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return f(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncAndThen(_f) {
+    return errAsync(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncMap(_f) {
+    return errAsync(this.error);
+  }
+  unwrapOr(v) {
+    return v;
+  }
+  match(_ok, err2) {
+    return err2(this.error);
+  }
+  safeUnwrap() {
+    const error = this.error;
+    return function* () {
+      yield err(error);
+      throw new Error("Do not use this generator out of `safeTry`");
+    }();
+  }
+  _unsafeUnwrap(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+  }
+  _unsafeUnwrapErr(_) {
+    return this.error;
+  }
+};
+var fromThrowable = Result.fromThrowable;
 
+// src/client/workflow/index.ts
+var Workflow = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Cancel an ongoing workflow
+   *
+   * @param workflowRunId run id of the workflow to delete
+   * @returns true if workflow is succesfully deleted. Otherwise throws QStashError
+   */
+  async cancel(workflowRunId) {
+    const result = await this.http.request({
+      path: ["v2", "workflows", "runs", `${workflowRunId}?cancel=true`],
+      method: "DELETE",
+      parseResponseAsJson: false
+    });
+    return result ?? true;
+  }
+};
 
-
-
-
-
-var _chunkR5CZPV7Hjs = require('./chunk-R5CZPV7H.js');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.Chat = _chunkR5CZPV7Hjs.Chat; exports.Client = _chunkR5CZPV7Hjs.Client; exports.Messages = _chunkR5CZPV7Hjs.Messages; exports.QStashWorkflowAbort = _chunkR5CZPV7Hjs.QStashWorkflowAbort; exports.QStashWorkflowError = _chunkR5CZPV7Hjs.QStashWorkflowError; exports.QstashChatRatelimitError = _chunkR5CZPV7Hjs.QstashChatRatelimitError; exports.QstashDailyRatelimitError = _chunkR5CZPV7Hjs.QstashDailyRatelimitError; exports.QstashError = _chunkR5CZPV7Hjs.QstashError; exports.QstashRatelimitError = _chunkR5CZPV7Hjs.QstashRatelimitError; exports.Receiver = _chunkR5CZPV7Hjs.Receiver; exports.Schedules = _chunkR5CZPV7Hjs.Schedules; exports.SignatureError = _chunkR5CZPV7Hjs.SignatureError; exports.UrlGroups = _chunkR5CZPV7Hjs.UrlGroups; exports.custom = _chunkR5CZPV7Hjs.custom; exports.decodeBase64 = _chunkR5CZPV7Hjs.decodeBase64; exports.formatWorkflowError = _chunkR5CZPV7Hjs.formatWorkflowError; exports.openai = _chunkR5CZPV7Hjs.openai; exports.setupAnalytics = _chunkR5CZPV7Hjs.setupAnalytics; exports.upstash = _chunkR5CZPV7Hjs.upstash;
+// src/client/client.ts
+var Client = class {
+  http;
+  token;
+  constructor(config) {
+    this.http = new HttpClient({
+      retry: config.retry,
+      baseUrl: config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "https://qstash.upstash.io",
+      authorization: `Bearer ${config.token}`
+    });
+    this.token = config.token;
+  }
+  /**
+   * Access the urlGroup API.
+   *
+   * Create, read, update or delete urlGroups.
+   */
+  get urlGroups() {
+    return new UrlGroups(this.http);
+  }
+  /**
+   * Deprecated. Use urlGroups instead.
+   *
+   * Access the topic API.
+   *
+   * Create, read, update or delete topics.
+   */
+  get topics() {
+    return this.urlGroups;
+  }
+  /**
+   * Access the dlq API.
+   *
+   * List or remove messages from the DLQ.
+   */
+  get dlq() {
+    return new DLQ(this.http);
+  }
+  /**
+   * Access the message API.
+   *
+   * Read or cancel messages.
+   */
+  get messages() {
+    return new Messages(this.http);
+  }
+  /**
+   * Access the schedule API.
+   *
+   * Create, read or delete schedules.
+   */
+  get schedules() {
+    return new Schedules(this.http);
+  }
+  /**
+   * Access the workflow API.
+   *
+   * cancel workflows.
+   */
+  get workflow() {
+    return new Workflow(this.http);
+  }
+  /**
+   * Access the queue API.
+   *
+   * Create, read, update or delete queues.
+   */
+  queue(request) {
+    return new Queue(this.http, request?.queueName);
+  }
+  /**
+   * Access the Chat API
+   *
+   * Call the create or prompt methods
+   */
+  chat() {
+    return new Chat(this.http, this.token);
+  }
+  async publish(request) {
+    const headers = processHeaders(request);
+    const response = await this.http.request({
+      path: ["v2", "publish", getRequestPath(request)],
+      body: request.body,
+      headers,
+      method: "POST"
+    });
+    return response;
+  }
+  /**
+   * publishJSON is a utility wrapper around `publish` that automatically serializes the body
+   * and sets the `Content-Type` header to `application/json`.
+   */
+  async publishJSON(request) {
+    const headers = prefixHeaders(new Headers(request.headers));
+    headers.set("Content-Type", "application/json");
+    ensureCallbackPresent(request);
+    appendLLMOptionsIfNeeded(request, headers, this.http);
+    const response = await this.publish({
+      ...request,
+      headers,
+      body: JSON.stringify(request.body)
+    });
+    return response;
+  }
+  /**
+   * Batch publish messages to QStash.
+   */
+  async batch(request) {
+    const messages = [];
+    for (const message of request) {
+      const headers = processHeaders(message);
+      const headerEntries = Object.fromEntries(headers.entries());
+      messages.push({
+        destination: getRequestPath(message),
+        headers: headerEntries,
+        body: message.body,
+        ...message.queueName && { queue: message.queueName }
+      });
+    }
+    const response = await this.http.request({
+      path: ["v2", "batch"],
+      body: JSON.stringify(messages),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+    const arrayResposne = Array.isArray(response) ? response : [response];
+    return arrayResposne;
+  }
+  /**
+   * Batch publish messages to QStash, serializing each body to JSON.
+   */
+  async batchJSON(request) {
+    for (const message of request) {
+      if ("body" in message) {
+        message.body = JSON.stringify(message.body);
+      }
+      message.headers = new Headers(message.headers);
+      ensureCallbackPresent(message);
+      appendLLMOptionsIfNeeded(message, message.headers, this.http);
+      message.headers.set("Content-Type", "application/json");
+    }
+    const response = await this.batch(request);
+    return response;
+  }
+  /**
+   * Retrieve your logs.
+   *
+   * The logs endpoint is paginated and returns only 100 logs at a time.
+   * If you want to receive more logs, you can use the cursor to paginate.
+   *
+   * The cursor is a unix timestamp with millisecond precision
+   *
+   * @example
+   * ```ts
+   * let cursor = Date.now()
+   * const logs: Log[] = []
+   * while (cursor > 0) {
+   *   const res = await qstash.logs({ cursor })
+   *   logs.push(...res.logs)
+   *   cursor = res.cursor ?? 0
+   * }
+   * ```
+   */
+  async events(request) {
+    const query = {};
+    if (typeof request?.cursor === "number" && request.cursor > 0) {
+      query.cursor = request.cursor.toString();
+    } else if (typeof request?.cursor === "string" && request.cursor !== "") {
+      query.cursor = request.cursor;
+    }
+    for (const [key, value] of Object.entries(request?.filter ?? {})) {
+      if (typeof value === "number" && value < 0) {
+        continue;
+      }
+      if (key === "urlGroup") {
+        query.topicName = value.toString();
+      } else if (typeof value !== "undefined") {
+        query[key] = value.toString();
+      }
+    }
+    const responsePayload = await this.http.request({
+      path: ["v2", "events"],
+      method: "GET",
+      query
+    });
+    return {
+      cursor: responsePayload.cursor,
+      events: responsePayload.events.map((event) => {
+        return {
+          ...event,
+          urlGroup: event.topicName
+        };
+      })
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Chat,
+  Client,
+  Messages,
+  QStashWorkflowAbort,
+  QStashWorkflowError,
+  QstashChatRatelimitError,
+  QstashDailyRatelimitError,
+  QstashError,
+  QstashRatelimitError,
+  Receiver,
+  Schedules,
+  SignatureError,
+  UrlGroups,
+  custom,
+  decodeBase64,
+  formatWorkflowError,
+  openai,
+  setupAnalytics,
+  upstash
+});