@windrun-huaiin/backend-core 14.6.0 → 15.1.0

package/dist/node_modules/.pnpm/@upstash_qstash@2.10.1/node_modules/@upstash/qstash/chunk-35B33QW3.js

@@ -1,1848 +0,0 @@
-'use strict';
-
-var index = require('../../../../../../_virtual/index.js');
-require('../../../../neverthrow@7.2.0/node_modules/neverthrow/dist/index.es.js');
-var verify = require('../../../../jose@5.10.0/node_modules/jose/dist/node/esm/jwt/verify.js');
-
-// src/receiver.ts
-
-// 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;
-  method = "POST";
-  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 { "content-type": "application/json" };
-    }
-    const header = this.owner === "anthropic" ? "x-api-key" : "authorization";
-    const headerValue = this.owner === "anthropic" ? this.token : `Bearer ${this.token}`;
-    const headers = {
-      [header]: headerValue,
-      "content-type": "application/json"
-    };
-    if (this.owner === "openai" && this.organization) {
-      headers["OpenAI-Organization"] = this.organization;
-    }
-    if (this.owner === "anthropic") {
-      headers["anthropic-version"] = "2023-06-01";
-    }
-    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");
-};
-
-// 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,
-    method: finalProvider.method
-  };
-  return finalProvider.onFinish(providerInfo, parameters);
-};
-var safeJoinHeaders = (headers, record) => {
-  const joinedHeaders = new Headers(record);
-  for (const [header, value] of headers.entries()) {
-    joinedHeaders.set(header, value);
-  }
-  return joinedHeaders;
-};
-var processApi = (request, headers, upstashToken) => {
-  if (!request.api) {
-    request.headers = headers;
-    return request;
-  }
-  const { url, appendHeaders, owner, method } = 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,
-      method: request.method ?? method,
-      headers: safeJoinHeaders(headers, appendHeaders),
-      ...owner === "upstash" && !request.api.analytics ? { api: { name: "llm" }, url: void 0, callback } : { url, api: void 0 }
-    };
-  } else {
-    return {
-      ...request,
-      method: request.method ?? method,
-      headers: safeJoinHeaders(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/error.ts
-var RATELIMIT_STATUS = 429;
-var QstashError = class extends Error {
-  status;
-  constructor(message, status) {
-    super(message);
-    this.name = "QstashError";
-    this.status = status;
-  }
-};
-var QstashRatelimitError = class extends QstashError {
-  limit;
-  remaining;
-  reset;
-  constructor(args) {
-    super(`Exceeded burst rate limit. ${JSON.stringify(args)}`, RATELIMIT_STATUS);
-    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)}`, RATELIMIT_STATUS);
-    this.name = "QstashChatRatelimitError";
-    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)}`, RATELIMIT_STATUS);
-    this.name = "QstashDailyRatelimitError";
-    this.limit = args.limit;
-    this.remaining = args.remaining;
-    this.reset = args.reset;
-  }
-};
-var QstashEmptyArrayError = class extends QstashError {
-  constructor(parameterName) {
-    super(
-      `Empty array provided for query parameter "${parameterName}". This would result in no filter being applied, which could affect all resources.`
-    );
-    this.name = "QstashEmptyArrayError";
-  }
-};
-
-// src/client/utils.ts
-var DEFAULT_BULK_COUNT = 100;
-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 wrapWithGlobalHeaders(headers, globalHeaders, telemetryHeaders) {
-  if (!globalHeaders) {
-    return headers;
-  }
-  const finalHeaders = new Headers(globalHeaders);
-  headers.forEach((value, key) => {
-    finalHeaders.set(key, value);
-  });
-  telemetryHeaders?.forEach((value, key) => {
-    if (!value)
-      return;
-    finalHeaders.append(key, value);
-  });
-  return finalHeaders;
-}
-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) {
-    headers.set("Upstash-Content-Based-Deduplication", "true");
-  }
-  if (request.retries !== void 0) {
-    headers.set("Upstash-Retries", request.retries.toFixed(0));
-  }
-  if (request.retryDelay !== void 0) {
-    headers.set("Upstash-Retry-Delay", request.retryDelay);
-  }
-  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.flowControl?.key) {
-    const parallelism = request.flowControl.parallelism?.toString();
-    const rate = (request.flowControl.rate ?? request.flowControl.ratePerSecond)?.toString();
-    const period = typeof request.flowControl.period === "number" ? `${request.flowControl.period}s` : request.flowControl.period;
-    const controlValue = [
-      parallelism ? `parallelism=${parallelism}` : void 0,
-      rate ? `rate=${rate}` : void 0,
-      period ? `period=${period}` : void 0
-    ].filter(Boolean);
-    if (controlValue.length === 0) {
-      throw new QstashError("Provide at least one of parallelism or ratePerSecond for flowControl");
-    }
-    headers.set("Upstash-Flow-Control-Key", request.flowControl.key);
-    headers.set("Upstash-Flow-Control-Value", controlValue.join(", "));
-  }
-  if (request.label !== void 0) {
-    headers.set("Upstash-Label", request.label);
-  }
-  if (request.redact !== void 0) {
-    const redactParts = [];
-    if (request.redact.body) {
-      redactParts.push("body");
-    }
-    if (request.redact.header !== void 0) {
-      if (request.redact.header === true) {
-        redactParts.push("header");
-      } else if (Array.isArray(request.redact.header) && request.redact.header.length > 0) {
-        for (const headerName of request.redact.header) {
-          redactParts.push(`header[${headerName}]`);
-        }
-      }
-    }
-    if (redactParts.length > 0) {
-      headers.set("Upstash-Redact-Fields", redactParts.join(","));
-    }
-  }
-  return headers;
-}
-function getRequestPath(request) {
-  const nonApiPath = request.url ?? request.urlGroup ?? request.topic;
-  if (nonApiPath)
-    return nonApiPath;
-  if (request.api?.name === "llm")
-    return `api/llm`;
-  if (request.api?.name === "email") {
-    const providerInfo = getProviderInfo(request.api, "not-needed");
-    return providerInfo.baseUrl;
-  }
-  throw new QstashError(`Failed to infer request path for ${JSON.stringify(request)}`);
-}
-function buildBulkActionFilterPayload(request) {
-  const cursor = "cursor" in request ? request.cursor : void 0;
-  if ("all" in request) {
-    const count2 = "count" in request ? request.count ?? DEFAULT_BULK_COUNT : DEFAULT_BULK_COUNT;
-    return { count: count2, cursor };
-  }
-  if ("dlqIds" in request) {
-    const ids = request.dlqIds;
-    if (Array.isArray(ids) && ids.length === 0) {
-      throw new QstashError(
-        "Empty dlqIds array provided. If you intend to target all DLQ messages, use { all: true } explicitly."
-      );
-    }
-    return { dlqIds: ids, cursor };
-  }
-  if ("messageIds" in request && request.messageIds) {
-    if (request.messageIds.length === 0) {
-      throw new QstashError(
-        "Empty messageIds array provided. If you intend to target all messages, use { all: true } explicitly."
-      );
-    }
-    return { messageIds: request.messageIds, cursor };
-  }
-  const count = "count" in request ? request.count ?? DEFAULT_BULK_COUNT : DEFAULT_BULK_COUNT;
-  return {
-    ...renameUrlGroup(request.filter),
-    count,
-    cursor
-  };
-}
-function renameUrlGroup(filter) {
-  const { urlGroup, api, ...rest } = filter;
-  return { ...rest, ...urlGroup === void 0 ? {} : { topicName: urlGroup } };
-}
-function normalizeCursor(response) {
-  const cursor = response.cursor;
-  return { ...response, cursor: cursor || void 0 };
-}
-function getRuntime() {
-  if (typeof process === "object" && typeof process.versions == "object" && process.versions.bun)
-    return `bun@${process.versions.bun}`;
-  if (typeof EdgeRuntime === "string")
-    return "edge-light";
-  else if (typeof process === "object" && typeof process.version === "string")
-    return `node@${process.version}`;
-  return "";
-}
-function getSafeEnvironment() {
-  return typeof process === "undefined" ? {} : process.env;
-}
-
-// src/client/multi-region/utils.ts
-var VALID_REGIONS = ["EU_CENTRAL_1", "US_EAST_1"];
-var DEFAULT_QSTASH_URL = "https://qstash.upstash.io";
-var getRegionFromEnvironment = (environment) => {
-  const region = environment.QSTASH_REGION;
-  return normalizeRegionHeader(region);
-};
-function readEnvironmentVariables(environmentVariables, environment, region) {
-  const result = {};
-  for (const variable of environmentVariables) {
-    const key = region ? `${region}_${variable}` : variable;
-    result[variable] = environment[key];
-  }
-  return result;
-}
-function readClientEnvironmentVariables(environment, region) {
-  return readEnvironmentVariables(["QSTASH_URL", "QSTASH_TOKEN"], environment, region);
-}
-function readReceiverEnvironmentVariables(environment, region) {
-  return readEnvironmentVariables(
-    ["QSTASH_CURRENT_SIGNING_KEY", "QSTASH_NEXT_SIGNING_KEY"],
-    environment,
-    region
-  );
-}
-function normalizeRegionHeader(region) {
-  if (!region) {
-    return void 0;
-  }
-  region = region.replaceAll("-", "_").toUpperCase();
-  if (VALID_REGIONS.includes(region)) {
-    return region;
-  }
-  console.warn(
-    `[Upstash QStash] Invalid UPSTASH_REGION header value: "${region}". Expected one of: ${VALID_REGIONS.join(
-      ", "
-    )}.`
-  );
-  return void 0;
-}
-
-// src/client/multi-region/incoming.ts
-var getReceiverSigningKeys = ({
-  environment,
-  regionFromHeader,
-  config
-}) => {
-  if (config?.currentSigningKey && config.nextSigningKey) {
-    return {
-      currentSigningKey: config.currentSigningKey,
-      nextSigningKey: config.nextSigningKey
-    };
-  }
-  const regionEnvironment = getRegionFromEnvironment(environment);
-  if (regionEnvironment) {
-    const regionHeader = normalizeRegionHeader(regionFromHeader);
-    if (regionHeader) {
-      const regionCreds = readReceiverEnvironmentVariables(environment, regionHeader);
-      if (regionCreds.QSTASH_CURRENT_SIGNING_KEY && regionCreds.QSTASH_NEXT_SIGNING_KEY) {
-        return {
-          currentSigningKey: regionCreds.QSTASH_CURRENT_SIGNING_KEY,
-          nextSigningKey: regionCreds.QSTASH_NEXT_SIGNING_KEY,
-          region: regionHeader
-        };
-      } else {
-        console.warn(
-          `[Upstash QStash] Signing keys not found for region "${regionHeader}". Falling back to default signing keys.`
-        );
-      }
-    } else {
-      console.warn(
-        `[Upstash QStash] Invalid UPSTASH_REGION header value: "${regionFromHeader}". Expected one of: EU-CENTRAL-1, US-EAST-1. Falling back to default signing keys.`
-      );
-    }
-  }
-  const defaultCreds = readReceiverEnvironmentVariables(environment);
-  if (defaultCreds.QSTASH_CURRENT_SIGNING_KEY && defaultCreds.QSTASH_NEXT_SIGNING_KEY) {
-    return {
-      currentSigningKey: defaultCreds.QSTASH_CURRENT_SIGNING_KEY,
-      nextSigningKey: defaultCreds.QSTASH_NEXT_SIGNING_KEY
-    };
-  }
-};
-
-// src/client/multi-region/outgoing.ts
-var getClientCredentials = (clientCredentialConfig) => {
-  const credentials = resolveCredentials(clientCredentialConfig);
-  return verifyCredentials(credentials);
-};
-var resolveCredentials = ({
-  environment,
-  config
-}) => {
-  if (config?.baseUrl && config.token) {
-    return {
-      baseUrl: config.baseUrl,
-      token: config.token
-    };
-  }
-  const region = getRegionFromEnvironment(environment);
-  if (region) {
-    const regionCreds = readClientEnvironmentVariables(environment, region);
-    if (regionCreds.QSTASH_URL && regionCreds.QSTASH_TOKEN) {
-      return {
-        baseUrl: regionCreds.QSTASH_URL,
-        token: regionCreds.QSTASH_TOKEN,
-        region
-      };
-    } else {
-      console.warn(
-        `[Upstash QStash] QSTASH_REGION is set to "${region}" but credentials are missing. Expected ${region}_QSTASH_URL and ${region}_QSTASH_TOKEN. Falling back to default credentials.`
-      );
-    }
-  }
-  const defaultCreds = readClientEnvironmentVariables(environment);
-  return {
-    baseUrl: config?.baseUrl ?? defaultCreds.QSTASH_URL ?? DEFAULT_QSTASH_URL,
-    token: config?.token ?? defaultCreds.QSTASH_TOKEN ?? ""
-  };
-};
-var verifyCredentials = (credentials) => {
-  const token = credentials.token;
-  let baseUrl = credentials.baseUrl;
-  baseUrl = baseUrl.replace(/\/$/, "");
-  if (baseUrl === "https://qstash.upstash.io/v2/publish") {
-    baseUrl = DEFAULT_QSTASH_URL;
-  }
-  if (!token) {
-    console.warn(
-      "[Upstash QStash] client token is not set. Either pass a token or set QSTASH_TOKEN env variable."
-    );
-  }
-  return { baseUrl, token };
-};
-
-// src/receiver.ts
-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 environment = getSafeEnvironment();
-    const signingKeys = getReceiverSigningKeys({
-      environment,
-      regionFromHeader: request.upstashRegion,
-      config: {
-        currentSigningKey: this.currentSigningKey,
-        nextSigningKey: this.nextSigningKey
-      }
-    });
-    if (!signingKeys) {
-      throw new Error(
-        "[Upstash QStash] No signing keys available for verification. See the warning above for more details."
-      );
-    }
-    let payload;
-    try {
-      payload = await this.verifyWithKey(signingKeys.currentSigningKey, request);
-    } catch {
-      payload = await this.verifyWithKey(signingKeys.nextSigningKey, request);
-    }
-    this.verifyBodyAndUrl(payload, request);
-    return true;
-  }
-  /**
-   * Verify signature with a specific signing key
-   */
-  async verifyWithKey(key, request) {
-    const jwt = await verify.jwtVerify(request.signature, new TextEncoder().encode(key), {
-      issuer: "Upstash",
-      clockTolerance: request.clockTolerance
-    }).catch((error) => {
-      throw new SignatureError(error.message);
-    });
-    return jwt.payload;
-  }
-  verifyBodyAndUrl(payload, request) {
-    const p = payload;
-    if (request.url !== void 0 && p.sub !== request.url) {
-      throw new SignatureError(`invalid subject: ${p.sub}, want: ${request.url}`);
-    }
-    const bodyHash = index.default.SHA256(request.body).toString(index.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}`);
-    }
-  }
-};
-
-// src/client/dlq.ts
-var DLQ = class {
-  http;
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * List messages in the dlq
-   *
-   * Can be called with:
-   * - Filters: `listMessages({ filter: { url: "https://example.com" } })`
-   * - DLQ IDs: `listMessages({ dlqIds: ["id1", "id2"] })`
-   * - No filter (list all): `listMessages()`
-   */
-  async listMessages(options = {}) {
-    const query = {
-      count: options.count,
-      ..."dlqIds" in options ? { dlqIds: options.dlqIds } : { ...renameUrlGroup(options.filter ?? {}), cursor: options.cursor }
-    };
-    const messagesPayload = await this.http.request({
-      method: "GET",
-      path: ["v2", "dlq"],
-      query
-    });
-    return {
-      messages: messagesPayload.messages.map((message) => {
-        return {
-          ...message,
-          urlGroup: message.topicName,
-          ratePerSecond: "rate" in message ? message.rate : void 0
-        };
-      }),
-      cursor: messagesPayload.cursor
-    };
-  }
-  /**
-   * Remove messages from the dlq.
-   *
-   * Can be called with:
-   * - A single dlqId: `delete("id")`
-   * - An array of dlqIds: `delete(["id1", "id2"])`
-   * - An object with dlqIds: `delete({ dlqIds: ["id1", "id2"] })`
-   * - A filter object: `delete({ filter: { url: "https://example.com", label: "label" } })`
-   * - All messages: `delete({ all: true })`
-   *
-   * Pass `count` to limit the number of messages processed per call (defaults to 100).
-   * Call in a loop until cursor is undefined:
-   *
-   * ```ts
-   * let cursor: string | undefined;
-   * do {
-   *   const result = await dlq.delete({ all: true, count: 100, cursor });
-   *   cursor = result.cursor;
-   * } while (cursor);
-   * ```
-   */
-  async delete(request) {
-    if (typeof request === "string") {
-      await this.http.request({
-        method: "DELETE",
-        path: ["v2", "dlq", request],
-        parseResponseAsJson: false
-      });
-      return { deleted: 1 };
-    }
-    if (Array.isArray(request) && request.length === 0)
-      return { deleted: 0 };
-    const filters = Array.isArray(request) ? { dlqIds: request } : request;
-    return await this.http.request({
-      method: "DELETE",
-      path: ["v2", "dlq"],
-      query: buildBulkActionFilterPayload(filters)
-    });
-  }
-  /**
-   * Remove multiple messages from the dlq using their `dlqId`s
-   *
-   * @deprecated Use `delete` instead
-   */
-  async deleteMany(request) {
-    return await this.delete(request);
-  }
-  /**
-   * Retry messages from the dlq.
-   *
-   * Can be called with:
-   * - A single dlqId: `retry("id")`
-   * - An array of dlqIds: `retry(["id1", "id2"])`
-   * - An object with dlqIds: `retry({ dlqIds: ["id1", "id2"] })`
-   * - A filter object: `retry({ filter: { url: "https://example.com", label: "label" } })`
-   * - All messages: `retry({ all: true })`
-   *
-   * Pass `count` to limit the number of messages processed per call (defaults to 100).
-   * Call in a loop until cursor is undefined:
-   *
-   * ```ts
-   * let cursor: string | undefined;
-   * do {
-   *   const result = await dlq.retry({ all: true, count: 100, cursor });
-   *   cursor = result.cursor;
-   * } while (cursor);
-   * ```
-   */
-  async retry(request) {
-    if (typeof request === "string")
-      request = [request];
-    if (Array.isArray(request) && request.length === 0)
-      return { responses: [] };
-    const filters = Array.isArray(request) ? { dlqIds: request } : request;
-    return normalizeCursor(
-      await this.http.request({
-        method: "POST",
-        path: ["v2", "dlq", "retry"],
-        query: buildBulkActionFilterPayload(filters)
-      })
-    );
-  }
-};
-
-// src/client/flow-control.ts
-var FlowControlApi = class {
-  http;
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Get a single flow control by key.
-   */
-  async get(flowControlKey) {
-    return await this.http.request({
-      method: "GET",
-      path: ["v2", "flowControl", flowControlKey]
-    });
-  }
-  /**
-   * Get the global parallelism info.
-   */
-  async getGlobalParallelism() {
-    const response = await this.http.request({
-      method: "GET",
-      path: ["v2", "globalParallelism"]
-    });
-    return {
-      parallelismMax: response.parallelismMax ?? 0,
-      parallelismCount: response.parallelismCount ?? 0
-    };
-  }
-  /**
-   * Pause message delivery for a flow-control key.
-   *
-   * Messages already in the waitlist will remain there.
-   * New incoming messages will be added directly to the waitlist.
-   */
-  async pause(flowControlKey) {
-    await this.http.request({
-      method: "POST",
-      path: ["v2", "flowControl", flowControlKey, "pause"],
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Resume message delivery for a flow-control key.
-   */
-  async resume(flowControlKey) {
-    await this.http.request({
-      method: "POST",
-      path: ["v2", "flowControl", flowControlKey, "resume"],
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Pin a processing configuration for a flow-control key.
-   *
-   * While pinned, the system ignores configurations provided by incoming
-   * messages and uses the pinned configuration instead.
-   */
-  async pin(flowControlKey, options) {
-    await this.http.request({
-      method: "POST",
-      path: ["v2", "flowControl", flowControlKey, "pin"],
-      query: {
-        parallelism: options.parallelism,
-        rate: options.rate,
-        period: options.period
-      },
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Remove the pinned configuration for a flow-control key.
-   *
-   * After unpinning, the system resumes updating the configuration
-   * based on incoming messages.
-   */
-  async unpin(flowControlKey, options) {
-    await this.http.request({
-      method: "POST",
-      path: ["v2", "flowControl", flowControlKey, "unpin"],
-      query: {
-        parallelism: options.parallelism,
-        rate: options.rate
-      },
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Reset the rate configuration state for a flow-control key.
-   *
-   * Clears the current rate count and immediately ends the current period.
-   * The current timestamp becomes the start of the new rate period.
-   */
-  async resetRate(flowControlKey) {
-    await this.http.request({
-      method: "POST",
-      path: ["v2", "flowControl", flowControlKey, "resetRate"],
-      parseResponseAsJson: false
-    });
-  }
-};
-
-// src/client/http.ts
-var HttpClient = class {
-  baseUrl;
-  authorization;
-  options;
-  retry;
-  headers;
-  telemetryHeaders;
-  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 ?? 5,
-      backoff: config.retry?.backoff ?? ((retryCount) => Math.exp(retryCount) * 50)
-    };
-    this.headers = config.headers;
-    this.telemetryHeaders = config.telemetryHeaders;
-  }
-  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_;
-        if (index < this.retry.attempts) {
-          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)
-          continue;
-        if (Array.isArray(value)) {
-          if (value.length === 0) {
-            throw new QstashEmptyArrayError(key);
-          }
-          for (const item of value) {
-            url.searchParams.append(key, item);
-          }
-        } else if (value instanceof Date) {
-          url.searchParams.set(key, value.getTime().toString());
-        } else {
-          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}`,
-        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");
-    }
-  }
-};
-
-// 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
-   */
-  createThirdParty = async (request) => {
-    const { baseUrl, token, owner, organization } = 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}`,
-      ...organization ? {
-        "OpenAI-Organization": organization
-      } : {},
-      ...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/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,
-      ratePerSecond: "rate" in messagePayload ? messagePayload.rate : void 0
-    };
-    return message;
-  }
-  /**
-   * Cancel messages.
-   *
-   * Can be called with:
-   * - A single messageId: `cancel("id")`
-   * - An array of messageIds: `cancel(["id1", "id2"])`
-   * - A filter object: `cancel({ filter: { flowControlKey: "key", label: "label" } })`
-   * - All messages: `cancel({ all: true })`
-   *
-   * Pass `count` to limit the number of messages processed per call (defaults to 100).
-   * Call in a loop until `cancelled` is 0:
-   *
-   * ```ts
-   * let cancelled: number;
-   * do {
-   *   const result = await messages.cancel({ all: true, count: 100 });
-   *   cancelled = result.cancelled;
-   * } while (cancelled > 0);
-   * ```
-   */
-  async cancel(request) {
-    if (typeof request === "string") {
-      return await this.http.request({
-        method: "DELETE",
-        path: ["v2", "messages", request]
-      });
-    }
-    if (Array.isArray(request) && request.length === 0)
-      return { cancelled: 0 };
-    const filters = Array.isArray(request) ? { messageIds: request } : request;
-    return await this.http.request({
-      method: "DELETE",
-      path: ["v2", "messages"],
-      query: buildBulkActionFilterPayload(filters)
-    });
-  }
-  /**
-   * Delete a message.
-   *
-   * @deprecated Use `cancel(messageId: string)` instead
-   */
-  async delete(messageId) {
-    await this.http.request({
-      method: "DELETE",
-      path: ["v2", "messages", messageId],
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Cancel multiple messages by their messageIds.
-   *
-   * @deprecated Use `cancel(messageIds: string[])` instead
-   */
-  async deleteMany(messageIds) {
-    const result = await this.cancel(messageIds);
-    return result.cancelled;
-  }
-  /**
-   * Cancel all messages
-   * @deprecated Use `cancel({all: true})` to cancel all
-   */
-  async deleteAll() {
-    const result = await this.cancel({ all: true });
-    return result.cancelled;
-  }
-};
-
-// 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 = wrapWithGlobalHeaders(
-      processHeaders(request),
-      this.http.headers,
-      this.http.telemetryHeaders
-    );
-    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");
-    const upstashToken = String(this.http.authorization).split("Bearer ")[1];
-    const nonApiRequest = processApi(request, headers, upstashToken);
-    const response = await this.enqueue({
-      ...nonApiRequest,
-      body: JSON.stringify(nonApiRequest.body)
-    });
-    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.retryDelay !== void 0) {
-      headers.set("Upstash-Retry-Delay", request.retryDelay);
-    }
-    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);
-    }
-    if (request.queueName !== void 0) {
-      headers.set("Upstash-Queue-Name", request.queueName);
-    }
-    if (request.flowControl?.key) {
-      const parallelism = request.flowControl.parallelism?.toString();
-      const rate = (request.flowControl.rate ?? request.flowControl.ratePerSecond)?.toString();
-      const period = typeof request.flowControl.period === "number" ? `${request.flowControl.period}s` : request.flowControl.period;
-      const controlValue = [
-        parallelism ? `parallelism=${parallelism}` : void 0,
-        rate ? `rate=${rate}` : void 0,
-        period ? `period=${period}` : void 0
-      ].filter(Boolean);
-      if (controlValue.length === 0) {
-        throw new QstashError(
-          "Provide at least one of parallelism or ratePerSecond for flowControl"
-        );
-      }
-      headers.set("Upstash-Flow-Control-Key", request.flowControl.key);
-      headers.set("Upstash-Flow-Control-Value", controlValue.join(", "));
-    }
-    if (request.label !== void 0) {
-      headers.set("Upstash-Label", request.label);
-    }
-    if (request.redact !== void 0) {
-      const redactParts = [];
-      if (request.redact.body) {
-        redactParts.push("body");
-      }
-      if (request.redact.header !== void 0) {
-        if (request.redact.header === true) {
-          redactParts.push("header");
-        } else if (Array.isArray(request.redact.header) && request.redact.header.length > 0) {
-          for (const headerName of request.redact.header) {
-            redactParts.push(`header[${headerName}]`);
-          }
-        }
-      }
-      if (redactParts.length > 0) {
-        headers.set("Upstash-Redact-Fields", redactParts.join(","));
-      }
-    }
-    return await this.http.request({
-      method: "POST",
-      headers: wrapWithGlobalHeaders(headers, this.http.headers, this.http.telemetryHeaders),
-      path: ["v2", "schedules", request.destination],
-      body: request.body
-    });
-  }
-  /**
-   * Get a schedule
-   */
-  async get(scheduleId) {
-    const schedule = await this.http.request({
-      method: "GET",
-      path: ["v2", "schedules", scheduleId]
-    });
-    if ("rate" in schedule)
-      schedule.ratePerSecond = schedule.rate;
-    return schedule;
-  }
-  /**
-   * List your schedules
-   */
-  async list() {
-    const schedules = await this.http.request({
-      method: "GET",
-      path: ["v2", "schedules"]
-    });
-    for (const schedule of schedules) {
-      if ("rate" in schedule)
-        schedule.ratePerSecond = schedule.rate;
-    }
-    return 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
-    });
-  }
-};
-
-// version.ts
-var VERSION = "2.10.1";
-
-// src/client/client.ts
-var Client = class {
-  http;
-  token;
-  constructor(config) {
-    const environment = getSafeEnvironment();
-    const { baseUrl, token } = getClientCredentials({ environment, config });
-    const enableTelemetry = environment.UPSTASH_DISABLE_TELEMETRY ? false : config?.enableTelemetry ?? true;
-    const isCloudflare = typeof caches !== "undefined" && "default" in caches;
-    const telemetryHeaders = new Headers(
-      enableTelemetry ? {
-        "Upstash-Telemetry-Sdk": `upstash-qstash-js@${VERSION}`,
-        "Upstash-Telemetry-Platform": isCloudflare ? "cloudflare" : environment.VERCEL ? "vercel" : environment.AWS_REGION ? "aws" : "",
-        "Upstash-Telemetry-Runtime": getRuntime()
-      } : {}
-    );
-    this.http = new HttpClient({
-      retry: config?.retry,
-      baseUrl,
-      authorization: `Bearer ${token}`,
-      //@ts-expect-error caused by undici and bunjs type overlap
-      headers: prefixHeaders(new Headers(config?.headers ?? {})),
-      //@ts-expect-error caused by undici and bunjs type overlap
-      telemetryHeaders
-    });
-    this.token = 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 flow control API.
-   *
-   * List, get, or reset flow controls.
-   */
-  get flowControl() {
-    return new FlowControlApi(this.http);
-  }
-  /**
-   * Access the workflow API.
-   *
-   * cancel workflows.
-   *
-   * @deprecated as of version 2.7.17. Will be removed in qstash-js 3.0.0.
-   * Please use @upstash/workflow instead https://github.com/upstash/workflow-js
-   * Migration Guide: https://upstash.com/docs/workflow/migration
-   */
-  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.
-   *
-   * @deprecated This will be removed in qstash-js 3.0.0. Please use an alternative SDK for interacting with LLMs.
-   *
-   * Use the create or prompt methods.
-   */
-  chat() {
-    return new Chat(this.http, this.token);
-  }
-  async publish(request) {
-    const headers = wrapWithGlobalHeaders(
-      processHeaders(request),
-      this.http.headers,
-      this.http.telemetryHeaders
-    );
-    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");
-    const upstashToken = String(this.http.authorization).split("Bearer ")[1];
-    const nonApiRequest = processApi(request, headers, upstashToken);
-    const response = await this.publish({
-      ...nonApiRequest,
-      body: JSON.stringify(nonApiRequest.body)
-    });
-    return response;
-  }
-  /**
-   * Batch publish messages to QStash.
-   */
-  async batch(request) {
-    const messages = [];
-    for (const message of request) {
-      const headers = wrapWithGlobalHeaders(
-        processHeaders(message),
-        this.http.headers,
-        this.http.telemetryHeaders
-      );
-      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) {
-    const batchPayload = request.map((message) => {
-      if ("body" in message) {
-        message.body = JSON.stringify(message.body);
-      }
-      const upstashToken = String(this.http.authorization).split("Bearer ")[1];
-      const nonApiMessage = processApi(message, new Headers(message.headers), upstashToken);
-      nonApiMessage.headers.set("Content-Type", "application/json");
-      return nonApiMessage;
-    });
-    const response = await this.batch(batchPayload);
-    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 logs(request = {}) {
-    const query = {
-      count: request.count,
-      ..."messageIds" in request ? { messageIds: request.messageIds } : { ...renameUrlGroup(request.filter ?? {}), cursor: request.cursor }
-    };
-    const responsePayload = await this.http.request({
-      path: ["v2", "events"],
-      method: "GET",
-      query
-    });
-    const logs = responsePayload.events.map((event) => ({ ...event, urlGroup: event.topicName }));
-    return { cursor: responsePayload.cursor, logs, events: logs };
-  }
-  /**
-   * @deprecated Will be removed in the next major release. Use the `logs` method instead.
-   *
-   * 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) {
-    return await this.logs(request);
-  }
-};
-
-// 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;
-  }
-};
-
-exports.BaseProvider = BaseProvider;
-exports.Chat = Chat;
-exports.Client = Client;
-exports.FlowControlApi = FlowControlApi;
-exports.Messages = Messages;
-exports.QstashChatRatelimitError = QstashChatRatelimitError;
-exports.QstashDailyRatelimitError = QstashDailyRatelimitError;
-exports.QstashEmptyArrayError = QstashEmptyArrayError;
-exports.QstashError = QstashError;
-exports.QstashRatelimitError = QstashRatelimitError;
-exports.Receiver = Receiver;
-exports.Schedules = Schedules;
-exports.SignatureError = SignatureError;
-exports.UrlGroups = UrlGroups;
-exports.Workflow = Workflow;
-exports.setupAnalytics = setupAnalytics;
-exports.upstash = upstash;