@upstash/qstash 2.8.4 → 2.9.0-rc

package/h3.js

@@ -361,120 +361,154 @@ var H3Response = globalThis.Response;
 // src/receiver.ts
 var jose = __toESM(require("jose"));
 var import_crypto_js = __toESM(require("crypto-js"));
-var SignatureError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SignatureError";
+
+// 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("/")}`;
   }
 };
-var Receiver = class {
-  currentSigningKey;
-  nextSigningKey;
-  constructor(config) {
-    this.currentSigningKey = config.currentSigningKey;
-    this.nextSigningKey = config.nextSigningKey;
+
+// 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;
   }
-  /**
-   * 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) {
-    let payload;
-    try {
-      payload = await this.verifyWithKey(this.currentSigningKey, request);
-    } catch {
-      payload = await this.verifyWithKey(this.nextSigningKey, request);
+  getRoute() {
+    return this.owner === "anthropic" ? ["v1", "messages"] : ["v1", "chat", "completions"];
+  }
+  getHeaders(options) {
+    if (this.owner === "upstash" && !options.analytics) {
+      return { "content-type": "application/json" };
     }
-    this.verifyBodyAndUrl(payload, request);
-    return true;
+    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;
   }
   /**
-   * Verify signature with a specific signing key
+   * Checks if callback exists and adds analytics in place if it's set.
+   *
+   * @param request
+   * @param options
    */
-  async verifyWithKey(key, request) {
-    const jwt = await jose.jwtVerify(request.signature, new TextEncoder().encode(key), {
-      issuer: "Upstash",
-      clockTolerance: request.clockTolerance
-    }).catch((error) => {
-      throw new SignatureError(error.message);
-    });
-    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 = import_crypto_js.default.SHA256(request.body).toString(import_crypto_js.default.enc.Base64url);
-    const padding = new RegExp(/=+$/);
-    if (p.body.replace(padding, "") !== bodyHash.replace(padding, "")) {
-      throw new SignatureError(`body hash does not match, want: ${p.body}, got: ${bodyHash}`);
+  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/dlq.ts
-var DLQ = class {
-  http;
-  constructor(http) {
-    this.http = http;
+// 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;
   }
-  /**
-   * List messages in the dlq
-   */
-  async listMessages(options) {
-    const filterPayload = {
-      ...options?.filter,
-      topicName: options?.filter?.urlGroup
+  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 }
     };
-    const messagesPayload = await this.http.request({
-      method: "GET",
-      path: ["v2", "dlq"],
-      query: {
-        cursor: options?.cursor,
-        count: options?.count,
-        ...filterPayload
-      }
-    });
+  } else {
     return {
-      messages: messagesPayload.messages.map((message) => {
-        return {
-          ...message,
-          urlGroup: message.topicName,
-          ratePerSecond: "rate" in message ? message.rate : void 0
-        };
-      }),
-      cursor: messagesPayload.cursor
+      ...request,
+      method: request.method ?? method,
+      headers: safeJoinHeaders(headers, appendHeaders),
+      url,
+      api: void 0
     };
   }
-  /**
-   * Remove a message from the dlq using it's `dlqId`
-   */
-  async delete(dlqMessageId) {
-    return await this.http.request({
-      method: "DELETE",
-      path: ["v2", "dlq", dlqMessageId],
-      parseResponseAsJson: false
-      // there is no response
-    });
-  }
-  /**
-   * Remove multiple messages from the dlq using their `dlqId`s
-   */
-  async deleteMany(request) {
-    return await this.http.request({
-      method: "DELETE",
-      path: ["v2", "dlq"],
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ dlqIds: request.dlqIds })
-    });
-  }
 };
+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;
@@ -556,644 +590,764 @@ var formatWorkflowError = (error) => {
   };
 };
 
-// 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();
+// src/client/utils.ts
+var isIgnoredHeader = (header) => {
+  const lowerCaseHeader = header.toLowerCase();
+  return lowerCaseHeader.startsWith("content-type") || lowerCaseHeader.startsWith("upstash-");
+};
+function prefixHeaders(headers) {
+  const keysToBePrefixed = [...headers.keys()].filter((key) => !isIgnoredHeader(key));
+  for (const key of keysToBePrefixed) {
+    const value = headers.get(key);
+    if (value !== null) {
+      headers.set(`Upstash-Forward-${key}`, value);
     }
+    headers.delete(key);
   }
-  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);
+  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`);
     }
-    const requestOptions = {
-      method: request.method,
-      headers,
-      body: request.body,
-      keepalive: request.keepalive
-    };
-    const url = new URL([request.baseUrl ?? this.baseUrl, ...request.path].join("/"));
-    if (request.query) {
-      for (const [key, value] of Object.entries(request.query)) {
-        if (value !== void 0) {
-          url.searchParams.set(key, value.toString());
-        }
-      }
+  }
+  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`);
     }
-    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 (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");
     }
-    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
+    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);
+  }
+  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)}`);
+}
+var NANOID_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
+var NANOID_LENGTH = 21;
+function nanoid() {
+  return [...crypto.getRandomValues(new Uint8Array(NANOID_LENGTH))].map((x) => NANOID_CHARS[x % NANOID_CHARS.length]).join("");
+}
+function decodeBase64(base64) {
+  try {
+    const binString = atob(base64);
+    const intArray = Uint8Array.from(binString, (m) => m.codePointAt(0));
+    return new TextDecoder().decode(intArray);
+  } catch (error) {
+    try {
+      const result = atob(base64);
+      console.warn(
+        `Upstash QStash: Failed while decoding base64 "${base64}". Decoding with atob and returning it instead. ${error}`
       );
+      return result;
+    } catch (error2) {
+      console.warn(
+        `Upstash QStash: Failed to decode base64 "${base64}" with atob. Returning it as it is. ${error2}`
+      );
+      return base64;
     }
   }
+}
+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/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}`
-            }
-          };
-        }
+// 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.`
+        );
       }
-    }
-    default: {
-      throw new Error("Unknown analytics provider");
+    } 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/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"
-      } : {}
+// 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
     };
-    if (request.analytics) {
-      const { baseURL, defaultHeaders } = setupAnalytics(
-        { name: "helicone", token: request.analytics.token },
-        this.getAuthorizationToken(),
-        request.provider.baseUrl,
-        "upstash"
+  }
+  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.`
       );
-      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
-    });
+  }
+  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;
+  }
   /**
-   * Calls the Upstash completions api given a ChatRequest.
+   * Verify the signature of a request.
    *
-   * Returns a ChatCompletion or a stream of ChatCompletionChunks
-   * if stream is enabled.
+   * 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.
    *
-   * @param request ChatRequest with messages
-   * @returns Chat completion or stream
+   * If that fails, the signature is invalid and a `SignatureError` is thrown.
    */
-  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
+  async verify(request) {
+    const environment = getSafeEnvironment();
+    const signingKeys = getReceiverSigningKeys({
+      environment,
+      regionFromHeader: request.upstashRegion,
+      config: {
+        currentSigningKey: this.currentSigningKey,
+        nextSigningKey: this.nextSigningKey
+      }
     });
-    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");
+    if (!signingKeys) {
+      throw new Error(
+        "[Upstash QStash] No signing keys available for verification. See the warning above for more details."
+      );
     }
-    return match[1];
+    let payload;
+    try {
+      payload = await this.verifyWithKey(signingKeys.currentSigningKey, request);
+    } catch {
+      payload = await this.verifyWithKey(signingKeys.nextSigningKey, request);
+    }
+    this.verifyBodyAndUrl(payload, request);
+    return true;
   }
   /**
-   * 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
+   * Verify signature with a specific signing key
    */
-  prompt = async (request) => {
-    const chatRequest = _Chat.toChatRequest(request);
-    return this.create(chatRequest);
-  };
+  async verifyWithKey(key, request) {
+    const jwt = await jose.jwtVerify(request.signature, new TextEncoder().encode(key), {
+      issuer: "Upstash",
+      clockTolerance: request.clockTolerance
+    }).catch((error) => {
+      throw new SignatureError(error.message);
+    });
+    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 = import_crypto_js.default.SHA256(request.body).toString(import_crypto_js.default.enc.Base64url);
+    const padding = new RegExp(/=+$/);
+    if (p.body.replace(padding, "") !== bodyHash.replace(padding, "")) {
+      throw new SignatureError(`body hash does not match, want: ${p.body}, got: ${bodyHash}`);
+    }
+  }
 };
 
-// src/client/messages.ts
-var Messages = class {
+// src/client/dlq.ts
+var DLQ = class {
   http;
   constructor(http) {
     this.http = http;
   }
   /**
-   * Get a message
+   * List messages in the dlq
    */
-  async get(messageId) {
-    const messagePayload = await this.http.request({
+  async listMessages(options) {
+    const filterPayload = {
+      ...options?.filter,
+      topicName: options?.filter?.urlGroup
+    };
+    const messagesPayload = await this.http.request({
       method: "GET",
-      path: ["v2", "messages", messageId]
+      path: ["v2", "dlq"],
+      query: {
+        cursor: options?.cursor,
+        count: options?.count,
+        ...filterPayload
+      }
     });
-    const message = {
-      ...messagePayload,
-      urlGroup: messagePayload.topicName,
-      ratePerSecond: "rate" in messagePayload ? messagePayload.rate : void 0
+    return {
+      messages: messagesPayload.messages.map((message) => {
+        return {
+          ...message,
+          urlGroup: message.topicName,
+          ratePerSecond: "rate" in message ? message.rate : void 0
+        };
+      }),
+      cursor: messagesPayload.cursor
     };
-    return message;
   }
   /**
-   * Cancel a message
+   * Remove a message from the dlq using it's `dlqId`
    */
-  async delete(messageId) {
+  async delete(dlqMessageId) {
     return await this.http.request({
       method: "DELETE",
-      path: ["v2", "messages", messageId],
+      path: ["v2", "dlq", dlqMessageId],
       parseResponseAsJson: false
+      // there is no response
     });
   }
-  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
+   * Remove multiple messages from the dlq using their `dlqId`s
    */
-  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);
+  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 joinedHeaders;
 };
-var processApi = (request, headers, upstashToken) => {
-  if (!request.api) {
-    request.headers = headers;
-    return request;
+
+// 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;
   }
-  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.");
+  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 {
-      ...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 }
+      response,
+      error
     };
-  } else {
-    return {
-      ...request,
-      method: request.method ?? method,
-      headers: safeJoinHeaders(headers, appendHeaders),
-      url,
-      api: void 0
+  };
+  processRequest = (request) => {
+    const headers = new Headers(request.headers);
+    if (!headers.has("Authorization")) {
+      headers.set("Authorization", this.authorization);
+    }
+    const requestOptions = {
+      method: request.method,
+      headers,
+      body: request.body,
+      keepalive: request.keepalive
     };
+    const url = new URL([request.baseUrl ?? this.baseUrl, ...request.path].join("/"));
+    if (request.query) {
+      for (const [key, value] of Object.entries(request.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, value.toString());
+        }
+      }
+    }
+    return [url.toString(), requestOptions];
+  };
+  async checkResponse(response) {
+    if (response.status === 429) {
+      if (response.headers.get("x-ratelimit-limit-requests")) {
+        throw new QstashChatRatelimitError({
+          "limit-requests": response.headers.get("x-ratelimit-limit-requests"),
+          "limit-tokens": response.headers.get("x-ratelimit-limit-tokens"),
+          "remaining-requests": response.headers.get("x-ratelimit-remaining-requests"),
+          "remaining-tokens": response.headers.get("x-ratelimit-remaining-tokens"),
+          "reset-requests": response.headers.get("x-ratelimit-reset-requests"),
+          "reset-tokens": response.headers.get("x-ratelimit-reset-tokens")
+        });
+      } else if (response.headers.get("RateLimit-Limit")) {
+        throw new QstashDailyRatelimitError({
+          limit: response.headers.get("RateLimit-Limit"),
+          remaining: response.headers.get("RateLimit-Remaining"),
+          reset: response.headers.get("RateLimit-Reset")
+        });
+      }
+      throw new QstashRatelimitError({
+        limit: response.headers.get("Burst-RateLimit-Limit"),
+        remaining: response.headers.get("Burst-RateLimit-Remaining"),
+        reset: response.headers.get("Burst-RateLimit-Reset")
+      });
+    }
+    if (response.status < 200 || response.status >= 300) {
+      const body = await response.text();
+      throw new QstashError(
+        body.length > 0 ? body : `Error: status=${response.status}`,
+        response.status
+      );
+    }
   }
 };
-function updateWithAnalytics(providerInfo, analytics) {
+
+// src/client/llm/providers.ts
+var setupAnalytics = (analytics, providerApiKey, providerBaseUrl, provider) => {
+  if (!analytics)
+    return {};
   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);
+      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}`
+            }
+          };
+        }
       }
-      return providerInfo;
     }
     default: {
-      throw new Error("Unknown analytics provider");
-    }
-  }
-}
-function updateProviderInfo(providerInfo, baseUrl, route) {
-  providerInfo.baseUrl = baseUrl;
-  providerInfo.route = route;
-  providerInfo.url = `${baseUrl}/${route.join("/")}`;
-}
-
-// src/client/utils.ts
-var isIgnoredHeader = (header) => {
-  const lowerCaseHeader = header.toLowerCase();
-  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);
+      throw new Error("Unknown analytics provider");
+    }
   }
-  if (request.callback !== void 0) {
-    headers.set("Upstash-Callback", request.callback);
+};
+
+// src/client/llm/chat.ts
+var Chat = class _Chat {
+  http;
+  token;
+  constructor(http, token) {
+    this.http = http;
+    this.token = token;
   }
-  if (request.failureCallback !== void 0) {
-    headers.set("Upstash-Failure-Callback", request.failureCallback);
+  static toChatRequest(request) {
+    const messages = [];
+    messages.push(
+      { role: "system", content: request.system },
+      { role: "user", content: request.user }
+    );
+    const chatRequest = { ...request, messages };
+    return chatRequest;
   }
-  if (request.timeout !== void 0) {
-    if (typeof request.timeout === "string") {
-      headers.set("Upstash-Timeout", request.timeout);
-    } else {
-      headers.set("Upstash-Timeout", `${request.timeout}s`);
+  /**
+   * 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;
     }
-  }
-  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");
+    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");
     }
-    headers.set("Upstash-Flow-Control-Key", request.flowControl.key);
-    headers.set("Upstash-Flow-Control-Value", controlValue.join(", "));
+    return match[1];
   }
-  if (request.label !== void 0) {
-    headers.set("Upstash-Label", request.label);
+  /**
+   * 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;
   }
-  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;
+  /**
+   * 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;
   }
-  throw new QstashError(`Failed to infer request path for ${JSON.stringify(request)}`);
-}
-var NANOID_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
-var NANOID_LENGTH = 21;
-function nanoid() {
-  return [...crypto.getRandomValues(new Uint8Array(NANOID_LENGTH))].map((x) => NANOID_CHARS[x % NANOID_CHARS.length]).join("");
-}
-function decodeBase64(base64) {
-  try {
-    const binString = atob(base64);
-    const intArray = Uint8Array.from(binString, (m) => m.codePointAt(0));
-    return new TextDecoder().decode(intArray);
-  } catch (error) {
-    try {
-      const result = atob(base64);
-      console.warn(
-        `Upstash QStash: Failed while decoding base64 "${base64}". Decoding with atob and returning it instead. ${error}`
-      );
-      return result;
-    } catch (error2) {
-      console.warn(
-        `Upstash QStash: Failed to decode base64 "${base64}" with atob. Returning it as it is. ${error2}`
-      );
-      return base64;
-    }
+  /**
+   * Cancel a message
+   */
+  async delete(messageId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages", messageId],
+      parseResponseAsJson: false
+    });
   }
-}
-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 "";
-}
+  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/queue.ts
 var Queue = class {
@@ -2910,19 +3064,15 @@ var Workflow = class {
 };
 
 // version.ts
-var VERSION = "v2.8.4";
+var VERSION = "v2.9.0-rc";
 
 // 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(
@@ -2941,11 +3091,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;
   }
   /**
@@ -3177,15 +3322,10 @@ var Client = class {
 // platforms/h3.ts
 var verifySignatureH3 = (handler, config) => {
   const currentSigningKey = config?.currentSigningKey ?? process.env.QSTASH_CURRENT_SIGNING_KEY;
-  if (!currentSigningKey) {
-    throw new Error(
-      "currentSigningKey is required, either in the config or as env variable QSTASH_CURRENT_SIGNING_KEY"
-    );
-  }
   const nextSigningKey = config?.nextSigningKey ?? process.env.QSTASH_NEXT_SIGNING_KEY;
-  if (!nextSigningKey) {
+  if (!currentSigningKey && !nextSigningKey && !process.env.QSTASH_REGION) {
     throw new Error(
-      "nextSigningKey is required, either in the config or as env variable QSTASH_NEXT_SIGNING_KEY"
+      "currentSigningKey and nextSigningKey are required, either in the config or as env variables (QSTASH_CURRENT_SIGNING_KEY and QSTASH_NEXT_SIGNING_KEY)"
     );
   }
   const receiver = new Receiver({
@@ -3200,11 +3340,13 @@ var verifySignatureH3 = (handler, config) => {
     if (typeof signature !== "string") {
       throw new TypeError("`Upstash-Signature` header is not a string");
     }
+    const upstashRegion = getHeader(event, "upstash-region");
     const body = await readRawBody(event);
     const isValid = await receiver.verify({
       signature,
       body: JSON.stringify(body),
-      clockTolerance: config?.clockTolerance
+      clockTolerance: config?.clockTolerance,
+      upstashRegion: typeof upstashRegion === "string" ? upstashRegion : void 0
     });
     if (!isValid) {
       return { status: 403, body: "invalid signature" };