ebay-mcp-remote-edition 3.1.2 → 3.3.0

package/build/server-http.js

@@ -1,6 +1,7 @@
 import express from 'express';
 import helmet from 'helmet';
 import cors from 'cors';
+import axios from 'axios';
 import { createServer as createHttpsServer } from 'https';
 import { readFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
@@ -10,8 +11,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { EbaySellerApi } from './api/index.js';
-import { getConfiguredEnvironment, getHostedOauthScopes, getEbayConfig, getOAuthAuthorizationUrl, validateCredentialsForEnvironment, ruNameToEnvironment, } from './config/environment.js';
-import { getToolDefinitions, executeTool } from './tools/index.js';
+import { getBaseUrl, getConfiguredEnvironment, getHostedOauthScopes, getEbayConfig, getOAuthAuthorizationUrl, getValidationRunnerUserId, validateCredentialsForEnvironment, ruNameToEnvironment, } from './config/environment.js';
 import { getVersion } from './utils/version.js';
 import { serverLogger } from './utils/logger.js';
 import { MultiUserAuthStore } from './auth/multi-user-store.js';
@@ -38,6 +38,48 @@ function htmlEscape(value) {
         .replace(/"/g, '"')
         .replace(/'/g, ''');
 }
+function getValidationIdFromBody(body) {
+    if (typeof body === 'object' &&
+        body !== null &&
+        'validationId' in body &&
+        typeof body.validationId === 'string') {
+        return body.validationId;
+    }
+    return '';
+}
+function getRetryTimestampFromBody(body) {
+    if (typeof body === 'object' &&
+        body !== null &&
+        'timestamp' in body &&
+        typeof body.timestamp === 'string') {
+        const parsed = new Date(body.timestamp);
+        if (Number.isFinite(parsed.getTime())) {
+            return new Date(parsed.getTime() + 30 * 60 * 1000).toISOString();
+        }
+    }
+    return new Date(Date.now() + 30 * 60 * 1000).toISOString();
+}
+function getAxiosFailureDebug(error) {
+    if (!axios.isAxiosError(error)) {
+        return {
+            responseStatus: null,
+            responseBodyExcerpt: null,
+        };
+    }
+    const responseStatus = error.response?.status ?? null;
+    const rawBody = error.response?.data;
+    if (rawBody === undefined) {
+        return {
+            responseStatus,
+            responseBodyExcerpt: null,
+        };
+    }
+    const bodyText = typeof rawBody === 'string' ? rawBody : JSON.stringify(rawBody, null, 2);
+    return {
+        responseStatus,
+        responseBodyExcerpt: bodyText.slice(0, 500),
+    };
+}
 function requireAdmin(req, res, next) {
     if (!CONFIG.adminApiKey) {
         res.status(500).json({ error: 'ADMIN_API_KEY is not configured' });
@@ -107,6 +149,7 @@ function createApp() {
     app.use(express.urlencoded({ extended: false }));
     app.use(helmet({ xPoweredBy: false }));
     app.use('/icons', express.static(join(projectRoot, 'public', 'icons')));
+    app.use('/callback-copy.js', express.static(join(projectRoot, 'public', 'callback-copy.js')));
     app.use((req, res, next) => {
         const start = Date.now();
         res.on('finish', () => {
@@ -317,9 +360,9 @@ function mountEnvRouter(hardcodedEnv, serverUrl, iconBaseUrl) {
             }
         }
         // Step 2: per-env RuName detection.
-        const sandboxRuName = process.env.EBAY_SANDBOX_RUNAME || process.env.EBAY_SANDBOX_REDIRECT_URI;
-        const productionRuName = process.env.EBAY_PRODUCTION_RUNAME || process.env.EBAY_PRODUCTION_REDIRECT_URI;
-        const genericRuName = process.env.EBAY_RUNAME || process.env.EBAY_REDIRECT_URI;
+        const sandboxRuName = process.env.EBAY_SANDBOX_RUNAME ?? process.env.EBAY_SANDBOX_REDIRECT_URI;
+        const productionRuName = process.env.EBAY_PRODUCTION_RUNAME ?? process.env.EBAY_PRODUCTION_REDIRECT_URI;
+        const genericRuName = process.env.EBAY_RUNAME ?? process.env.EBAY_REDIRECT_URI;
         const sandboxDetected = ruNameToEnvironment(sandboxRuName);
         const productionDetected = ruNameToEnvironment(productionRuName);
         if (sandboxDetected && !productionDetected)
@@ -333,6 +376,130 @@ function mountEnvRouter(hardcodedEnv, serverUrl, iconBaseUrl) {
         // Step 4: final fallback.
         return getConfiguredEnvironment();
     }
+    router.post('/validation/run', requireAdmin, async (req, res) => {
+        const environment = resolveEnv(req);
+        const validationRunnerUserId = getValidationRunnerUserId(environment);
+        if (!validationRunnerUserId) {
+            res.status(500).json({
+                status: 'error',
+                validationId: getValidationIdFromBody(req.body),
+                errorCode: 'VALIDATION_USER_NOT_CONFIGURED',
+                message: `No validation runner user is configured for ${environment}`,
+                retryable: false,
+                nextCheckAt: null,
+            });
+            return;
+        }
+        const storedTokens = await authStore.getUserTokens(validationRunnerUserId, environment);
+        if (!storedTokens?.tokenData) {
+            res.status(500).json({
+                status: 'error',
+                validationId: getValidationIdFromBody(req.body),
+                errorCode: 'VALIDATION_USER_TOKENS_MISSING',
+                message: `Stored refresh-token-backed credentials were not found for validation user ${validationRunnerUserId} in ${environment}`,
+                retryable: false,
+                nextCheckAt: null,
+            });
+            return;
+        }
+        try {
+            const api = await createUserScopedApi(validationRunnerUserId, environment);
+            const { runValidation } = await import('./validation/run-validation.js');
+            const result = await runValidation(api, req.body);
+            if (result.status === 'error') {
+                res.status(500).json(result);
+                return;
+            }
+            res.json(result);
+        }
+        catch (error) {
+            res.status(500).json({
+                status: 'error',
+                validationId: getValidationIdFromBody(req.body),
+                errorCode: 'VALIDATION_ROUTE_ERROR',
+                message: error instanceof Error ? error.message : String(error),
+                retryable: true,
+                nextCheckAt: getRetryTimestampFromBody(req.body),
+            });
+        }
+    });
+    router.get('/validation/health', requireAdmin, async (req, res) => {
+        const environment = resolveEnv(req);
+        const validationRunnerUserId = getValidationRunnerUserId(environment);
+        const storedTokens = validationRunnerUserId
+            ? await authStore.getUserTokens(validationRunnerUserId, environment)
+            : null;
+        const socialConfig = {
+            hasTwitterBearerToken: Boolean(process.env.TWITTER_BEARER_TOKEN?.trim()),
+            hasYoutubeApiKey: Boolean(process.env.YOUTUBE_API_KEY?.trim()),
+            hasRedditUserAgent: Boolean(process.env.REDDIT_USER_AGENT?.trim()),
+        };
+        let authenticated = false;
+        let authError = null;
+        let tokenStatus = null;
+        let authDebug = null;
+        if (validationRunnerUserId && storedTokens?.tokenData) {
+            try {
+                const api = await createUserScopedApi(validationRunnerUserId, environment);
+                const oauthClient = api.getAuthClient().getOAuthClient();
+                const config = api.getAuthClient().getConfig();
+                authDebug = {
+                    ...oauthClient.getAuthDebugInfo(),
+                    configuredMarketplaceId: config.marketplaceId ?? '',
+                    configuredContentLanguage: config.contentLanguage ?? '',
+                };
+                await api.getAuthClient().getOAuthClient().getAccessToken();
+                authenticated = true;
+                tokenStatus = api.getTokenInfo();
+            }
+            catch (error) {
+                authError = error instanceof Error ? error.message : String(error);
+                const failureDebug = getAxiosFailureDebug(error);
+                authDebug = authDebug
+                    ? {
+                        ...authDebug,
+                        responseStatus: failureDebug.responseStatus,
+                        responseBodyExcerpt: failureDebug.responseBodyExcerpt,
+                    }
+                    : null;
+                serverLogger.error('Validation health auth check failed', {
+                    environment,
+                    validationRunnerUserId,
+                    tokenEndpoint: authDebug?.tokenEndpoint ?? null,
+                    responseStatus: failureDebug.responseStatus,
+                    responseBodyExcerpt: failureDebug.responseBodyExcerpt,
+                    authError,
+                });
+            }
+        }
+        const healthResponse = {
+            status: authenticated ? 'ok' : 'degraded',
+            environment,
+            validationRunnerUserId,
+            hasStoredTokens: !!storedTokens?.tokenData,
+            authenticated,
+            tokenStatus,
+            authDebug,
+            providers: {
+                ebay: { available: true, implemented: true, confidence: 'medium' },
+                social: { available: false, implemented: false, confidence: 'low' },
+                chart: { available: false, implemented: false, confidence: 'low' },
+                socialConfig,
+            },
+            ...(authError ? { authError } : {}),
+        };
+        serverLogger.info('Validation health response emitted', {
+            environment,
+            path: req.originalUrl,
+            status: healthResponse.status,
+            version: getVersion(),
+            hasSocialConfigAtRoot: Object.prototype.hasOwnProperty.call(healthResponse, 'socialConfig'),
+            hasSocialConfigUnderProviders: Object.prototype.hasOwnProperty.call(healthResponse.providers, 'socialConfig'),
+            providerKeys: Object.keys(healthResponse.providers),
+            socialConfig,
+        });
+        res.json(healthResponse);
+    });
     // ── RFC 8414 – Authorization Server Metadata ──────────────────────────
     // For env-scoped routers: endpoints are relative to the env base URL.
     // For the ROOT router: endpoints are relative to the DEFAULT environment's
@@ -671,6 +838,19 @@ function mountEnvRouter(hardcodedEnv, serverUrl, iconBaseUrl) {
         next();
     };
     async function createMcpServer(userId, environment) {
+        let getToolDefinitions;
+        let executeTool;
+        try {
+            ({ getToolDefinitions, executeTool } = await import('./tools/index.js'));
+        }
+        catch (error) {
+            serverLogger.error('Failed to import MCP tool registry', {
+                userId,
+                environment,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
         const api = await createUserScopedApi(userId, environment);
         const server = new McpServer({
             name: 'ebay-mcp-remote-edition',
@@ -685,23 +865,36 @@ function mountEnvRouter(hardcodedEnv, serverUrl, iconBaseUrl) {
         });
         const tools = getToolDefinitions();
         for (const toolDef of tools) {
-            server.registerTool(toolDef.name, { description: toolDef.description, inputSchema: toolDef.inputSchema }, async (args) => {
-                try {
-                    const result = await executeTool(api, toolDef.name, args);
-                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-                }
-                catch (error) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }, null, 2),
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-            });
+            try {
+                server.registerTool(toolDef.name, { description: toolDef.description, inputSchema: toolDef.inputSchema }, async (args) => {
+                    try {
+                        const result = await executeTool(api, toolDef.name, args);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }, null, 2),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                });
+            }
+            catch (error) {
+                serverLogger.error('Failed to register MCP tool', {
+                    toolName: toolDef.name,
+                    userId,
+                    environment,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
         }
         return server;
     }
@@ -717,26 +910,51 @@ function mountEnvRouter(hardcodedEnv, serverUrl, iconBaseUrl) {
             transport = transports.get(sessionId);
         }
         else if (!sessionId && isInitializeRequest(req.body)) {
-            transport = new StreamableHTTPServerTransport({
-                sessionIdGenerator: () => randomUUID(),
-                onsessioninitialized: (newSessionId) => {
-                    transports.set(newSessionId, transport);
-                    serverLogger.info('New MCP session initialized', {
-                        sessionId: newSessionId,
-                        userId: userContext.userId,
-                        environment: userContext.environment,
-                    });
-                },
-            });
-            transport.onclose = () => {
-                if (transport.sessionId) {
-                    transports.delete(transport.sessionId);
-                }
-            };
-            const server = await createMcpServer(userContext.userId, userContext.environment);
-            await server.connect(transport);
+            try {
+                transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    onsessioninitialized: (newSessionId) => {
+                        transports.set(newSessionId, transport);
+                        serverLogger.info('New MCP session initialized', {
+                            sessionId: newSessionId,
+                            userId: userContext.userId,
+                            environment: userContext.environment,
+                        });
+                    },
+                });
+                transport.onclose = () => {
+                    if (transport.sessionId) {
+                        transports.delete(transport.sessionId);
+                    }
+                };
+                const server = await createMcpServer(userContext.userId, userContext.environment);
+                await server.connect(transport);
+            }
+            catch (error) {
+                serverLogger.error('Failed to initialize MCP session', {
+                    userId: userContext.userId,
+                    environment: userContext.environment,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                res.status(500).json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32603,
+                        message: error instanceof Error ? error.message : 'Failed to initialize MCP session',
+                    },
+                    id: null,
+                });
+                return;
+            }
         }
         else {
+            serverLogger.warn('Rejected MCP request without valid transport session', {
+                hasSessionId: !!sessionId,
+                sessionId,
+                isInitialize: isInitializeRequest(req.body),
+                userId: userContext.userId,
+                environment: userContext.environment,
+            });
             res.status(400).json({
                 jsonrpc: '2.0',
                 error: { code: -32000, message: 'Bad Request: No valid session ID provided' },
@@ -769,7 +987,6 @@ async function handleOAuthCallback(req, res, serverUrl) {
     try {
         const code = typeof req.query.code === 'string' ? req.query.code : undefined;
         const state = typeof req.query.state === 'string' ? req.query.state : undefined;
-        const envFromQuery = typeof req.query.env === 'string' ? req.query.env : undefined;
         const oauthError = typeof req.query.error === 'string' ? req.query.error : undefined;
         const errorDescription = typeof req.query.error_description === 'string' ? req.query.error_description : undefined;
         serverLogger.info('[oauth/callback] Received', {
@@ -787,33 +1004,37 @@ async function handleOAuthCallback(req, res, serverUrl) {
             res.status(400).send('<h1>Missing authorization code</h1>');
             return;
         }
-        let environment;
-        let stateRecord = null;
-        if (state) {
-            stateRecord = await authStore.consumeOAuthState(state);
-            if (!stateRecord) {
-                serverLogger.warn('[oauth/callback] OAuth state not found or expired', { state });
-                res.status(400).send('<h1>Invalid or expired OAuth state</h1>');
-                return;
-            }
-            environment = stateRecord.environment;
-            serverLogger.info('[oauth/callback] State resolved', {
-                environment,
-                isMcpFlow: !!(stateRecord.mcpClientId && stateRecord.mcpRedirectUri),
-            });
+        if (!state) {
+            serverLogger.warn('[oauth/callback] Missing OAuth state in callback');
+            res
+                .status(400)
+                .send("<h1>Missing OAuth state</h1><p>Restart the OAuth flow from this server's /oauth/start or /authorize endpoint.</p>");
+            return;
         }
-        else {
-            environment =
-                envFromQuery === 'sandbox' || envFromQuery === 'production'
-                    ? envFromQuery
-                    : getConfiguredEnvironment();
-            serverLogger.warn('OAuth callback received without state; falling back to configured/query environment', { environment });
+        const stateRecord = await authStore.getOAuthState(state);
+        if (!stateRecord) {
+            serverLogger.warn('[oauth/callback] OAuth state not found or expired', { state });
+            res.status(400).send('<h1>Invalid or expired OAuth state</h1>');
+            return;
         }
+        const environment = stateRecord.environment;
+        serverLogger.info('[oauth/callback] State resolved', {
+            environment,
+            isMcpFlow: !!(stateRecord.mcpClientId && stateRecord.mcpRedirectUri),
+        });
+        const ebayConfig = getEbayConfig(environment);
+        serverLogger.info('[oauth/callback] Prepared eBay token exchange', {
+            environment,
+            tokenBaseUrl: getBaseUrl(environment),
+            clientIdPrefix: ebayConfig.clientId ? `${ebayConfig.clientId.slice(0, 12)}...` : '(missing)',
+            ruName: ebayConfig.redirectUri ?? '(missing)',
+        });
         const userId = randomUUID();
         const api = await createUserScopedApi(userId, environment);
         const oauthClient = api.getAuthClient().getOAuthClient();
         serverLogger.info('[oauth/callback] Exchanging code for eBay tokens', { userId });
         const tokenData = await oauthClient.exchangeCodeForToken(code);
+        await authStore.deleteOAuthState(state);
         serverLogger.info('[oauth/callback] eBay token exchange successful', {
             userId,
             hasScope: !!tokenData.scope,
@@ -901,32 +1122,7 @@ async function handleOAuthCallback(req, res, serverUrl) {
       .muted { color: #6b7280; }
       a { color: #2563eb; }
     </style>
-    <script>
-      async function copyText(elementId, statusId) {
-        const token = document.getElementById(elementId).innerText;
-        const status = document.getElementById(statusId);
-        try {
-          if (navigator.clipboard && window.isSecureContext) {
-            await navigator.clipboard.writeText(token);
-          } else {
-            const temp = document.createElement('textarea');
-            temp.value = token;
-            temp.setAttribute('readonly', '');
-            temp.style.position = 'absolute';
-            temp.style.left = '-9999px';
-            document.body.appendChild(temp);
-            temp.select();
-            document.execCommand('copy');
-            document.body.removeChild(temp);
-          }
-          status.textContent = 'Copied!';
-          setTimeout(() => { status.textContent = ''; }, 1800);
-        } catch (err) {
-          status.textContent = 'Copy failed — select manually';
-          setTimeout(() => { status.textContent = ''; }, 2500);
-        }
-      }
-    </script>
+    <script src="/callback-copy.js" defer></script>
   </head>
   <body>
     <h1>eBay account connected ✓</h1>
@@ -936,21 +1132,21 @@ async function handleOAuthCallback(req, res, serverUrl) {
     <h2>① Session token — paste as Bearer token in your MCP client</h2>
     <div class="card">
       <pre id="session-token">${htmlEscape(session.sessionToken)}</pre>
-      <button class="copy-btn" onclick="copyText('session-token','st-status')">Copy</button><span id="st-status" class="copy-status"></span>
+      <button class="copy-btn" data-copy-source="session-token" data-copy-status="st-status">Copy</button><span id="st-status" class="copy-status"></span>
       <p class="muted">Set as <code>EBAY_SESSION_TOKEN</code> in your server env to survive restarts.</p>
     </div>
 
     <h2>② eBay user access token</h2>
     <div class="card">
       <pre id="access-token">${htmlEscape(tokenData.access_token)}</pre>
-      <button class="copy-btn" onclick="copyText('access-token','at-status')">Copy</button><span id="at-status" class="copy-status"></span>
+      <button class="copy-btn" data-copy-source="access-token" data-copy-status="at-status">Copy</button><span id="at-status" class="copy-status"></span>
       <p class="muted">Set as <code>EBAY_USER_ACCESS_TOKEN</code> in your server env (optional — auto-refreshed from refresh token).</p>
     </div>
 
     <h2>③ eBay user refresh token</h2>
     <div class="card">
       <pre id="refresh-token">${htmlEscape(tokenData.refresh_token ?? '')}</pre>
-      <button class="copy-btn" onclick="copyText('refresh-token','rt-status')">Copy</button><span id="rt-status" class="copy-status"></span>
+      <button class="copy-btn" data-copy-source="refresh-token" data-copy-status="rt-status">Copy</button><span id="rt-status" class="copy-status"></span>
       <p class="muted">Set as <code>EBAY_USER_REFRESH_TOKEN</code> in your server env. The server uses this to keep the access token fresh automatically.</p>
     </div>
 

package/build/tools/chat-tools.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export const chatGptTools = [
+    {
+        name: 'search',
+        description: 'Search for eBay inventory items',
+        inputSchema: {
+            query: z.string().describe('Search query'),
+            limit: z.number().optional().describe('Maximum number of results'),
+        },
+        title: 'Search',
+        outputSchema: {
+            type: 'object',
+            properties: {
+                success: { type: 'boolean' },
+                data: { type: 'object' },
+            },
+        },
+        annotations: {
+            title: 'Search',
+            readOnlyHint: true,
+        },
+        _meta: {
+            category: 'chat',
+            version: '1.0.0',
+        },
+    },
+    {
+        name: 'fetch',
+        description: 'Fetch a specific eBay inventory item by SKU',
+        inputSchema: {
+            id: z.string().describe('Item SKU'),
+        },
+        title: 'Fetch',
+        outputSchema: {
+            type: 'object',
+            properties: {
+                success: { type: 'boolean' },
+                data: { type: 'object' },
+            },
+        },
+        annotations: {
+            title: 'Fetch',
+            readOnlyHint: true,
+        },
+        _meta: {
+            category: 'chat',
+            version: '1.0.0',
+        },
+    },
+];

package/build/tools/index.js

@@ -1,6 +1,6 @@
 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 { chatGptTools } from '../tools/chat-tools.js';
 import { getApiStatusFeed } from '../utils/api-status-feed.js';
 import { convertToTimestamp, validateTokenExpiry } from '../utils/date-converter.js';
 // Import Zod schemas for input validation
@@ -196,7 +196,7 @@ export async function executeTool(api, toolName, args) {
                 };
             }
             catch (error) {
-                throw new Error(`Failed to convert date: ${error instanceof Error ? error.message : String(error)}`);
+                throw new Error(`Failed to convert date: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
             }
         }
         case 'ebay_validate_token_expiry': {
@@ -217,7 +217,7 @@ export async function executeTool(api, toolName, args) {
                 };
             }
             catch (error) {
-                throw new Error(`Failed to validate token expiry: ${error instanceof Error ? error.message : String(error)}`);
+                throw new Error(`Failed to validate token expiry: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
             }
         }
         case 'ebay_set_user_tokens_with_expiry': {
@@ -272,7 +272,7 @@ export async function executeTool(api, toolName, args) {
                 };
             }
             catch (error) {
-                throw new Error(`Failed to set user tokens: ${error instanceof Error ? error.message : String(error)}`);
+                throw new Error(`Failed to set user tokens: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
             }
         }
         case 'ebay_display_credentials': {
@@ -370,7 +370,7 @@ export async function executeTool(api, toolName, args) {
                 };
             }
             catch (error) {
-                throw new Error(`Failed to exchange authorization code: ${error instanceof Error ? error.message : String(error)}`);
+                throw new Error(`Failed to exchange authorization code: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
             }
         }
         case 'ebay_refresh_access_token': {
@@ -401,7 +401,7 @@ export async function executeTool(api, toolName, args) {
                 };
             }
             catch (error) {
-                throw new Error(`Failed to refresh access token: ${error instanceof Error ? error.message : String(error)}`);
+                throw new Error(`Failed to refresh access token: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
             }
         }
         // Account Management
@@ -966,8 +966,33 @@ export async function executeTool(api, toolName, args) {
         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);
+            // The MCP tool definition wraps inputs inside a `destination` field:
+            // { destination: { name, endpoint, verificationToken } }
+            // eBay API expects: { name, status, deliveryConfig: { endpoint, verificationToken } }
+            const dest = args.destination;
+            if (dest) {
+                const { name, endpoint, verificationToken, status } = dest;
+                const ebayPayload = {
+                    name,
+                    status: status ?? 'ENABLED',
+                    deliveryConfig: { endpoint, verificationToken },
+                };
+                return await api.notification.createDestination(ebayPayload);
+            }
+            else {
+                // Fallback: legacy flat delivery_config format
+                const validated = createDestinationSchema.parse(args);
+                const { delivery_config, name, status } = validated;
+                const ebayPayload = {
+                    name,
+                    status: status ?? 'ENABLED',
+                    deliveryConfig: {
+                        endpoint: delivery_config?.endpoint,
+                        verificationToken: delivery_config?.verification_token,
+                    },
+                };
+                return await api.notification.createDestination(ebayPayload);
+            }
         }
         case 'ebay_get_notification_destination': {
             const validated = getDestinationSchema.parse(args);
@@ -987,7 +1012,23 @@ export async function executeTool(api, toolName, args) {
         }
         case 'ebay_create_notification_subscription': {
             const validated = createSubscriptionSchema.parse(args);
-            return await api.notification.createSubscription(validated);
+            // Convert snake_case to camelCase for eBay API
+            const subPayload = {};
+            if (validated.destination_id !== undefined)
+                subPayload.destinationId = validated.destination_id;
+            if (validated.status !== undefined)
+                subPayload.status = validated.status;
+            if (validated.topic_id !== undefined)
+                subPayload.topicId = validated.topic_id;
+            if (validated.payload !== undefined) {
+                const p = validated.payload;
+                subPayload.payload = {
+                    ...(p.delivery_protocol !== undefined && { deliveryProtocol: p.delivery_protocol }),
+                    ...(p.format !== undefined && { format: p.format }),
+                    ...(p.schema_version !== undefined && { schemaVersion: p.schema_version }),
+                };
+            }
+            return await api.notification.createSubscription(subPayload);
         }
         case 'ebay_get_notification_subscription': {
             const validated = getSubscriptionSchema.parse(args);

package/build/utils/version.js

@@ -16,7 +16,7 @@ export function getPackageJson() {
         return cachedPackageJson;
     }
     catch {
-        return { name: 'ebay-mcp-remote-edition', version: '1.0.0' };
+        return { name: 'ebay-mcp-remote-edition', version: '3.1.2' };
     }
 }
 export function getVersion() {

package/build/validation/providers/chart.js

@@ -0,0 +1,3 @@
+export function getChartValidationSignals(_request) {
+    return {};
+}