@upstash/qstash 2.8.3 → 2.9.0-rc

package/index.js

@@ -57,120 +57,170 @@ module.exports = __toCommonJS(src_exports);
 // src/receiver.ts
 var jose = __toESM(require("jose"));
 var import_crypto_js = __toESM(require("crypto-js"));
-var SignatureError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SignatureError";
+
+// 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");
+};
+var openai = ({
+  token,
+  organization
+}) => {
+  return new LLMProvider("https://api.openai.com", token, "openai", organization);
+};
+var anthropic = ({ token }) => {
+  return new LLMProvider("https://api.anthropic.com", token, "anthropic");
+};
+var custom = ({
+  baseUrl,
+  token
+}) => {
+  const trimmedBaseUrl = baseUrl.replace(/\/(v1\/)?chat\/completions$/, "");
+  return new LLMProvider(trimmedBaseUrl, token, "custom");
+};
 
-// src/client/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;
@@ -230,26 +280,425 @@ var QStashWorkflowError = class extends QstashError {
     this.name = "QStashWorkflowError";
   }
 };
-var QStashWorkflowAbort = class extends Error {
-  stepInfo;
-  stepName;
-  constructor(stepName, stepInfo) {
-    super(
-      `This is an Upstash Workflow error thrown after a step executes. It is expected to be raised. Make sure that you await for each step. Also, if you are using try/catch blocks, you should not wrap context.run/sleep/sleepUntil/call methods with try/catch. Aborting workflow after executing step '${stepName}'.`
-    );
-    this.name = "QStashWorkflowAbort";
-    this.stepName = stepName;
-    this.stepInfo = stepInfo;
+var QStashWorkflowAbort = class extends Error {
+  stepInfo;
+  stepName;
+  constructor(stepName, stepInfo) {
+    super(
+      `This is an Upstash Workflow error thrown after a step executes. It is expected to be raised. Make sure that you await for each step. Also, if you are using try/catch blocks, you should not wrap context.run/sleep/sleepUntil/call methods with try/catch. Aborting workflow after executing step '${stepName}'.`
+    );
+    this.name = "QStashWorkflowAbort";
+    this.stepName = stepName;
+    this.stepInfo = stepInfo;
+  }
+};
+var formatWorkflowError = (error) => {
+  return error instanceof Error ? {
+    error: error.name,
+    message: error.message
+  } : {
+    error: "Error",
+    message: "An error occured while executing workflow."
+  };
+};
+
+// src/client/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);
+  }
+  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);
+  }
+  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 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/multi-region/incoming.ts
+var getReceiverSigningKeys = ({
+  environment,
+  regionFromHeader,
+  config
+}) => {
+  if (config?.currentSigningKey && config.nextSigningKey) {
+    return {
+      currentSigningKey: config.currentSigningKey,
+      nextSigningKey: config.nextSigningKey
+    };
+  }
+  const regionEnvironment = getRegionFromEnvironment(environment);
+  if (regionEnvironment) {
+    const regionHeader = normalizeRegionHeader(regionFromHeader);
+    if (regionHeader) {
+      const regionCreds = readReceiverEnvironmentVariables(environment, regionHeader);
+      if (regionCreds.QSTASH_CURRENT_SIGNING_KEY && regionCreds.QSTASH_NEXT_SIGNING_KEY) {
+        return {
+          currentSigningKey: regionCreds.QSTASH_CURRENT_SIGNING_KEY,
+          nextSigningKey: regionCreds.QSTASH_NEXT_SIGNING_KEY,
+          region: regionHeader
+        };
+      } else {
+        console.warn(
+          `[Upstash QStash] Signing keys not found for region "${regionHeader}". Falling back to default signing keys.`
+        );
+      }
+    } else {
+      console.warn(
+        `[Upstash QStash] Invalid UPSTASH_REGION header value: "${regionFromHeader}". Expected one of: EU-CENTRAL-1, US-EAST-1. Falling back to default signing keys.`
+      );
+    }
+  }
+  const defaultCreds = readReceiverEnvironmentVariables(environment);
+  if (defaultCreds.QSTASH_CURRENT_SIGNING_KEY && defaultCreds.QSTASH_NEXT_SIGNING_KEY) {
+    return {
+      currentSigningKey: defaultCreds.QSTASH_CURRENT_SIGNING_KEY,
+      nextSigningKey: defaultCreds.QSTASH_NEXT_SIGNING_KEY
+    };
+  }
+};
+
+// src/client/multi-region/outgoing.ts
+var getClientCredentials = (clientCredentialConfig) => {
+  const credentials = resolveCredentials(clientCredentialConfig);
+  return verifyCredentials(credentials);
+};
+var resolveCredentials = ({
+  environment,
+  config
+}) => {
+  if (config?.baseUrl && config.token) {
+    return {
+      baseUrl: config.baseUrl,
+      token: config.token
+    };
+  }
+  const region = getRegionFromEnvironment(environment);
+  if (region) {
+    const regionCreds = readClientEnvironmentVariables(environment, region);
+    if (regionCreds.QSTASH_URL && regionCreds.QSTASH_TOKEN) {
+      return {
+        baseUrl: regionCreds.QSTASH_URL,
+        token: regionCreds.QSTASH_TOKEN,
+        region
+      };
+    } else {
+      console.warn(
+        `[Upstash QStash] QSTASH_REGION is set to "${region}" but credentials are missing. Expected ${region}_QSTASH_URL and ${region}_QSTASH_TOKEN. Falling back to default credentials.`
+      );
+    }
+  }
+  const defaultCreds = readClientEnvironmentVariables(environment);
+  return {
+    baseUrl: config?.baseUrl ?? defaultCreds.QSTASH_URL ?? DEFAULT_QSTASH_URL,
+    token: config?.token ?? defaultCreds.QSTASH_TOKEN ?? ""
+  };
+};
+var verifyCredentials = (credentials) => {
+  const token = credentials.token;
+  let baseUrl = credentials.baseUrl;
+  baseUrl = baseUrl.replace(/\/$/, "");
+  if (baseUrl === "https://qstash.upstash.io/v2/publish") {
+    baseUrl = DEFAULT_QSTASH_URL;
+  }
+  if (!token) {
+    console.warn(
+      "[Upstash QStash] client token is not set. Either pass a token or set QSTASH_TOKEN env variable."
+    );
+  }
+  return { baseUrl, token };
+};
+
+// src/receiver.ts
+var SignatureError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SignatureError";
+  }
+};
+var Receiver = class {
+  currentSigningKey;
+  nextSigningKey;
+  constructor(config) {
+    this.currentSigningKey = config?.currentSigningKey;
+    this.nextSigningKey = config?.nextSigningKey;
+  }
+  /**
+   * Verify the signature of a request.
+   *
+   * Tries to verify the signature with the current signing key.
+   * If that fails, maybe because you have rotated the keys recently, it will
+   * try to verify the signature with the next signing key.
+   *
+   * If that fails, the signature is invalid and a `SignatureError` is thrown.
+   */
+  async verify(request) {
+    const environment = getSafeEnvironment();
+    const signingKeys = getReceiverSigningKeys({
+      environment,
+      regionFromHeader: request.upstashRegion,
+      config: {
+        currentSigningKey: this.currentSigningKey,
+        nextSigningKey: this.nextSigningKey
+      }
+    });
+    if (!signingKeys) {
+      throw new Error(
+        "[Upstash QStash] No signing keys available for verification. See the warning above for more details."
+      );
+    }
+    let payload;
+    try {
+      payload = await this.verifyWithKey(signingKeys.currentSigningKey, request);
+    } catch {
+      payload = await this.verifyWithKey(signingKeys.nextSigningKey, request);
+    }
+    this.verifyBodyAndUrl(payload, request);
+    return true;
+  }
+  /**
+   * Verify signature with a specific signing key
+   */
+  async verifyWithKey(key, request) {
+    const jwt = await 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/dlq.ts
+var DLQ = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List messages in the dlq
+   */
+  async listMessages(options) {
+    const filterPayload = {
+      ...options?.filter,
+      topicName: options?.filter?.urlGroup
+    };
+    const messagesPayload = await this.http.request({
+      method: "GET",
+      path: ["v2", "dlq"],
+      query: {
+        cursor: options?.cursor,
+        count: options?.count,
+        ...filterPayload
+      }
+    });
+    return {
+      messages: messagesPayload.messages.map((message) => {
+        return {
+          ...message,
+          urlGroup: message.topicName,
+          ratePerSecond: "rate" in message ? message.rate : void 0
+        };
+      }),
+      cursor: messagesPayload.cursor
+    };
+  }
+  /**
+   * Remove a message from the dlq using it's `dlqId`
+   */
+  async delete(dlqMessageId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "dlq", dlqMessageId],
+      parseResponseAsJson: false
+      // there is no response
+    });
+  }
+  /**
+   * Remove multiple messages from the dlq using their `dlqId`s
+   */
+  async deleteMany(request) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "dlq"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ dlqIds: request.dlqIds })
+    });
   }
-};
-var formatWorkflowError = (error) => {
-  return error instanceof Error ? {
-    error: error.name,
-    message: error.message
-  } : {
-    error: "Error",
-    message: "An error occured while executing workflow."
-  };
 };
 
 // src/client/http.ts
@@ -527,380 +976,85 @@ var Chat = class _Chat {
       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");
-};
-var openai = ({
-  token,
-  organization
-}) => {
-  return new LLMProvider("https://api.openai.com", token, "openai", organization);
-};
-var anthropic = ({ token }) => {
-  return new LLMProvider("https://api.anthropic.com", token, "anthropic");
-};
-var custom = ({
-  baseUrl,
-  token
-}) => {
-  const trimmedBaseUrl = baseUrl.replace(/\/(v1\/)?chat\/completions$/, "");
-  return new LLMProvider(trimmedBaseUrl, token, "custom");
-};
-
-// src/client/api/utils.ts
-var getProviderInfo = (api, upstashToken) => {
-  const { name, provider, ...parameters } = api;
-  const finalProvider = provider ?? upstash();
-  if (finalProvider.owner === "upstash" && !finalProvider.token) {
-    finalProvider.token = upstashToken;
-  }
-  if (!finalProvider.baseUrl)
-    throw new TypeError("baseUrl cannot be empty or undefined!");
-  if (!finalProvider.token)
-    throw new TypeError("token cannot be empty or undefined!");
-  if (finalProvider.apiKind !== name) {
-    throw new TypeError(
-      `Unexpected api name. Expected '${finalProvider.apiKind}', received ${name}`
-    );
-  }
-  const providerInfo = {
-    url: finalProvider.getUrl(),
-    baseUrl: finalProvider.baseUrl,
-    route: finalProvider.getRoute(),
-    appendHeaders: finalProvider.getHeaders(parameters),
-    owner: finalProvider.owner,
-    method: finalProvider.method
+      body,
+      baseUrl: analyticsConfig.baseURL
+    });
+    return response;
   };
-  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.");
+  // 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 {
-      ...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
-    };
+    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);
+  };
 };
-function updateWithAnalytics(providerInfo, analytics) {
-  switch (analytics.name) {
-    case "helicone": {
-      providerInfo.appendHeaders["Helicone-Auth"] = `Bearer ${analytics.token}`;
-      if (providerInfo.owner === "upstash") {
-        updateProviderInfo(providerInfo, "https://qstash.helicone.ai", [
-          "llm",
-          ...providerInfo.route
-        ]);
-      } else {
-        providerInfo.appendHeaders["Helicone-Target-Url"] = providerInfo.baseUrl;
-        updateProviderInfo(providerInfo, "https://gateway.helicone.ai", providerInfo.route);
-      }
-      return providerInfo;
-    }
-    default: {
-      throw new Error("Unknown analytics provider");
-    }
-  }
-}
-function updateProviderInfo(providerInfo, baseUrl, route) {
-  providerInfo.baseUrl = baseUrl;
-  providerInfo.route = route;
-  providerInfo.url = `${baseUrl}/${route.join("/")}`;
-}
 
-// src/client/utils.ts
-var isIgnoredHeader = (header) => {
-  const lowerCaseHeader = header.toLowerCase();
-  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`);
-    }
+// src/client/messages.ts
+var Messages = class {
+  http;
+  constructor(http) {
+    this.http = http;
   }
-  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(", "));
+  /**
+   * 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.label !== void 0) {
-    headers.set("Upstash-Label", request.label);
+  /**
+   * Cancel a message
+   */
+  async delete(messageId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages", messageId],
+      parseResponseAsJson: false
+    });
   }
-  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;
+  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;
   }
-  throw new QstashError(`Failed to infer request path for ${JSON.stringify(request)}`);
-}
-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;
-    }
+  async deleteAll() {
+    const result = await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages"]
+    });
+    return result.cancelled;
   }
-}
-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 {
@@ -1262,19 +1416,15 @@ var Workflow = class {
 };
 
 // version.ts
-var VERSION = "v2.8.3";
+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(
@@ -1293,11 +1443,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;
   }
   /**