@upstash/qstash 2.7.13 → 2.7.15

package/{chunk-IYU467WN.mjs → chunk-LSYJT55T.mjs}

@@ -1,7 +1,7 @@
 import {
   Receiver,
   serve
-} from "./chunk-Q6E5NF42.mjs";
+} from "./chunk-Y52A3KZT.mjs";
 
 // node_modules/defu/dist/defu.mjs
 function isPlainObject(value) {

package/chunk-X4MWA7DF.mjs

@@ -0,0 +1,34 @@
+import {
+  BaseProvider
+} from "./chunk-Y52A3KZT.mjs";
+
+// src/client/api/email.ts
+var EmailProvider = class extends BaseProvider {
+  apiKind = "email";
+  batch;
+  constructor(baseUrl, token, owner, batch) {
+    super(baseUrl, token, owner);
+    this.batch = batch;
+  }
+  getRoute() {
+    return this.batch ? ["emails", "batch"] : ["emails"];
+  }
+  getHeaders(_options) {
+    return {
+      "upstash-forward-authorization": `Bearer ${this.token}`
+    };
+  }
+  onFinish(providerInfo, _options) {
+    return providerInfo;
+  }
+};
+var resend = ({
+  token,
+  batch = false
+}) => {
+  return new EmailProvider("https://api.resend.com", token, "resend", batch);
+};
+
+export {
+  resend
+};

package/{chunk-Q6E5NF42.mjs → chunk-Y52A3KZT.mjs}

@@ -24,11 +24,14 @@ var Receiver = class {
    * If that fails, the signature is invalid and a `SignatureError` is thrown.
    */
   async verify(request) {
-    const isValid = await this.verifyWithKey(this.currentSigningKey, request);
-    if (isValid) {
-      return true;
+    let payload;
+    try {
+      payload = await this.verifyWithKey(this.currentSigningKey, request);
+    } catch {
+      payload = await this.verifyWithKey(this.nextSigningKey, request);
     }
-    return this.verifyWithKey(this.nextSigningKey, request);
+    this.verifyBodyAndUrl(payload, request);
+    return true;
   }
   /**
    * Verify signature with a specific signing key
@@ -40,7 +43,10 @@ var Receiver = class {
     }).catch((error) => {
       throw new SignatureError(error.message);
     });
-    const p = jwt.payload;
+    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}`);
     }
@@ -49,7 +55,6 @@ var Receiver = class {
     if (p.body.replace(padding, "") !== bodyHash.replace(padding, "")) {
       throw new SignatureError(`body hash does not match, want: ${p.body}, got: ${bodyHash}`);
     }
-    return true;
   }
 };
 
@@ -200,7 +205,7 @@ var HttpClient = class {
       attempts: 1,
       backoff: () => 0
     } : {
-      attempts: config.retry?.retries ? config.retry.retries + 1 : 5,
+      attempts: config.retry?.retries ?? 5,
       backoff: config.retry?.backoff ?? ((retryCount) => Math.exp(retryCount) * 50)
     };
   }
@@ -245,13 +250,15 @@ var HttpClient = class {
     const [url, requestOptions] = this.processRequest(request);
     let response = void 0;
     let error = void 0;
-    for (let index = 0; index < this.retry.attempts; index++) {
+    for (let index = 0; index <= this.retry.attempts; index++) {
       try {
         response = await fetch(url.toString(), requestOptions);
         break;
       } catch (error_) {
         error = error_;
-        await new Promise((r) => setTimeout(r, this.retry.backoff(index)));
+        if (index < this.retry.attempts) {
+          await new Promise((r) => setTimeout(r, this.retry.backoff(index)));
+        }
       }
     }
     if (!response) {
@@ -348,37 +355,6 @@ var setupAnalytics = (analytics, providerApiKey, providerBaseUrl, provider) => {
     }
   }
 };
-var upstash = () => {
-  return {
-    owner: "upstash",
-    baseUrl: "https://qstash.upstash.io/llm",
-    token: "",
-    organization: void 0
-  };
-};
-var openai = ({
-  token,
-  organization
-}) => {
-  return {
-    token,
-    owner: "openai",
-    baseUrl: "https://api.openai.com",
-    organization
-  };
-};
-var custom = ({
-  baseUrl,
-  token
-}) => {
-  const trimmedBaseUrl = baseUrl.replace(/\/(v1\/)?chat\/completions$/, "");
-  return {
-    token,
-    owner: "custom",
-    baseUrl: trimmedBaseUrl,
-    organization: void 0
-  };
-};
 
 // src/client/llm/chat.ts
 var Chat = class _Chat {
@@ -454,7 +430,6 @@ var Chat = class _Chat {
    * @param request ChatRequest with messages
    * @returns Chat completion or stream
    */
-  // eslint-disable-next-line @typescript-eslint/require-await
   createThirdParty = async (request) => {
     const { baseUrl, token, owner, organization } = request.provider;
     if (owner === "upstash")
@@ -515,63 +490,6 @@ var Chat = class _Chat {
   };
 };
 
-// src/client/llm/utils.ts
-function appendLLMOptionsIfNeeded(request, headers, http) {
-  if (!request.api)
-    return;
-  const provider = request.api.provider;
-  const analytics = request.api.analytics;
-  if (provider?.owner === "upstash") {
-    handleUpstashProvider(request, headers, http, analytics);
-    return;
-  }
-  if (!("provider" in request.api))
-    return;
-  const { baseUrl, token } = validateProviderConfig(provider);
-  const analyticsConfig = analytics ? setupAnalytics({ name: analytics.name, token: analytics.token }, token, baseUrl, "custom") : void 0;
-  if (analyticsConfig) {
-    setAnalyticsHeaders(headers, analyticsConfig);
-    request.url = analyticsConfig.baseURL;
-  } else {
-    request.url = `${baseUrl}/v1/chat/completions`;
-    headers.set("Authorization", `Bearer ${token}`);
-  }
-}
-function handleUpstashProvider(request, headers, http, analytics) {
-  if (analytics) {
-    const analyticsConfig = setupAnalytics(
-      { name: analytics.name, token: analytics.token },
-      //@ts-expect-error hacky way to get bearer token
-      String(http.authorization).split("Bearer ")[1],
-      request.api?.provider?.baseUrl,
-      "upstash"
-    );
-    setAnalyticsHeaders(headers, analyticsConfig);
-    request.url = analyticsConfig.baseURL;
-  } else {
-    request.api = { name: "llm" };
-  }
-}
-function validateProviderConfig(provider) {
-  if (!provider?.baseUrl)
-    throw new Error("baseUrl cannot be empty or undefined!");
-  if (!provider.token)
-    throw new Error("token cannot be empty or undefined!");
-  return { baseUrl: provider.baseUrl, token: provider.token };
-}
-function setAnalyticsHeaders(headers, analyticsConfig) {
-  headers.set("Helicone-Auth", analyticsConfig.defaultHeaders?.["Helicone-Auth"] ?? "");
-  headers.set("Authorization", analyticsConfig.defaultHeaders?.Authorization ?? "");
-  if (analyticsConfig.defaultHeaders?.["Helicone-Target-Url"]) {
-    headers.set("Helicone-Target-Url", analyticsConfig.defaultHeaders["Helicone-Target-Url"]);
-  }
-}
-function ensureCallbackPresent(request) {
-  if (request.api?.name === "llm" && !request.callback) {
-    throw new TypeError("Callback cannot be undefined when using LLM");
-  }
-}
-
 // src/client/messages.ts
 var Messages = class {
   http;
@@ -620,6 +538,160 @@ var Messages = class {
   }
 };
 
+// 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;
+  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 {};
+    }
+    const header = this.owner === "anthropic" ? "x-api-key" : "authorization";
+    const headerValue = this.owner === "anthropic" ? this.token : `Bearer ${this.token}`;
+    const headers = { [header]: headerValue };
+    if (this.owner === "openai" && this.organization) {
+      headers["OpenAI-Organization"] = this.organization;
+    }
+    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
+  };
+  return finalProvider.onFinish(providerInfo, parameters);
+};
+var processApi = (request, upstashToken) => {
+  if (!request.api) {
+    return request;
+  }
+  const { url, appendHeaders, owner } = 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,
+      // @ts-expect-error undici header conflict
+      headers: new Headers({
+        ...request.headers,
+        ...appendHeaders
+      }),
+      ...owner === "upstash" && !request.api.analytics ? { api: { name: "llm" }, url: void 0, callback } : { url, api: void 0 }
+    };
+  } else {
+    return {
+      ...request,
+      // @ts-expect-error undici header conflict
+      headers: new Headers({
+        ...request.headers,
+        ...appendHeaders
+      }),
+      url,
+      api: void 0
+    };
+  }
+};
+function updateWithAnalytics(providerInfo, analytics) {
+  switch (analytics.name) {
+    case "helicone": {
+      providerInfo.appendHeaders["Helicone-Auth"] = `Bearer ${analytics.token}`;
+      if (providerInfo.owner === "upstash") {
+        updateProviderInfo(providerInfo, "https://qstash.helicone.ai", [
+          "llm",
+          ...providerInfo.route
+        ]);
+      } else {
+        providerInfo.appendHeaders["Helicone-Target-Url"] = providerInfo.baseUrl;
+        updateProviderInfo(providerInfo, "https://gateway.helicone.ai", providerInfo.route);
+      }
+      return providerInfo;
+    }
+    default: {
+      throw new Error("Unknown analytics provider");
+    }
+  }
+}
+function updateProviderInfo(providerInfo, baseUrl, route) {
+  providerInfo.baseUrl = baseUrl;
+  providerInfo.route = route;
+  providerInfo.url = `${baseUrl}/${route.join("/")}`;
+}
+
 // src/client/utils.ts
 var isIgnoredHeader = (header) => {
   const lowerCaseHeader = header.toLowerCase();
@@ -652,7 +724,7 @@ function processHeaders(request) {
   if (request.deduplicationId !== void 0) {
     headers.set("Upstash-Deduplication-Id", request.deduplicationId);
   }
-  if (request.contentBasedDeduplication !== void 0) {
+  if (request.contentBasedDeduplication) {
     headers.set("Upstash-Content-Based-Deduplication", "true");
   }
   if (request.retries !== void 0) {
@@ -674,7 +746,16 @@ function processHeaders(request) {
   return headers;
 }
 function getRequestPath(request) {
-  return request.url ?? request.urlGroup ?? request.topic ?? `api/${request.api?.name}`;
+  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;
@@ -687,10 +768,18 @@ function decodeBase64(base64) {
     const intArray = Uint8Array.from(binString, (m) => m.codePointAt(0));
     return new TextDecoder().decode(intArray);
   } catch (error) {
-    console.warn(
-      `Upstash Qstash: Failed while decoding base64 "${base64}". Decoding with atob and returning it instead. ${error}`
-    );
-    return atob(base64);
+    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;
+    }
   }
 }
 
@@ -781,11 +870,12 @@ var Queue = class {
   async enqueueJSON(request) {
     const headers = prefixHeaders(new Headers(request.headers));
     headers.set("Content-Type", "application/json");
-    ensureCallbackPresent(request);
-    appendLLMOptionsIfNeeded(request, headers, this.http);
+    request.headers = headers;
+    const upstashToken = String(this.http.authorization).split("Bearer ")[1];
+    const nonApiRequest = processApi(request, upstashToken);
     const response = await this.enqueue({
-      ...request,
-      body: JSON.stringify(request.body),
+      ...nonApiRequest,
+      body: JSON.stringify(nonApiRequest.body),
       headers
     });
     return response;
@@ -865,6 +955,9 @@ var Schedules = class {
     if (request.scheduleId !== void 0) {
       headers.set("Upstash-Schedule-Id", request.scheduleId);
     }
+    if (request.queueName !== void 0) {
+      headers.set("Upstash-Queue-Name", request.queueName);
+    }
     return await this.http.request({
       method: "POST",
       headers,
@@ -1080,12 +1173,12 @@ var Client = class {
   async publishJSON(request) {
     const headers = prefixHeaders(new Headers(request.headers));
     headers.set("Content-Type", "application/json");
-    ensureCallbackPresent(request);
-    appendLLMOptionsIfNeeded(request, headers, this.http);
+    request.headers = headers;
+    const upstashToken = String(this.http.authorization).split("Bearer ")[1];
+    const nonApiRequest = processApi(request, upstashToken);
     const response = await this.publish({
-      ...request,
-      headers,
-      body: JSON.stringify(request.body)
+      ...nonApiRequest,
+      body: JSON.stringify(nonApiRequest.body)
     });
     return response;
   }
@@ -1119,16 +1212,17 @@ var Client = class {
    * Batch publish messages to QStash, serializing each body to JSON.
    */
   async batchJSON(request) {
-    for (const message of request) {
+    const batchPayload = request.map((message) => {
       if ("body" in message) {
         message.body = JSON.stringify(message.body);
       }
       message.headers = new Headers(message.headers);
-      ensureCallbackPresent(message);
-      appendLLMOptionsIfNeeded(message, message.headers, this.http);
-      message.headers.set("Content-Type", "application/json");
-    }
-    const response = await this.batch(request);
+      const upstashToken = String(this.http.authorization).split("Bearer ")[1];
+      const nonApiMessage = processApi(message, upstashToken);
+      nonApiMessage.headers.set("Content-Type", "application/json");
+      return nonApiMessage;
+    });
+    const response = await this.batch(batchPayload);
     return response;
   }
   /**
@@ -2581,11 +2675,13 @@ export {
   QStashWorkflowAbort,
   formatWorkflowError,
   setupAnalytics,
+  Chat,
+  Messages,
+  BaseProvider,
   upstash,
   openai,
+  anthropic,
   custom,
-  Chat,
-  Messages,
   decodeBase64,
   Schedules,
   UrlGroups,