ebay-mcp 1.13.2 → 1.14.0

package/build/api/analytics-and-report/analytics.js

@@ -1,83 +1,129 @@
-import { withApiError } from '../../api/shared/request.js';
+import { buildEndpointParams, optionalStringEffect, requestGetEffect, requireObjectEffect, requireStringEffect, } from '../../api/shared/request.js';
+import { Effect } from 'effect';
 /**
  * Analytics API - Sales and traffic analytics
  * Based on: docs/sell-apps/analytics-and-report/sell_analytics_v1_oas3.json
  */
 export class AnalyticsApi {
-    client;
     basePath = '/sell/analytics/v1';
+    client;
     constructor(client) {
         this.client = client;
     }
     /**
-     * Get traffic report for listings
-     * @throws Error if required parameters are missing or invalid
+     * Retrieves listing traffic report metrics.
+     *
+     * @param input - Traffic report dimension, filter, metric, and optional sort expression.
+     * @returns An Effect that succeeds with eBay's generated traffic report response.
+     *
+     * @example
+     * ```ts
+     * const report = await Effect.runPromise(
+     *   analyticsApi.getTrafficReport({
+     *     dimension: 'LISTING',
+     *     filter: 'listing_ids:{123}',
+     *     metric: 'IMPRESSION',
+     *   }),
+     * );
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/sell/analytics/resources/traffic_report/methods/getTrafficReport
      */
-    async getTrafficReport(dimension, filter, metric, sort) {
-        // Input validation
-        if (!dimension || typeof dimension !== 'string') {
-            throw new Error('dimension is required and must be a string');
-        }
-        if (!filter || typeof filter !== 'string') {
-            throw new Error('filter is required and must be a string');
-        }
-        if (!metric || typeof metric !== 'string') {
-            throw new Error('metric is required and must be a string');
-        }
-        if (sort !== undefined && typeof sort !== 'string') {
-            throw new Error('sort must be a string when provided');
-        }
-        const params = {
-            dimension,
-            filter,
-            metric,
-        };
-        if (sort)
-            params.sort = sort;
-        return await withApiError('Failed to get traffic report', () => this.client.get(`${this.basePath}/traffic_report`, params));
-    }
+    getTrafficReport = (input) => {
+        const { basePath, client } = this;
+        const path = `${basePath}/traffic_report`;
+        return Effect.gen(function* () {
+            const validatedInput = yield* requireObjectEffect(input, 'input');
+            const validatedDimension = yield* requireStringEffect(validatedInput.dimension, 'dimension');
+            const validatedFilter = yield* requireStringEffect(validatedInput.filter, 'filter');
+            const validatedMetric = yield* requireStringEffect(validatedInput.metric, 'metric');
+            const validatedSort = yield* optionalStringEffect(validatedInput.sort, 'sort');
+            const params = buildEndpointParams({
+                dimension: { wireName: 'dimension', value: validatedDimension },
+                filter: { wireName: 'filter', value: validatedFilter },
+                metric: { wireName: 'metric', value: validatedMetric },
+                sort: { wireName: 'sort', value: validatedSort },
+            });
+            return yield* requestGetEffect(client, path, params);
+        });
+    };
     /**
-     * Find all seller standards profiles
-     * Endpoint: GET /seller_standards_profile
-     * @throws Error if the request fails
+     * Retrieves every seller standards profile available for the seller.
+     *
+     * @param input - Empty endpoint input object.
+     * @returns An Effect that succeeds with eBay's generated seller standards profile collection.
+     *
+     * @example
+     * ```ts
+     * const profiles = await Effect.runPromise(analyticsApi.findSellerStandardsProfiles({}));
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/sell/analytics/resources/seller_standards_profile/methods/findSellerStandardsProfiles
      */
-    async findSellerStandardsProfiles() {
-        return await withApiError('Failed to find seller standards profiles', () => this.client.get(`${this.basePath}/seller_standards_profile`));
-    }
+    findSellerStandardsProfiles = (input = {}) => {
+        void input;
+        return requestGetEffect(this.client, `${this.basePath}/seller_standards_profile`);
+    };
     /**
-     * Get a specific seller standards profile
-     * Endpoint: GET /seller_standards_profile/{program}/{cycle}
-     * @throws Error if required parameters are missing or invalid
+     * Retrieves one seller standards profile by program and cycle.
+     *
+     * @param input - Seller standards program identifier and cycle.
+     * @returns An Effect that succeeds with eBay's generated StandardsProfile response.
+     *
+     * @example
+     * ```ts
+     * const profile = await Effect.runPromise(
+     *   analyticsApi.getSellerStandardsProfile({
+     *     program: 'CUSTOMER_SERVICE',
+     *     cycle: 'CURRENT',
+     *   }),
+     * );
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/sell/analytics/resources/seller_standards_profile/methods/getSellerStandardsProfile
      */
-    async getSellerStandardsProfile(program, cycle) {
-        // Input validation
-        if (!program || typeof program !== 'string') {
-            throw new Error('program is required and must be a string');
-        }
-        if (!cycle || typeof cycle !== 'string') {
-            throw new Error('cycle is required and must be a string');
-        }
-        return await withApiError('Failed to get seller standards profile', () => this.client.get(`${this.basePath}/seller_standards_profile/${program}/${cycle}`));
-    }
+    getSellerStandardsProfile = (input) => {
+        const { basePath, client } = this;
+        return Effect.gen(function* () {
+            const validatedInput = yield* requireObjectEffect(input, 'input');
+            const validatedProgram = yield* requireStringEffect(validatedInput.program, 'program');
+            const validatedCycle = yield* requireStringEffect(validatedInput.cycle, 'cycle');
+            return yield* requestGetEffect(client, `${basePath}/seller_standards_profile/${validatedProgram}/${validatedCycle}`);
+        });
+    };
     /**
-     * Get customer service metrics
-     * Endpoint: GET /customer_service_metric/{customer_service_metric_type}/{evaluation_type}
-     * @throws Error if required parameters are missing or invalid
+     * Retrieves customer service metric benchmarks for a marketplace.
+     *
+     * @param input - Metric type, evaluation type, and marketplace identifier.
+     * @returns An Effect that succeeds with eBay's generated customer service metric response.
+     *
+     * @example
+     * ```ts
+     * const metric = await Effect.runPromise(
+     *   analyticsApi.getCustomerServiceMetric({
+     *     customerServiceMetricType: 'ITEM_NOT_AS_DESCRIBED',
+     *     evaluationType: 'CURRENT',
+     *     evaluationMarketplaceId: 'EBAY_US',
+     *   }),
+     * );
+     * ```
+     *
+     * @see https://developer.ebay.com/api-docs/sell/analytics/resources/customer_service_metric/methods/getCustomerServiceMetric
      */
-    async getCustomerServiceMetric(customerServiceMetricType, evaluationType, evaluationMarketplaceId) {
-        // Input validation
-        if (!customerServiceMetricType || typeof customerServiceMetricType !== 'string') {
-            throw new Error('customerServiceMetricType is required and must be a string');
-        }
-        if (!evaluationType || typeof evaluationType !== 'string') {
-            throw new Error('evaluationType is required and must be a string');
-        }
-        if (!evaluationMarketplaceId || typeof evaluationMarketplaceId !== 'string') {
-            throw new Error('evaluationMarketplaceId is required and must be a string');
-        }
-        const params = {
-            evaluation_marketplace_id: evaluationMarketplaceId,
-        };
-        return await withApiError('Failed to get customer service metric', () => this.client.get(`${this.basePath}/customer_service_metric/${customerServiceMetricType}/${evaluationType}`, params));
-    }
+    getCustomerServiceMetric = (input) => {
+        const { basePath, client } = this;
+        return Effect.gen(function* () {
+            const validatedInput = yield* requireObjectEffect(input, 'input');
+            const validatedMetricType = yield* requireStringEffect(validatedInput.customerServiceMetricType, 'customerServiceMetricType');
+            const validatedEvaluationType = yield* requireStringEffect(validatedInput.evaluationType, 'evaluationType');
+            const validatedMarketplaceId = yield* requireStringEffect(validatedInput.evaluationMarketplaceId, 'evaluationMarketplaceId');
+            const params = buildEndpointParams({
+                evaluationMarketplaceId: {
+                    wireName: 'evaluation_marketplace_id',
+                    value: validatedMarketplaceId,
+                },
+            });
+            return yield* requestGetEffect(client, `${basePath}/customer_service_metric/${validatedMetricType}/${validatedEvaluationType}`, params);
+        });
+    };
 }

package/build/api/client.js

@@ -1,34 +1,16 @@
 import { EbayOAuthClient } from '../auth/oauth.js';
+import { clientRequestError } from '../api/clientRequestError.js';
+import { RateLimitTracker } from '../api/rateLimitTracker.js';
 import { getBaseUrl } from '../config/environment.js';
-import { httpRequest, isHttpError } from '../utils/http.js';
-import { isRecord } from '../utils/type-guards.js';
+import { getErrorMessage } from '../utils/errors.js';
+import { httpRequestEffect, isHttpError } from '../utils/http.js';
+import { isRecord } from '../utils/typeGuards.js';
 import { apiLogger, logRequest, logResponse, logErrorResponse } from '../utils/logger.js';
-/**
- * Rate limit tracking
- */
-class RateLimitTracker {
-    requestTimestamps = [];
-    windowMs = 60000; // 1 minute window
-    maxRequests = 5000; // Conservative limit
-    canMakeRequest() {
-        const now = Date.now();
-        // Remove timestamps older than window
-        this.requestTimestamps = this.requestTimestamps.filter((timestamp) => now - timestamp < this.windowMs);
-        return this.requestTimestamps.length < this.maxRequests;
-    }
-    recordRequest() {
-        this.requestTimestamps.push(Date.now());
-    }
-    getStats() {
-        const now = Date.now();
-        this.requestTimestamps = this.requestTimestamps.filter((timestamp) => now - timestamp < this.windowMs);
-        return {
-            current: this.requestTimestamps.length,
-            max: this.maxRequests,
-            windowMs: this.windowMs,
-        };
-    }
-}
+import { Effect } from 'effect';
+/** Sleep for a retry backoff delay without exposing timers to callers. */
+const sleep = (delayMs) => Effect.promise(() => new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+}));
 /**
  * Base client for making eBay API requests.
  *
@@ -43,7 +25,7 @@ export class EbayApiClient {
     baseUrl;
     rateLimitTracker;
     config;
-    timeoutMs = 30000;
+    timeoutMs = 30_000;
     /**
      * Build default request headers based on configured marketplace and language.
      */
@@ -54,6 +36,8 @@ export class EbayApiClient {
         };
         if (this.config.contentLanguage) {
             headers['Content-Language'] = this.config.contentLanguage;
+            // undici defaults Accept-Language to `*`, which eBay Inventory rejects (error 25709).
+            headers['Accept-Language'] = this.config.contentLanguage;
         }
         if (this.config.marketplaceId) {
             headers['X-EBAY-C-MARKETPLACE-ID'] = this.config.marketplaceId;
@@ -67,11 +51,16 @@ export class EbayApiClient {
         this.rateLimitTracker = new RateLimitTracker();
     }
     /**
-     * Validate that access token is available before making API request
+     * Return the credential validation error that would block an authenticated request.
      */
-    validateAccessToken() {
-        if (!this.config.clientId || !this.config.clientSecret) {
-            throw new Error('Missing required eBay credentials. Please set EBAY_CLIENT_ID and EBAY_CLIENT_SECRET in your .env file.');
+    accessTokenValidationError(method, url) {
+        if (!(this.config.clientId && this.config.clientSecret)) {
+            return clientRequestError({
+                kind: 'missingCredentials',
+                method,
+                url,
+                message: 'Missing required eBay credentials. Please set EBAY_CLIENT_ID and EBAY_CLIENT_SECRET in your .env file.',
+            });
         }
     }
     /**
@@ -80,7 +69,7 @@ export class EbayApiClient {
      */
     ebayErrorDetail(data) {
         if (isRecord(data) && Array.isArray(data.errors)) {
-            const firstError = data.errors[0];
+            const [firstError] = data.errors;
             if (isRecord(firstError)) {
                 const detail = firstError.longMessage ?? firstError.message;
                 if (typeof detail === 'string') {
@@ -88,41 +77,58 @@ export class EbayApiClient {
                 }
             }
         }
-        return undefined;
     }
     /**
-     * Core request path shared by every verb. Injects auth + default headers,
-     * enforces the rate limit, logs, and applies eBay's retry/refresh semantics.
-     * Resolves with the decoded response body; throws an `Error` with a
-     * caller-friendly message on failure.
-     *
-     * @param absolute - When true, `endpoint` is treated as a full URL (used by
-     *   APIs on a different host, e.g. Identity on `apiz.ebay.com`).
+     * Serialize the full error response body so structured fields (errorId, parameters)
+     * survive into the thrown message for diagnostics.
      */
-    async request(method, endpoint, options) {
-        // In proxy auth mode the upstream proxy supplies credentials, so the server
-        // neither requires nor validates its own. See EBAY_MCP_DISABLE_AUTH_HEADER.
-        if (!this.config.disableAuthHeader) {
-            this.validateAccessToken();
+    ebayErrorBody(data) {
+        if (data == null)
+            return '';
+        try {
+            return ` | response: ${JSON.stringify(data)}`;
+        }
+        catch {
+            return '';
         }
+    }
+    /**
+     * Core request boundary shared by every verb.
+     */
+    async request(method, endpoint, options) {
+        return await Effect.runPromise(this.requestEffect(method, endpoint, options));
+    }
+    /**
+     * Build the request Effect that owns auth, logging, retry, and transport errors.
+     */
+    requestEffect(method, endpoint, options) {
         const url = options.absolute ? endpoint : `${this.baseUrl}${endpoint}`;
-        let authRetried = false;
-        let serverRetries = 0;
-        // Retry loop: each pass either returns the body (success), `continue`s to
-        // retry, or throws. Retries are bounded so this can never spin forever —
-        // `authRetried` allows one token-refresh retry on 401, and `serverRetries`
-        // allows up to three backoff retries on 5xx. Once both are spent, the next
-        // failure throws and the loop exits.
-        //
-        // Example: a 401 then two 503s then success runs four passes —
-        //   pass 1: 401  → refresh token, continue   (authRetried → true)
-        //   pass 2: 503  → backoff, continue          (serverRetries → 1)
-        //   pass 3: 503  → backoff, continue          (serverRetries → 2)
-        //   pass 4: 200  → return response.data
-        while (true) {
+        return this.sendWithRetry(method, url, options, {
+            authRetried: false,
+            serverRetries: 0,
+        });
+    }
+    /**
+     * Execute one request attempt, recursively re-entering for bounded retries.
+     */
+    sendWithRetry(method, url, options, state) {
+        return Effect.gen(this, function* () {
+            // In proxy auth mode the upstream proxy supplies credentials, so the server
+            // neither requires nor validates its own. See EBAY_MCP_DISABLE_AUTH_HEADER.
+            if (!this.config.disableAuthHeader) {
+                const validationError = this.accessTokenValidationError(method, url);
+                if (validationError) {
+                    return yield* Effect.fail(validationError);
+                }
+            }
             if (!this.rateLimitTracker.canMakeRequest()) {
                 const stats = this.rateLimitTracker.getStats();
-                throw new Error(`Rate limit exceeded: ${stats.current}/${stats.max} requests in ${stats.windowMs}ms window. Please wait before making more requests.`);
+                return yield* Effect.fail(clientRequestError({
+                    kind: 'localRateLimit',
+                    method,
+                    url,
+                    message: `Rate limit exceeded: ${stats.current}/${stats.max} requests in ${stats.windowMs}ms window. Please wait before making more requests.`,
+                }));
             }
             const headers = {
                 ...this.getDefaultHeaders(),
@@ -131,86 +137,142 @@ export class EbayApiClient {
             // Proxy auth mode: attach no Authorization header and acquire no token —
             // the upstream proxy injects whatever credentials eBay requires.
             if (!this.config.disableAuthHeader) {
-                const token = await this.authClient.getAccessToken();
+                const token = yield* this.authClient.getAccessToken().pipe(Effect.mapError((cause) => clientRequestError({
+                    kind: 'tokenAcquisition',
+                    method,
+                    url,
+                    message: `Failed to get access token: ${getErrorMessage(cause)}`,
+                    cause,
+                })));
                 if (!token) {
-                    throw new Error('Access token is missing. Provide EBAY_USER_REFRESH_TOKEN or valid app credentials, then retry.');
+                    return yield* Effect.fail(clientRequestError({
+                        kind: 'missingAccessToken',
+                        method,
+                        url,
+                        message: 'Access token is missing. Provide EBAY_USER_REFRESH_TOKEN or valid app credentials, then retry.',
+                    }));
                 }
                 headers.Authorization = `Bearer ${token}`;
             }
             this.rateLimitTracker.recordRequest();
             logRequest(method, url, options.params, options.data);
-            try {
-                const response = await httpRequest({
-                    method,
-                    url,
-                    params: options.params,
-                    headers,
-                    body: options.data,
-                    timeoutMs: this.timeoutMs,
-                });
+            return yield* httpRequestEffect({
+                method,
+                url,
+                params: options.params,
+                headers,
+                body: options.data,
+                timeoutMs: this.timeoutMs,
+                responseType: options.responseType,
+            }).pipe(Effect.map((response) => {
                 logResponse(response.status, response.statusText, response.data, response.headers['x-ebay-c-ratelimit-remaining'], response.headers['x-ebay-c-ratelimit-limit']);
                 return response.data;
-            }
-            catch (error) {
-                if (!isHttpError(error)) {
-                    throw error;
-                }
-                if (error.status != null) {
-                    logErrorResponse(error.status, error.statusText, url, error.data);
-                }
-                else {
-                    apiLogger.error('No response received from server', { url });
-                }
-                // 401 — refresh the token once, then retry the request. Skipped in proxy
-                // auth mode: the server holds no token to refresh, so a 401 (the proxy's
-                // own auth failing) is surfaced directly rather than retried.
-                if (error.status === 401 && !this.config.disableAuthHeader) {
-                    if (!authRetried) {
-                        authRetried = true;
-                        apiLogger.warn('Authentication error (401). Attempting to refresh user token...');
-                        try {
-                            await this.authClient.getAccessToken();
-                        }
-                        catch (refreshError) {
-                            const reason = refreshError instanceof Error ? refreshError.message : 'Unknown error';
-                            apiLogger.error('Failed to refresh token', { error: reason });
-                            const detail = this.ebayErrorDetail(error.data) ?? 'Invalid access token';
-                            throw new Error(`${detail}. Token refresh failed: ${reason}. ` +
-                                `Please use the ebay_set_user_tokens_with_expiry tool to provide valid tokens.`);
-                        }
-                        apiLogger.info('Token refreshed successfully. Retrying request...');
-                        continue;
-                    }
+            }), Effect.catchAll((error) => this.handleRequestFailure(error, { method, url, options, state })));
+        });
+    }
+    /**
+     * Convert an HTTP failure into a bounded retry or final request error.
+     */
+    handleRequestFailure(error, context) {
+        const { method, url, options, state } = context;
+        if (!isHttpError(error)) {
+            return Effect.fail(clientRequestError({
+                kind: 'transport',
+                method,
+                url,
+                message: getErrorMessage(error),
+                cause: error,
+            }));
+        }
+        if (error.status == null) {
+            apiLogger.error('No response received from server', { url });
+        }
+        else {
+            logErrorResponse(error.status, error.statusText, url, error.data);
+        }
+        // 401 — refresh the token once, then retry the request. Skipped in proxy
+        // auth mode: the server holds no token to refresh, so a 401 (the proxy's
+        // own auth failing) is surfaced directly rather than retried.
+        if (error.status === 401 && !this.config.disableAuthHeader) {
+            if (!state.authRetried) {
+                apiLogger.warn('Authentication error (401). Attempting to refresh user token...');
+                return this.authClient.getAccessToken().pipe(Effect.catchAll((refreshError) => {
+                    const reason = getErrorMessage(refreshError);
+                    apiLogger.error('Failed to refresh token', { error: reason });
                     const detail = this.ebayErrorDetail(error.data) ?? 'Invalid access token';
-                    throw new Error(`${detail}. Automatic token refresh failed. ` +
-                        `Please use the ebay_set_user_tokens_with_expiry tool to provide valid tokens.`);
-                }
-                // 429 — surface a clear rate-limit message with the server's retry hint.
-                if (error.status === 429) {
-                    const retryAfter = error.headers['retry-after'];
-                    const waitTime = retryAfter ? parseInt(retryAfter, 10) * 1000 : 60000;
-                    throw new Error(`eBay API rate limit exceeded. Retry after ${waitTime / 1000} seconds. ` +
-                        `Consider reducing request frequency or upgrading to user tokens for higher limits.`);
-                }
-                // 5xx — retry up to three times with exponential backoff.
-                if (error.status != null && error.status >= 500 && serverRetries < 3) {
-                    const delay = Math.pow(2, serverRetries) * 1000;
-                    serverRetries++;
-                    apiLogger.warn(`Server error (${error.status}). Retrying...`, {
-                        attempt: `${serverRetries}/3`,
-                        delayMs: Math.min(delay, 5000),
+                    return Effect.fail(clientRequestError({
+                        kind: 'tokenRefresh',
+                        method,
+                        url,
+                        status: error.status,
+                        message: `${detail}. Token refresh failed: ${reason}. ` +
+                            'Please use the ebay_set_user_tokens_with_expiry tool to provide valid tokens.',
+                        cause: refreshError,
+                    }));
+                }), Effect.flatMap(() => {
+                    apiLogger.info('Token refreshed successfully. Retrying request...');
+                    return this.sendWithRetry(method, url, options, {
+                        ...state,
+                        authRetried: true,
                     });
-                    await new Promise((resolve) => {
-                        setTimeout(resolve, Math.min(delay, 5000));
-                    });
-                    continue;
-                }
-                if (error.status != null) {
-                    throw new Error(`eBay API Error: ${this.ebayErrorDetail(error.data) ?? error.message}`);
-                }
-                throw error;
+                }));
             }
+            const detail = this.ebayErrorDetail(error.data) ?? 'Invalid access token';
+            return Effect.fail(clientRequestError({
+                kind: 'tokenRefresh',
+                method,
+                url,
+                status: error.status,
+                message: `${detail}. Automatic token refresh failed. ` +
+                    'Please use the ebay_set_user_tokens_with_expiry tool to provide valid tokens.',
+                cause: error,
+            }));
         }
+        // 429 — surface a clear rate-limit message with the server's retry hint.
+        if (error.status === 429) {
+            const retryAfter = error.headers['retry-after'];
+            const waitTime = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : 60_000;
+            return Effect.fail(clientRequestError({
+                kind: 'remoteRateLimit',
+                method,
+                url,
+                status: error.status,
+                message: `eBay API rate limit exceeded. Retry after ${waitTime / 1000} seconds. ` +
+                    'Consider reducing request frequency or upgrading to user tokens for higher limits.',
+                cause: error,
+            }));
+        }
+        // 5xx — retry up to three times with exponential backoff.
+        if (error.status != null && error.status >= 500 && state.serverRetries < 3) {
+            const delay = 2 ** state.serverRetries * 1000;
+            const delayMs = Math.min(delay, 5000);
+            const nextServerRetries = state.serverRetries + 1;
+            apiLogger.warn(`Server error (${error.status}). Retrying...`, {
+                attempt: `${nextServerRetries}/3`,
+                delayMs,
+            });
+            return sleep(delayMs).pipe(Effect.flatMap(() => this.sendWithRetry(method, url, options, {
+                ...state,
+                serverRetries: nextServerRetries,
+            })));
+        }
+        if (error.status != null) {
+            return Effect.fail(clientRequestError({
+                kind: 'httpStatus',
+                method,
+                url,
+                status: error.status,
+                message: `eBay API Error: ${this.ebayErrorDetail(error.data) ?? error.message}${this.ebayErrorBody(error.data)}`,
+                cause: error,
+            }));
+        }
+        return Effect.fail(clientRequestError({
+            kind: 'transport',
+            method,
+            url,
+            message: error.message,
+            cause: error,
+        }));
     }
     /**
      * Make a GET request to eBay API
@@ -219,6 +281,7 @@ export class EbayApiClient {
         return await this.request('GET', endpoint, {
             params: { ...params, ...config?.params },
             headers: config?.headers,
+            responseType: config?.responseType,
         });
     }
     /**
@@ -229,6 +292,7 @@ export class EbayApiClient {
             data,
             params: config?.params,
             headers: config?.headers,
+            responseType: config?.responseType,
         });
     }
     /**
@@ -239,6 +303,7 @@ export class EbayApiClient {
             data,
             params: config?.params,
             headers: config?.headers,
+            responseType: config?.responseType,
         });
     }
     /**
@@ -248,14 +313,13 @@ export class EbayApiClient {
         return await this.request('DELETE', endpoint, {
             params: config?.params,
             headers: config?.headers,
+            responseType: config?.responseType,
         });
     }
     /**
      * Initialize the client (load user tokens from storage)
      */
-    async initialize() {
-        await this.authClient.initialize();
-    }
+    initialize = () => this.authClient.initialize();
     /**
      * Check if client is authenticated
      */
@@ -271,10 +335,7 @@ export class EbayApiClient {
     /**
      * Set user access and refresh tokens
      */
-    setUserTokens(accessToken, refreshToken, accessTokenExpiry, refreshTokenExpiry) {
-        this.authClient.setUserTokens(accessToken, refreshToken, accessTokenExpiry, refreshTokenExpiry);
-        return Promise.resolve();
-    }
+    setUserTokens = (accessToken, refreshToken, accessTokenExpiry, refreshTokenExpiry) => this.authClient.setUserTokens(accessToken, refreshToken, accessTokenExpiry, refreshTokenExpiry);
     /**
      * Get token information for debugging
      */
@@ -304,9 +365,7 @@ export class EbayApiClient {
      * This is useful when you encounter "Invalid access token" errors
      * The token will be automatically saved to storage after refresh
      */
-    async refreshUserToken() {
-        await this.authClient.refreshUserToken();
-    }
+    refreshUserToken = () => this.authClient.refreshUserToken();
     /**
      * Make a GET request with a full URL (for APIs that use different base URLs)
      * Used by Identity API which uses the apiz subdomain