@unboundcx/sdk 2.6.16 → 2.7.0

package/base.js

@@ -101,6 +101,14 @@ export class BaseSDK {
   removeTransport(name) {
     this.transports.delete(name);
   }
+  
+  _getJsonSafely(str, defaultValue) {
+    try {
+      return JSON.parse(str);
+    } catch (e) {
+      return defaultValue;
+    }
+  }
 
   async _getAvailableTransport(forceFetch = false) {
     if (forceFetch) {
@@ -174,9 +182,10 @@ export class BaseSDK {
 
     // Try transport plugins first
     const transport = await this._getAvailableTransport(forceFetch);
+    let response;
     if (transport) {
       try {
-        const result = await transport.request(endpoint, method, params, {
+        response = await transport.request(endpoint, method, params, {
           namespace: this.namespace,
           token: this.token,
           callId: this.callId,
@@ -184,13 +193,7 @@ export class BaseSDK {
           baseURL: this.baseURL || this.fullUrl,
         });
         
-        // Debug logging for transport plugins
-        if (this.debugMode) {
-          const status = result?.status || 200;
-          console.log(`API :: ${transport.name} :: ${method.toUpperCase()} :: ${endpoint} :: ${status}`);
-        }
         
-        return result;
       } catch (err) {
         // IMPORTANT: This catch block should ONLY handle transport-level failures
         // (e.g., WebSocket disconnected, plugin unavailable, network errors)
@@ -198,22 +201,22 @@ export class BaseSDK {
         // Transport plugins should:
         // - RETURN API error responses normally (400, 500, etc.) as response objects
         // - ONLY THROW for transport mechanism failures
-        //
-        // This ensures API errors are passed through unchanged, just like built-in fetch
         
-        if (this.debugMode) {
-          console.log(`API :: Transport ${transport.name} failure :: ${method.toUpperCase()} :: ${endpoint} :: ${err.message}`);
-        }
         console.warn(
           `Transport ${transport.name} mechanism failed, falling back to HTTP:`,
           err.message,
         );
-        // Fall through to built-in HTTP fetch
+
+        // Built-in HTTP transport (fallback)
+        return this._httpRequest(endpoint, method, params);
       }
+    } else {
+      // No transport available, fallback to HTTP
+      return this._httpRequest(endpoint, method, params);
     }
 
-    // Built-in HTTP transport (fallback)
-    return this._httpRequest(endpoint, method, params);
+    return this._processResponse(response, transport.name, method, endpoint);
+
   }
 
   _isMultipartBody(body) {
@@ -306,72 +309,102 @@ export class BaseSDK {
 
     const response = await fetch(url, options);
     
+    return this._processResponse(response, 'https', method, endpoint);
+    
+  }
+
+  async _processResponse(response, transport, method, endpoint) {
     // Check if the response indicates an HTTP error
     // These are API/configuration errors, not transport failures
     if (!response.ok) {
       let errorBody;
-      const contentType = response.headers.get('content-type') || '';
-      
-      try {
-        if (contentType.includes('application/json')) {
-          errorBody = await response.json();
-        } else {
-          errorBody = await response.text();
+      if (response?.body) {
+          errorBody = response.body;
+      } else if (response?.headers?.['content-type']) {
+        const contentType = response.headers['content-type'];
+        try {
+          if (typeof  response?.json === 'function' || typeof response?.text === 'function') {
+            if (contentType.includes('application/json')) {
+              errorBody = await response.json();
+            } else if (contentType.includes('text/')) {
+              errorBody = await response.text();
+            }
+          } else {
+            if (contentType.includes('application/json')) {
+              errorBody = this._getJsonSafely(response?.body, response?.body || {});
+            } else if (contentType.includes('text/')) {
+              errorBody = response?.body || '';
+            }
+          }
+          if (!errorBody) {
+            errorBody = `HTTP ${response.status} ${response.statusText}`;
+          }
+        } catch (parseError) {
+          errorBody = `HTTP ${response.status} ${response.statusText}`;
         }
-      } catch (parseError) {
+      } else {
         errorBody = `HTTP ${response.status} ${response.statusText}`;
       }
       
       // Create a structured error for API/HTTP failures
-      const httpError = new Error(`API :: Error :: https :: ${options.method} :: ${endpoint} :: ${response.status} :: ${response.statusText}`);
+      const httpError = new Error(`API :: Error :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${response.status} :: ${response.statusText}`);
       httpError.status = response.status;
       httpError.statusText = response.statusText;
-      httpError.method = options.method;
+      httpError.method = method;
       httpError.endpoint = endpoint;
       httpError.body = errorBody;
+      httpError.message = errorBody?.error || errorBody?.message || 'API Error';
       
+          // Debug logging for successful HTTP requests
+    if (this.debugMode) {
+      console.log(`API :: ERROR :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${response?.status} :: ${responseRequestId}`, httpError);
+    }
+
       throw httpError;
     }
-    
-    // Check content type to determine how to parse successful response
-    const contentType = response.headers.get('content-type') || '';
-    let bodyResponse;
-    
-    if (contentType.includes('application/json')) {
-      bodyResponse = await response.json();
-    } else if (contentType.includes('text/')) {
-      bodyResponse = await response.text();
+
+    let responseBody;
+    if (response?.body) {
+        responseBody = response.body;
+    } else if (response?.headers?.['content-type']) {
+      const contentType = response.headers['content-type'];
+      try {
+        if (transport === 'https') {
+          if (contentType.includes('application/json')) {
+            responseBody = await response.json();
+          } else if (contentType.includes('text/')) {
+            responseBody = await response.text();
+          } else {
+            responseBody = await response.arrayBuffer();
+          }
+        } else {
+          if (contentType.includes('application/json')) {
+            responseBody = this._getJsonSafely(response.body, response.body);
+          } else if (contentType.includes('text/')) {
+            responseBody = response?.body || '';
+          }
+        }
+        if (!responseBody) {
+          responseBody = {};
+        }
+      } catch (parseError) {
+        responseBody = {};
+      }
     } else {
-      // For binary content (PDFs, images, etc), return as ArrayBuffer
-      bodyResponse = await response.arrayBuffer();
+      responseBody = {};
     }
-
+  
     const responseHeaders = response.headers;
     const responseRequestId =
       responseHeaders?.get?.('x-request-id') ||
       responseHeaders?.['x-request-id'];
 
-    if (!response.ok) {
-      // Debug logging for HTTP errors
-      if (this.debugMode) {
-        console.log(`API :: https :: ${method.toUpperCase()} :: ${endpoint} :: ${response?.status}`);
-      }
-      
-      throw {
-        name: `API :: Error :: https :: ${method} :: ${endpoint} :: ${responseRequestId} :: ${response?.status} :: ${response?.statusText}`,
-        message: bodyResponse?.message || `API Error occured.`,
-        method,
-        endpoint,
-        status: response?.status,
-        statusText: response?.statusText,
-      };
-    }
 
     // Debug logging for successful HTTP requests
     if (this.debugMode) {
-      console.log(`API :: https :: ${method.toUpperCase()} :: ${endpoint} :: ${response?.status}`);
+      console.log(`API :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${response?.status} :: ${responseRequestId}`);
     }
     
-    return bodyResponse;
+    return responseBody;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "2.6.16",
+  "version": "2.7.0",
   "description": "Official JavaScript SDK for the Unbound API - A comprehensive toolkit for integrating with Unbound's communication, AI, and data management services",
   "main": "index.js",
   "type": "module",