ebay-mcp-remote-edition 1.0.0

package/build/tools/index.js

@@ -0,0 +1,1200 @@
+import { getOAuthAuthorizationUrl, validateScopes } from '../config/environment.js';
+import { accountTools, analyticsTools, communicationTools, developerTools, fulfillmentTools, inventoryTools, marketingTools, metadataTools, otherApiTools, taxonomyTools, tradingTools, tokenManagementTools, } from '../tools/definitions/index.js';
+import { chatGptTools } from '../tools/tool-definitions.js';
+import { getApiStatusFeed } from '../utils/api-status-feed.js';
+import { convertToTimestamp, validateTokenExpiry } from '../utils/date-converter.js';
+// Import Zod schemas for input validation
+import { getAwaitingFeedbackSchema, getFeedbackRatingSummarySchema, getFeedbackSchema, leaveFeedbackForBuyerSchema, respondToFeedbackSchema, } from '../utils/communication/feedback.js';
+import { bulkUpdateConversationSchema, getConversationSchema, getConversationsSchema, sendMessageSchema, updateConversationSchema, } from '../utils/communication/message.js';
+import { findEligibleItemsSchema, getOffersToBuyersSchema, sendOfferToInterestedBuyersSchema, } from '../utils/communication/negotiation.js';
+import { createDestinationSchema, createSubscriptionFilterSchema, createSubscriptionSchema, deleteDestinationSchema, deleteSubscriptionFilterSchema, deleteSubscriptionSchema, disableSubscriptionSchema, enableSubscriptionSchema, getConfigSchema, getDestinationSchema, getPublicKeySchema, getSubscriptionFilterSchema, getSubscriptionSchema, getSubscriptionsSchema, getTopicSchema, getTopicsSchema, testSubscriptionSchema, updateConfigSchema, updateDestinationSchema, updateSubscriptionSchema, } from '../utils/communication/notification.js';
+/**
+ * Get all tool definitions for the MCP server
+ */
+export function getToolDefinitions() {
+    const chatConnectorTools = chatGptTools.filter((tool) => tool.name === 'search' || tool.name === 'fetch');
+    return [
+        ...chatConnectorTools,
+        ...tokenManagementTools,
+        ...accountTools,
+        ...inventoryTools,
+        ...fulfillmentTools,
+        ...marketingTools,
+        ...analyticsTools,
+        ...metadataTools,
+        ...taxonomyTools,
+        ...communicationTools,
+        ...otherApiTools,
+        ...developerTools,
+        ...tradingTools,
+    ];
+}
+/**
+ * Execute a tool based on its name
+ */
+export async function executeTool(api, toolName, args) {
+    switch (toolName) {
+        // ChatGPT Connector Tools
+        case 'search': {
+            // For this example, we'll treat the query as a search for inventory items.
+            // A more robust implementation might search across different types of content.
+            const requestedLimitRaw = args.limit;
+            const limit = typeof requestedLimitRaw === 'number' && Number.isFinite(requestedLimitRaw)
+                ? Math.max(Math.floor(requestedLimitRaw), 1)
+                : 10;
+            const query = args.query?.toLowerCase().trim();
+            const pageSize = query ? Math.min(Math.max(limit, 50), 200) : limit;
+            const matches = [];
+            let offset = 0;
+            while (matches.length < limit) {
+                const response = await api.inventory.getInventoryItems(pageSize, offset);
+                const pageItems = response.inventoryItems ?? [];
+                if (pageItems.length === 0) {
+                    break;
+                }
+                // Filter to only include items with valid SKUs (required for getInventoryItem calls)
+                const itemsWithSku = pageItems.filter((item) => typeof item.sku === 'string' && item.sku.trim() !== '');
+                const filtered = query
+                    ? itemsWithSku.filter((item) => (item.product?.title ?? '').toLowerCase().includes(query))
+                    : itemsWithSku;
+                matches.push(...filtered);
+                offset += pageSize;
+                const total = response.total;
+                if (typeof total === 'number' && offset >= total) {
+                    break;
+                }
+                if (!query || pageItems.length < pageSize) {
+                    break;
+                }
+            }
+            const results = matches.slice(0, limit).map((item) => ({
+                id: item.sku,
+                title: item.product?.title ?? 'No Title',
+                // The URL should be a canonical link to the item, which we don't have here.
+                // We'll use a placeholder.
+                url: `https://www.ebay.com/`, // Placeholder URL
+            }));
+            // Format the response as required by the ChatGPT connector spec.
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ results }),
+                    },
+                ],
+            };
+        }
+        case 'fetch': {
+            const sku = args.id;
+            const item = await api.inventory.getInventoryItem(sku);
+            // Format the response as required by the ChatGPT connector spec.
+            const result = {
+                id: sku,
+                title: item.product?.title ?? 'No Title',
+                text: item.product?.description ?? 'No description available.',
+                url: `https://www.ebay.com/`, // Placeholder URL
+                metadata: {
+                    source: 'ebay_inventory',
+                    aspects: item.product?.aspects,
+                    condition: item.condition,
+                },
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        case 'ebay_get_oauth_url': {
+            // Get config from environment
+            const clientId = process.env.EBAY_CLIENT_ID ?? '';
+            const environment = (process.env.EBAY_ENVIRONMENT ?? 'sandbox');
+            const envRedirectUri = process.env.EBAY_REDIRECT_URI;
+            // Use redirectUri from args if provided, otherwise use from .env
+            const redirectUri = args.redirectUri ?? envRedirectUri;
+            const scopes = args.scopes;
+            const state = args.state;
+            if (!clientId) {
+                throw new Error('EBAY_CLIENT_ID environment variable is required to generate OAuth URL');
+            }
+            if (!redirectUri) {
+                throw new Error('Redirect URI is required. Either provide it as a parameter or set EBAY_REDIRECT_URI in your .env file.');
+            }
+            // Validate scopes if custom scopes are provided
+            let scopeWarnings = [];
+            let validatedScopes = scopes;
+            if (scopes && scopes.length > 0) {
+                const validation = validateScopes(scopes, environment);
+                scopeWarnings = validation.warnings;
+                validatedScopes = validation.validScopes;
+            }
+            const authUrl = getOAuthAuthorizationUrl(clientId, redirectUri, environment, validatedScopes, state);
+            const result = {
+                authorizationUrl: authUrl,
+                redirectUri,
+                instructions: 'Open this URL in a browser to authorize the application. After authorization, you will be redirected to your redirect URI with an authorization code that can be exchanged for an access token.',
+                environment,
+                scopes: scopes ?? 'default (all Sell API scopes)',
+            };
+            // Include warnings if any scopes are invalid for the environment
+            if (scopeWarnings.length > 0) {
+                result.warnings = scopeWarnings;
+            }
+            return result;
+        }
+        case 'ebay_set_user_tokens': {
+            const accessToken = args.accessToken;
+            const refreshToken = args.refreshToken;
+            if (!accessToken || !refreshToken) {
+                throw new Error('Both accessToken and refreshToken are required');
+            }
+            await api.setUserTokens(accessToken, refreshToken);
+            return {
+                success: true,
+                message: 'User tokens successfully stored. These tokens will be used for all subsequent API requests and will be automatically refreshed when needed.',
+                tokenInfo: api.getTokenInfo(),
+            };
+        }
+        case 'ebay_get_token_status': {
+            const tokenInfo = api.getTokenInfo();
+            const hasUserTokens = api.hasUserTokens();
+            return {
+                hasUserToken: tokenInfo.hasUserToken,
+                hasAppAccessToken: tokenInfo.hasAppAccessToken,
+                authenticated: api.isAuthenticated(),
+                currentTokenType: tokenInfo.hasUserToken
+                    ? 'user_token (10,000-50,000 req/day)'
+                    : tokenInfo.hasAppAccessToken
+                        ? 'app_access_token (1,000 req/day)'
+                        : 'none',
+                message: hasUserTokens
+                    ? 'Using user access token with automatic refresh'
+                    : 'Using app access token from client credentials flow (lower rate limits). Consider setting user tokens for higher rate limits.',
+            };
+        }
+        case 'ebay_clear_tokens': {
+            const authClient = api.getAuthClient().getOAuthClient();
+            authClient.clearAllTokens();
+            return {
+                success: true,
+                message: 'All tokens cleared successfully. You will need to re-authenticate for subsequent API calls.',
+            };
+        }
+        case 'ebay_convert_date_to_timestamp': {
+            const dateInput = args.dateInput;
+            try {
+                const timestamp = convertToTimestamp(dateInput);
+                return {
+                    success: true,
+                    timestamp,
+                    input: dateInput,
+                    formattedDate: new Date(timestamp).toISOString(),
+                    message: `Successfully converted to timestamp: ${timestamp}ms (${new Date(timestamp).toISOString()})`,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to convert date: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        case 'ebay_validate_token_expiry': {
+            const accessTokenExpiry = args.accessTokenExpiry;
+            const refreshTokenExpiry = args.refreshTokenExpiry;
+            try {
+                // Convert to timestamps
+                const accessExpiry = convertToTimestamp(accessTokenExpiry);
+                const refreshExpiry = convertToTimestamp(refreshTokenExpiry);
+                // Validate
+                const validation = validateTokenExpiry(accessExpiry, refreshExpiry);
+                return {
+                    ...validation,
+                    accessTokenExpiryTimestamp: accessExpiry,
+                    refreshTokenExpiryTimestamp: refreshExpiry,
+                    accessTokenExpiryDate: new Date(accessExpiry).toISOString(),
+                    refreshTokenExpiryDate: new Date(refreshExpiry).toISOString(),
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to validate token expiry: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        case 'ebay_set_user_tokens_with_expiry': {
+            const accessToken = args.accessToken;
+            const refreshToken = args.refreshToken;
+            const accessTokenExpiry = args.accessTokenExpiry;
+            const refreshTokenExpiry = args.refreshTokenExpiry;
+            const autoRefresh = args.autoRefresh ?? true;
+            if (!accessToken || !refreshToken) {
+                throw new Error('Both accessToken and refreshToken are required');
+            }
+            try {
+                // Convert expiry times to timestamps if provided
+                let accessExpiry;
+                let refreshExpiry;
+                if (accessTokenExpiry !== undefined) {
+                    accessExpiry = convertToTimestamp(accessTokenExpiry);
+                }
+                if (refreshTokenExpiry !== undefined) {
+                    refreshExpiry = convertToTimestamp(refreshTokenExpiry);
+                }
+                // Set tokens (will use defaults if expiry times not provided)
+                await api.setUserTokens(accessToken, refreshToken, accessExpiry, refreshExpiry);
+                // If autoRefresh is enabled, attempt to get a fresh access token
+                // (The OAuth client will handle refresh internally if needed)
+                if (autoRefresh) {
+                    try {
+                        const authClient = api.getAuthClient().getOAuthClient();
+                        await authClient.getAccessToken();
+                        return {
+                            success: true,
+                            message: 'User tokens stored successfully in memory. Access token validated and refreshed if needed. To persist tokens, update EBAY_USER_REFRESH_TOKEN in .env file.',
+                            tokenInfo: api.getTokenInfo(),
+                            refreshed: true,
+                        };
+                    }
+                    catch (refreshError) {
+                        return {
+                            success: true,
+                            message: 'User tokens stored, but failed to validate/refresh access token. You may need to re-authorize.',
+                            tokenInfo: api.getTokenInfo(),
+                            refreshed: false,
+                            refreshError: refreshError instanceof Error ? refreshError.message : 'Unknown error',
+                        };
+                    }
+                }
+                return {
+                    success: true,
+                    message: 'User tokens successfully stored in memory. These tokens will be used for all subsequent API requests and will be automatically refreshed when needed. To persist tokens, update EBAY_USER_REFRESH_TOKEN in .env file.',
+                    tokenInfo: api.getTokenInfo(),
+                    refreshed: false,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to set user tokens: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        case 'ebay_display_credentials': {
+            // Get configuration from environment
+            const clientId = process.env.EBAY_CLIENT_ID ?? '';
+            const clientSecret = process.env.EBAY_CLIENT_SECRET ?? '';
+            const environment = process.env.EBAY_ENVIRONMENT ?? 'sandbox';
+            const redirectUri = process.env.EBAY_REDIRECT_URI ?? '';
+            const refreshToken = process.env.EBAY_USER_REFRESH_TOKEN ?? '';
+            // Get current token info from API
+            const tokenInfo = api.getTokenInfo();
+            const authClient = api.getAuthClient().getOAuthClient();
+            // Helper function to mask sensitive tokens
+            const maskToken = (token) => {
+                if (!token || token.length < 12)
+                    return '***';
+                return `${token.substring(0, 6)}...${token.substring(token.length - 6)}`;
+            };
+            // Get internal token details from the auth client
+            const internalTokens = authClient.getUserTokens();
+            const appToken = authClient.getCachedAppAccessToken();
+            const appTokenExpiry = authClient.getCachedAppAccessTokenExpiry();
+            return {
+                credentials: {
+                    clientId: clientId ? maskToken(clientId) : 'Not set',
+                    clientSecret: clientSecret ? '****** (set)' : 'Not set',
+                    environment,
+                    redirectUri: redirectUri || 'Not set',
+                },
+                tokens: {
+                    refreshToken: refreshToken ? maskToken(refreshToken) : 'Not set (in .env)',
+                    accessToken: internalTokens?.userAccessToken
+                        ? maskToken(internalTokens.userAccessToken)
+                        : 'Not available',
+                    accessTokenExpiry: internalTokens?.userAccessTokenExpiry
+                        ? {
+                            timestamp: internalTokens.userAccessTokenExpiry,
+                            date: new Date(internalTokens.userAccessTokenExpiry).toISOString(),
+                            expired: Date.now() >= internalTokens.userAccessTokenExpiry,
+                        }
+                        : 'Not available',
+                    refreshTokenExpiry: internalTokens?.userRefreshTokenExpiry
+                        ? {
+                            timestamp: internalTokens.userRefreshTokenExpiry,
+                            date: new Date(internalTokens.userRefreshTokenExpiry).toISOString(),
+                            expired: Date.now() >= internalTokens.userRefreshTokenExpiry,
+                        }
+                        : 'Not available',
+                    appToken: appToken ? maskToken(appToken) : 'Not cached',
+                    appTokenExpiry: appTokenExpiry
+                        ? {
+                            timestamp: appTokenExpiry,
+                            date: new Date(appTokenExpiry).toISOString(),
+                            expired: Date.now() >= appTokenExpiry,
+                        }
+                        : 'Not available',
+                },
+                status: {
+                    hasUserToken: tokenInfo.hasUserToken,
+                    hasAppAccessToken: tokenInfo.hasAppAccessToken,
+                    authenticated: api.isAuthenticated(),
+                    currentTokenType: tokenInfo.hasUserToken
+                        ? 'user_token (10,000-50,000 req/day)'
+                        : tokenInfo.hasAppAccessToken
+                            ? 'app_access_token (1,000 req/day)'
+                            : 'none',
+                },
+                scopes: internalTokens?.scope ? internalTokens.scope.split(' ') : [],
+            };
+        }
+        case 'ebay_exchange_authorization_code': {
+            const code = args.code;
+            if (!code) {
+                throw new Error('Authorization code is required');
+            }
+            try {
+                // URL-decode the code if it's URL-encoded (contains % characters)
+                const decodedCode = code.includes('%') ? decodeURIComponent(code) : code;
+                // Get the OAuth client
+                const authClient = api.getAuthClient().getOAuthClient();
+                // Exchange the authorization code for tokens
+                const tokenData = await authClient.exchangeCodeForToken(decodedCode);
+                return {
+                    success: true,
+                    message: 'Authorization code successfully exchanged for tokens. Tokens have been stored and will be used for subsequent API requests.',
+                    tokenData: {
+                        accessToken: `${tokenData.access_token.substring(0, 20)}...${tokenData.access_token.slice(-10)}`,
+                        refreshToken: `${tokenData.refresh_token.substring(0, 20)}...${tokenData.refresh_token.slice(-10)}`,
+                        expiresIn: tokenData.expires_in,
+                        refreshTokenExpiresIn: tokenData.refresh_token_expires_in,
+                        tokenType: tokenData.token_type,
+                        scope: tokenData.scope,
+                    },
+                    note: 'The refresh token has been saved to your .env file for future use.',
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to exchange authorization code: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        case 'ebay_refresh_access_token': {
+            const authClient = api.getAuthClient().getOAuthClient();
+            // Check if user tokens are available
+            if (!api.hasUserTokens()) {
+                throw new Error('No user tokens available. Please set user tokens first using ebay_set_user_tokens_with_expiry or add EBAY_USER_REFRESH_TOKEN to your .env file.');
+            }
+            try {
+                // Call the public refreshUserToken method
+                await authClient.refreshUserToken();
+                // Get updated token info
+                const internalTokens = authClient.getUserTokens();
+                return {
+                    success: true,
+                    message: 'Access token refreshed successfully',
+                    accessToken: internalTokens?.userAccessToken
+                        ? `${internalTokens.userAccessToken.substring(0, 6)}...${internalTokens.userAccessToken.substring(internalTokens.userAccessToken.length - 6)}`
+                        : 'Not available',
+                    accessTokenExpiry: internalTokens?.userAccessTokenExpiry
+                        ? {
+                            timestamp: internalTokens.userAccessTokenExpiry,
+                            date: new Date(internalTokens.userAccessTokenExpiry).toISOString(),
+                            expiresInSeconds: Math.floor((internalTokens.userAccessTokenExpiry - Date.now()) / 1000),
+                        }
+                        : 'Not available',
+                    tokenInfo: api.getTokenInfo(),
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to refresh access token: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Account Management
+        case 'ebay_get_custom_policies':
+            return await api.account.getCustomPolicies(args.policyTypes);
+        case 'ebay_get_fulfillment_policies':
+            return await api.account.getFulfillmentPolicies(args.marketplaceId);
+        case 'ebay_get_payment_policies':
+            return await api.account.getPaymentPolicies(args.marketplaceId);
+        case 'ebay_get_return_policies':
+            return await api.account.getReturnPolicies(args.marketplaceId);
+        // Fulfillment Policy CRUD
+        case 'ebay_create_fulfillment_policy':
+            return await api.account.createFulfillmentPolicy(args.policy);
+        case 'ebay_get_fulfillment_policy':
+            return await api.account.getFulfillmentPolicy(args.fulfillmentPolicyId);
+        case 'ebay_get_fulfillment_policy_by_name':
+            return await api.account.getFulfillmentPolicyByName(args.marketplaceId, args.name);
+        case 'ebay_update_fulfillment_policy':
+            return await api.account.updateFulfillmentPolicy(args.fulfillmentPolicyId, args.policy);
+        case 'ebay_delete_fulfillment_policy':
+            return await api.account.deleteFulfillmentPolicy(args.fulfillmentPolicyId);
+        // Payment Policy CRUD
+        case 'ebay_create_payment_policy':
+            return await api.account.createPaymentPolicy(args.policy);
+        case 'ebay_get_payment_policy':
+            return await api.account.getPaymentPolicy(args.paymentPolicyId);
+        case 'ebay_get_payment_policy_by_name':
+            return await api.account.getPaymentPolicyByName(args.marketplaceId, args.name);
+        case 'ebay_update_payment_policy':
+            return await api.account.updatePaymentPolicy(args.paymentPolicyId, args.policy);
+        case 'ebay_delete_payment_policy':
+            return await api.account.deletePaymentPolicy(args.paymentPolicyId);
+        // Return Policy CRUD
+        case 'ebay_create_return_policy':
+            return await api.account.createReturnPolicy(args.policy);
+        case 'ebay_get_return_policy':
+            return await api.account.getReturnPolicy(args.returnPolicyId);
+        case 'ebay_get_return_policy_by_name':
+            return await api.account.getReturnPolicyByName(args.marketplaceId, args.name);
+        case 'ebay_update_return_policy':
+            return await api.account.updateReturnPolicy(args.returnPolicyId, args.policy);
+        case 'ebay_delete_return_policy':
+            return await api.account.deleteReturnPolicy(args.returnPolicyId);
+        // Custom Policy CRUD
+        case 'ebay_create_custom_policy':
+            return await api.account.createCustomPolicy(args.policy);
+        case 'ebay_get_custom_policy':
+            return await api.account.getCustomPolicy(args.customPolicyId);
+        case 'ebay_update_custom_policy':
+            return await api.account.updateCustomPolicy(args.customPolicyId, args.policy);
+        case 'ebay_delete_custom_policy':
+            return await api.account.deleteCustomPolicy(args.customPolicyId);
+        // KYC, Payments, Programs, Sales Tax, Subscription
+        case 'ebay_get_kyc':
+            return await api.account.getKyc();
+        case 'ebay_opt_in_to_payments_program':
+            return await api.account.optInToPaymentsProgram(args.marketplaceId, args.paymentsProgramType);
+        case 'ebay_get_payments_program_status':
+            return await api.account.getPaymentsProgramStatus(args.marketplaceId, args.paymentsProgramType);
+        case 'ebay_get_rate_tables':
+            return await api.account.getRateTables();
+        case 'ebay_create_or_replace_sales_tax':
+            return await api.account.createOrReplaceSalesTax(args.countryCode, args.jurisdictionId, args.salesTaxBase);
+        case 'ebay_bulk_create_or_replace_sales_tax':
+            return await api.account.bulkCreateOrReplaceSalesTax(args.requests);
+        case 'ebay_delete_sales_tax':
+            return await api.account.deleteSalesTax(args.countryCode, args.jurisdictionId);
+        case 'ebay_get_sales_tax':
+            return await api.account.getSalesTax(args.countryCode, args.jurisdictionId);
+        case 'ebay_get_sales_taxes':
+            return await api.account.getSalesTaxes(args.countryCode);
+        case 'ebay_get_subscription':
+            return await api.account.getSubscription(args.limitType);
+        case 'ebay_opt_in_to_program':
+            return await api.account.optInToProgram(args.request);
+        case 'ebay_opt_out_of_program':
+            return await api.account.optOutOfProgram(args.request);
+        case 'ebay_get_opted_in_programs':
+            return await api.account.getOptedInPrograms();
+        case 'ebay_get_privileges':
+            return await api.account.getPrivileges();
+        case 'ebay_get_advertising_eligibility':
+            return await api.account.getAdvertisingEligibility(args.marketplaceId, args.programTypes);
+        case 'ebay_get_payments_program':
+            return await api.account.getPaymentsProgram(args.marketplaceId, args.paymentsProgramType);
+        case 'ebay_get_payments_program_onboarding':
+            return await api.account.getPaymentsProgramOnboarding(args.marketplaceId, args.paymentsProgramType);
+        // Inventory Management
+        case 'ebay_get_inventory_items':
+            return await api.inventory.getInventoryItems(args.limit, args.offset);
+        case 'ebay_get_inventory_item':
+            return await api.inventory.getInventoryItem(args.sku);
+        case 'ebay_create_inventory_item':
+            return await api.inventory.createOrReplaceInventoryItem(args.sku, args.inventoryItem);
+        case 'ebay_delete_inventory_item':
+            return await api.inventory.deleteInventoryItem(args.sku);
+        // Bulk Operations
+        case 'ebay_bulk_create_or_replace_inventory_item':
+            return await api.inventory.bulkCreateOrReplaceInventoryItem(args.requests);
+        case 'ebay_bulk_get_inventory_item':
+            return await api.inventory.bulkGetInventoryItem(args.requests);
+        case 'ebay_bulk_update_price_quantity':
+            return await api.inventory.bulkUpdatePriceQuantity(args.requests);
+        // Product Compatibility
+        case 'ebay_get_product_compatibility':
+            return await api.inventory.getProductCompatibility(args.sku);
+        case 'ebay_create_or_replace_product_compatibility':
+            return await api.inventory.createOrReplaceProductCompatibility(args.sku, args.compatibility);
+        case 'ebay_delete_product_compatibility':
+            return await api.inventory.deleteProductCompatibility(args.sku);
+        // Inventory Item Groups
+        case 'ebay_get_inventory_item_group':
+            return await api.inventory.getInventoryItemGroup(args.inventoryItemGroupKey);
+        case 'ebay_create_or_replace_inventory_item_group':
+            return await api.inventory.createOrReplaceInventoryItemGroup(args.inventoryItemGroupKey, args.inventoryItemGroup);
+        case 'ebay_delete_inventory_item_group':
+            return await api.inventory.deleteInventoryItemGroup(args.inventoryItemGroupKey);
+        // Location Management
+        case 'ebay_get_inventory_locations':
+            return await api.inventory.getInventoryLocations(args.limit, args.offset);
+        case 'ebay_get_inventory_location':
+            return await api.inventory.getInventoryLocation(args.merchantLocationKey);
+        case 'ebay_create_or_replace_inventory_location':
+            return await api.inventory.createOrReplaceInventoryLocation(args.merchantLocationKey, args.location);
+        case 'ebay_delete_inventory_location':
+            return await api.inventory.deleteInventoryLocation(args.merchantLocationKey);
+        case 'ebay_disable_inventory_location':
+            return await api.inventory.disableInventoryLocation(args.merchantLocationKey);
+        case 'ebay_enable_inventory_location':
+            return await api.inventory.enableInventoryLocation(args.merchantLocationKey);
+        case 'ebay_update_location_details':
+            return await api.inventory.updateLocationDetails(args.merchantLocationKey, args.locationDetails);
+        // Offer Management
+        case 'ebay_get_offers':
+            return await api.inventory.getOffers(args.sku, args.marketplaceId, args.limit);
+        case 'ebay_get_offer':
+            return await api.inventory.getOffer(args.offerId);
+        case 'ebay_create_offer':
+            return await api.inventory.createOffer(args.offer);
+        case 'ebay_update_offer':
+            return await api.inventory.updateOffer(args.offerId, args.offer);
+        case 'ebay_delete_offer':
+            return await api.inventory.deleteOffer(args.offerId);
+        case 'ebay_publish_offer':
+            return await api.inventory.publishOffer(args.offerId);
+        case 'ebay_withdraw_offer':
+            return await api.inventory.withdrawOffer(args.offerId);
+        case 'ebay_bulk_create_offer':
+            return await api.inventory.bulkCreateOffer(args.requests);
+        case 'ebay_bulk_publish_offer':
+            return await api.inventory.bulkPublishOffer(args.requests);
+        case 'ebay_get_listing_fees':
+            return await api.inventory.getListingFees(args.offers);
+        // Listing Migration
+        case 'ebay_bulk_migrate_listing':
+            return await api.inventory.bulkMigrateListing(args.requests);
+        case 'ebay_get_listing_locations':
+            return await api.inventory.getListingLocations(args.listingId, args.sku);
+        case 'ebay_create_or_replace_sku_location_mapping':
+            return await api.inventory.createOrReplaceSkuLocationMapping(args.listingId, args.sku, args.locationMapping);
+        case 'ebay_delete_sku_location_mapping':
+            return await api.inventory.deleteSkuLocationMapping(args.listingId, args.sku);
+        case 'ebay_publish_offer_by_inventory_item_group':
+            return await api.inventory.publishOfferByInventoryItemGroup(args.request);
+        case 'ebay_withdraw_offer_by_inventory_item_group':
+            return await api.inventory.withdrawOfferByInventoryItemGroup(args.request);
+        // Order Management
+        case 'ebay_get_orders':
+            return await api.fulfillment.getOrders(args.filter, args.limit, args.offset);
+        case 'ebay_get_order':
+            return await api.fulfillment.getOrder(args.orderId);
+        case 'ebay_create_shipping_fulfillment':
+            return await api.fulfillment.createShippingFulfillment(args.orderId, args.fulfillment);
+        case 'ebay_issue_refund':
+            return await api.fulfillment.issueRefund(args.orderId, args.refundData);
+        case 'ebay_get_shipping_fulfillments':
+            return await api.fulfillment.getShippingFulfillments(args.orderId);
+        case 'ebay_get_shipping_fulfillment':
+            return await api.fulfillment.getShippingFulfillment(args.orderId, args.fulfillmentId);
+        case 'ebay_get_payment_dispute_summaries':
+            return await api.dispute.getPaymentDisputeSummaries({
+                order_id: args.orderFilter,
+                buyer_username: args.buyerFilter,
+                payment_dispute_status: args.openFilter ? 'OPEN' : undefined,
+                limit: args.limit,
+                offset: args.offset,
+            });
+        case 'ebay_get_payment_dispute':
+            return await api.dispute.getPaymentDispute(args.paymentDisputeId);
+        case 'ebay_get_payment_dispute_activities':
+            return await api.dispute.getActivities(args.paymentDisputeId);
+        case 'ebay_accept_payment_dispute':
+            return await api.dispute.acceptPaymentDispute(args.paymentDisputeId, args.returnAddress);
+        case 'ebay_contest_payment_dispute':
+            return await api.dispute.contestPaymentDispute(args.paymentDisputeId, args.returnAddress);
+        case 'ebay_add_payment_dispute_evidence':
+            return await api.dispute.addEvidence(args.paymentDisputeId, args);
+        case 'ebay_update_payment_dispute_evidence':
+            return await api.dispute.updateEvidence(args.paymentDisputeId, args);
+        case 'ebay_upload_payment_dispute_evidence_file':
+            return await api.dispute.uploadEvidenceFile(args.paymentDisputeId, args.file);
+        case 'ebay_fetch_payment_dispute_evidence_content':
+            return await api.dispute.fetchEvidenceContent(args.paymentDisputeId, args.evidenceId, args.fileId);
+        // Marketing - Campaign Management
+        case 'ebay_get_campaigns':
+            return await api.marketing.getCampaigns(args.campaignStatus, args.marketplaceId, args.limit);
+        case 'ebay_get_campaign':
+            return await api.marketing.getCampaign(args.campaignId);
+        case 'ebay_get_campaign_by_name':
+            return await api.marketing.getCampaignByName(args.campaignName);
+        case 'ebay_create_campaign':
+            return await api.marketing.createCampaign(args.campaign);
+        case 'ebay_clone_campaign':
+            return await api.marketing.cloneCampaign(args.campaignId, args.cloneData);
+        case 'ebay_pause_campaign':
+            return await api.marketing.pauseCampaign(args.campaignId);
+        case 'ebay_resume_campaign':
+            return await api.marketing.resumeCampaign(args.campaignId);
+        case 'ebay_end_campaign':
+            return await api.marketing.endCampaign(args.campaignId);
+        case 'ebay_update_campaign_identification':
+            return await api.marketing.updateCampaignIdentification(args.campaignId, args.updateData);
+        // Marketing - Ad Operations (Bulk)
+        case 'ebay_bulk_create_ads_by_inventory_reference':
+            return await api.marketing.bulkCreateAdsByInventoryReference(args.campaignId, args.ads);
+        case 'ebay_bulk_create_ads_by_listing_id':
+            return await api.marketing.bulkCreateAdsByListingId(args.campaignId, args.ads);
+        case 'ebay_bulk_delete_ads_by_inventory_reference':
+            return await api.marketing.bulkDeleteAdsByInventoryReference(args.campaignId, args.ads);
+        case 'ebay_delete_ads_by_inventory_reference':
+            return await api.marketing.deleteAdsByInventoryReference(args.campaignId, {
+                inventoryReferenceId: args.inventoryReferenceId,
+                inventoryReferenceType: args.inventoryReferenceType,
+            });
+        case 'ebay_bulk_delete_ads_by_listing_id':
+            return await api.marketing.bulkDeleteAdsByListingId(args.campaignId, args.ads);
+        case 'ebay_bulk_update_ads_bid_by_inventory_reference':
+            return await api.marketing.bulkUpdateAdsBidByInventoryReference(args.campaignId, args.ads);
+        case 'ebay_bulk_update_ads_bid_by_listing_id':
+            return await api.marketing.bulkUpdateAdsBidByListingId(args.campaignId, args.ads);
+        case 'ebay_bulk_update_ads_status':
+            return await api.marketing.bulkUpdateAdsStatus(args.campaignId, args.ads);
+        case 'ebay_bulk_update_ads_status_by_listing_id':
+            return await api.marketing.bulkUpdateAdsStatusByListingId(args.campaignId, args.ads);
+        // Marketing - Ad Operations (Single)
+        case 'ebay_create_ad':
+            return await api.marketing.createAd(args.campaignId, args.ad);
+        case 'ebay_create_ads_by_inventory_reference':
+            return await api.marketing.createAdsByInventoryReference(args.campaignId, args.ads);
+        case 'ebay_get_ad':
+            return await api.marketing.getAd(args.campaignId, args.adId);
+        case 'ebay_get_ads':
+            return await api.marketing.getAds(args.campaignId, args.adGroupIds, args.adStatus, args.limit, args.listingIds, args.offset);
+        case 'ebay_get_ads_by_inventory_reference':
+            return await api.marketing.getAdsByInventoryReference(args.campaignId, args.inventoryReferenceId, args.inventoryReferenceType);
+        case 'ebay_get_ads_by_listing_id':
+            return await api.marketing.getAdsByListingId(args.campaignId, args.listingId);
+        case 'ebay_delete_ad':
+            return await api.marketing.deleteAd(args.campaignId, args.adId);
+        case 'ebay_clone_ad':
+            return await api.marketing.cloneAd(args.campaignId, args.adId, args.ad);
+        case 'ebay_update_ad_bid':
+            return await api.marketing.updateBid(args.campaignId, args.adId, args.bidData);
+        // Marketing - Ad Group Management
+        case 'ebay_create_ad_group':
+            return await api.marketing.createAdGroup(args.campaignId, args.adGroup);
+        case 'ebay_get_ad_group':
+            return await api.marketing.getAdGroup(args.campaignId, args.adGroupId);
+        case 'ebay_get_ad_groups':
+            return await api.marketing.getAdGroups(args.campaignId, args.adGroupStatus, args.limit, args.offset);
+        case 'ebay_clone_ad_group':
+            return await api.marketing.cloneAdGroup(args.campaignId, args.adGroupId, args.adGroup);
+        case 'ebay_update_ad_group_bids':
+            return await api.marketing.updateAdGroupBids(args.campaignId, args.adGroupId, args.bidsData);
+        case 'ebay_update_ad_group_keywords':
+            return await api.marketing.updateAdGroupKeywords(args.campaignId, args.adGroupId, args.keywordsData);
+        // Marketing - Keyword Management
+        case 'ebay_create_keyword':
+            return await api.marketing.createKeyword(args.campaignId, args.adGroupId, args.keyword);
+        case 'ebay_get_keyword':
+            return await api.marketing.getKeyword(args.campaignId, args.adGroupId, args.keywordId);
+        case 'ebay_get_keywords':
+            return await api.marketing.getKeywords(args.campaignId, args.adGroupId, args.keywordStatus, args.limit, args.offset);
+        case 'ebay_delete_keyword':
+            return await api.marketing.deleteKeyword(args.campaignId, args.adGroupId, args.keywordId);
+        case 'ebay_update_keyword_bid':
+            return await api.marketing.updateKeywordBid(args.campaignId, args.adGroupId, args.keywordId, args.bidData);
+        case 'ebay_bulk_create_keywords':
+            return await api.marketing.bulkCreateKeywords(args.campaignId, args.adGroupId, args.keywords);
+        case 'ebay_bulk_delete_keywords':
+            return await api.marketing.bulkDeleteKeywords(args.campaignId, args.adGroupId, args.keywords);
+        case 'ebay_bulk_update_keyword_bids':
+            return await api.marketing.bulkUpdateKeywordBids(args.campaignId, args.adGroupId, args.keywords);
+        // Marketing - Negative Keywords (Campaign Level)
+        case 'ebay_create_negative_keyword':
+            return await api.marketing.createNegativeKeyword(args.campaignId, args.negativeKeyword);
+        case 'ebay_get_negative_keyword':
+            return await api.marketing.getNegativeKeyword(args.campaignId, args.negativeKeywordId);
+        case 'ebay_get_negative_keywords':
+            return await api.marketing.getNegativeKeywords(args.campaignId, args.limit, args.offset);
+        case 'ebay_delete_negative_keyword':
+            return await api.marketing.deleteNegativeKeyword(args.campaignId, args.negativeKeywordId);
+        case 'ebay_update_negative_keyword':
+            return await api.marketing.updateNegativeKeyword(args.campaignId, args.negativeKeywordId, args.negativeKeyword);
+        case 'ebay_bulk_create_negative_keywords':
+            return await api.marketing.bulkCreateNegativeKeywords(args.campaignId, args.negativeKeywords);
+        case 'ebay_bulk_update_negative_keywords':
+            return await api.marketing.bulkUpdateNegativeKeywords(args.campaignId, args.negativeKeywords);
+        case 'ebay_bulk_delete_negative_keywords':
+            return await api.marketing.bulkDeleteNegativeKeywords(args.campaignId, args.negativeKeywords);
+        // Marketing - Negative Keywords (Ad Group Level)
+        case 'ebay_create_negative_keyword_for_ad_group':
+            return await api.marketing.createNegativeKeywordForAdGroup(args.adGroupId, args.negativeKeyword);
+        case 'ebay_get_negative_keyword_for_ad_group':
+            return await api.marketing.getNegativeKeywordForAdGroup(args.adGroupId, args.negativeKeywordId);
+        case 'ebay_get_negative_keywords_for_ad_group':
+            return await api.marketing.getNegativeKeywordsForAdGroup(args.adGroupId, args.limit, args.offset);
+        case 'ebay_delete_negative_keyword_for_ad_group':
+            return await api.marketing.deleteNegativeKeywordForAdGroup(args.adGroupId, args.negativeKeywordId);
+        case 'ebay_update_negative_keyword_for_ad_group':
+            return await api.marketing.updateNegativeKeywordForAdGroup(args.adGroupId, args.negativeKeywordId, args.negativeKeyword);
+        case 'ebay_bulk_create_negative_keywords_for_ad_group':
+            return await api.marketing.bulkCreateNegativeKeywordsForAdGroup(args.adGroupId, args.negativeKeywords);
+        case 'ebay_bulk_update_negative_keywords_for_ad_group':
+            return await api.marketing.bulkUpdateNegativeKeywordsForAdGroup(args.adGroupId, args.negativeKeywords);
+        case 'ebay_bulk_delete_negative_keywords_for_ad_group':
+            return await api.marketing.bulkDeleteNegativeKeywordsForAdGroup(args.adGroupId, args.negativeKeywords);
+        // Marketing - Targeting
+        case 'ebay_create_targeting':
+            return await api.marketing.createTargeting(args.campaignId, args.targeting);
+        case 'ebay_get_targeting':
+            return await api.marketing.getTargeting(args.campaignId);
+        case 'ebay_update_targeting':
+            return await api.marketing.updateTargeting(args.campaignId, args.targeting);
+        // Marketing - Suggestions
+        case 'ebay_suggest_bids':
+            return await api.marketing.suggestBids(args.campaignId, args.adGroupId);
+        case 'ebay_suggest_keywords':
+            return await api.marketing.suggestKeywords(args.campaignId, args.adGroupId, args.suggestion);
+        // Marketing - Reporting
+        case 'ebay_create_report_task':
+            return await api.marketing.createReportTask(args.reportTask);
+        case 'ebay_get_report_task':
+            return await api.marketing.getReportTask(args.reportTaskId);
+        case 'ebay_get_report_tasks':
+            return await api.marketing.getReportTasks(args.reportTaskStatuses, args.limit, args.offset);
+        case 'ebay_get_ad_report':
+            return await api.marketing.getAdReport(args.dimension, args.metric, args.reportStartDate, args.reportEndDate, args.sort, args.listingIds, args.marketplaceId);
+        case 'ebay_get_ad_report_metadata':
+            return await api.marketing.getAdReportMetadata();
+        case 'ebay_get_ad_report_metadata_for_report_type':
+            return await api.marketing.getAdReportMetadataForReportType(args.reportType);
+        // Marketing - Promotions (Item Promotion)
+        case 'ebay_get_promotions':
+            return await api.marketing.getPromotions(args.marketplaceId, args.limit);
+        case 'ebay_get_item_promotion':
+            return await api.marketing.getItemPromotion(args.promotionId);
+        case 'ebay_create_item_promotion':
+            return await api.marketing.createPromotion(args.promotion);
+        case 'ebay_update_item_promotion':
+            return await api.marketing.updateItemPromotion(args.promotionId, args.promotion);
+        case 'ebay_delete_item_promotion':
+            return await api.marketing.deleteItemPromotion(args.promotionId);
+        case 'ebay_pause_item_promotion':
+            return await api.marketing.pauseItemPromotion(args.promotionId);
+        case 'ebay_resume_item_promotion':
+            return await api.marketing.resumeItemPromotion(args.promotionId);
+        case 'ebay_get_promotion_report':
+            return await api.marketing.getPromotionReport(args.marketplaceId, args.promotionStatus, args.limit, args.offset);
+        case 'ebay_get_promotion_summary_report':
+            return await api.marketing.getPromotionSummaryReport(args.marketplaceId);
+        case 'ebay_delete_campaign':
+            return await api.marketing.deleteCampaign(args.campaignId);
+        case 'ebay_launch_campaign':
+            return await api.marketing.launchCampaign(args.campaignId);
+        case 'ebay_find_campaign_by_ad_reference':
+            return await api.marketing.findCampaignByAdReference(args.inventoryReferenceId, args.inventoryReferenceType, args.listingId);
+        case 'ebay_setup_quick_campaign':
+            return await api.marketing.setupQuickCampaign(args.quickCampaign);
+        case 'ebay_suggest_budget':
+            return await api.marketing.suggestBudget(args.campaignId);
+        case 'ebay_suggest_items':
+            return await api.marketing.suggestItems(args.campaignId);
+        case 'ebay_suggest_max_cpc':
+            return await api.marketing.suggestMaxCpc(args.suggestionRequest);
+        case 'ebay_update_ad_rate_strategy':
+            return await api.marketing.updateAdRateStrategy(args.campaignId, args.strategy);
+        case 'ebay_update_bidding_strategy':
+            return await api.marketing.updateBiddingStrategy(args.campaignId, args.strategy);
+        case 'ebay_update_campaign_budget':
+            return await api.marketing.updateCampaignBudget(args.campaignId, args.budget);
+        case 'ebay_update_ad_group':
+            return await api.marketing.updateAdGroup(args.campaignId, args.adGroupId, args.updateData);
+        case 'ebay_update_keyword':
+            return await api.marketing.updateKeyword(args.campaignId, args.keywordId, args.updateData);
+        case 'ebay_bulk_create_campaign_keyword':
+            return await api.marketing.bulkCreateKeyword(args.campaignId, args.keywords);
+        case 'ebay_bulk_update_campaign_keyword':
+            return await api.marketing.bulkUpdateKeyword(args.campaignId, args.keywords);
+        case 'ebay_get_report':
+            return await api.marketing.getReport(args.reportId);
+        case 'ebay_delete_report_task':
+            return await api.marketing.deleteReportTask(args.reportTaskId);
+        case 'ebay_create_item_price_markdown_promotion':
+            return await api.marketing.createItemPriceMarkdownPromotion(args.promotion);
+        case 'ebay_get_item_price_markdown_promotion':
+            return await api.marketing.getItemPriceMarkdownPromotion(args.promotionId);
+        case 'ebay_update_item_price_markdown_promotion':
+            return await api.marketing.updateItemPriceMarkdownPromotion(args.promotionId, args.promotion);
+        case 'ebay_delete_item_price_markdown_promotion':
+            return await api.marketing.deleteItemPriceMarkdownPromotion(args.promotionId);
+        case 'ebay_get_listing_set':
+            return await api.marketing.getListingSet(args.promotionId);
+        case 'ebay_pause_promotion':
+            return await api.marketing.pausePromotion(args.promotionId);
+        case 'ebay_resume_promotion':
+            return await api.marketing.resumePromotion(args.promotionId);
+        case 'ebay_get_email_campaigns':
+            return await api.marketing.getEmailCampaigns(args.limit, args.offset);
+        case 'ebay_create_email_campaign':
+            return await api.marketing.createEmailCampaign(args.emailCampaign);
+        case 'ebay_get_email_campaign':
+            return await api.marketing.getEmailCampaign(args.emailCampaignId);
+        case 'ebay_update_email_campaign':
+            return await api.marketing.updateEmailCampaign(args.emailCampaignId, args.emailCampaign);
+        case 'ebay_delete_email_campaign':
+            return await api.marketing.deleteEmailCampaign(args.emailCampaignId);
+        case 'ebay_get_email_audiences':
+            return await api.marketing.getAudiences();
+        case 'ebay_get_email_preview':
+            return await api.marketing.getEmailPreview(args.emailCampaignId);
+        case 'ebay_get_email_report':
+            return await api.marketing.getEmailReport(args.limit, args.offset);
+        // Recommendation
+        case 'ebay_find_listing_recommendations':
+            return await api.recommendation.findListingRecommendations(args.listingIds ? { listingIds: args.listingIds } : undefined, args.filter, args.limit, args.offset, args.marketplaceId);
+        // Analytics
+        case 'ebay_get_traffic_report':
+            return await api.analytics.getTrafficReport(args.dimension, args.filter, args.metric, args.sort);
+        case 'ebay_find_seller_standards_profiles':
+            return await api.analytics.findSellerStandardsProfiles();
+        case 'ebay_get_seller_standards_profile':
+            return await api.analytics.getSellerStandardsProfile(args.program, args.cycle);
+        case 'ebay_get_customer_service_metric':
+            return await api.analytics.getCustomerServiceMetric(args.customerServiceMetricType, args.evaluationType, args.evaluationMarketplaceId);
+        // Metadata
+        case 'ebay_get_automotive_parts_compatibility_policies':
+            return await api.metadata.getAutomotivePartsCompatibilityPolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_category_policies':
+            return await api.metadata.getCategoryPolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_extended_producer_responsibility_policies':
+            return await api.metadata.getExtendedProducerResponsibilityPolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_hazardous_materials_labels':
+            return await api.metadata.getHazardousMaterialsLabels(args.marketplaceId);
+        case 'ebay_get_item_condition_policies':
+            return await api.metadata.getItemConditionPolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_listing_structure_policies':
+            return await api.metadata.getListingStructurePolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_negotiated_price_policies':
+            return await api.metadata.getNegotiatedPricePolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_product_safety_labels':
+            return await api.metadata.getProductSafetyLabels(args.marketplaceId);
+        case 'ebay_get_regulatory_policies':
+            return await api.metadata.getRegulatoryPolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_return_policy_metadata':
+            return await api.metadata.getReturnPolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_shipping_cost_type_policies':
+            return await api.metadata.getShippingCostTypePolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_classified_ad_policies':
+            return await api.metadata.getClassifiedAdPolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_currencies':
+            return await api.metadata.getCurrencies(args.marketplaceId);
+        case 'ebay_get_listing_type_policies':
+            return await api.metadata.getListingTypePolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_motors_listing_policies':
+            return await api.metadata.getMotorsListingPolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_shipping_policies':
+            return await api.metadata.getShippingPolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_site_visibility_policies':
+            return await api.metadata.getSiteVisibilityPolicies(args.marketplaceId, args.filter);
+        case 'ebay_get_compatibilities_by_specification':
+            return await api.metadata.getCompatibilitiesBySpecification(args.specification);
+        case 'ebay_get_compatibility_property_names':
+            return await api.metadata.getCompatibilityPropertyNames(args.data);
+        case 'ebay_get_compatibility_property_values':
+            return await api.metadata.getCompatibilityPropertyValues(args.data);
+        case 'ebay_get_multi_compatibility_property_values':
+            return await api.metadata.getMultiCompatibilityPropertyValues(args.data);
+        case 'ebay_get_product_compatibilities':
+            return await api.metadata.getProductCompatibilities(args.data);
+        case 'ebay_get_sales_tax_jurisdictions':
+            return await api.metadata.getSalesTaxJurisdictions(args.countryCode);
+        // Taxonomy
+        case 'ebay_get_default_category_tree_id':
+            return await api.taxonomy.getDefaultCategoryTreeId(args.marketplaceId);
+        case 'ebay_get_category_tree':
+            return await api.taxonomy.getCategoryTree(args.categoryTreeId);
+        case 'ebay_get_category_suggestions':
+            return await api.taxonomy.getCategorySuggestions(args.categoryTreeId, args.query);
+        case 'ebay_get_item_aspects_for_category':
+            return await api.taxonomy.getItemAspectsForCategory(args.categoryTreeId, args.categoryId);
+        // Communication - Negotiation
+        case 'ebay_get_offers_to_buyers': {
+            const validated = getOffersToBuyersSchema.parse(args);
+            return await api.negotiation.getOffersToBuyers(validated.filter, validated.limit ? Number(validated.limit) : undefined, validated.offset ? Number(validated.offset) : undefined);
+        }
+        case 'ebay_send_offer_to_interested_buyers': {
+            const validated = sendOfferToInterestedBuyersSchema.parse(args);
+            return await api.negotiation.sendOfferToInterestedBuyers(validated);
+        }
+        case 'ebay_find_eligible_items': {
+            const validated = findEligibleItemsSchema.parse(args);
+            return await api.negotiation.findEligibleItems(validated.marketplace_id, validated.limit ? Number(validated.limit) : undefined, validated.offset ? Number(validated.offset) : undefined);
+        }
+        // Communication - Message
+        case 'ebay_search_messages': {
+            const validated = getConversationsSchema.parse(args);
+            return await api.message.searchMessages(undefined, validated.limit ? Number(validated.limit) : undefined, validated.offset ? Number(validated.offset) : undefined);
+        }
+        case 'ebay_get_message': {
+            const validated = getConversationSchema.parse(args);
+            return await api.message.getMessage(validated.conversation_id);
+        }
+        case 'ebay_send_message': {
+            const validated = sendMessageSchema.parse(args);
+            return await api.message.sendMessage(validated);
+        }
+        case 'ebay_reply_to_message': {
+            // This is a deprecated method that maps to sendMessage
+            // We'll validate with a simple schema
+            if (!args.messageId || !args.messageContent) {
+                throw new Error('messageId and messageContent are required');
+            }
+            return await api.message.replyToMessage(args.messageId, args.messageContent);
+        }
+        case 'ebay_get_conversations': {
+            const validated = getConversationsSchema.parse(args);
+            return await api.message.getConversations(undefined, validated.limit ? Number(validated.limit) : undefined, validated.offset ? Number(validated.offset) : undefined);
+        }
+        case 'ebay_get_conversation': {
+            const validated = getConversationSchema.parse(args);
+            return await api.message.getConversation(validated.conversation_id);
+        }
+        case 'ebay_bulk_update_conversation': {
+            const validated = bulkUpdateConversationSchema.parse(args);
+            return await api.message.bulkUpdateConversation(validated);
+        }
+        case 'ebay_update_conversation': {
+            const validated = updateConversationSchema.parse(args);
+            return await api.message.updateConversation(validated);
+        }
+        // Communication - Notification
+        case 'ebay_get_notification_config': {
+            getConfigSchema.parse(args); // Validate empty args
+            return await api.notification.getConfig();
+        }
+        case 'ebay_update_notification_config': {
+            const validated = updateConfigSchema.parse(args);
+            return await api.notification.updateConfig(validated);
+        }
+        case 'ebay_get_notification_destinations':
+            return await api.notification.getDestinations(args.limit, args.continuationToken);
+        case 'ebay_create_notification_destination': {
+            const validated = createDestinationSchema.parse(args);
+            return await api.notification.createDestination(validated);
+        }
+        case 'ebay_get_notification_destination': {
+            const validated = getDestinationSchema.parse(args);
+            return await api.notification.getDestination(validated.destination_id);
+        }
+        case 'ebay_update_notification_destination': {
+            const validated = updateDestinationSchema.parse(args);
+            return await api.notification.updateDestination(validated.destination_id, validated);
+        }
+        case 'ebay_delete_notification_destination': {
+            const validated = deleteDestinationSchema.parse(args);
+            return await api.notification.deleteDestination(validated.destination_id);
+        }
+        case 'ebay_get_notification_subscriptions': {
+            const validated = getSubscriptionsSchema.parse(args);
+            return await api.notification.getSubscriptions(validated.limit ? Number(validated.limit) : undefined, validated.continuation_token);
+        }
+        case 'ebay_create_notification_subscription': {
+            const validated = createSubscriptionSchema.parse(args);
+            return await api.notification.createSubscription(validated);
+        }
+        case 'ebay_get_notification_subscription': {
+            const validated = getSubscriptionSchema.parse(args);
+            return await api.notification.getSubscription(validated.subscription_id);
+        }
+        case 'ebay_update_notification_subscription': {
+            const validated = updateSubscriptionSchema.parse(args);
+            return await api.notification.updateSubscription(validated.subscription_id, validated);
+        }
+        case 'ebay_delete_notification_subscription': {
+            const validated = deleteSubscriptionSchema.parse(args);
+            return await api.notification.deleteSubscription(validated.subscription_id);
+        }
+        case 'ebay_disable_notification_subscription': {
+            const validated = disableSubscriptionSchema.parse(args);
+            return await api.notification.disableSubscription(validated.subscription_id);
+        }
+        case 'ebay_enable_notification_subscription': {
+            const validated = enableSubscriptionSchema.parse(args);
+            return await api.notification.enableSubscription(validated.subscription_id);
+        }
+        case 'ebay_test_notification_subscription': {
+            const validated = testSubscriptionSchema.parse(args);
+            return await api.notification.testSubscription(validated.subscription_id);
+        }
+        case 'ebay_get_notification_topic': {
+            const validated = getTopicSchema.parse(args);
+            return await api.notification.getTopic(validated.topic_id);
+        }
+        case 'ebay_get_notification_topics': {
+            const validated = getTopicsSchema.parse(args);
+            return await api.notification.getTopics(validated.limit ? Number(validated.limit) : undefined, validated.continuation_token);
+        }
+        case 'ebay_create_notification_subscription_filter': {
+            const validated = createSubscriptionFilterSchema.parse(args);
+            return await api.notification.createSubscriptionFilter(validated.subscription_id, validated);
+        }
+        case 'ebay_get_notification_subscription_filter': {
+            const validated = getSubscriptionFilterSchema.parse(args);
+            return await api.notification.getSubscriptionFilter(validated.subscription_id, validated.filter_id);
+        }
+        case 'ebay_delete_notification_subscription_filter': {
+            const validated = deleteSubscriptionFilterSchema.parse(args);
+            return await api.notification.deleteSubscriptionFilter(validated.subscription_id, validated.filter_id);
+        }
+        case 'ebay_get_notification_public_key': {
+            const validated = getPublicKeySchema.parse(args);
+            return await api.notification.getPublicKey(validated.public_key_id);
+        }
+        // Communication - Feedback
+        case 'ebay_get_feedback': {
+            const validated = getFeedbackSchema.parse(args);
+            return await api.feedback.getFeedback(validated.transaction_id ?? '');
+        }
+        case 'ebay_leave_feedback_for_buyer': {
+            const validated = leaveFeedbackForBuyerSchema.parse(args);
+            return await api.feedback.leaveFeedbackForBuyer(validated);
+        }
+        case 'ebay_get_feedback_summary': {
+            getFeedbackRatingSummarySchema.parse(args); // Validate empty args
+            return await api.feedback.getFeedbackSummary();
+        }
+        case 'ebay_get_awaiting_feedback': {
+            const validated = getAwaitingFeedbackSchema.parse(args);
+            return await api.feedback.getAwaitingFeedback(validated.filter, validated.limit ? Number(validated.limit) : undefined, validated.offset ? Number(validated.offset) : undefined);
+        }
+        case 'ebay_respond_to_feedback': {
+            const validated = respondToFeedbackSchema.parse(args);
+            return await api.feedback.respondToFeedback(validated.feedback_id ?? '', validated.response_text ?? '');
+        }
+        // Other APIs - Identity
+        case 'ebay_get_user':
+            return await api.identity.getUser();
+        // Other APIs - Compliance
+        case 'ebay_get_listing_violations':
+            return await api.compliance.getListingViolations(args.complianceType, args.offset, args.limit);
+        case 'ebay_get_listing_violations_summary':
+            return await api.compliance.getListingViolationsSummary(args.complianceType);
+        case 'ebay_suppress_violation':
+            return await api.compliance.suppressViolation(args.listingViolationId);
+        // Other APIs - VERO
+        case 'ebay_create_vero_report':
+            return await api.vero.createVeroReport(args.reportData);
+        case 'ebay_get_vero_report':
+            return await api.vero.getVeroReport(args.veroReportId);
+        case 'ebay_get_vero_report_items':
+            return await api.vero.getVeroReportItems(args.filter, args.limit, args.offset);
+        case 'ebay_get_vero_reason_code':
+            return await api.vero.getVeroReasonCode(args.veroReasonCodeId);
+        case 'ebay_get_vero_reason_codes':
+            return await api.vero.getVeroReasonCodes();
+        // Other APIs - Translation
+        case 'ebay_translate':
+            return await api.translation.translate(args.from, args.to, args.translationContext, args.text);
+        // Other APIs - eDelivery
+        case 'ebay_create_shipping_quote':
+            return await api.edelivery.createShippingQuote(args.shippingQuoteRequest);
+        case 'ebay_get_shipping_quote':
+            return await api.edelivery.getShippingQuote(args.shippingQuoteId);
+        // eDelivery - Cost & Preferences
+        case 'ebay_get_actual_costs':
+            return await api.edelivery.getActualCosts(args.params);
+        case 'ebay_get_address_preferences':
+            return await api.edelivery.getAddressPreferences();
+        case 'ebay_create_address_preference':
+            return await api.edelivery.createAddressPreference(args.addressPreference);
+        case 'ebay_get_consign_preferences':
+            return await api.edelivery.getConsignPreferences();
+        case 'ebay_create_consign_preference':
+            return await api.edelivery.createConsignPreference(args.consignPreference);
+        // eDelivery - Agents & Services
+        case 'ebay_get_agents':
+            return await api.edelivery.getAgents(args.params);
+        case 'ebay_get_battery_qualifications':
+            return await api.edelivery.getBatteryQualifications(args.params);
+        case 'ebay_get_dropoff_sites':
+            return await api.edelivery.getDropoffSites(args.params);
+        case 'ebay_get_shipping_services':
+            return await api.edelivery.getShippingServices(args.params);
+        // eDelivery - Bundles
+        case 'ebay_create_bundle':
+            return await api.edelivery.createBundle(args.bundleRequest);
+        case 'ebay_get_bundle':
+            return await api.edelivery.getBundle(args.bundleId);
+        case 'ebay_cancel_bundle':
+            return await api.edelivery.cancelBundle(args.bundleId);
+        case 'ebay_get_bundle_label':
+            return await api.edelivery.getBundleLabel(args.bundleId);
+        // eDelivery - Packages (Single)
+        case 'ebay_create_package':
+            return await api.edelivery.createPackage(args.packageRequest);
+        case 'ebay_get_package':
+            return await api.edelivery.getPackage(args.packageId);
+        case 'ebay_delete_package':
+            return await api.edelivery.deletePackage(args.packageId);
+        case 'ebay_get_package_by_order_line_item':
+            return await api.edelivery.getPackageByOrderLineItem(args.orderLineItemId);
+        case 'ebay_cancel_package':
+            return await api.edelivery.cancelPackage(args.packageId);
+        case 'ebay_clone_package':
+            return await api.edelivery.clonePackage(args.packageId);
+        case 'ebay_confirm_package':
+            return await api.edelivery.confirmPackage(args.packageId);
+        // eDelivery - Packages (Bulk)
+        case 'ebay_bulk_cancel_packages':
+            return await api.edelivery.bulkCancelPackages(args.bulkCancelRequest);
+        case 'ebay_bulk_confirm_packages':
+            return await api.edelivery.bulkConfirmPackages(args.bulkConfirmRequest);
+        case 'ebay_bulk_delete_packages':
+            return await api.edelivery.bulkDeletePackages(args.bulkDeleteRequest);
+        // eDelivery - Labels & Tracking
+        case 'ebay_get_labels':
+            return await api.edelivery.getLabels(args.params);
+        case 'ebay_get_handover_sheet':
+            return await api.edelivery.getHandoverSheet(args.params);
+        case 'ebay_get_tracking':
+            return await api.edelivery.getTracking(args.params);
+        // eDelivery - Other
+        case 'ebay_create_complaint':
+            return await api.edelivery.createComplaint(args.complaintRequest);
+        case 'SearchClaudeCodeDocs':
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Tool 'SearchClaudeCodeDocs' called with query: ${args.query}. This tool is not yet fully implemented.`,
+                    },
+                ],
+            };
+        // Developer API - API Status (public RSS feed)
+        case 'ebay_get_api_status': {
+            const result = await getApiStatusFeed({
+                limit: args.limit,
+                status: args.status,
+                api: args.api,
+            });
+            return { items: result.items, ...(result.error && { error: result.error }) };
+        }
+        // Developer API - Rate Limits
+        case 'ebay_get_rate_limits':
+            return await api.developer.getRateLimits(args.apiContext, args.apiName);
+        case 'ebay_get_user_rate_limits':
+            return await api.developer.getUserRateLimits(args.apiContext, args.apiName);
+        // Developer API - Client Registration
+        case 'ebay_register_client':
+            return await api.developer.registerClient(args.clientSettings);
+        // Developer API - Signing Keys
+        case 'ebay_get_signing_keys':
+            return await api.developer.getSigningKeys();
+        case 'ebay_create_signing_key':
+            return await api.developer.createSigningKey(args.signingKeyCipher ? { signingKeyCipher: args.signingKeyCipher } : undefined);
+        case 'ebay_get_signing_key':
+            return await api.developer.getSigningKey(args.signingKeyId);
+        // Trading API - Listing Management
+        case 'ebay_get_active_listings':
+            return await api.trading.getActiveListings(args.page, args.entriesPerPage);
+        case 'ebay_get_listing':
+            return await api.trading.getListing(args.itemId);
+        case 'ebay_create_listing':
+            return await api.trading.createListing(args.item);
+        case 'ebay_revise_listing':
+            return await api.trading.reviseListing(args.itemId, args.fields);
+        case 'ebay_end_listing':
+            return await api.trading.endListing(args.itemId, args.reason);
+        case 'ebay_relist_item':
+            return await api.trading.relistItem(args.itemId, args.modifications);
+        default:
+            throw new Error(`Unknown tool: ${toolName}`);
+    }
+}