@windrun-huaiin/backend-core 13.0.0 → 14.1.0

package/dist/node_modules/.pnpm/{@upstash_qstash@2.8.4/node_modules/@upstash/qstash/chunk-RQPZUJXG.js → @upstash_qstash@2.10.1/node_modules/@upstash/qstash/chunk-35B33QW3.js}

@@ -1,9 +1,526 @@
 'use strict';
 
-var index = require('../../../../../../_virtual/index2.js');
+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) {
@@ -15,8 +532,8 @@ var Receiver = class {
   currentSigningKey;
   nextSigningKey;
   constructor(config) {
-    this.currentSigningKey = config.currentSigningKey;
-    this.nextSigningKey = config.nextSigningKey;
+    this.currentSigningKey = config?.currentSigningKey;
+    this.nextSigningKey = config?.nextSigningKey;
   }
   /**
    * Verify the signature of a request.
@@ -28,11 +545,25 @@ var Receiver = class {
    * 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(this.currentSigningKey, request);
+      payload = await this.verifyWithKey(signingKeys.currentSigningKey, request);
     } catch {
-      payload = await this.verifyWithKey(this.nextSigningKey, request);
+      payload = await this.verifyWithKey(signingKeys.nextSigningKey, request);
     }
     this.verifyBodyAndUrl(payload, request);
     return true;
@@ -54,7 +585,7 @@ var Receiver = class {
     if (request.url !== void 0 && p.sub !== request.url) {
       throw new SignatureError(`invalid subject: ${p.sub}, want: ${request.url}`);
     }
-    const bodyHash = index.SHA256(request.body).toString(index.enc.Base64url);
+    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}`);
@@ -70,20 +601,21 @@ var DLQ = class {
   }
   /**
    * 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 filterPayload = {
-      ...options?.filter,
-      topicName: options?.filter?.urlGroup
+  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: {
-        cursor: options?.cursor,
-        count: options?.count,
-        ...filterPayload
-      }
+      query
     });
     return {
       messages: messagesPayload.messages.map((message) => {
@@ -97,79 +629,187 @@ var DLQ = class {
     };
   }
   /**
-   * Remove a message from the dlq using it's `dlqId`
+   * 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(dlqMessageId) {
+  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", dlqMessageId],
-      parseResponseAsJson: false
-      // there is no response
+      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.http.request({
-      method: "DELETE",
-      path: ["v2", "dlq"],
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ dlqIds: request.dlqIds })
-    });
+    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/error.ts
-var RATELIMIT_STATUS = 429;
-var QstashError = class extends Error {
-  status;
-  constructor(message, status) {
-    super(message);
-    this.name = "QstashError";
-    this.status = status;
+// src/client/flow-control.ts
+var FlowControlApi = class {
+  http;
+  constructor(http) {
+    this.http = http;
   }
-};
-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;
+  /**
+   * Get a single flow control by key.
+   */
+  async get(flowControlKey) {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "flowControl", flowControlKey]
+    });
   }
-};
-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"];
+  /**
+   * 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
+    });
   }
-};
-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;
+  /**
+   * 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
+    });
   }
 };
 
@@ -270,7 +910,18 @@ var HttpClient = class {
     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) {
+        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());
         }
       }
@@ -421,371 +1072,151 @@ var Chat = class _Chat {
    */
   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 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/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
+    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
     };
-  }
-};
-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");
+    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];
   }
-}
-function updateProviderInfo(providerInfo, baseUrl, route) {
-  providerInfo.baseUrl = baseUrl;
-  providerInfo.route = route;
-  providerInfo.url = `${baseUrl}/${route.join("/")}`;
-}
-
-// src/client/utils.ts
-var isIgnoredHeader = (header) => {
-  const lowerCaseHeader = header.toLowerCase();
-  return lowerCaseHeader.startsWith("content-type") || lowerCaseHeader.startsWith("upstash-");
+  /**
+   * 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);
+  };
 };
-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);
+
+// src/client/messages.ts
+var Messages = class {
+  http;
+  constructor(http) {
+    this.http = http;
   }
-  if (request.failureCallback !== void 0) {
-    headers.set("Upstash-Failure-Callback", request.failureCallback);
+  /**
+   * 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;
   }
-  if (request.timeout !== void 0) {
-    if (typeof request.timeout === "string") {
-      headers.set("Upstash-Timeout", request.timeout);
-    } else {
-      headers.set("Upstash-Timeout", `${request.timeout}s`);
+  /**
+   * 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)
+    });
   }
-  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(", "));
+  /**
+   * Delete a message.
+   *
+   * @deprecated Use `cancel(messageId: string)` instead
+   */
+  async delete(messageId) {
+    await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages", messageId],
+      parseResponseAsJson: false
+    });
   }
-  if (request.label !== void 0) {
-    headers.set("Upstash-Label", request.label);
+  /**
+   * Cancel multiple messages by their messageIds.
+   *
+   * @deprecated Use `cancel(messageIds: string[])` instead
+   */
+  async deleteMany(messageIds) {
+    const result = await this.cancel(messageIds);
+    return result.cancelled;
   }
-  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;
+  /**
+   * Cancel all messages
+   * @deprecated Use `cancel({all: true})` to cancel all
+   */
+  async deleteAll() {
+    const result = await this.cancel({ all: true });
+    return result.cancelled;
   }
-  throw new QstashError(`Failed to infer request path for ${JSON.stringify(request)}`);
-}
-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 "";
-}
+};
 
 // src/client/queue.ts
 var Queue = class {
@@ -987,6 +1418,24 @@ var Schedules = class {
     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),
@@ -1116,19 +1565,15 @@ var UrlGroups = class {
 };
 
 // version.ts
-var VERSION = "v2.8.4";
+var VERSION = "2.10.1";
 
 // src/client/client.ts
 var Client = class {
   http;
   token;
   constructor(config) {
-    const environment = typeof process === "undefined" ? {} : process.env;
-    let baseUrl = (config?.baseUrl ?? environment.QSTASH_URL ?? "https://qstash.upstash.io").replace(/\/$/, "");
-    if (baseUrl === "https://qstash.upstash.io/v2/publish") {
-      baseUrl = "https://qstash.upstash.io";
-    }
-    const token = config?.token ?? environment.QSTASH_TOKEN;
+    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(
@@ -1147,11 +1592,6 @@ var Client = class {
       //@ts-expect-error caused by undici and bunjs type overlap
       telemetryHeaders
     });
-    if (!token) {
-      console.warn(
-        "[Upstash QStash] client token is not set. Either pass a token or set QSTASH_TOKEN env variable."
-      );
-    }
     this.token = token;
   }
   /**
@@ -1196,6 +1636,14 @@ var Client = class {
   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.
    *
@@ -1320,39 +1768,18 @@ var Client = class {
    * }
    * ```
    */
-  async logs(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();
-      }
-    }
+  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) => {
-      return {
-        ...event,
-        urlGroup: event.topicName
-      };
-    });
-    return {
-      cursor: responsePayload.cursor,
-      logs,
-      events: logs
-    };
+    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.
@@ -1405,9 +1832,11 @@ var Workflow = class {
 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;