@oxyhq/services 5.13.1 → 5.13.3

package/src/core/OxyServices.ts

@@ -56,7 +56,6 @@
  *
  * See method JSDoc for more details and options.
  */
-import axios, { type AxiosInstance, type InternalAxiosRequestConfig } from 'axios';
 import { jwtDecode } from 'jwt-decode';
 import type { 
   OxyConfig as OxyConfigBase, 
@@ -67,6 +66,8 @@ import type {
   AssetUrlResponse, 
   AssetVariant 
 } from '../models/interfaces';
+import { normalizeLanguageCode, getLanguageMetadata, getLanguageName, getNativeLanguageName } from '../utils/languageUtils';
+import type { LanguageMetadata } from '../utils/languageUtils';
 /**
  * OxyConfig - Configuration for OxyServices
  * @property baseURL - The Oxy API base URL (e.g., https://api.oxy.so)
@@ -78,6 +79,8 @@ export interface OxyConfig extends OxyConfigBase {
 import type { SessionLoginResponse } from '../models/session';
 import { handleHttpError } from '../utils/errorUtils';
 import { buildSearchParams, buildPaginationParams, type PaginationParams } from '../utils/apiUtils';
+import { HttpClient } from './HttpClient';
+import { RequestManager, type RequestOptions } from './RequestManager';
 
 interface JwtPayload {
   exp?: number;
@@ -117,55 +120,18 @@ export class OxyAuthenticationTimeoutError extends OxyAuthenticationError {
  * OxyServices - Unified client library for interacting with the Oxy API
  * 
  * This class provides all API functionality in one simple, easy-to-use interface.
- * No need to manage multiple service instances - everything is available directly.
+ * Architecture:
+ * - HttpClient: Handles HTTP communication and authentication
+ * - RequestManager: Handles caching, deduplication, queuing, and retry
+ * - OxyServices: Provides high-level API methods
  */
-// Centralized token store
-class TokenStore {
-  private static instance: TokenStore;
-  private accessToken: string | null = null;
-  private refreshToken: string | null = null;
-
-  private constructor() {}
-
-  static getInstance(): TokenStore {
-    if (!TokenStore.instance) {
-      TokenStore.instance = new TokenStore();
-    }
-    return TokenStore.instance;
-  }
-
-  setTokens(accessToken: string, refreshToken = ''): void {
-    this.accessToken = accessToken;
-    this.refreshToken = refreshToken;
-  }
-
-  getAccessToken(): string | null {
-    return this.accessToken;
-  }
-
-  getRefreshToken(): string | null {
-    return this.refreshToken;
-  }
-
-  clearTokens(): void {
-    this.accessToken = null;
-    this.refreshToken = null;
-  }
-
-  hasAccessToken(): boolean {
-    return !!this.accessToken;
-  }
-}
-
 export class OxyServices {
-  protected client: AxiosInstance;
-  private tokenStore: TokenStore;
+  private httpClient: HttpClient;
+  private requestManager: RequestManager;
   private cloudURL: string;
+  private config: OxyConfig;
+  
 
-  /**
-   * Creates a new instance of the OxyServices client
-   * @param config - Configuration for the client
-   */
   /**
    * Creates a new instance of the OxyServices client
    * @param config - Configuration for the client
@@ -173,99 +139,33 @@ export class OxyServices {
    *   config.cloudURL: Oxy Cloud URL (e.g., https://cloud.oxy.so)
    */
   constructor(config: OxyConfig) {
-    this.client = axios.create({ 
-      baseURL: config.baseURL,
-      timeout: 5000 // 5 second timeout
-    });
+    this.config = config;
     this.cloudURL = config.cloudURL || OXY_CLOUD_URL;
-    this.tokenStore = TokenStore.getInstance();
-    this.setupInterceptors();
+
+    // Initialize HTTP client (handles authentication and interceptors)
+    this.httpClient = new HttpClient(config);
+
+    // Initialize request manager (handles caching, deduplication, queuing, retry)
+    this.requestManager = new RequestManager(this.httpClient, config);
   }
 
   // Test-only utility to reset global tokens between jest tests
   static __resetTokensForTests(): void {
-    try {
-      TokenStore.getInstance().clearTokens();
-    } catch {}
+    HttpClient.__resetTokensForTests();
   }
 
+
   /**
-   * Setup axios interceptors for authentication and error handling
+   * Make a request with all performance optimizations
+   * This is the main method for all API calls - ensures authentication and performance features
    */
-  private setupInterceptors(): void {
-    // Request interceptor for adding auth header and handling token refresh
-    this.client.interceptors.request.use(
-      async (req: InternalAxiosRequestConfig) => {
-        console.log('🔍 Interceptor - URL:', req.url);
-        console.log('🔍 Interceptor - Has token:', this.tokenStore.hasAccessToken());
-        
-        const accessToken = this.tokenStore.getAccessToken();
-        if (!accessToken) {
-          console.log('❌ Interceptor - No token available');
-          return req;
-        }
-        
-        try {
-          console.log('✅ Interceptor - Adding Authorization header');
-          
-          const decoded = jwtDecode<JwtPayload>(accessToken);
-          const currentTime = Math.floor(Date.now() / 1000);
-        
-          // If token expires in less than 60 seconds, refresh it
-          if (decoded.exp && decoded.exp - currentTime < 60) {
-            // For session-based tokens, get a new token from the session
-            if (decoded.sessionId) {
-              try {
-                // Create a new axios instance to avoid interceptor recursion
-                const refreshClient = axios.create({ 
-                  baseURL: this.client.defaults.baseURL,
-                  timeout: this.client.defaults.timeout
-                });
-                const res = await refreshClient.get(`/api/session/token/${decoded.sessionId}`);
-                this.tokenStore.setTokens(res.data.accessToken);
-                req.headers.Authorization = `Bearer ${res.data.accessToken}`;
-                console.log('✅ Interceptor - Token refreshed and Authorization header set');
-              } catch (refreshError) {
-                // If refresh fails, use current token anyway
-                req.headers.Authorization = `Bearer ${accessToken}`;
-                console.log('❌ Interceptor - Token refresh failed, using current token');
-              }
-            } else {
-              // No session ID, use current token
-              req.headers.Authorization = `Bearer ${accessToken}`;
-              console.log('✅ Interceptor - No session ID, using current token');
-            }
-          } else {
-            // Add authorization header with current token
-            req.headers.Authorization = `Bearer ${accessToken}`;
-            console.log('✅ Interceptor - Authorization header set with current token');
-          }
-        } catch (error) {
-          console.log('❌ Interceptor - Error processing token:', error);
-          // Even if there's an error, still try to use the token
-          req.headers.Authorization = `Bearer ${accessToken}`;
-          console.log('⚠️ Interceptor - Using token despite error');
-        }
-        
-        return req;
-      },
-      (error) => {
-        console.log('❌ Interceptor - Request error:', error);
-        return Promise.reject(error);
-      }
-    );
-
-    // Response interceptor for handling auth errors
-    this.client.interceptors.response.use(
-      (response) => response,
-      (error) => {
-        if (error.response?.status === 401) {
-          console.log('❌ Response interceptor - 401 Unauthorized, clearing tokens');
-          this.clearTokens();
-        }
-        return Promise.reject(error);
-      }
-    );
+  private async makeRequest<T>(
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
+    url: string,
+    data?: any,
+    options: RequestOptions = {}
+  ): Promise<T> {
+    return this.requestManager.request<T>(method, url, data, options);
   }
 
   // ============================================================================
@@ -276,7 +176,35 @@ export class OxyServices {
    * Get the configured Oxy API base URL
    */
   public getBaseURL(): string {
-    return this.client.defaults.baseURL || '';
+    return this.httpClient.getBaseURL();
+  }
+
+  /**
+   * Get performance metrics
+   */
+  public getMetrics() {
+    return this.requestManager.getMetrics();
+  }
+
+  /**
+   * Clear request cache
+   */
+  public clearCache(): void {
+    this.requestManager.clearCache();
+  }
+
+  /**
+   * Clear specific cache entry
+   */
+  public clearCacheEntry(key: string): void {
+    this.requestManager.clearCacheEntry(key);
+  }
+
+  /**
+   * Get cache statistics
+   */
+  public getCacheStats() {
+    return this.requestManager.getCacheStats();
   }
 
   /**
@@ -286,25 +214,33 @@ export class OxyServices {
     return this.cloudURL;
   }
 
+  /**
+   * Get the underlying HTTP client instance
+   * Useful for advanced use cases that need direct access to the HttpClient
+   */
+  public getClient(): HttpClient {
+    return this.httpClient;
+  }
+
   /**
    * Set authentication tokens
    */
   public setTokens(accessToken: string, refreshToken = ''): void {
-    this.tokenStore.setTokens(accessToken, refreshToken);
+    this.httpClient.setTokens(accessToken, refreshToken);
   }
 
   /**
    * Clear stored authentication tokens
    */
   public clearTokens(): void {
-    this.tokenStore.clearTokens();
+    this.httpClient.clearTokens();
   }
 
   /**
    * Get the current user ID from the access token
    */
   public getCurrentUserId(): string | null {
-    const accessToken = this.tokenStore.getAccessToken();
+    const accessToken = this.httpClient.getAccessToken();
     if (!accessToken) {
       return null;
     }
@@ -321,21 +257,21 @@ export class OxyServices {
    * Check if the client has a valid access token
    */
   private hasAccessToken(): boolean {
-    return this.tokenStore.hasAccessToken();
+    return this.httpClient.hasAccessToken();
   }
 
   /**
    * Check if the client has a valid access token (public method)
    */
   public hasValidToken(): boolean {
-    return this.tokenStore.hasAccessToken();
+    return this.httpClient.hasAccessToken();
   }
 
   /**
    * Get the raw access token (for constructing anchor URLs when needed)
    */
   public getAccessToken(): string | null {
-    return this.tokenStore.getAccessToken();
+    return this.httpClient.getAccessToken();
   }
 
   /**
@@ -354,7 +290,7 @@ export class OxyServices {
     const checkInterval = 100; // Check every 100ms
 
     while (Date.now() - startTime < timeoutMs) {
-      if (this.tokenStore.hasAccessToken()) {
+      if (this.httpClient.hasAccessToken()) {
         return true;
       }
       await new Promise(resolve => setTimeout(resolve, checkInterval));
@@ -385,17 +321,14 @@ export class OxyServices {
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       try {
         // First attempt: check if we have a token
-        if (!this.tokenStore.hasAccessToken()) {
+        if (!this.httpClient.hasAccessToken()) {
           if (attempt === 0) {
             // On first attempt, wait briefly for authentication to complete
-            console.log(`🔄 ${operationName} - Waiting for authentication...`);
             const authReady = await this.waitForAuthentication(authTimeoutMs);
             
             if (!authReady) {
               throw new OxyAuthenticationTimeoutError(operationName, authTimeoutMs);
             }
-            
-            console.log(`✅ ${operationName} - Authentication ready, proceeding...`);
           } else {
             // On retry attempts, fail immediately if no token
             throw new OxyAuthenticationError(
@@ -416,7 +349,6 @@ export class OxyServices {
                            error instanceof OxyAuthenticationError;
 
         if (isAuthError && !isLastAttempt && !(error instanceof OxyAuthenticationTimeoutError)) {
-          console.log(`🔄 ${operationName} - Auth error on attempt ${attempt + 1}, retrying in ${retryDelay}ms...`);
           await new Promise(resolve => setTimeout(resolve, retryDelay));
           continue;
         }
@@ -442,19 +374,16 @@ export class OxyServices {
     }
 
     try {
-      const res = await this.client.get('/api/auth/validate');
-      return res.data.valid === true;
+      const res = await this.makeRequest<{ valid: boolean }>('GET', '/api/auth/validate', undefined, {
+        cache: false,
+        retry: false,
+      });
+      return res.valid === true;
     } catch (error) {
       return false;
     }
   }
 
-  /**
-   * Get the HTTP client instance (public for external use)
-   */
-  public getClient(): AxiosInstance {
-    return this.client;
-  }
 
   /**
    * Centralized error handling
@@ -478,8 +407,7 @@ export class OxyServices {
     [key: string]: any 
   }> {
     try {
-      const res = await this.client.get('/health');
-      return res.data;
+      return await this.makeRequest('GET', '/health', undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -494,15 +422,15 @@ export class OxyServices {
    */
   async signUp(username: string, email: string, password: string): Promise<{ message: string; token: string; user: User }> {
     try {
-      const res = await this.client.post('/api/auth/signup', {
+      const res = await this.makeRequest<{ message: string; token: string; user: User }>('POST', '/api/auth/signup', {
         username,
         email,
         password
-      });
-      if (!res || !res.data || (typeof res.data === 'object' && Object.keys(res.data).length === 0)) {
+      }, { cache: false });
+      if (!res || (typeof res === 'object' && Object.keys(res).length === 0)) {
         throw new OxyAuthenticationError('Sign up failed', 'SIGNUP_FAILED', 400);
       }
-      return res.data;
+      return res;
     } catch (error) {
       throw this.handleError(error);
     }
@@ -513,8 +441,7 @@ export class OxyServices {
    */
   async requestRecovery(identifier: string): Promise<{ delivery?: string; destination?: string }> {
     try {
-      const res = await this.client.post('/api/auth/recover/request', { identifier });
-      return res.data;
+      return await this.makeRequest('POST', '/api/auth/recover/request', { identifier }, { cache: false });
     } catch (error: any) {
       throw this.handleError(error);
     }
@@ -525,8 +452,7 @@ export class OxyServices {
    */
   async verifyRecoveryCode(identifier: string, code: string): Promise<{ verified: boolean }> {
     try {
-      const res = await this.client.post('/api/auth/recover/verify', { identifier, code });
-      return res.data;
+      return await this.makeRequest('POST', '/api/auth/recover/verify', { identifier, code }, { cache: false });
     } catch (error: any) {
       throw this.handleError(error);
     }
@@ -537,8 +463,7 @@ export class OxyServices {
    */
   async resetPassword(identifier: string, code: string, newPassword: string): Promise<{ success: boolean }> {
     try {
-      const res = await this.client.post('/api/auth/recover/reset', { identifier, code, newPassword });
-      return res.data;
+      return await this.makeRequest('POST', '/api/auth/recover/reset', { identifier, code, newPassword }, { cache: false });
     } catch (error: any) {
       throw this.handleError(error);
     }
@@ -549,8 +474,7 @@ export class OxyServices {
    */
   async resetPasswordWithTotp(identifier: string, code: string, newPassword: string): Promise<{ success: boolean }> {
     try {
-      const res = await this.client.post('/api/auth/recover/totp/reset', { identifier, code, newPassword });
-      return res.data;
+      return await this.makeRequest('POST', '/api/auth/recover/totp/reset', { identifier, code, newPassword }, { cache: false });
     } catch (error: any) {
       throw this.handleError(error);
     }
@@ -558,8 +482,7 @@ export class OxyServices {
 
   async resetPasswordWithBackupCode(identifier: string, backupCode: string, newPassword: string): Promise<{ success: boolean }> {
     try {
-      const res = await this.client.post('/api/auth/recover/backup/reset', { identifier, backupCode, newPassword });
-      return res.data;
+      return await this.makeRequest('POST', '/api/auth/recover/backup/reset', { identifier, backupCode, newPassword }, { cache: false });
     } catch (error: any) {
       throw this.handleError(error);
     }
@@ -567,8 +490,7 @@ export class OxyServices {
 
   async resetPasswordWithRecoveryKey(identifier: string, recoveryKey: string, newPassword: string): Promise<{ success: boolean; nextRecoveryKey?: string }> {
     try {
-      const res = await this.client.post('/api/auth/recover/recovery-key/reset', { identifier, recoveryKey, newPassword });
-      return res.data;
+      return await this.makeRequest('POST', '/api/auth/recover/recovery-key/reset', { identifier, recoveryKey, newPassword }, { cache: false });
     } catch (error: any) {
       throw this.handleError(error);
     }
@@ -584,13 +506,12 @@ export class OxyServices {
     deviceFingerprint?: any
   ): Promise<SessionLoginResponse | { mfaRequired: true; mfaToken: string; expiresAt: string }> {
     try {
-      const res = await this.client.post('/api/auth/login', {
+      return await this.makeRequest<SessionLoginResponse | { mfaRequired: true; mfaToken: string; expiresAt: string }>('POST', '/api/auth/login', {
         username,
         password,
         deviceName,
         deviceFingerprint
-      });
-      return res.data;
+      }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -601,8 +522,7 @@ export class OxyServices {
    */
   async verifyTotpLogin(mfaToken: string, code: string): Promise<SessionLoginResponse> {
     try {
-      const res = await this.client.post('/api/auth/totp/verify-login', { mfaToken, code });
-      return res.data;
+      return await this.makeRequest<SessionLoginResponse>('POST', '/api/auth/totp/verify-login', { mfaToken, code }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -613,8 +533,38 @@ export class OxyServices {
    */
   async getUserBySession(sessionId: string): Promise<User> {
     try {
-      const res = await this.client.get(`/api/session/user/${sessionId}`);
-      return res.data;
+      return await this.makeRequest<User>('GET', `/api/session/user/${sessionId}`, undefined, {
+        cache: true,
+        cacheTTL: 2 * 60 * 1000, // 2 minutes cache for user data
+      });
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Batch get multiple user profiles by session IDs (optimized for account switching)
+   * Returns array of { sessionId, user } objects
+   */
+  async getUsersBySessions(sessionIds: string[]): Promise<Array<{ sessionId: string; user: User | null }>> {
+    try {
+      if (!Array.isArray(sessionIds) || sessionIds.length === 0) {
+        return [];
+      }
+      
+      // Deduplicate and sort sessionIds for consistent cache keys
+      const uniqueSessionIds = Array.from(new Set(sessionIds)).sort();
+      
+      return await this.makeRequest<Array<{ sessionId: string; user: User | null }>>(
+        'POST',
+        '/api/session/users/batch',
+        { sessionIds: uniqueSessionIds },
+        {
+          cache: true,
+          cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+          deduplicate: true, // Important for batch requests
+        }
+      );
     } catch (error) {
       throw this.handleError(error);
     }
@@ -625,19 +575,16 @@ export class OxyServices {
    */
   async getTokenBySession(sessionId: string): Promise<{ accessToken: string; expiresAt: string }> {
     try {
-      console.log('🔑 getTokenBySession - Fetching token for session:', sessionId);
-      const res = await this.client.get(`/api/session/token/${sessionId}`);
-      const { accessToken } = res.data;
-      
-      console.log('🔑 getTokenBySession - Token received:', !!accessToken);
+      const res = await this.makeRequest<{ accessToken: string; expiresAt: string }>('GET', `/api/session/token/${sessionId}`, undefined, {
+        cache: false,
+        retry: false,
+      });
       
       // Set the token in the centralized token store
-      this.setTokens(accessToken);
-      console.log('🔑 getTokenBySession - Token set in store');
+      this.setTokens(res.accessToken);
       
-      return res.data;
+      return res;
     } catch (error) {
-      console.log('❌ getTokenBySession - Error:', error);
       throw this.handleError(error);
     }
   }
@@ -647,8 +594,9 @@ export class OxyServices {
    */
   async getSessionsBySessionId(sessionId: string): Promise<any[]> {
     try {
-      const res = await this.client.get(`/api/session/sessions/${sessionId}`);
-      return res.data;
+      return await this.makeRequest('GET', `/api/session/sessions/${sessionId}`, undefined, {
+        cache: false,
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -663,7 +611,7 @@ export class OxyServices {
         ? `/api/session/logout/${sessionId}/${targetSessionId}`
         : `/api/session/logout/${sessionId}`;
       
-      await this.client.post(url);
+      await this.makeRequest('POST', url, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -674,7 +622,7 @@ export class OxyServices {
    */
   async logoutAllSessions(sessionId: string): Promise<void> {
     try {
-      await this.client.post(`/api/session/logout-all/${sessionId}`);
+      await this.makeRequest('POST', `/api/session/logout-all/${sessionId}`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -706,9 +654,11 @@ export class OxyServices {
         params.append('useHeaderValidation', 'true');
       }
 
-      const url = `/api/session/validate/${sessionId}?${params.toString()}`;
-      const res = await this.client.get(url);
-      return res.data;
+      const url = `/api/session/validate/${sessionId}`;
+      const urlParams: any = {};
+      if (options.deviceFingerprint) urlParams.deviceFingerprint = options.deviceFingerprint;
+      if (options.useHeaderValidation) urlParams.useHeaderValidation = 'true';
+      return await this.makeRequest('GET', url, urlParams, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -719,8 +669,7 @@ export class OxyServices {
    */
   async checkUsernameAvailability(username: string): Promise<{ available: boolean; message: string }> {
     try {
-      const res = await this.client.get(`/api/auth/check-username/${username}`);
-      return res.data;
+      return await this.makeRequest('GET', `/api/auth/check-username/${username}`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -731,8 +680,7 @@ export class OxyServices {
    */
   async checkEmailAvailability(email: string): Promise<{ available: boolean; message: string }> {
     try {
-      const res = await this.client.get(`/api/auth/check-email/${email}`);
-      return res.data;
+      return await this.makeRequest('GET', `/api/auth/check-email/${email}`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -747,8 +695,10 @@ export class OxyServices {
    */
   async getProfileByUsername(username: string): Promise<User> {
     try {
-      const res = await this.client.get(`/api/profiles/username/${username}`);
-      return res.data;
+      return await this.makeRequest<User>('GET', `/api/profiles/username/${username}`, undefined, {
+        cache: true,
+        cacheTTL: 5 * 60 * 1000, // 5 minutes cache for profiles
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -760,10 +710,8 @@ export class OxyServices {
 
   async startTotpEnrollment(sessionId: string): Promise<{ secret: string; otpauthUrl: string; issuer: string; label: string }> {
     try {
-      const res = await this.client.post('/api/auth/totp/enroll/start', { sessionId }, {
-        headers: { 'x-session-id': sessionId }
-      });
-      return res.data;
+      // Note: x-session-id header is handled by HttpClient interceptors if needed
+      return await this.makeRequest('POST', '/api/auth/totp/enroll/start', { sessionId }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -771,10 +719,7 @@ export class OxyServices {
 
   async verifyTotpEnrollment(sessionId: string, code: string): Promise<{ enabled: boolean; backupCodes?: string[]; recoveryKey?: string }> {
     try {
-      const res = await this.client.post('/api/auth/totp/enroll/verify', { sessionId, code }, {
-        headers: { 'x-session-id': sessionId }
-      });
-      return res.data;
+      return await this.makeRequest('POST', '/api/auth/totp/enroll/verify', { sessionId, code }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -782,10 +727,7 @@ export class OxyServices {
 
   async disableTotp(sessionId: string, code: string): Promise<{ disabled: boolean }> {
     try {
-      const res = await this.client.post('/api/auth/totp/disable', { sessionId, code }, {
-        headers: { 'x-session-id': sessionId }
-      });
-      return res.data;
+      return await this.makeRequest('POST', '/api/auth/totp/disable', { sessionId, code }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -798,9 +740,14 @@ export class OxyServices {
     try {
       const params = { query, ...pagination };
       const searchParams = buildSearchParams(params);
-      
-      const res = await this.client.get(`/api/profiles/search?${searchParams.toString()}`);
-      return res.data;
+      const paramsObj: any = {};
+      searchParams.forEach((value, key) => {
+        paramsObj[key] = value;
+      });
+      return await this.makeRequest<User[]>('GET', '/api/profiles/search', paramsObj, {
+        cache: true,
+        cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -818,8 +765,7 @@ export class OxyServices {
     [key: string]: any;
   }>> {
     return this.withAuthRetry(async () => {
-      const res = await this.client.get('/api/profiles/recommendations');
-      return res.data;
+      return await this.makeRequest('GET', '/api/profiles/recommendations', undefined, { cache: true });
     }, 'getProfileRecommendations');
   }
 
@@ -828,8 +774,10 @@ export class OxyServices {
    */
   async getUserById(userId: string): Promise<User> {
     try {
-      const res = await this.client.get(`/api/users/${userId}`);
-      return res.data;
+      return await this.makeRequest<User>('GET', `/api/users/${userId}`, undefined, {
+        cache: true,
+        cacheTTL: 5 * 60 * 1000, // 5 minutes cache
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -840,8 +788,10 @@ export class OxyServices {
    */
   async getCurrentUser(): Promise<User> {
     return this.withAuthRetry(async () => {
-      const res = await this.client.get('/api/users/me');
-      return res.data;
+      return await this.makeRequest<User>('GET', '/api/users/me', undefined, {
+        cache: true,
+        cacheTTL: 1 * 60 * 1000, // 1 minute cache for current user
+      });
     }, 'getCurrentUser');
   }
 
@@ -850,20 +800,136 @@ export class OxyServices {
    */
   async updateProfile(updates: Record<string, any>): Promise<User> {
     try {
-      const res = await this.client.put('/api/users/me', updates);
-      return res.data;
+      return await this.makeRequest<User>('PUT', '/api/users/me', updates, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
   }
 
+  // ============================================================================
+  // LANGUAGE METHODS
+  // ============================================================================
+
+  /**
+   * Get the current language from storage or user profile
+   * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+   * @returns The current language code (e.g., 'en-US') or null if not set
+   */
+  async getCurrentLanguage(storageKeyPrefix: string = 'oxy_session'): Promise<string | null> {
+    try {
+      // First try to get from user profile if authenticated
+      try {
+        const user = await this.getCurrentUser();
+        const userLanguage = (user as Record<string, unknown>)?.language as string | undefined;
+        if (userLanguage) {
+          return normalizeLanguageCode(userLanguage) || userLanguage;
+        }
+      } catch (e) {
+        // User not authenticated or error, continue to storage
+      }
+
+      // Fall back to storage
+      const storage = await this.getStorage();
+      const storageKey = `${storageKeyPrefix}_language`;
+      const storedLanguage = await storage.getItem(storageKey);
+      if (storedLanguage) {
+        return normalizeLanguageCode(storedLanguage) || storedLanguage;
+      }
+
+      return null;
+    } catch (error) {
+      if (__DEV__) {
+        console.warn('Failed to get current language:', error);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Get the current language with metadata (name, nativeName, etc.)
+   * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+   * @returns Language metadata object or null if not set
+   */
+  async getCurrentLanguageMetadata(storageKeyPrefix: string = 'oxy_session'): Promise<LanguageMetadata | null> {
+    const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+    return getLanguageMetadata(languageCode);
+  }
+
+  /**
+   * Get the current language name (e.g., 'English')
+   * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+   * @returns Language name or null if not set
+   */
+  async getCurrentLanguageName(storageKeyPrefix: string = 'oxy_session'): Promise<string | null> {
+    const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+    if (!languageCode) return null;
+    return getLanguageName(languageCode);
+  }
+
+  /**
+   * Get the current native language name (e.g., 'Español')
+   * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+   * @returns Native language name or null if not set
+   */
+  async getCurrentNativeLanguageName(storageKeyPrefix: string = 'oxy_session'): Promise<string | null> {
+    const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+    if (!languageCode) return null;
+    return getNativeLanguageName(languageCode);
+  }
+
+  /**
+   * Get appropriate storage for the platform (similar to DeviceManager)
+   * @private
+   */
+  private async getStorage(): Promise<{
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+  }> {
+    const isReactNative = typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+    
+    if (isReactNative) {
+      try {
+        const asyncStorageModule = await import('@react-native-async-storage/async-storage');
+        const storage = (asyncStorageModule.default as unknown) as import('@react-native-async-storage/async-storage').AsyncStorageStatic;
+        return {
+          getItem: storage.getItem.bind(storage),
+          setItem: storage.setItem.bind(storage),
+          removeItem: storage.removeItem.bind(storage),
+        };
+      } catch (error) {
+        console.error('AsyncStorage not available in React Native:', error);
+        throw new Error('AsyncStorage is required in React Native environment');
+      }
+    } else {
+      // Use localStorage for web
+      return {
+        getItem: async (key: string) => {
+          if (typeof window !== 'undefined' && window.localStorage) {
+            return localStorage.getItem(key);
+          }
+          return null;
+        },
+        setItem: async (key: string, value: string) => {
+          if (typeof window !== 'undefined' && window.localStorage) {
+            localStorage.setItem(key, value);
+          }
+        },
+        removeItem: async (key: string) => {
+          if (typeof window !== 'undefined' && window.localStorage) {
+            localStorage.removeItem(key);
+          }
+        }
+      };
+    }
+  }
+
   /**
    * Update user by ID (admin function)
    */
   async updateUser(userId: string, updates: Record<string, any>): Promise<User> {
     try {
-      const res = await this.client.put(`/api/users/${userId}`, updates);
-      return res.data;
+      return await this.makeRequest<User>('PUT', `/api/users/${userId}`, updates, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -874,8 +940,7 @@ export class OxyServices {
    */
   async followUser(userId: string): Promise<{ success: boolean; message: string }> {
     try {
-      const res = await this.client.post(`/api/users/${userId}/follow`);
-      return res.data;
+      return await this.makeRequest('POST', `/api/users/${userId}/follow`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -886,8 +951,7 @@ export class OxyServices {
    */
   async unfollowUser(userId: string): Promise<{ success: boolean; message: string }> {
     try {
-      const res = await this.client.delete(`/api/users/${userId}/follow`);
-      return res.data;
+      return await this.makeRequest('DELETE', `/api/users/${userId}/follow`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -898,8 +962,10 @@ export class OxyServices {
    */
   async getFollowStatus(userId: string): Promise<{ isFollowing: boolean }> {
     try {
-      const res = await this.client.get(`/api/users/${userId}/follow-status`);
-      return res.data;
+      return await this.makeRequest('GET', `/api/users/${userId}/follow-status`, undefined, {
+        cache: true,
+        cacheTTL: 1 * 60 * 1000, // 1 minute cache
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -914,8 +980,15 @@ export class OxyServices {
   ): Promise<{ followers: User[]; total: number; hasMore: boolean }> {
     try {
       const params = buildPaginationParams(pagination || {});
-      const res = await this.client.get(`/api/users/${userId}/followers?${params.toString()}`);
-      return res.data;
+      const response = await this.makeRequest<{ data: User[]; pagination: { total: number; hasMore: boolean } }>('GET', `/api/users/${userId}/followers`, params, {
+        cache: true,
+        cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+      });
+      return {
+        followers: response.data || [],
+        total: response.pagination.total,
+        hasMore: response.pagination.hasMore,
+      };
     } catch (error) {
       throw this.handleError(error);
     }
@@ -930,8 +1003,15 @@ export class OxyServices {
   ): Promise<{ following: User[]; total: number; hasMore: boolean }> {
     try {
       const params = buildPaginationParams(pagination || {});
-      const res = await this.client.get(`/api/users/${userId}/following?${params.toString()}`);
-      return res.data;
+      const response = await this.makeRequest<{ data: User[]; pagination: { total: number; hasMore: boolean } }>('GET', `/api/users/${userId}/following`, params, {
+        cache: true,
+        cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+      });
+      return {
+        following: response.data || [],
+        total: response.pagination.total,
+        hasMore: response.pagination.hasMore,
+      };
     } catch (error) {
       throw this.handleError(error);
     }
@@ -942,8 +1022,9 @@ export class OxyServices {
    */
   async getNotifications(): Promise<Notification[]> {
     return this.withAuthRetry(async () => {
-      const res = await this.client.get('/api/notifications');
-      return res.data;
+      return await this.makeRequest<Notification[]>('GET', '/api/notifications', undefined, {
+        cache: false, // Don't cache notifications - always get fresh data
+      });
     }, 'getNotifications');
   }
 
@@ -952,8 +1033,10 @@ export class OxyServices {
    */
   async getUnreadCount(): Promise<number> {
     try {
-      const res = await this.client.get('/api/notifications/unread-count');
-      return res.data.count;
+      const res = await this.makeRequest<{ count: number }>('GET', '/api/notifications/unread-count', undefined, {
+        cache: false, // Don't cache unread count - always get fresh data
+      });
+      return res.count;
     } catch (error) {
       throw this.handleError(error);
     }
@@ -964,8 +1047,7 @@ export class OxyServices {
    */
   async createNotification(data: Partial<Notification>): Promise<Notification> {
     try {
-      const res = await this.client.post('/api/notifications', data);
-      return res.data;
+      return await this.makeRequest<Notification>('POST', '/api/notifications', data, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -976,7 +1058,7 @@ export class OxyServices {
    */
   async markNotificationAsRead(notificationId: string): Promise<void> {
     try {
-      await this.client.put(`/api/notifications/${notificationId}/read`);
+      await this.makeRequest('PUT', `/api/notifications/${notificationId}/read`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -987,7 +1069,7 @@ export class OxyServices {
    */
   async markAllNotificationsAsRead(): Promise<void> {
     try {
-      await this.client.put('/api/notifications/read-all');
+      await this.makeRequest('PUT', '/api/notifications/read-all', undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -998,7 +1080,7 @@ export class OxyServices {
    */
   async deleteNotification(notificationId: string): Promise<void> {
     try {
-      await this.client.delete(`/api/notifications/${notificationId}`);
+      await this.makeRequest('DELETE', `/api/notifications/${notificationId}`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1013,8 +1095,7 @@ export class OxyServices {
    */
   async createPayment(data: any): Promise<any> {
     try {
-      const res = await this.client.post('/api/payments', data);
-      return res.data;
+      return await this.makeRequest('POST', '/api/payments', data, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1025,8 +1106,10 @@ export class OxyServices {
    */
   async getPayment(paymentId: string): Promise<any> {
     try {
-      const res = await this.client.get(`/api/payments/${paymentId}`);
-      return res.data;
+      return await this.makeRequest('GET', `/api/payments/${paymentId}`, undefined, {
+        cache: true,
+        cacheTTL: 5 * 60 * 1000, // 5 minutes cache
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1037,8 +1120,9 @@ export class OxyServices {
    */
   async getUserPayments(): Promise<any[]> {
     try {
-      const res = await this.client.get('/api/payments/user');
-      return res.data;
+      return await this.makeRequest('GET', '/api/payments/user', undefined, {
+        cache: false, // Don't cache user payments - always get fresh data
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1053,8 +1137,10 @@ export class OxyServices {
    */
   async getUserKarma(userId: string): Promise<any> {
     try {
-      const res = await this.client.get(`/api/karma/${userId}`);
-      return res.data;
+      return await this.makeRequest('GET', `/api/karma/${userId}`, undefined, {
+        cache: true,
+        cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1065,11 +1151,10 @@ export class OxyServices {
    */
   async giveKarma(userId: string, amount: number, reason?: string): Promise<any> {
     try {
-      const res = await this.client.post(`/api/karma/${userId}/give`, {
+      return await this.makeRequest('POST', `/api/karma/${userId}/give`, {
         amount,
         reason
-      });
-      return res.data;
+      }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1080,8 +1165,10 @@ export class OxyServices {
    */
   async getUserKarmaTotal(userId: string): Promise<any> {
     try {
-      const res = await this.client.get(`/api/karma/${userId}/total`);
-      return res.data;
+      return await this.makeRequest('GET', `/api/karma/${userId}/total`, undefined, {
+        cache: true,
+        cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1092,12 +1179,14 @@ export class OxyServices {
    */
   async getUserKarmaHistory(userId: string, limit?: number, offset?: number): Promise<any> {
     try {
-      const params = new URLSearchParams();
-      if (limit) params.append('limit', limit.toString());
-      if (offset) params.append('offset', offset.toString());
+      const params: any = {};
+      if (limit) params.limit = limit;
+      if (offset) params.offset = offset;
       
-      const res = await this.client.get(`/api/karma/${userId}/history?${params.toString()}`);
-      return res.data;
+      return await this.makeRequest('GET', `/api/karma/${userId}/history`, params, {
+        cache: true,
+        cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1108,8 +1197,10 @@ export class OxyServices {
    */
   async getKarmaLeaderboard(): Promise<any> {
     try {
-      const res = await this.client.get('/api/karma/leaderboard');
-      return res.data;
+      return await this.makeRequest('GET', '/api/karma/leaderboard', undefined, {
+        cache: true,
+        cacheTTL: 5 * 60 * 1000, // 5 minutes cache
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1120,8 +1211,10 @@ export class OxyServices {
    */
   async getKarmaRules(): Promise<any> {
     try {
-      const res = await this.client.get('/api/karma/rules');
-      return res.data;
+      return await this.makeRequest('GET', '/api/karma/rules', undefined, {
+        cache: true,
+        cacheTTL: 30 * 60 * 1000, // 30 minutes cache (rules don't change often)
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1137,8 +1230,7 @@ export class OxyServices {
   async deleteFile(fileId: string): Promise<any> {
     try {
       // Central Asset Service delete with force=true behavior controlled by caller via assetDelete
-      const res = await this.client.delete(`/api/assets/${encodeURIComponent(fileId)}`);
-      return res.data;
+      return await this.makeRequest('DELETE', `/api/assets/${encodeURIComponent(fileId)}`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1153,7 +1245,7 @@ export class OxyServices {
   if (variant) params.set('variant', variant);
   if (expiresIn) params.set('expiresIn', String(expiresIn));
   params.set('fallback', 'placeholderVisible');
-  const token = this.tokenStore.getAccessToken();
+  const token = this.httpClient.getAccessToken();
   if (token) params.set('token', token);
 
   // Use params.toString() to detect whether there are query params.
@@ -1179,12 +1271,12 @@ export class OxyServices {
    */
   async listUserFiles(limit?: number, offset?: number): Promise<{ files: any[]; total: number; hasMore: boolean }> {
     try {
-      const params = new URLSearchParams();
-      if (limit) params.append('limit', String(limit));
-      if (offset) params.append('offset', String(offset));
-  const qs = params.toString();
-  const res = await this.client.get(`/api/assets${qs ? `?${qs}` : ''}`);
-      return res.data;
+      const paramsObj: any = {};
+      if (limit) paramsObj.limit = limit;
+      if (offset) paramsObj.offset = offset;
+      return await this.makeRequest('GET', '/api/assets', paramsObj, {
+        cache: false, // Don't cache file lists - always get fresh data
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1197,8 +1289,12 @@ export class OxyServices {
    */
   async getFileContentAsText(fileId: string, variant?: string): Promise<string> {
     try {
-      const urlRes = await this.client.get(`/api/assets/${encodeURIComponent(fileId)}/url${variant ? `?variant=${encodeURIComponent(variant)}` : ''}`);
-      const downloadUrl = urlRes.data?.url;
+      const params: any = variant ? { variant } : undefined;
+      const urlRes = await this.makeRequest<{ url: string }>('GET', `/api/assets/${encodeURIComponent(fileId)}/url`, params, {
+        cache: true,
+        cacheTTL: 10 * 60 * 1000, // 10 minutes cache for URLs
+      });
+      const downloadUrl = urlRes?.url;
       const response = await fetch(downloadUrl);
       return await response.text();
     } catch (error) {
@@ -1211,8 +1307,12 @@ export class OxyServices {
    */
   async getFileContentAsBlob(fileId: string, variant?: string): Promise<Blob> {
     try {
-      const urlRes = await this.client.get(`/api/assets/${encodeURIComponent(fileId)}/url${variant ? `?variant=${encodeURIComponent(variant)}` : ''}`);
-      const downloadUrl = urlRes.data?.url;
+      const params: any = variant ? { variant } : undefined;
+      const urlRes = await this.makeRequest<{ url: string }>('GET', `/api/assets/${encodeURIComponent(fileId)}/url`, params, {
+        cache: true,
+        cacheTTL: 10 * 60 * 1000, // 10 minutes cache for URLs
+      });
+      const downloadUrl = urlRes?.url;
       const response = await fetch(downloadUrl);
       return await response.blob();
     } catch (error) {
@@ -1247,12 +1347,11 @@ export class OxyServices {
    */
   async assetInit(sha256: string, size: number, mime: string): Promise<AssetInitResponse> {
     try {
-      const res = await this.client.post('/api/assets/init', {
+      return await this.makeRequest<AssetInitResponse>('POST', '/api/assets/init', {
         sha256,
         size,
         mime
-      });
-      return res.data;
+      }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1263,15 +1362,14 @@ export class OxyServices {
    */
   async assetComplete(fileId: string, originalName: string, size: number, mime: string, visibility?: 'private' | 'public' | 'unlisted', metadata?: Record<string, any>): Promise<any> {
     try {
-      const res = await this.client.post('/api/assets/complete', {
+      return await this.makeRequest('POST', '/api/assets/complete', {
         fileId,
         originalName,
         size,
         mime,
         visibility,
         metadata
-      });
-      return res.data;
+      }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1295,8 +1393,11 @@ export class OxyServices {
         // Fallback: direct upload via API to avoid CORS issues
         const fd = new FormData();
         fd.append('file', file);
-        await this.client.post(`/api/assets/${encodeURIComponent(initResponse.fileId)}/upload-direct`, fd, {
-          headers: { 'Content-Type': 'multipart/form-data' }
+        // Use httpClient directly for FormData uploads (bypasses RequestManager for special handling)
+        await this.httpClient.request({
+          method: 'POST',
+          url: `/api/assets/${encodeURIComponent(initResponse.fileId)}/upload-direct`,
+          data: fd,
         });
       }
 
@@ -1354,8 +1455,7 @@ export class OxyServices {
       const body: any = { app, entityType, entityId };
       if (visibility) body.visibility = visibility;
       if (webhookUrl) body.webhookUrl = webhookUrl;
-      const res = await this.client.post(`/api/assets/${fileId}/links`, body);
-      return res.data;
+      return await this.makeRequest('POST', `/api/assets/${fileId}/links`, body, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1366,14 +1466,11 @@ export class OxyServices {
    */
   async assetUnlink(fileId: string, app: string, entityType: string, entityId: string): Promise<any> {
     try {
-      const res = await this.client.delete(`/api/assets/${fileId}/links`, {
-        data: {
-          app,
-          entityType,
-          entityId
-        }
-      });
-      return res.data;
+      return await this.makeRequest('DELETE', `/api/assets/${fileId}/links`, {
+        app,
+        entityType,
+        entityId
+      }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1384,8 +1481,10 @@ export class OxyServices {
    */
   async assetGet(fileId: string): Promise<any> {
     try {
-      const res = await this.client.get(`/api/assets/${fileId}`);
-      return res.data;
+      return await this.makeRequest('GET', `/api/assets/${fileId}`, undefined, {
+        cache: true,
+        cacheTTL: 5 * 60 * 1000, // 5 minutes cache
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1396,15 +1495,14 @@ export class OxyServices {
    */
   async assetGetUrl(fileId: string, variant?: string, expiresIn?: number): Promise<AssetUrlResponse> {
     try {
-      const params = new URLSearchParams();
-      if (variant) params.set('variant', variant);
-      if (expiresIn) params.set('expiresIn', expiresIn.toString());
-      
-      const queryString = params.toString();
-      const url = `/api/assets/${fileId}/url${queryString ? `?${queryString}` : ''}`;
+      const params: any = {};
+      if (variant) params.variant = variant;
+      if (expiresIn) params.expiresIn = expiresIn;
       
-      const res = await this.client.get(url);
-      return res.data;
+      return await this.makeRequest<AssetUrlResponse>('GET', `/api/assets/${fileId}/url`, params, {
+        cache: true,
+        cacheTTL: 10 * 60 * 1000, // 10 minutes cache for URLs
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1415,8 +1513,7 @@ export class OxyServices {
    */
   async assetRestore(fileId: string): Promise<any> {
     try {
-      const res = await this.client.post(`/api/assets/${fileId}/restore`);
-      return res.data;
+      return await this.makeRequest('POST', `/api/assets/${fileId}/restore`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1427,9 +1524,8 @@ export class OxyServices {
    */
   async assetDelete(fileId: string, force: boolean = false): Promise<any> {
     try {
-      const params = force ? '?force=true' : '';
-      const res = await this.client.delete(`/api/assets/${fileId}${params}`);
-      return res.data;
+      const params: any = force ? { force: 'true' } : undefined;
+      return await this.makeRequest('DELETE', `/api/assets/${fileId}`, params, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1455,10 +1551,9 @@ export class OxyServices {
    */
   async assetUpdateVisibility(fileId: string, visibility: 'private' | 'public' | 'unlisted'): Promise<any> {
     try {
-      const res = await this.client.patch(`/api/assets/${fileId}/visibility`, {
+      return await this.makeRequest('PATCH', `/api/assets/${fileId}/visibility`, {
         visibility
-      });
-      return res.data;
+      }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1515,8 +1610,11 @@ export class OxyServices {
    */
   async getDeveloperApps(): Promise<any[]> {
     try {
-      const res = await this.client.get('/api/developer/apps');
-      return res.data.apps || [];
+      const res = await this.makeRequest<{ apps?: any[] }>('GET', '/api/developer/apps', undefined, {
+        cache: true,
+        cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+      });
+      return res.apps || [];
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1533,8 +1631,8 @@ export class OxyServices {
     scopes?: string[];
   }): Promise<any> {
     try {
-      const res = await this.client.post('/api/developer/apps', data);
-      return res.data.app;
+      const res = await this.makeRequest<{ app: any }>('POST', '/api/developer/apps', data, { cache: false });
+      return res.app;
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1545,8 +1643,11 @@ export class OxyServices {
    */
   async getDeveloperApp(appId: string): Promise<any> {
     try {
-      const res = await this.client.get(`/api/developer/apps/${appId}`);
-      return res.data.app;
+      const res = await this.makeRequest<{ app: any }>('GET', `/api/developer/apps/${appId}`, undefined, {
+        cache: true,
+        cacheTTL: 5 * 60 * 1000, // 5 minutes cache
+      });
+      return res.app;
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1563,8 +1664,8 @@ export class OxyServices {
     scopes?: string[];
   }): Promise<any> {
     try {
-      const res = await this.client.patch(`/api/developer/apps/${appId}`, data);
-      return res.data.app;
+      const res = await this.makeRequest<{ app: any }>('PATCH', `/api/developer/apps/${appId}`, data, { cache: false });
+      return res.app;
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1575,8 +1676,7 @@ export class OxyServices {
    */
   async regenerateDeveloperAppSecret(appId: string): Promise<any> {
     try {
-      const res = await this.client.post(`/api/developer/apps/${appId}/regenerate-secret`);
-      return res.data;
+      return await this.makeRequest('POST', `/api/developer/apps/${appId}/regenerate-secret`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1587,8 +1687,7 @@ export class OxyServices {
    */
   async deleteDeveloperApp(appId: string): Promise<any> {
     try {
-      const res = await this.client.delete(`/api/developer/apps/${appId}`);
-      return res.data;
+      return await this.makeRequest('DELETE', `/api/developer/apps/${appId}`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1603,11 +1702,10 @@ export class OxyServices {
    */
   async updateLocation(latitude: number, longitude: number): Promise<any> {
     try {
-      const res = await this.client.post('/api/location', {
+      return await this.makeRequest('POST', '/api/location', {
         latitude,
         longitude
-      });
-      return res.data;
+      }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1618,9 +1716,10 @@ export class OxyServices {
    */
   async getNearbyUsers(radius?: number): Promise<any[]> {
     try {
-      const params = radius ? `?radius=${radius}` : '';
-      const res = await this.client.get(`/api/location/nearby${params}`);
-      return res.data;
+      const params: any = radius ? { radius } : undefined;
+      return await this.makeRequest('GET', '/api/location/nearby', params, {
+        cache: false, // Don't cache location data - always get fresh data
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1635,10 +1734,10 @@ export class OxyServices {
    */
   async trackEvent(eventName: string, properties?: Record<string, any>): Promise<void> {
     try {
-      await this.client.post('/api/analytics/events', {
+      await this.makeRequest('POST', '/api/analytics/events', {
         event: eventName,
         properties
-      });
+      }, { cache: false, retry: false }); // Don't retry analytics events
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1649,12 +1748,14 @@ export class OxyServices {
    */
   async getAnalytics(startDate?: string, endDate?: string): Promise<any> {
     try {
-      const params = new URLSearchParams();
-      if (startDate) params.append('startDate', startDate);
-      if (endDate) params.append('endDate', endDate);
+      const params: any = {};
+      if (startDate) params.startDate = startDate;
+      if (endDate) params.endDate = endDate;
       
-      const res = await this.client.get(`/api/analytics?${params.toString()}`);
-      return res.data;
+      return await this.makeRequest('GET', '/api/analytics', params, {
+        cache: true,
+        cacheTTL: 5 * 60 * 1000, // 5 minutes cache
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1669,8 +1770,7 @@ export class OxyServices {
    */
   async registerDevice(deviceData: any): Promise<any> {
     try {
-      const res = await this.client.post('/api/devices', deviceData);
-      return res.data;
+      return await this.makeRequest('POST', '/api/devices', deviceData, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1681,8 +1781,9 @@ export class OxyServices {
    */
   async getUserDevices(): Promise<any[]> {
     try {
-      const res = await this.client.get('/api/devices');
-      return res.data;
+      return await this.makeRequest('GET', '/api/devices', undefined, {
+        cache: false, // Don't cache device list - always get fresh data
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1693,7 +1794,7 @@ export class OxyServices {
    */
   async removeDevice(deviceId: string): Promise<void> {
     try {
-      await this.client.delete(`/api/devices/${deviceId}`);
+      await this.makeRequest('DELETE', `/api/devices/${deviceId}`, undefined, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1701,11 +1802,16 @@ export class OxyServices {
 
   /**
    * Get device sessions
+   * Note: Not cached by default to ensure fresh data, but can be cached via makeRequest if needed
    */
   async getDeviceSessions(sessionId: string): Promise<any[]> {
     try {
-      const res = await this.client.get(`/api/session/device/sessions/${sessionId}`);
-      return res.data;
+      // Use makeRequest for consistent error handling and optional caching
+      // Cache disabled by default to ensure fresh session data
+      return await this.makeRequest<any[]>('GET', `/api/session/device/sessions/${sessionId}`, undefined, {
+        cache: false, // Don't cache sessions - always get fresh data
+        deduplicate: true, // Deduplicate concurrent requests for same sessionId
+      });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1720,8 +1826,11 @@ export class OxyServices {
       if (deviceId) params.append('deviceId', deviceId);
       if (excludeCurrent) params.append('excludeCurrent', 'true');
       
-      const res = await this.client.post(`/api/session/device/logout-all/${sessionId}?${params.toString()}`);
-      return res.data;
+      const urlParams: any = {};
+      params.forEach((value, key) => {
+        urlParams[key] = value;
+      });
+      return await this.makeRequest('POST', `/api/session/device/logout-all/${sessionId}`, urlParams, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1732,8 +1841,7 @@ export class OxyServices {
    */
   async updateDeviceName(sessionId: string, deviceName: string): Promise<any> {
     try {
-      const res = await this.client.put(`/api/session/device/name/${sessionId}`, { deviceName });
-      return res.data;
+      return await this.makeRequest('PUT', `/api/session/device/name/${sessionId}`, { deviceName }, { cache: false });
     } catch (error) {
       throw this.handleError(error);
     }
@@ -1753,8 +1861,15 @@ export class OxyServices {
     image?: string;
   }> {
     try {
-      const res = await this.client.get(`/api/link-metadata?url=${encodeURIComponent(url)}`);
-      return res.data;
+      return await this.makeRequest<{
+        url: string;
+        title: string;
+        description: string;
+        image?: string;
+      }>('GET', '/api/link-metadata', { url }, {
+        cache: true,
+        cacheTTL: 30 * 60 * 1000, // 30 minutes cache for link metadata
+      });
     } catch (error) {
       throw this.handleError(error);
     }