@scalemule/nextjs 0.0.1 → 0.0.2

package/dist/index.js

@@ -5,6 +5,16 @@ var jsxRuntime = require('react/jsx-runtime');
 
 // src/provider.tsx
 
+// src/types/index.ts
+var ScaleMuleApiError = class extends Error {
+  constructor(error) {
+    super(error.message);
+    this.name = "ScaleMuleApiError";
+    this.code = error.code;
+    this.field = error.field;
+  }
+};
+
 // src/client.ts
 var GATEWAY_URLS = {
   dev: "https://api-dev.scalemule.com",
@@ -87,14 +97,14 @@ var RateLimitQueue = class {
       try {
         this.requestsInWindow++;
         const result = await request.execute();
-        if (!result.success && result.error?.code === "RATE_LIMITED") {
+        request.resolve(result);
+      } catch (error) {
+        if (error instanceof ScaleMuleApiError && error.code === "RATE_LIMITED") {
           this.queue.unshift(request);
           this.rateLimitedUntil = Date.now() + 6e4;
         } else {
-          request.resolve(result);
+          request.reject(error);
         }
-      } catch (error) {
-        request.reject(error);
       }
     }
     this.processing = false;
@@ -437,11 +447,12 @@ var ScaleMuleClient = class {
           signal: controller.signal
         });
         clearTimeout(timeoutId);
-        const data = await response.json();
+        const text = await response.text();
+        const responseData = text ? JSON.parse(text) : null;
         if (!response.ok) {
-          const error = data.error || {
+          const error = responseData?.error || {
             code: `HTTP_${response.status}`,
-            message: data.message || response.statusText
+            message: responseData?.message || response.statusText
           };
           if (attempt < maxRetries && RETRYABLE_STATUS_CODES.has(response.status)) {
             lastError = error;
@@ -455,11 +466,15 @@ var ScaleMuleClient = class {
           if (this.debug) {
             console.error("[ScaleMule] Request failed:", error);
           }
-          return { success: false, error };
+          throw new ScaleMuleApiError(error);
         }
+        const data = responseData?.data !== void 0 ? responseData.data : responseData;
         return data;
       } catch (err) {
         clearTimeout(timeoutId);
+        if (err instanceof ScaleMuleApiError) {
+          throw err;
+        }
         const error = {
           code: err instanceof Error && err.name === "AbortError" ? "TIMEOUT" : "NETWORK_ERROR",
           message: err instanceof Error ? err.message : "Network request failed"
@@ -476,10 +491,10 @@ var ScaleMuleClient = class {
         if (this.debug) {
           console.error("[ScaleMule] Network error:", err);
         }
-        return { success: false, error };
+        throw new ScaleMuleApiError(error);
       }
     }
-    return { success: false, error: lastError || { code: "UNKNOWN", message: "Request failed" } };
+    throw new ScaleMuleApiError(lastError || { code: "UNKNOWN", message: "Request failed" });
   }
   /**
    * GET request
@@ -575,11 +590,12 @@ var ScaleMuleClient = class {
           headers,
           body: retryFormData
         });
-        const data = await response.json();
+        const uploadText = await response.text();
+        const responseData = uploadText ? JSON.parse(uploadText) : null;
         if (!response.ok) {
-          const error = data.error || {
+          const error = responseData?.error || {
             code: `HTTP_${response.status}`,
-            message: data.message || response.statusText
+            message: responseData?.message || response.statusText
           };
           if (attempt < maxRetries && RETRYABLE_STATUS_CODES.has(response.status)) {
             lastError = error;
@@ -590,10 +606,14 @@ var ScaleMuleClient = class {
             await sleep(delay);
             continue;
           }
-          return { success: false, error };
+          throw new ScaleMuleApiError(error);
         }
+        const data = responseData?.data !== void 0 ? responseData.data : responseData;
         return data;
       } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          throw err;
+        }
         lastError = {
           code: "UPLOAD_ERROR",
           message: err instanceof Error ? err.message : "Upload failed"
@@ -608,10 +628,7 @@ var ScaleMuleClient = class {
         }
       }
     }
-    return {
-      success: false,
-      error: lastError || { code: "UPLOAD_ERROR", message: "Upload failed after retries" }
-    };
+    throw new ScaleMuleApiError(lastError || { code: "UPLOAD_ERROR", message: "Upload failed after retries" });
   }
   /**
    * Upload with progress using XMLHttpRequest (with retry)
@@ -619,35 +636,35 @@ var ScaleMuleClient = class {
   async uploadWithProgress(url, formData, onProgress, maxRetries = 2) {
     let lastError = null;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      const result = await this.singleUploadWithProgress(url, formData, onProgress);
-      if (result.success) {
-        return result;
-      }
-      const errorCode = result.error?.code || "";
-      const isNetworkError = errorCode === "UPLOAD_ERROR" || errorCode === "NETWORK_ERROR";
-      const isRetryableHttp = errorCode.startsWith("HTTP_") && RETRYABLE_STATUS_CODES.has(parseInt(errorCode.replace("HTTP_", ""), 10));
-      if (attempt < maxRetries && (isNetworkError || isRetryableHttp)) {
-        lastError = result.error || null;
-        const delay = getBackoffDelay(attempt);
-        if (this.debug) {
-          console.log(`[ScaleMule] Upload retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
+      try {
+        return await this.singleUploadWithProgress(url, formData, onProgress);
+      } catch (err) {
+        if (!(err instanceof ScaleMuleApiError)) {
+          throw err;
         }
-        await sleep(delay);
-        onProgress(0);
-        continue;
+        const errorCode = err.code;
+        const isNetworkError = errorCode === "UPLOAD_ERROR" || errorCode === "NETWORK_ERROR";
+        const isRetryableHttp = errorCode.startsWith("HTTP_") && RETRYABLE_STATUS_CODES.has(parseInt(errorCode.replace("HTTP_", ""), 10));
+        if (attempt < maxRetries && (isNetworkError || isRetryableHttp)) {
+          lastError = { code: err.code, message: err.message };
+          const delay = getBackoffDelay(attempt);
+          if (this.debug) {
+            console.log(`[ScaleMule] Upload retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
+          }
+          await sleep(delay);
+          onProgress(0);
+          continue;
+        }
+        throw err;
       }
-      return result;
     }
-    return {
-      success: false,
-      error: lastError || { code: "UPLOAD_ERROR", message: "Upload failed after retries" }
-    };
+    throw new ScaleMuleApiError(lastError || { code: "UPLOAD_ERROR", message: "Upload failed after retries" });
   }
   /**
    * Single upload attempt with progress using XMLHttpRequest
    */
   singleUploadWithProgress(url, formData, onProgress) {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
       const xhr = new XMLHttpRequest();
       xhr.upload.addEventListener("progress", (event) => {
         if (event.lengthComputable) {
@@ -659,34 +676,23 @@ var ScaleMuleClient = class {
         try {
           const data = JSON.parse(xhr.responseText);
           if (xhr.status >= 200 && xhr.status < 300) {
-            resolve(data);
+            const unwrapped = data?.data !== void 0 ? data.data : data;
+            resolve(unwrapped);
           } else {
-            resolve({
-              success: false,
-              error: data.error || {
-                code: `HTTP_${xhr.status}`,
-                message: data.message || "Upload failed"
-              }
-            });
+            reject(new ScaleMuleApiError(data.error || {
+              code: `HTTP_${xhr.status}`,
+              message: data.message || "Upload failed"
+            }));
           }
         } catch {
-          resolve({
-            success: false,
-            error: { code: "PARSE_ERROR", message: "Failed to parse response" }
-          });
+          reject(new ScaleMuleApiError({ code: "PARSE_ERROR", message: "Failed to parse response" }));
         }
       });
       xhr.addEventListener("error", () => {
-        resolve({
-          success: false,
-          error: { code: "UPLOAD_ERROR", message: "Upload failed" }
-        });
+        reject(new ScaleMuleApiError({ code: "UPLOAD_ERROR", message: "Upload failed" }));
       });
       xhr.addEventListener("abort", () => {
-        resolve({
-          success: false,
-          error: { code: "UPLOAD_ABORTED", message: "Upload cancelled" }
-        });
+        reject(new ScaleMuleApiError({ code: "UPLOAD_ABORTED", message: "Upload cancelled" }));
       });
       xhr.open("POST", url);
       xhr.setRequestHeader("x-api-key", this.apiKey);
@@ -786,17 +792,19 @@ function ScaleMuleProvider({
             setUser(cachedUser);
             setInitializing(false);
           }
-          const response = await client.get("/v1/auth/me");
-          if (mounted) {
-            if (response.success && response.data) {
-              setUser(response.data);
-              setCachedUser(response.data);
-            } else {
+          try {
+            const userData = await client.get("/v1/auth/me");
+            if (mounted) {
+              setUser(userData);
+              setCachedUser(userData);
+            }
+          } catch (authErr) {
+            if (mounted) {
               setUser(null);
               setCachedUser(null);
               await client.clearSession();
-              if (response.error && onAuthError) {
-                onAuthError(response.error);
+              if (onAuthError && authErr && typeof authErr === "object" && "code" in authErr) {
+                onAuthError(authErr);
               }
             }
           }
@@ -891,31 +899,29 @@ function useAuth() {
     async (data) => {
       setError(null);
       if (authProxyUrl) {
-        const response2 = await proxyFetch(
+        const response = await proxyFetch(
           authProxyUrl,
           "register",
           { body: data }
         );
-        if (!response2.success || !response2.data) {
-          const err = response2.error || {
+        if (!response.success || !response.data) {
+          const err = response.error || {
             code: "REGISTER_FAILED",
             message: "Registration failed"
           };
           setError(err);
           throw err;
         }
-        return response2.data.user;
+        return response.data.user;
       }
-      const response = await client.post("/v1/auth/register", data);
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "REGISTER_FAILED",
-          message: "Registration failed"
-        };
-        setError(err);
+      try {
+        return await client.post("/v1/auth/register", data);
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
-      return response.data;
     },
     [client, setError, authProxyUrl]
   );
@@ -923,42 +929,42 @@ function useAuth() {
     async (data) => {
       setError(null);
       if (authProxyUrl) {
-        const response2 = await proxyFetch(
+        const response = await proxyFetch(
           authProxyUrl,
           "login",
           { body: data }
         );
-        if (!response2.success || !response2.data) {
-          const err = response2.error || {
+        if (!response.success || !response.data) {
+          const err = response.error || {
             code: "LOGIN_FAILED",
             message: "Login failed"
           };
           setError(err);
           throw err;
         }
-        if ("requires_mfa" in response2.data && response2.data.requires_mfa) {
-          return response2.data;
+        if ("requires_mfa" in response.data && response.data.requires_mfa) {
+          return response.data;
         }
-        const loginData2 = response2.data;
+        const loginData2 = response.data;
         const responseUser = "user" in loginData2 ? loginData2.user : null;
         if (responseUser) {
           setUser(responseUser);
         }
-        return response2.data;
+        return response.data;
       }
-      const response = await client.post("/v1/auth/login", data);
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "LOGIN_FAILED",
-          message: "Login failed"
-        };
-        setError(err);
+      let loginResult;
+      try {
+        loginResult = await client.post("/v1/auth/login", data);
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
-      if ("requires_mfa" in response.data && response.data.requires_mfa) {
-        return response.data;
+      if ("requires_mfa" in loginResult && loginResult.requires_mfa) {
+        return loginResult;
       }
-      const loginData = response.data;
+      const loginData = loginResult;
       await client.setSession(loginData.session_token, loginData.user.id);
       setUser(loginData.user);
       return loginData;
@@ -988,14 +994,25 @@ function useAuth() {
   const forgotPassword = react.useCallback(
     async (email) => {
       setError(null);
-      const response = authProxyUrl ? await proxyFetch(authProxyUrl, "forgot-password", { body: { email } }) : await client.post("/v1/auth/forgot-password", { email });
-      if (!response.success) {
-        const err = response.error || {
-          code: "FORGOT_PASSWORD_FAILED",
-          message: "Failed to send password reset email"
-        };
-        setError(err);
-        throw err;
+      if (authProxyUrl) {
+        const response = await proxyFetch(authProxyUrl, "forgot-password", { body: { email } });
+        if (!response.success) {
+          const err = response.error || {
+            code: "FORGOT_PASSWORD_FAILED",
+            message: "Failed to send password reset email"
+          };
+          setError(err);
+          throw err;
+        }
+      } else {
+        try {
+          await client.post("/v1/auth/forgot-password", { email });
+        } catch (err) {
+          if (err instanceof ScaleMuleApiError) {
+            setError(err);
+          }
+          throw err;
+        }
       }
     },
     [client, setError, authProxyUrl]
@@ -1003,14 +1020,25 @@ function useAuth() {
   const resetPassword = react.useCallback(
     async (token, newPassword) => {
       setError(null);
-      const response = authProxyUrl ? await proxyFetch(authProxyUrl, "reset-password", { body: { token, new_password: newPassword } }) : await client.post("/v1/auth/reset-password", { token, new_password: newPassword });
-      if (!response.success) {
-        const err = response.error || {
-          code: "RESET_PASSWORD_FAILED",
-          message: "Failed to reset password"
-        };
-        setError(err);
-        throw err;
+      if (authProxyUrl) {
+        const response = await proxyFetch(authProxyUrl, "reset-password", { body: { token, new_password: newPassword } });
+        if (!response.success) {
+          const err = response.error || {
+            code: "RESET_PASSWORD_FAILED",
+            message: "Failed to reset password"
+          };
+          setError(err);
+          throw err;
+        }
+      } else {
+        try {
+          await client.post("/v1/auth/reset-password", { token, new_password: newPassword });
+        } catch (err) {
+          if (err instanceof ScaleMuleApiError) {
+            setError(err);
+          }
+          throw err;
+        }
       }
     },
     [client, setError, authProxyUrl]
@@ -1018,14 +1046,25 @@ function useAuth() {
   const verifyEmail = react.useCallback(
     async (token) => {
       setError(null);
-      const response = authProxyUrl ? await proxyFetch(authProxyUrl, "verify-email", { body: { token } }) : await client.post("/v1/auth/verify-email", { token });
-      if (!response.success) {
-        const err = response.error || {
-          code: "VERIFY_EMAIL_FAILED",
-          message: "Failed to verify email"
-        };
-        setError(err);
-        throw err;
+      if (authProxyUrl) {
+        const response = await proxyFetch(authProxyUrl, "verify-email", { body: { token } });
+        if (!response.success) {
+          const err = response.error || {
+            code: "VERIFY_EMAIL_FAILED",
+            message: "Failed to verify email"
+          };
+          setError(err);
+          throw err;
+        }
+      } else {
+        try {
+          await client.post("/v1/auth/verify-email", { token });
+        } catch (err) {
+          if (err instanceof ScaleMuleApiError) {
+            setError(err);
+          }
+          throw err;
+        }
       }
       if (user) {
         if (authProxyUrl) {
@@ -1034,9 +1073,10 @@ function useAuth() {
             setUser(userResponse.data.user);
           }
         } else {
-          const userResponse = await client.get("/v1/auth/me");
-          if (userResponse.success && userResponse.data) {
-            setUser(userResponse.data);
+          try {
+            const userData = await client.get("/v1/auth/me");
+            setUser(userData);
+          } catch {
           }
         }
       }
@@ -1045,7 +1085,17 @@ function useAuth() {
   );
   const resendVerification = react.useCallback(async () => {
     setError(null);
-    const response = authProxyUrl ? await proxyFetch(authProxyUrl, "resend-verification", { body: user ? {} : void 0 }) : (() => {
+    if (authProxyUrl) {
+      const response = await proxyFetch(authProxyUrl, "resend-verification", { body: user ? {} : void 0 });
+      if (!response.success) {
+        const err = response.error || {
+          code: "RESEND_FAILED",
+          message: "Failed to resend verification email"
+        };
+        setError(err);
+        throw err;
+      }
+    } else {
       if (!user) {
         const err = {
           code: "NOT_AUTHENTICATED",
@@ -1053,36 +1103,34 @@ function useAuth() {
         };
         throw err;
       }
-      return client.post("/v1/auth/resend-verification");
-    })();
-    const result = await response;
-    if (!result.success) {
-      const err = result.error || {
-        code: "RESEND_FAILED",
-        message: "Failed to resend verification email"
-      };
-      setError(err);
-      throw err;
+      try {
+        await client.post("/v1/auth/resend-verification");
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
+        throw err;
+      }
     }
   }, [client, user, setError, authProxyUrl]);
   const refreshSession = react.useCallback(async () => {
     setError(null);
     if (authProxyUrl) {
-      const response2 = await proxyFetch(
+      const response = await proxyFetch(
         authProxyUrl,
         "refresh"
       );
-      if (!response2.success) {
+      if (!response.success) {
         setUser(null);
-        const err = response2.error || {
+        const err = response.error || {
           code: "REFRESH_FAILED",
           message: "Session expired"
         };
         setError(err);
         throw err;
       }
-      if (response2.data?.user) {
-        setUser(response2.data.user);
+      if (response.data?.user) {
+        setUser(response.data.user);
       }
       return;
     }
@@ -1095,46 +1143,45 @@ function useAuth() {
       setError(err);
       throw err;
     }
-    const response = await client.post(
-      "/v1/auth/refresh",
-      { session_token: sessionToken }
-    );
-    if (!response.success || !response.data) {
+    try {
+      const refreshData = await client.post(
+        "/v1/auth/refresh",
+        { session_token: sessionToken }
+      );
+      const userId = client.getUserId();
+      if (userId) {
+        await client.setSession(refreshData.session_token, userId);
+      }
+    } catch (err) {
       await client.clearSession();
       setUser(null);
-      const err = response.error || {
-        code: "REFRESH_FAILED",
-        message: "Session expired"
-      };
-      setError(err);
+      if (err instanceof ScaleMuleApiError) {
+        setError(err);
+      }
       throw err;
     }
-    const userId = client.getUserId();
-    if (userId) {
-      await client.setSession(response.data.session_token, userId);
-    }
   }, [client, setUser, setError, authProxyUrl]);
   const startOAuth = react.useCallback(
     async (config) => {
       setError(null);
-      const response = await client.post("/v1/auth/oauth/start", {
-        provider: config.provider,
-        redirect_url: config.redirectUrl,
-        scopes: config.scopes,
-        state: config.state
-      });
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "OAUTH_START_FAILED",
-          message: "Failed to start OAuth flow"
-        };
-        setError(err);
+      let oauthData;
+      try {
+        oauthData = await client.post("/v1/auth/oauth/start", {
+          provider: config.provider,
+          redirect_url: config.redirectUrl,
+          scopes: config.scopes,
+          state: config.state
+        });
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
       if (typeof sessionStorage !== "undefined") {
-        sessionStorage.setItem("scalemule_oauth_state", response.data.state);
+        sessionStorage.setItem("scalemule_oauth_state", oauthData.state);
       }
-      return response.data;
+      return oauthData;
     },
     [client, setError]
   );
@@ -1153,33 +1200,32 @@ function useAuth() {
         }
         sessionStorage.removeItem("scalemule_oauth_state");
       }
-      const response = await client.post("/v1/auth/oauth/callback", request);
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "OAUTH_CALLBACK_FAILED",
-          message: "Failed to complete OAuth flow"
-        };
-        setError(err);
+      let callbackData;
+      try {
+        callbackData = await client.post("/v1/auth/oauth/callback", request);
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
-      await client.setSession(response.data.session_token, response.data.user.id);
-      setUser(response.data.user);
-      return response.data;
+      await client.setSession(callbackData.session_token, callbackData.user.id);
+      setUser(callbackData.user);
+      return callbackData;
     },
     [client, setUser, setError]
   );
   const getLinkedAccounts = react.useCallback(async () => {
     setError(null);
-    const response = await client.get("/v1/auth/oauth/accounts");
-    if (!response.success || !response.data) {
-      const err = response.error || {
-        code: "GET_ACCOUNTS_FAILED",
-        message: "Failed to get linked accounts"
-      };
-      setError(err);
+    try {
+      const data = await client.get("/v1/auth/oauth/accounts");
+      return data.accounts;
+    } catch (err) {
+      if (err instanceof ScaleMuleApiError) {
+        setError(err);
+      }
       throw err;
     }
-    return response.data.accounts;
   }, [client, setError]);
   const linkAccount = react.useCallback(
     async (config) => {
@@ -1192,36 +1238,35 @@ function useAuth() {
         setError(err);
         throw err;
       }
-      const response = await client.post("/v1/auth/oauth/link", {
-        provider: config.provider,
-        redirect_url: config.redirectUrl,
-        scopes: config.scopes
-      });
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "LINK_ACCOUNT_FAILED",
-          message: "Failed to start account linking"
-        };
-        setError(err);
+      let linkData;
+      try {
+        linkData = await client.post("/v1/auth/oauth/link", {
+          provider: config.provider,
+          redirect_url: config.redirectUrl,
+          scopes: config.scopes
+        });
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
       if (typeof sessionStorage !== "undefined") {
-        sessionStorage.setItem("scalemule_oauth_state", response.data.state);
+        sessionStorage.setItem("scalemule_oauth_state", linkData.state);
       }
-      return response.data;
+      return linkData;
     },
     [client, user, setError]
   );
   const unlinkAccount = react.useCallback(
     async (provider) => {
       setError(null);
-      const response = await client.delete(`/v1/auth/oauth/accounts/${provider}`);
-      if (!response.success) {
-        const err = response.error || {
-          code: "UNLINK_ACCOUNT_FAILED",
-          message: "Failed to unlink account"
-        };
-        setError(err);
+      try {
+        await client.delete(`/v1/auth/oauth/accounts/${provider}`);
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
     },
@@ -1229,46 +1274,41 @@ function useAuth() {
   );
   const getMFAStatus = react.useCallback(async () => {
     setError(null);
-    const response = await client.get("/v1/auth/mfa/status");
-    if (!response.success || !response.data) {
-      const err = response.error || {
-        code: "GET_MFA_STATUS_FAILED",
-        message: "Failed to get MFA status"
-      };
-      setError(err);
+    try {
+      return await client.get("/v1/auth/mfa/status");
+    } catch (err) {
+      if (err instanceof ScaleMuleApiError) {
+        setError(err);
+      }
       throw err;
     }
-    return response.data;
   }, [client, setError]);
   const setupMFA = react.useCallback(
     async (request) => {
       setError(null);
-      const response = await client.post(
-        "/v1/auth/mfa/setup",
-        request
-      );
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "MFA_SETUP_FAILED",
-          message: "Failed to setup MFA"
-        };
-        setError(err);
+      try {
+        return await client.post(
+          "/v1/auth/mfa/setup",
+          request
+        );
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
-      return response.data;
     },
     [client, setError]
   );
   const verifyMFA = react.useCallback(
     async (request) => {
       setError(null);
-      const response = await client.post("/v1/auth/mfa/verify", request);
-      if (!response.success) {
-        const err = response.error || {
-          code: "MFA_VERIFY_FAILED",
-          message: "Failed to verify MFA code"
-        };
-        setError(err);
+      try {
+        await client.post("/v1/auth/mfa/verify", request);
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
     },
@@ -1277,35 +1317,34 @@ function useAuth() {
   const completeMFAChallenge = react.useCallback(
     async (challengeToken, code, method) => {
       setError(null);
-      const response = await client.post("/v1/auth/mfa/challenge", {
-        challenge_token: challengeToken,
-        code,
-        method
-      });
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "MFA_CHALLENGE_FAILED",
-          message: "Failed to complete MFA challenge"
-        };
-        setError(err);
+      let mfaResult;
+      try {
+        mfaResult = await client.post("/v1/auth/mfa/challenge", {
+          challenge_token: challengeToken,
+          code,
+          method
+        });
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
-      await client.setSession(response.data.session_token, response.data.user.id);
-      setUser(response.data.user);
-      return response.data;
+      await client.setSession(mfaResult.session_token, mfaResult.user.id);
+      setUser(mfaResult.user);
+      return mfaResult;
     },
     [client, setUser, setError]
   );
   const disableMFA = react.useCallback(
     async (password) => {
       setError(null);
-      const response = await client.post("/v1/auth/mfa/disable", { password });
-      if (!response.success) {
-        const err = response.error || {
-          code: "MFA_DISABLE_FAILED",
-          message: "Failed to disable MFA"
-        };
-        setError(err);
+      try {
+        await client.post("/v1/auth/mfa/disable", { password });
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
     },
@@ -1314,32 +1353,42 @@ function useAuth() {
   const regenerateBackupCodes = react.useCallback(
     async (password) => {
       setError(null);
-      const response = await client.post("/v1/auth/mfa/backup-codes", {
-        password
-      });
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "REGENERATE_CODES_FAILED",
-          message: "Failed to regenerate backup codes"
-        };
-        setError(err);
+      try {
+        const data = await client.post("/v1/auth/mfa/backup-codes", {
+          password
+        });
+        return data.backup_codes;
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
-      return response.data.backup_codes;
     },
     [client, setError]
   );
   const sendPhoneCode = react.useCallback(
     async (request) => {
       setError(null);
-      const response = authProxyUrl ? await proxyFetch(authProxyUrl, "phone/send-code", { body: request }) : await client.post("/v1/auth/phone/send-code", request);
-      if (!response.success) {
-        const err = response.error || {
-          code: "SEND_CODE_FAILED",
-          message: "Failed to send verification code"
-        };
-        setError(err);
-        throw err;
+      if (authProxyUrl) {
+        const response = await proxyFetch(authProxyUrl, "phone/send-code", { body: request });
+        if (!response.success) {
+          const err = response.error || {
+            code: "SEND_CODE_FAILED",
+            message: "Failed to send verification code"
+          };
+          setError(err);
+          throw err;
+        }
+      } else {
+        try {
+          await client.post("/v1/auth/phone/send-code", request);
+        } catch (err) {
+          if (err instanceof ScaleMuleApiError) {
+            setError(err);
+          }
+          throw err;
+        }
       }
     },
     [client, setError, authProxyUrl]
@@ -1347,14 +1396,25 @@ function useAuth() {
   const verifyPhone = react.useCallback(
     async (request) => {
       setError(null);
-      const response = authProxyUrl ? await proxyFetch(authProxyUrl, "phone/verify", { body: request }) : await client.post("/v1/auth/phone/verify", request);
-      if (!response.success) {
-        const err = response.error || {
-          code: "VERIFY_PHONE_FAILED",
-          message: "Failed to verify phone number"
-        };
-        setError(err);
-        throw err;
+      if (authProxyUrl) {
+        const response = await proxyFetch(authProxyUrl, "phone/verify", { body: request });
+        if (!response.success) {
+          const err = response.error || {
+            code: "VERIFY_PHONE_FAILED",
+            message: "Failed to verify phone number"
+          };
+          setError(err);
+          throw err;
+        }
+      } else {
+        try {
+          await client.post("/v1/auth/phone/verify", request);
+        } catch (err) {
+          if (err instanceof ScaleMuleApiError) {
+            setError(err);
+          }
+          throw err;
+        }
       }
       if (user) {
         if (authProxyUrl) {
@@ -1363,9 +1423,10 @@ function useAuth() {
             setUser(userResponse.data.user);
           }
         } else {
-          const userResponse = await client.get("/v1/auth/me");
-          if (userResponse.success && userResponse.data) {
-            setUser(userResponse.data);
+          try {
+            const userData = await client.get("/v1/auth/me");
+            setUser(userData);
+          } catch {
           }
         }
       }
@@ -1376,38 +1437,38 @@ function useAuth() {
     async (request) => {
       setError(null);
       if (authProxyUrl) {
-        const response2 = await proxyFetch(
+        const response = await proxyFetch(
           authProxyUrl,
           "phone/login",
           { body: request }
         );
-        if (!response2.success || !response2.data) {
-          const err = response2.error || {
+        if (!response.success || !response.data) {
+          const err = response.error || {
             code: "PHONE_LOGIN_FAILED",
             message: "Failed to login with phone"
           };
           setError(err);
           throw err;
         }
-        const loginData = response2.data;
+        const loginData = response.data;
         const responseUser = "user" in loginData ? loginData.user : null;
         if (responseUser) {
           setUser(responseUser);
         }
-        return response2.data;
+        return response.data;
       }
-      const response = await client.post("/v1/auth/phone/login", request);
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "PHONE_LOGIN_FAILED",
-          message: "Failed to login with phone"
-        };
-        setError(err);
+      let phoneLoginData;
+      try {
+        phoneLoginData = await client.post("/v1/auth/phone/login", request);
+      } catch (err) {
+        if (err instanceof ScaleMuleApiError) {
+          setError(err);
+        }
         throw err;
       }
-      await client.setSession(response.data.session_token, response.data.user.id);
-      setUser(response.data.user);
-      return response.data;
+      await client.setSession(phoneLoginData.session_token, phoneLoginData.user.id);
+      setUser(phoneLoginData.user);
+      return phoneLoginData;
     },
     [client, setUser, setError, authProxyUrl]
   );
@@ -1482,12 +1543,11 @@ function useBilling() {
       setError(null);
       setLoading(true);
       try {
-        const response = await client.post("/v1/billing/connected-accounts", data);
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data;
+        return await client.post("/v1/billing/connected-accounts", data);
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1498,12 +1558,11 @@ function useBilling() {
     setError(null);
     setLoading(true);
     try {
-      const response = await client.get("/v1/billing/connected-accounts/me");
-      if (!response.success || !response.data) {
-        setError(response.error || null);
-        return null;
-      }
-      return response.data;
+      return await client.get("/v1/billing/connected-accounts/me");
+    } catch (err) {
+      const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+      setError(apiError);
+      return null;
     } finally {
       setLoading(false);
     }
@@ -1513,12 +1572,11 @@ function useBilling() {
       setError(null);
       setLoading(true);
       try {
-        const response = await client.get(`/v1/billing/connected-accounts/${id}`);
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data;
+        return await client.get(`/v1/billing/connected-accounts/${id}`);
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1530,15 +1588,15 @@ function useBilling() {
       setError(null);
       setLoading(true);
       try {
-        const response = await client.post(
+        const result = await client.post(
           `/v1/billing/connected-accounts/${id}/onboarding-link`,
           data
         );
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data.url;
+        return result.url;
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1550,14 +1608,13 @@ function useBilling() {
       setError(null);
       setLoading(true);
       try {
-        const response = await client.get(
+        return await client.get(
           `/v1/billing/connected-accounts/${id}/balance`
         );
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data;
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1569,12 +1626,11 @@ function useBilling() {
       setError(null);
       setLoading(true);
       try {
-        const response = await client.post("/v1/billing/payments", data);
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data;
+        return await client.post("/v1/billing/payments", data);
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1586,12 +1642,11 @@ function useBilling() {
       setError(null);
       setLoading(true);
       try {
-        const response = await client.get(`/v1/billing/payments/${id}`);
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data;
+        return await client.get(`/v1/billing/payments/${id}`);
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1604,12 +1659,11 @@ function useBilling() {
       setLoading(true);
       try {
         const query = params ? "?" + Object.entries(params).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`).join("&") : "";
-        const response = await client.get(`/v1/billing/payments${query}`);
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return [];
-        }
-        return response.data;
+        return await client.get(`/v1/billing/payments${query}`);
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return [];
       } finally {
         setLoading(false);
       }
@@ -1621,12 +1675,11 @@ function useBilling() {
       setError(null);
       setLoading(true);
       try {
-        const response = await client.post(`/v1/billing/payments/${id}/refund`, data);
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data;
+        return await client.post(`/v1/billing/payments/${id}/refund`, data);
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1639,14 +1692,13 @@ function useBilling() {
       setLoading(true);
       try {
         const query = params ? "?" + Object.entries(params).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`).join("&") : "";
-        const response = await client.get(
+        return await client.get(
           `/v1/billing/connected-accounts/${accountId}/payouts${query}`
         );
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return [];
-        }
-        return response.data;
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return [];
       } finally {
         setLoading(false);
       }
@@ -1658,14 +1710,13 @@ function useBilling() {
       setError(null);
       setLoading(true);
       try {
-        const response = await client.get(
+        return await client.get(
           `/v1/billing/connected-accounts/${accountId}/payout-schedule`
         );
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data;
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1677,15 +1728,14 @@ function useBilling() {
       setError(null);
       setLoading(true);
       try {
-        const response = await client.put(
+        return await client.put(
           `/v1/billing/connected-accounts/${accountId}/payout-schedule`,
           data
         );
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data;
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1698,12 +1748,11 @@ function useBilling() {
       setLoading(true);
       try {
         const query = params ? "?" + Object.entries(params).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`).join("&") : "";
-        const response = await client.get(`/v1/billing/transactions${query}`);
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return [];
-        }
-        return response.data;
+        return await client.get(`/v1/billing/transactions${query}`);
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return [];
       } finally {
         setLoading(false);
       }
@@ -1716,14 +1765,13 @@ function useBilling() {
       setLoading(true);
       try {
         const query = params ? "?" + Object.entries(params).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`).join("&") : "";
-        const response = await client.get(
+        return await client.get(
           `/v1/billing/transactions/summary${query}`
         );
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data;
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1735,15 +1783,15 @@ function useBilling() {
       setError(null);
       setLoading(true);
       try {
-        const response = await client.post(
+        const result = await client.post(
           "/v1/billing/setup-sessions",
           data
         );
-        if (!response.success || !response.data) {
-          setError(response.error || null);
-          return null;
-        }
-        return response.data.client_secret;
+        return result.client_secret;
+      } catch (err) {
+        const apiError = err instanceof ScaleMuleApiError ? err : { code: "UNKNOWN", message: err instanceof Error ? err.message : "Unknown error" };
+        setError(apiError);
+        return null;
       } finally {
         setLoading(false);
       }
@@ -1811,17 +1859,9 @@ function useContent(options = {}) {
         if (p.offset) queryParams.set("offset", p.offset.toString());
         const query = queryParams.toString();
         const path = `/v1/storage/my-files${query ? `?${query}` : ""}`;
-        const response = await client.get(path);
-        if (!response.success || !response.data) {
-          const err = response.error || {
-            code: "LIST_FAILED",
-            message: "Failed to list files"
-          };
-          setLocalError(err);
-          throw err;
-        }
-        setFiles(response.data.files);
-        return response.data;
+        const data = await client.get(path);
+        setFiles(data.files);
+        return data;
       } finally {
         setLoading(false);
       }
@@ -1848,22 +1888,14 @@ function useContent(options = {}) {
           setUploadProgress(progress);
           options2?.onProgress?.(progress);
         };
-        const response = await client.upload(
+        const data = await client.upload(
           "/v1/storage/upload",
           file,
           additionalFields,
           { onProgress }
         );
-        if (!response.success || !response.data) {
-          const err = response.error || {
-            code: "UPLOAD_FAILED",
-            message: "Failed to upload file"
-          };
-          setLocalError(err);
-          throw err;
-        }
         await list();
-        return response.data;
+        return data;
       } finally {
         setLoading(false);
         setUploadProgress(null);
@@ -1876,15 +1908,7 @@ function useContent(options = {}) {
       setLocalError(null);
       setLoading(true);
       try {
-        const response = await client.delete(`/v1/storage/files/${fileId}`);
-        if (!response.success) {
-          const err = response.error || {
-            code: "DELETE_FAILED",
-            message: "Failed to delete file"
-          };
-          setLocalError(err);
-          throw err;
-        }
+        await client.delete(`/v1/storage/files/${fileId}`);
         setFiles((prev) => prev.filter((f) => f.id !== fileId));
       } finally {
         setLoading(false);
@@ -1895,16 +1919,7 @@ function useContent(options = {}) {
   const get = react.useCallback(
     async (fileId) => {
       setLocalError(null);
-      const response = await client.get(`/v1/storage/files/${fileId}/info`);
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "GET_FAILED",
-          message: "Failed to get file info"
-        };
-        setLocalError(err);
-        throw err;
-      }
-      return response.data;
+      return await client.get(`/v1/storage/files/${fileId}/info`);
     },
     [client]
   );
@@ -1914,16 +1929,7 @@ function useContent(options = {}) {
   const getSignedUploadUrl = react.useCallback(
     async (request) => {
       setLocalError(null);
-      const response = await client.post("/v1/storage/signed-upload", request);
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "SIGNED_URL_FAILED",
-          message: "Failed to get signed upload URL"
-        };
-        setLocalError(err);
-        throw err;
-      }
-      return response.data;
+      return await client.post("/v1/storage/signed-upload", request);
     },
     [client]
   );
@@ -1978,17 +1984,9 @@ function useContent(options = {}) {
   const completeSignedUpload = react.useCallback(
     async (fileId) => {
       setLocalError(null);
-      const response = await client.post(`/v1/storage/signed-upload/${fileId}/complete`);
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "COMPLETE_UPLOAD_FAILED",
-          message: "Failed to complete upload"
-        };
-        setLocalError(err);
-        throw err;
-      }
+      const data = await client.post(`/v1/storage/signed-upload/${fileId}/complete`);
       await list();
-      return response.data;
+      return data;
     },
     [client, list]
   );
@@ -2037,17 +2035,9 @@ function useUser() {
       setLocalError(null);
       setLoading(true);
       try {
-        const response = await client.patch("/v1/auth/profile", data);
-        if (!response.success || !response.data) {
-          const err = response.error || {
-            code: "UPDATE_FAILED",
-            message: "Failed to update profile"
-          };
-          setLocalError(err);
-          throw err;
-        }
-        setUser(response.data);
-        return response.data;
+        const profileData = await client.patch("/v1/auth/profile", data);
+        setUser(profileData);
+        return profileData;
       } finally {
         setLoading(false);
       }
@@ -2059,18 +2049,10 @@ function useUser() {
       setLocalError(null);
       setLoading(true);
       try {
-        const response = await client.post("/v1/auth/change-password", {
+        await client.post("/v1/auth/change-password", {
           current_password: currentPassword,
           new_password: newPassword
         });
-        if (!response.success) {
-          const err = response.error || {
-            code: "CHANGE_PASSWORD_FAILED",
-            message: "Failed to change password"
-          };
-          setLocalError(err);
-          throw err;
-        }
       } finally {
         setLoading(false);
       }
@@ -2082,18 +2064,10 @@ function useUser() {
       setLocalError(null);
       setLoading(true);
       try {
-        const response = await client.post("/v1/auth/change-email", {
+        await client.post("/v1/auth/change-email", {
           new_email: newEmail,
           password
         });
-        if (!response.success) {
-          const err = response.error || {
-            code: "CHANGE_EMAIL_FAILED",
-            message: "Failed to change email"
-          };
-          setLocalError(err);
-          throw err;
-        }
       } finally {
         setLoading(false);
       }
@@ -2105,17 +2079,9 @@ function useUser() {
       setLocalError(null);
       setLoading(true);
       try {
-        const response = await client.post("/v1/auth/delete-account", {
+        await client.post("/v1/auth/delete-account", {
           password
         });
-        if (!response.success) {
-          const err = response.error || {
-            code: "DELETE_ACCOUNT_FAILED",
-            message: "Failed to delete account"
-          };
-          setLocalError(err);
-          throw err;
-        }
         await client.clearSession();
         setUser(null);
       } finally {
@@ -2128,18 +2094,9 @@ function useUser() {
     setLocalError(null);
     setLoading(true);
     try {
-      const response = await client.post(
+      return await client.post(
         "/v1/auth/export-data"
       );
-      if (!response.success || !response.data) {
-        const err = response.error || {
-          code: "EXPORT_FAILED",
-          message: "Failed to export data"
-        };
-        setLocalError(err);
-        throw err;
-      }
-      return response.data;
     } finally {
       setLoading(false);
     }
@@ -2621,15 +2578,7 @@ function useAnalytics(options = {}) {
         return { tracked: 1, session_id: sessionIdRef.current || void 0 };
       }
       const endpoint = useV2 ? "/v1/analytics/v2/events" : "/v1/analytics/events";
-      const response = await client.post(endpoint, fullEvent);
-      if (!response.success) {
-        const err = response.error || {
-          code: "TRACK_FAILED",
-          message: "Failed to track event"
-        };
-        throw err;
-      }
-      return response.data || { tracked: 1, session_id: sessionIdRef.current || void 0 };
+      return await client.post(endpoint, fullEvent);
     },
     // Note: sessionId removed - we use ref to keep this stable
     [client, buildFullEvent, useV2, analyticsProxyUrl, publishableKey, gatewayUrl]
@@ -2647,7 +2596,7 @@ function useAnalytics(options = {}) {
         }
         return await sendEvent(event);
       } catch (err) {
-        if (err && typeof err === "object" && "code" in err) {
+        if (err instanceof ScaleMuleApiError) {
           setError(err);
         }
         throw err;
@@ -2709,18 +2658,9 @@ function useAnalytics(options = {}) {
           return { tracked: events.length, session_id: sessionIdRef.current || void 0 };
         }
         const endpoint = useV2 ? "/v1/analytics/v2/events/batch" : "/v1/analytics/events/batch";
-        const response = await client.post(endpoint, {
+        return await client.post(endpoint, {
           events: fullEvents
         });
-        if (!response.success) {
-          const err = response.error || {
-            code: "BATCH_TRACK_FAILED",
-            message: "Failed to track events"
-          };
-          setError(err);
-          throw err;
-        }
-        return response.data || { tracked: events.length, session_id: sessionIdRef.current || void 0 };
       } finally {
         setLoading(false);
       }
@@ -3083,6 +3023,7 @@ function createSafeLogger(prefix) {
   };
 }
 
+exports.ScaleMuleApiError = ScaleMuleApiError;
 exports.ScaleMuleClient = ScaleMuleClient;
 exports.ScaleMuleProvider = ScaleMuleProvider;
 exports.composePhone = composePhone;