@crosspost/sdk 0.1.8 → 0.1.9

package/dist/index.cjs

@@ -4215,6 +4215,7 @@ var ApiErrorCode = /* @__PURE__ */ ((ApiErrorCode2) => {
   ApiErrorCode2["POST_DELETION_FAILED"] = "POST_DELETION_FAILED";
   ApiErrorCode2["POST_INTERACTION_FAILED"] = "POST_INTERACTION_FAILED";
   ApiErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  ApiErrorCode2["INVALID_RESPONSE"] = "INVALID_RESPONSE";
   return ApiErrorCode2;
 })(ApiErrorCode || {});
 var ApiErrorCodeSchema = z.enum(Object.values(ApiErrorCode));
@@ -4294,7 +4295,11 @@ var errorCodeToStatusCode = {
   [
     "NETWORK_ERROR"
     /* NETWORK_ERROR */
-  ]: 503
+  ]: 503,
+  [
+    "INVALID_RESPONSE"
+    /* INVALID_RESPONSE */
+  ]: 500
 };
 var ErrorDetailSchema = z.object({
   message: z.string().describe("Human-readable error message"),
@@ -4983,103 +4988,96 @@ async function makeRequest(method, path, options, data, query) {
   const context = {
     method,
     path,
-    url,
-    retries: options.retries
+    url
   };
-  return apiWrapper(async () => {
-    let lastError = null;
-    for (let attempt = 0; attempt <= options.retries; attempt++) {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+  try {
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json"
+    };
+    if (method === "GET") {
+      const nearAccount = options.nearAccount || options.nearAuthData?.account_id;
+      if (!nearAccount) {
+        throw new CrosspostError(
+          "No NEAR account provided for GET request",
+          ApiErrorCode.UNAUTHORIZED,
+          401
+        );
+      }
+      headers["X-Near-Account"] = nearAccount;
+    } else {
+      if (!options.nearAuthData) {
+        throw new CrosspostError(
+          "NEAR authentication data required for non-GET request",
+          ApiErrorCode.UNAUTHORIZED,
+          401
+        );
+      }
+      headers["Authorization"] = `Bearer ${(0, import_near_sign_verify.createAuthToken)(options.nearAuthData)}`;
+    }
+    const requestOptions = {
+      method,
+      headers,
+      body: method !== "GET" && data ? JSON.stringify(data) : void 0,
+      signal: controller.signal
+    };
+    const response = await fetch(url, requestOptions);
+    clearTimeout(timeoutId);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch (jsonError) {
+      let responseText;
       try {
-        const headers = {
-          "Content-Type": "application/json",
-          "Accept": "application/json"
-        };
-        if (method === "GET") {
-          const nearAccount = options.nearAccount || options.nearAuthData?.account_id;
-          if (!nearAccount) {
-            throw new CrosspostError(
-              "No NEAR account provided for GET request",
-              ApiErrorCode.UNAUTHORIZED,
-              401
-            );
-          }
-          headers["X-Near-Account"] = nearAccount;
-        } else {
-          if (!options.nearAuthData) {
-            throw new CrosspostError(
-              "NEAR authentication data required for non-GET request",
-              ApiErrorCode.UNAUTHORIZED,
-              401
-            );
-          }
-          headers["Authorization"] = `Bearer ${(0, import_near_sign_verify.createAuthToken)(options.nearAuthData)}`;
-        }
-        const requestOptions = {
-          method,
-          headers,
-          body: method !== "GET" && data ? JSON.stringify(data) : void 0,
-          signal: controller.signal
-        };
-        const response = await fetch(url, requestOptions);
-        clearTimeout(timeoutId);
-        let responseData;
-        try {
-          responseData = await response.json();
-        } catch (jsonError) {
-          if (!response.ok) {
-            throw new CrosspostError(
-              `API request failed with status ${response.status} and non-JSON response`,
-              ApiErrorCode.NETWORK_ERROR,
-              response.status,
-              { originalStatusText: response.statusText }
-            );
-          }
-          throw new CrosspostError(
-            `Failed to parse JSON response: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`,
-            ApiErrorCode.INTERNAL_ERROR,
-            response.status
-          );
-        }
-        if (!response.ok) {
-          lastError = handleErrorResponse(responseData, response.status);
-          const shouldRetry = lastError instanceof CrosspostError && lastError.code === ApiErrorCode.RATE_LIMITED;
-          if (shouldRetry && attempt < options.retries) {
-            await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
-            continue;
-          }
-          throw lastError;
-        }
-        if (responseData && typeof responseData === "object" && "success" in responseData) {
-          if (responseData.success) {
-            return responseData.data;
-          } else {
-            lastError = handleErrorResponse(responseData, response.status);
-            const shouldRetry = lastError instanceof CrosspostError && lastError.code === ApiErrorCode.RATE_LIMITED;
-            if (shouldRetry && attempt < options.retries) {
-              await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
-              continue;
-            }
-            throw lastError;
-          }
-        }
-      } catch (error) {
-        clearTimeout(timeoutId);
-        lastError = error instanceof Error ? error : new Error(String(error));
-        const isNetworkError2 = error instanceof TypeError || error instanceof DOMException && error.name === "AbortError";
-        if (isNetworkError2 && attempt < options.retries) {
-          await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
-          continue;
-        }
-        if (!(error instanceof CrosspostError)) {
-          throw createNetworkError(error, url, options.timeout);
-        }
-        throw error;
+        responseText = await response.text();
+      } catch (_) {
       }
+      throw new CrosspostError(
+        `API request failed with status ${response.status} and non-JSON response`,
+        ApiErrorCode.INVALID_RESPONSE,
+        response.status,
+        {
+          originalStatusText: response.statusText,
+          originalError: jsonError instanceof Error ? jsonError.message : String(jsonError),
+          responseText
+        }
+      );
+    }
+    if (!response.ok) {
+      throw handleErrorResponse(responseData, response.status);
     }
-    throw lastError || new CrosspostError("Request failed after multiple retries", ApiErrorCode.INTERNAL_ERROR, 500);
-  }, context);
+    if (!responseData || typeof responseData !== "object" || !("success" in responseData)) {
+      throw new CrosspostError(
+        "Invalid success response format from API",
+        ApiErrorCode.INVALID_RESPONSE,
+        response.status,
+        { responseData }
+      );
+    }
+    if (responseData.success) {
+      return responseData.data;
+    }
+    throw handleErrorResponse(responseData, response.status);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof CrosspostError) {
+      throw enrichErrorWithContext(error, context);
+    }
+    if (error instanceof TypeError || error instanceof DOMException && error.name === "AbortError") {
+      throw enrichErrorWithContext(createNetworkError(error, url, options.timeout), context);
+    }
+    throw enrichErrorWithContext(
+      new CrosspostError(
+        error instanceof Error ? error.message : String(error),
+        ApiErrorCode.INTERNAL_ERROR,
+        500,
+        { originalError: String(error) }
+      ),
+      context
+    );
+  }
 }
 
 // src/api/activity.ts
@@ -5415,8 +5413,7 @@ var SystemApi = class {
 // src/core/config.ts
 var DEFAULT_CONFIG = {
   baseUrl: "https://open-crosspost-proxy.deno.dev/",
-  timeout: 3e4,
-  retries: 2
+  timeout: 3e4
 };
 
 // src/core/client.ts
@@ -5428,12 +5425,10 @@ var CrosspostClient = class {
   constructor(config = {}) {
     const baseUrl = config.baseUrl || DEFAULT_CONFIG.baseUrl;
     const timeout = config.timeout || DEFAULT_CONFIG.timeout;
-    const retries = config.retries ?? DEFAULT_CONFIG.retries;
     const nearAuthData = config.nearAuthData;
     this.options = {
       baseUrl,
       timeout,
-      retries,
       nearAuthData
     };
     this.auth = new AuthApi(this.options);

package/dist/index.d.cts

@@ -24,10 +24,6 @@ interface RequestOptions {
      * Request timeout in milliseconds
      */
     timeout: number;
-    /**
-     * Number of retries for failed requests
-     */
-    retries: number;
 }
 
 /**
@@ -228,11 +224,6 @@ interface CrosspostClientConfig {
      * @default 30000
      */
     timeout?: number;
-    /**
-     * Number of retries for failed requests (specifically for network errors or 5xx status codes)
-     * @default 2
-     */
-    retries?: number;
 }
 
 /**

package/dist/index.d.ts

@@ -24,10 +24,6 @@ interface RequestOptions {
      * Request timeout in milliseconds
      */
     timeout: number;
-    /**
-     * Number of retries for failed requests
-     */
-    retries: number;
 }
 
 /**
@@ -228,11 +224,6 @@ interface CrosspostClientConfig {
      * @default 30000
      */
     timeout?: number;
-    /**
-     * Number of retries for failed requests (specifically for network errors or 5xx status codes)
-     * @default 2
-     */
-    retries?: number;
 }
 
 /**

package/dist/index.js

@@ -4095,6 +4095,7 @@ var ApiErrorCode = /* @__PURE__ */ ((ApiErrorCode2) => {
   ApiErrorCode2["POST_DELETION_FAILED"] = "POST_DELETION_FAILED";
   ApiErrorCode2["POST_INTERACTION_FAILED"] = "POST_INTERACTION_FAILED";
   ApiErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  ApiErrorCode2["INVALID_RESPONSE"] = "INVALID_RESPONSE";
   return ApiErrorCode2;
 })(ApiErrorCode || {});
 var ApiErrorCodeSchema = z.enum(Object.values(ApiErrorCode));
@@ -4174,7 +4175,11 @@ var errorCodeToStatusCode = {
   [
     "NETWORK_ERROR"
     /* NETWORK_ERROR */
-  ]: 503
+  ]: 503,
+  [
+    "INVALID_RESPONSE"
+    /* INVALID_RESPONSE */
+  ]: 500
 };
 var ErrorDetailSchema = z.object({
   message: z.string().describe("Human-readable error message"),
@@ -4863,103 +4868,96 @@ async function makeRequest(method, path, options, data, query) {
   const context = {
     method,
     path,
-    url,
-    retries: options.retries
+    url
   };
-  return apiWrapper(async () => {
-    let lastError = null;
-    for (let attempt = 0; attempt <= options.retries; attempt++) {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+  try {
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json"
+    };
+    if (method === "GET") {
+      const nearAccount = options.nearAccount || options.nearAuthData?.account_id;
+      if (!nearAccount) {
+        throw new CrosspostError(
+          "No NEAR account provided for GET request",
+          ApiErrorCode.UNAUTHORIZED,
+          401
+        );
+      }
+      headers["X-Near-Account"] = nearAccount;
+    } else {
+      if (!options.nearAuthData) {
+        throw new CrosspostError(
+          "NEAR authentication data required for non-GET request",
+          ApiErrorCode.UNAUTHORIZED,
+          401
+        );
+      }
+      headers["Authorization"] = `Bearer ${createAuthToken(options.nearAuthData)}`;
+    }
+    const requestOptions = {
+      method,
+      headers,
+      body: method !== "GET" && data ? JSON.stringify(data) : void 0,
+      signal: controller.signal
+    };
+    const response = await fetch(url, requestOptions);
+    clearTimeout(timeoutId);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch (jsonError) {
+      let responseText;
       try {
-        const headers = {
-          "Content-Type": "application/json",
-          "Accept": "application/json"
-        };
-        if (method === "GET") {
-          const nearAccount = options.nearAccount || options.nearAuthData?.account_id;
-          if (!nearAccount) {
-            throw new CrosspostError(
-              "No NEAR account provided for GET request",
-              ApiErrorCode.UNAUTHORIZED,
-              401
-            );
-          }
-          headers["X-Near-Account"] = nearAccount;
-        } else {
-          if (!options.nearAuthData) {
-            throw new CrosspostError(
-              "NEAR authentication data required for non-GET request",
-              ApiErrorCode.UNAUTHORIZED,
-              401
-            );
-          }
-          headers["Authorization"] = `Bearer ${createAuthToken(options.nearAuthData)}`;
-        }
-        const requestOptions = {
-          method,
-          headers,
-          body: method !== "GET" && data ? JSON.stringify(data) : void 0,
-          signal: controller.signal
-        };
-        const response = await fetch(url, requestOptions);
-        clearTimeout(timeoutId);
-        let responseData;
-        try {
-          responseData = await response.json();
-        } catch (jsonError) {
-          if (!response.ok) {
-            throw new CrosspostError(
-              `API request failed with status ${response.status} and non-JSON response`,
-              ApiErrorCode.NETWORK_ERROR,
-              response.status,
-              { originalStatusText: response.statusText }
-            );
-          }
-          throw new CrosspostError(
-            `Failed to parse JSON response: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`,
-            ApiErrorCode.INTERNAL_ERROR,
-            response.status
-          );
-        }
-        if (!response.ok) {
-          lastError = handleErrorResponse(responseData, response.status);
-          const shouldRetry = lastError instanceof CrosspostError && lastError.code === ApiErrorCode.RATE_LIMITED;
-          if (shouldRetry && attempt < options.retries) {
-            await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
-            continue;
-          }
-          throw lastError;
-        }
-        if (responseData && typeof responseData === "object" && "success" in responseData) {
-          if (responseData.success) {
-            return responseData.data;
-          } else {
-            lastError = handleErrorResponse(responseData, response.status);
-            const shouldRetry = lastError instanceof CrosspostError && lastError.code === ApiErrorCode.RATE_LIMITED;
-            if (shouldRetry && attempt < options.retries) {
-              await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
-              continue;
-            }
-            throw lastError;
-          }
-        }
-      } catch (error) {
-        clearTimeout(timeoutId);
-        lastError = error instanceof Error ? error : new Error(String(error));
-        const isNetworkError2 = error instanceof TypeError || error instanceof DOMException && error.name === "AbortError";
-        if (isNetworkError2 && attempt < options.retries) {
-          await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
-          continue;
-        }
-        if (!(error instanceof CrosspostError)) {
-          throw createNetworkError(error, url, options.timeout);
-        }
-        throw error;
+        responseText = await response.text();
+      } catch (_) {
       }
+      throw new CrosspostError(
+        `API request failed with status ${response.status} and non-JSON response`,
+        ApiErrorCode.INVALID_RESPONSE,
+        response.status,
+        {
+          originalStatusText: response.statusText,
+          originalError: jsonError instanceof Error ? jsonError.message : String(jsonError),
+          responseText
+        }
+      );
+    }
+    if (!response.ok) {
+      throw handleErrorResponse(responseData, response.status);
     }
-    throw lastError || new CrosspostError("Request failed after multiple retries", ApiErrorCode.INTERNAL_ERROR, 500);
-  }, context);
+    if (!responseData || typeof responseData !== "object" || !("success" in responseData)) {
+      throw new CrosspostError(
+        "Invalid success response format from API",
+        ApiErrorCode.INVALID_RESPONSE,
+        response.status,
+        { responseData }
+      );
+    }
+    if (responseData.success) {
+      return responseData.data;
+    }
+    throw handleErrorResponse(responseData, response.status);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof CrosspostError) {
+      throw enrichErrorWithContext(error, context);
+    }
+    if (error instanceof TypeError || error instanceof DOMException && error.name === "AbortError") {
+      throw enrichErrorWithContext(createNetworkError(error, url, options.timeout), context);
+    }
+    throw enrichErrorWithContext(
+      new CrosspostError(
+        error instanceof Error ? error.message : String(error),
+        ApiErrorCode.INTERNAL_ERROR,
+        500,
+        { originalError: String(error) }
+      ),
+      context
+    );
+  }
 }
 
 // src/api/activity.ts
@@ -5295,8 +5293,7 @@ var SystemApi = class {
 // src/core/config.ts
 var DEFAULT_CONFIG = {
   baseUrl: "https://open-crosspost-proxy.deno.dev/",
-  timeout: 3e4,
-  retries: 2
+  timeout: 3e4
 };
 
 // src/core/client.ts
@@ -5308,12 +5305,10 @@ var CrosspostClient = class {
   constructor(config = {}) {
     const baseUrl = config.baseUrl || DEFAULT_CONFIG.baseUrl;
     const timeout = config.timeout || DEFAULT_CONFIG.timeout;
-    const retries = config.retries ?? DEFAULT_CONFIG.retries;
     const nearAuthData = config.nearAuthData;
     this.options = {
       baseUrl,
       timeout,
-      retries,
       nearAuthData
     };
     this.auth = new AuthApi(this.options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crosspost/sdk",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "SDK for interacting with the Crosspost API",
   "type": "module",
   "main": "dist/index.cjs",

package/src/core/client.ts

@@ -24,14 +24,12 @@ export class CrosspostClient {
   constructor(config: CrosspostClientConfig = {}) {
     const baseUrl = config.baseUrl || DEFAULT_CONFIG.baseUrl; // you can deploy your own
     const timeout = config.timeout || DEFAULT_CONFIG.timeout;
-    const retries = config.retries ?? DEFAULT_CONFIG.retries;
 
     const nearAuthData = config.nearAuthData;
 
     this.options = {
       baseUrl,
       timeout,
-      retries,
       nearAuthData,
     };
 

package/src/core/config.ts

@@ -18,11 +18,6 @@ export interface CrosspostClientConfig {
    * @default 30000
    */
   timeout?: number;
-  /**
-   * Number of retries for failed requests (specifically for network errors or 5xx status codes)
-   * @default 2
-   */
-  retries?: number;
 }
 
 /**
@@ -31,5 +26,4 @@ export interface CrosspostClientConfig {
 export const DEFAULT_CONFIG: Required<Omit<CrosspostClientConfig, 'nearAuthData'>> = {
   baseUrl: 'https://open-crosspost-proxy.deno.dev/',
   timeout: 30000,
-  retries: 2,
 };

package/src/core/request.ts

@@ -1,9 +1,9 @@
 import { ApiErrorCode, type StatusCode } from '@crosspost/types';
 import { createAuthToken, type NearAuthData } from 'near-sign-verify';
 import {
-  apiWrapper,
   createNetworkError,
   CrosspostError,
+  enrichErrorWithContext,
   handleErrorResponse,
 } from '../utils/error.ts';
 
@@ -29,14 +29,10 @@ export interface RequestOptions {
    * Request timeout in milliseconds
    */
   timeout: number;
-  /**
-   * Number of retries for failed requests
-   */
-  retries: number;
 }
 
 /**
- * Makes a request to the API with retry and error handling
+ * Makes a request to the API with error handling
  *
  * @param method The HTTP method
  * @param path The API path
@@ -76,131 +72,118 @@ export async function makeRequest<
     method,
     path,
     url,
-    retries: options.retries,
   };
 
-  return apiWrapper(async () => {
-    let lastError: Error | null = null;
-
-    for (let attempt = 0; attempt <= options.retries; attempt++) {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+
+  try {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+    };
+
+    // For GET requests, use X-Near-Account header if available
+    if (method === 'GET') {
+      const nearAccount = options.nearAccount || options.nearAuthData?.account_id;
+      if (!nearAccount) {
+        throw new CrosspostError(
+          'No NEAR account provided for GET request',
+          ApiErrorCode.UNAUTHORIZED,
+          401,
+        );
+      }
+      headers['X-Near-Account'] = nearAccount;
+    } else {
+      // For non-GET requests, require nearAuthData
+      if (!options.nearAuthData) {
+        throw new CrosspostError(
+          'NEAR authentication data required for non-GET request',
+          ApiErrorCode.UNAUTHORIZED,
+          401,
+        );
+      }
+      headers['Authorization'] = `Bearer ${createAuthToken(options.nearAuthData)}`;
+    }
 
+    const requestOptions: RequestInit = {
+      method,
+      headers,
+      body: method !== 'GET' && data ? JSON.stringify(data) : undefined,
+      signal: controller.signal,
+    };
+
+    const response = await fetch(url, requestOptions);
+    clearTimeout(timeoutId);
+
+    let responseData: any;
+    try {
+      responseData = await response.json();
+    } catch (jsonError) {
+      // JSON parsing failed - try to get response text for context
+      let responseText: string | undefined;
       try {
-        const headers: Record<string, string> = {
-          'Content-Type': 'application/json',
-          'Accept': 'application/json',
-        };
-
-        // For GET requests, use X-Near-Account header if available
-        if (method === 'GET') {
-          const nearAccount = options.nearAccount || options.nearAuthData?.account_id;
-          if (!nearAccount) {
-            throw new CrosspostError(
-              'No NEAR account provided for GET request',
-              ApiErrorCode.UNAUTHORIZED,
-              401,
-            );
-          }
-          headers['X-Near-Account'] = nearAccount;
-        } else {
-          // For non-GET requests, require nearAuthData
-          if (!options.nearAuthData) {
-            throw new CrosspostError(
-              'NEAR authentication data required for non-GET request',
-              ApiErrorCode.UNAUTHORIZED,
-              401,
-            );
-          }
-          headers['Authorization'] = `Bearer ${createAuthToken(options.nearAuthData)}`;
-        }
-
-        const requestOptions: RequestInit = {
-          method,
-          headers,
-          body: method !== 'GET' && data ? JSON.stringify(data) : undefined,
-          signal: controller.signal,
-        };
-
-        const response = await fetch(url, requestOptions);
-        clearTimeout(timeoutId); // Clear timeout if fetch completes
-
-        let responseData: any;
-        try {
-          responseData = await response.json();
-        } catch (jsonError) {
-          // If JSON parsing fails, did API throw an error?
-          if (!response.ok) {
-            throw new CrosspostError(
-              `API request failed with status ${response.status} and non-JSON response`,
-              ApiErrorCode.NETWORK_ERROR,
-              response.status as StatusCode,
-              { originalStatusText: response.statusText },
-            );
-          }
-          // Otherwise, throw a custom error
-          throw new CrosspostError(
-            `Failed to parse JSON response: ${
-              jsonError instanceof Error ? jsonError.message : String(jsonError)
-            }`,
-            ApiErrorCode.INTERNAL_ERROR,
-            response.status as StatusCode,
-          );
-        }
-
-        if (!response.ok) {
-          lastError = handleErrorResponse(responseData, response.status);
-          // Only retry rate limit errors
-          const shouldRetry = lastError instanceof CrosspostError &&
-            lastError.code === ApiErrorCode.RATE_LIMITED;
-          if (shouldRetry && attempt < options.retries) {
-            await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt))); // Exponential backoff
-            continue; // Retry
-          }
-          throw lastError; // Throw error if not retrying or retries exhausted
-        }
-
-        // Handle response based on success flag
-        if (responseData && typeof responseData === 'object' && 'success' in responseData) {
-          if (responseData.success) {
-            // Success response - return the data
-            return responseData.data as TResponse;
-          } else {
-            // Error response - handle with our error utilities
-            lastError = handleErrorResponse(responseData, response.status);
-            // Only retry rate limit errors
-            const shouldRetry = lastError instanceof CrosspostError &&
-              lastError.code === ApiErrorCode.RATE_LIMITED;
-            if (shouldRetry && attempt < options.retries) {
-              await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt))); // Exponential backoff
-              continue; // Retry
-            }
-            throw lastError;
-          }
-        }
-      } catch (error) {
-        clearTimeout(timeoutId); // Clear timeout on error
-        lastError = error instanceof Error ? error : new Error(String(error)); // Store the error
-
-        // Handle fetch/network errors specifically for retries
-        const isNetworkError = error instanceof TypeError ||
-          (error instanceof DOMException && error.name === 'AbortError');
-        if (isNetworkError && attempt < options.retries) {
-          await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt))); // Exponential backoff
-          continue; // Retry network error
-        }
-
-        // If it's not a known ApiError/PlatformError, wrap it
-        if (!(error instanceof CrosspostError)) {
-          throw createNetworkError(error, url, options.timeout);
-        }
-
-        throw error; // Re-throw known ApiError or final network error
-      }
+        responseText = await response.text();
+      } catch (_) { /* ignore */ }
+
+      throw new CrosspostError(
+        `API request failed with status ${response.status} and non-JSON response`,
+        ApiErrorCode.INVALID_RESPONSE,
+        response.status as StatusCode,
+        {
+          originalStatusText: response.statusText,
+          originalError: jsonError instanceof Error ? jsonError.message : String(jsonError),
+          responseText,
+        },
+      );
     }
 
-    // Should not be reachable if retries >= 0, but needed for type safety
-    throw lastError ||
-      new CrosspostError('Request failed after multiple retries', ApiErrorCode.INTERNAL_ERROR, 500);
-  }, context);
+    // Handle non-ok responses (4xx/5xx)
+    if (!response.ok) {
+      throw handleErrorResponse(responseData, response.status);
+    }
+
+    // Validate success response structure
+    if (!responseData || typeof responseData !== 'object' || !('success' in responseData)) {
+      throw new CrosspostError(
+        'Invalid success response format from API',
+        ApiErrorCode.INVALID_RESPONSE,
+        response.status as StatusCode,
+        { responseData },
+      );
+    }
+
+    if (responseData.success) {
+      return responseData.data as TResponse;
+    }
+
+    // If we get here, we have response.ok but success: false
+    // This is unexpected - treat as an error
+    throw handleErrorResponse(responseData, response.status);
+  } catch (error) {
+    clearTimeout(timeoutId);
+
+    if (error instanceof CrosspostError) {
+      // Enrich CrosspostError with request context
+      throw enrichErrorWithContext(error, context);
+    }
+
+    // Handle network errors (including timeouts)
+    if (
+      error instanceof TypeError || (error instanceof DOMException && error.name === 'AbortError')
+    ) {
+      throw enrichErrorWithContext(createNetworkError(error, url, options.timeout), context);
+    }
+
+    // For any other errors, wrap them with context
+    throw enrichErrorWithContext(
+      new CrosspostError(
+        error instanceof Error ? error.message : String(error),
+        ApiErrorCode.INTERNAL_ERROR,
+        500,
+        { originalError: String(error) },
+      ),
+      context,
+    );
+  }
 }