ebay-mcp-remote-edition 3.1.2 → 3.2.0

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
@@ -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 {};
+}

package/build/validation/providers/ebay-sold.js

@@ -0,0 +1,171 @@
+import axios from 'axios';
+function round(value) {
+    return Math.round(value * 100) / 100;
+}
+function normalizePrice(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return round(value);
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value.replace(/[^0-9.-]+/g, ''));
+        if (Number.isFinite(parsed)) {
+            return round(parsed);
+        }
+    }
+    return null;
+}
+function buildSoldKeywords(request) {
+    const parts = new Set();
+    const push = (values) => {
+        for (const value of values) {
+            const normalized = value.trim();
+            if (normalized) {
+                parts.add(normalized);
+            }
+        }
+    };
+    push([request.item.name]);
+    push(request.item.canonicalArtists.slice(0, 2));
+    push(request.item.relatedAlbums.slice(0, 1));
+    push(request.item.variation.slice(0, 2));
+    push([request.validation.validationType]);
+    return Array.from(parts).join(' ').replace(/\s+/g, ' ').trim();
+}
+function parseSoldDate(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = new Date(value);
+    if (Number.isFinite(parsed.getTime())) {
+        return parsed.toISOString();
+    }
+    return null;
+}
+function normalizeProducts(products) {
+    return (products ?? []).slice(0, 10).map((product) => ({
+        title: product.title?.trim() ?? 'Untitled sold listing',
+        soldAt: parseSoldDate(product.date_sold),
+        priceUsd: normalizePrice(product.sale_price),
+        itemUrl: typeof product.link === 'string' ? product.link : null,
+    }));
+}
+function bucketSoldVelocity(soldItemsSample, requestTimestamp) {
+    const requestDate = new Date(requestTimestamp);
+    if (!Number.isFinite(requestDate.getTime())) {
+        return {
+            day1Sold: null,
+            day2Sold: null,
+            day3Sold: null,
+            day4Sold: null,
+            day5Sold: null,
+            daysTracked: null,
+        };
+    }
+    const buckets = [0, 0, 0, 0, 0];
+    let maxTrackedDay = 0;
+    for (const item of soldItemsSample) {
+        if (!item.soldAt) {
+            continue;
+        }
+        const soldDate = new Date(item.soldAt);
+        if (!Number.isFinite(soldDate.getTime()) || soldDate.getTime() > requestDate.getTime()) {
+            continue;
+        }
+        const diffDays = Math.floor((requestDate.getTime() - soldDate.getTime()) / (24 * 60 * 60 * 1000));
+        if (diffDays >= 0 && diffDays < 5) {
+            buckets[diffDays] += 1;
+            maxTrackedDay = Math.max(maxTrackedDay, diffDays + 1);
+        }
+    }
+    return {
+        day1Sold: buckets[0],
+        day2Sold: buckets[1],
+        day3Sold: buckets[2],
+        day4Sold: buckets[3],
+        day5Sold: buckets[4],
+        daysTracked: maxTrackedDay > 0 ? maxTrackedDay : null,
+    };
+}
+function scoreSoldConfidence(soldResultsCount, soldItemsSample) {
+    const datedItems = soldItemsSample.filter((item) => item.soldAt !== null).length;
+    if ((soldResultsCount ?? 0) >= 20 && datedItems >= 3) {
+        return 'High';
+    }
+    if ((soldResultsCount ?? 0) >= 8) {
+        return 'Medium';
+    }
+    return 'Low';
+}
+function createEmptySoldSignals(query, status, errorMessage) {
+    return {
+        provider: 'third_party_sold_api',
+        confidence: 'Low',
+        soldResultsCount: null,
+        soldAveragePriceUsd: null,
+        soldMedianPriceUsd: null,
+        soldMinPriceUsd: null,
+        soldMaxPriceUsd: null,
+        soldItemsSample: [],
+        soldVelocity: {
+            day1Sold: null,
+            day2Sold: null,
+            day3Sold: null,
+            day4Sold: null,
+            day5Sold: null,
+            daysTracked: null,
+        },
+        query,
+        responseUrl: null,
+        status,
+        ...(errorMessage ? { errorMessage } : {}),
+    };
+}
+export async function getEbaySoldValidationSignals(request) {
+    const soldApiUrl = process.env.SOLD_ITEMS_API_URL?.trim();
+    const soldApiKey = process.env.SOLD_ITEMS_API_KEY?.trim();
+    const query = buildSoldKeywords(request);
+    if (!soldApiUrl || !soldApiKey || !query) {
+        return createEmptySoldSignals(query, 'unavailable');
+    }
+    try {
+        const endpoint = soldApiUrl.endsWith('/findCompletedItems')
+            ? soldApiUrl
+            : `${soldApiUrl.replace(/\/$/, '')}/findCompletedItems`;
+        const host = new URL(endpoint).host;
+        const response = await axios.post(endpoint, {
+            keywords: query,
+            excluded_keywords: 'set lot bundle photocard fanmade replica unofficial',
+            max_search_results: 120,
+            remove_outliers: true,
+            site_id: '0',
+        }, {
+            timeout: 30000,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-rapidapi-key': soldApiKey,
+                'x-rapidapi-host': host,
+            },
+        });
+        const data = response.data;
+        const soldItemsSample = normalizeProducts(data.products);
+        const soldVelocity = bucketSoldVelocity(soldItemsSample, request.timestamp);
+        const soldResultsCount = typeof data.results === 'number' && Number.isFinite(data.results) ? data.results : null;
+        return {
+            provider: 'third_party_sold_api',
+            confidence: scoreSoldConfidence(soldResultsCount, soldItemsSample),
+            soldResultsCount,
+            soldAveragePriceUsd: normalizePrice(data.average_price),
+            soldMedianPriceUsd: normalizePrice(data.median_price),
+            soldMinPriceUsd: normalizePrice(data.min_price),
+            soldMaxPriceUsd: normalizePrice(data.max_price),
+            soldItemsSample,
+            soldVelocity,
+            query,
+            responseUrl: typeof data.response_url === 'string' ? data.response_url : null,
+            status: data.success === false ? 'error' : 'ok',
+        };
+    }
+    catch (error) {
+        return createEmptySoldSignals(query, 'error', error instanceof Error ? error.message : String(error));
+    }
+}

package/build/validation/providers/ebay.js

@@ -0,0 +1,112 @@
+import { getBaseUrl } from '../../config/environment.js';
+function round(value) {
+    return Math.round(value * 100) / 100;
+}
+function buildQueryTerms(request) {
+    const terms = new Set();
+    const addTerms = (values, maxTerms = values.length) => {
+        for (const value of values) {
+            if (!value)
+                continue;
+            const normalized = value.trim();
+            if (!normalized)
+                continue;
+            terms.add(normalized);
+            if (terms.size >= maxTerms) {
+                break;
+            }
+        }
+    };
+    addTerms([request.item.name], 1);
+    addTerms(request.item.canonicalArtists, 3);
+    addTerms(request.item.relatedAlbums, 5);
+    addTerms(request.item.variation, 7);
+    addTerms([request.validation.validationType], 8);
+    return Array.from(terms);
+}
+export function buildEbayValidationQuery(request) {
+    return buildQueryTerms(request).join(' ').replace(/\s+/g, ' ').trim();
+}
+function deriveTrend(current, previous, fallback) {
+    if (current === null || previous === null || previous <= 0) {
+        return fallback || 'Stable';
+    }
+    const deltaRatio = (current - previous) / previous;
+    if (deltaRatio >= 0.08)
+        return 'Rising';
+    if (deltaRatio <= -0.08)
+        return 'Falling';
+    return 'Stable';
+}
+function median(values) {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+    return sorted[middle];
+}
+export async function getEbayValidationSignals(api, request) {
+    const ebayQuery = buildEbayValidationQuery(request);
+    const fallbackTrend = request.validation.currentMetrics.marketPriceTrend || 'Stable';
+    const emptyResult = {
+        avgWatchersPerListing: null,
+        preOrderListingsCount: null,
+        marketPriceUsd: null,
+        avgShippingCostUsd: null,
+        competitionLevel: null,
+        marketPriceTrend: fallbackTrend,
+        ebayQuery,
+        sampleSize: 0,
+        soldVelocity: {
+            day1Sold: request.validation.currentMetrics.day1Sold,
+            day2Sold: request.validation.currentMetrics.day2Sold,
+            day3Sold: request.validation.currentMetrics.day3Sold,
+            day4Sold: request.validation.currentMetrics.day4Sold,
+            day5Sold: request.validation.currentMetrics.day5Sold,
+            daysTracked: request.validation.currentMetrics.daysTracked,
+        },
+    };
+    if (!ebayQuery) {
+        return emptyResult;
+    }
+    try {
+        const environment = api.getAuthClient().getConfig().environment;
+        const browseUrl = `${getBaseUrl(environment)}/buy/browse/v1/item_summary/search`;
+        const response = await api.getAuthClient().getWithFullUrl(browseUrl, {
+            q: ebayQuery,
+            limit: 25,
+            sort: 'newlyListed',
+        });
+        const itemSummaries = response.itemSummaries ?? [];
+        const prices = itemSummaries
+            .map((item) => Number(item.price?.value ?? Number.NaN))
+            .filter((value) => Number.isFinite(value) && value > 0);
+        const shipping = itemSummaries
+            .map((item) => Number(item.shippingOptions?.[0]?.shippingCost?.value ?? Number.NaN))
+            .filter((value) => Number.isFinite(value) && value >= 0);
+        const marketPriceUsd = median(prices);
+        const avgShippingCostUsd = shipping.length > 0
+            ? shipping.reduce((sum, value) => sum + value, 0) / shipping.length
+            : null;
+        const totalListings = typeof response.total === 'number' && Number.isFinite(response.total)
+            ? response.total
+            : itemSummaries.length;
+        return {
+            avgWatchersPerListing: null,
+            preOrderListingsCount: totalListings,
+            marketPriceUsd: marketPriceUsd === null ? null : round(marketPriceUsd),
+            avgShippingCostUsd: avgShippingCostUsd === null ? null : round(avgShippingCostUsd),
+            competitionLevel: totalListings,
+            marketPriceTrend: deriveTrend(marketPriceUsd, request.validation.currentMetrics.marketPriceUsd, fallbackTrend),
+            ebayQuery,
+            sampleSize: itemSummaries.length,
+            soldVelocity: emptyResult.soldVelocity,
+        };
+    }
+    catch {
+        return emptyResult;
+    }
+}

package/build/validation/providers/social.js

@@ -0,0 +1,7 @@
+export function getSocialValidationSignals(_request) {
+    return {
+        twitterTrending: false,
+        youtubeViews24hMillions: null,
+        redditPostsCount7d: null,
+    };
+}

package/build/validation/recommendation.js

@@ -0,0 +1,84 @@
+function addHours(timestamp, hours) {
+    return new Date(new Date(timestamp).getTime() + hours * 60 * 60 * 1000).toISOString();
+}
+export function buildValidationRecommendation(request, signals) {
+    const dDay = request.validation.dDay;
+    const baseCadence = typeof dDay === 'number' && dDay >= -3 && dDay <= 3 ? 'Hourly' : 'Daily';
+    const shouldAutoTrack = request.validation.autoCheckEnabled &&
+        request.validation.automationStatus === 'Watching' &&
+        request.validation.buyDecision === 'Watching';
+    const trackingCadence = shouldAutoTrack ? baseCadence : 'Off';
+    const nextCheckAt = !shouldAutoTrack
+        ? null
+        : trackingCadence === 'Hourly'
+            ? addHours(request.timestamp, 1)
+            : addHours(request.timestamp, 24);
+    const marketPrice = signals.sold.soldMedianPriceUsd ?? signals.ebay.marketPriceUsd;
+    const wholesale = request.item.wholesalePrice;
+    const marginRatio = marketPrice !== null && wholesale !== null && wholesale > 0
+        ? (marketPrice - wholesale) / wholesale
+        : null;
+    const recentSoldCount = [
+        signals.sold.soldVelocity.day1Sold,
+        signals.sold.soldVelocity.day2Sold,
+        signals.sold.soldVelocity.day3Sold,
+    ].reduce((sum, value) => sum + (value ?? 0), 0);
+    let latestAiRecommendation = 'Continue watching until stronger market signal appears.';
+    let latestAiConfidence = 'Medium';
+    let monitoringNotes = 'Baseline recommendation generated from current validation state.';
+    if (!shouldAutoTrack) {
+        latestAiRecommendation =
+            'Automatic tracking paused because the validation is no longer in a watchable state.';
+        latestAiConfidence = 'High';
+        monitoringNotes =
+            'Stop conditions were met, so automation will not schedule another validation run.';
+    }
+    else if (marginRatio !== null &&
+        marginRatio >= 1 &&
+        signals.ebay.preOrderListingsCount !== null &&
+        signals.ebay.preOrderListingsCount >= 25) {
+        latestAiRecommendation =
+            'Demand and pricing look constructive. Continue tracking closely and be ready to upgrade from watch status if sell-through strengthens.';
+        latestAiConfidence = 'High';
+        monitoringNotes =
+            'Healthy active-listing volume and strong projected margin support continued monitoring.';
+        if (signals.sold.soldMedianPriceUsd !== null) {
+            monitoringNotes =
+                'Healthy active-listing volume and sold comparables support continued monitoring without yet forcing a buy-state change.';
+        }
+    }
+    else if (signals.sold.soldMedianPriceUsd !== null &&
+        recentSoldCount > 0 &&
+        signals.sold.confidence !== 'Low') {
+        latestAiRecommendation =
+            'Recent sold comparables support real resale demand. Continue watching closely while waiting for a stronger conviction signal.';
+        latestAiConfidence = signals.sold.confidence === 'High' ? 'High' : 'Medium';
+        monitoringNotes =
+            'Sold-item data confirms recent transaction activity, improving confidence while remaining conservative on buy-state changes.';
+    }
+    else if (signals.sold.soldMedianPriceUsd !== null) {
+        latestAiRecommendation =
+            'Sold comps are available, but sample depth is still limited. Keep monitoring until resale momentum becomes clearer.';
+        latestAiConfidence = 'Medium';
+        monitoringNotes =
+            'Temporary sold-provider data is present, but sample depth is not yet strong enough to justify an automatic buy-decision change.';
+    }
+    else if (signals.social.youtubeViews24hMillions !== null ||
+        signals.social.redditPostsCount7d !== null) {
+        latestAiRecommendation =
+            'Demand signals are mixed. Keep monitoring until eBay pricing and social momentum become more decisive.';
+        latestAiConfidence = 'Medium';
+        monitoringNotes =
+            'Cross-channel activity exists, but the combined signal is not strong enough for an automatic buy change.';
+    }
+    return {
+        buyDecision: request.validation.buyDecision,
+        automationStatus: shouldAutoTrack ? 'Watching' : 'Paused',
+        trackingCadence,
+        shouldAutoTrack,
+        nextCheckAt,
+        latestAiRecommendation,
+        latestAiConfidence,
+        monitoringNotes,
+    };
+}

package/build/validation/run-validation.js

@@ -0,0 +1,140 @@
+import { validationRunRequestSchema } from './schemas.js';
+import { getEbayValidationSignals } from './providers/ebay.js';
+import { getEbaySoldValidationSignals } from './providers/ebay-sold.js';
+import { getSocialValidationSignals } from './providers/social.js';
+import { getChartValidationSignals } from './providers/chart.js';
+import { buildValidationRecommendation } from './recommendation.js';
+function addMinutes(timestamp, minutes) {
+    return new Date(new Date(timestamp).getTime() + minutes * 60 * 1000).toISOString();
+}
+function mapErrorCode(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/refresh|authorization expired|access token|token/i.test(message)) {
+        return 'EBAY_AUTH_FAILED';
+    }
+    return 'VALIDATION_RUN_FAILED';
+}
+function getValidationId(input) {
+    if (typeof input === 'object' &&
+        input !== null &&
+        'validationId' in input &&
+        typeof input.validationId === 'string') {
+        return input.validationId;
+    }
+    return '';
+}
+function buildProviderDebug(ebay, sold, social, chart) {
+    return {
+        ebay: {
+            status: ebay.sampleSize > 0 ? 'ok' : 'partial',
+            confidence: ebay.sampleSize >= 10 ? 'medium' : 'low',
+            sampleSize: ebay.sampleSize,
+            hasMarketPrice: ebay.marketPriceUsd !== null,
+            hasShipping: ebay.avgShippingCostUsd !== null,
+            hasWatchers: ebay.avgWatchersPerListing !== null,
+        },
+        sold: {
+            status: sold.status,
+            provider: sold.provider,
+            confidence: sold.confidence.toLowerCase(),
+            results: sold.soldResultsCount,
+            hasMedianPrice: sold.soldMedianPriceUsd !== null,
+            hasVelocity: sold.soldVelocity.daysTracked !== null,
+        },
+        social: {
+            status: 'stub',
+            confidence: 'low',
+            hasSignals: social.twitterTrending ||
+                social.youtubeViews24hMillions !== null ||
+                social.redditPostsCount7d !== null,
+        },
+        chart: {
+            status: 'stub',
+            confidence: 'low',
+            hasSignals: Object.keys(chart).length > 0,
+        },
+    };
+}
+export async function runValidation(api, input) {
+    let request;
+    try {
+        request = validationRunRequestSchema.parse(input);
+    }
+    catch (error) {
+        return {
+            status: 'error',
+            validationId: getValidationId(input),
+            errorCode: 'VALIDATION_REQUEST_INVALID',
+            message: error instanceof Error ? error.message : String(error),
+            retryable: false,
+            nextCheckAt: null,
+        };
+    }
+    try {
+        const ebay = await getEbayValidationSignals(api, request);
+        const sold = await getEbaySoldValidationSignals(request);
+        const social = getSocialValidationSignals(request);
+        const chart = getChartValidationSignals(request);
+        const marketPriceUsd = sold.soldMedianPriceUsd ?? ebay.marketPriceUsd;
+        const soldVelocity = {
+            day1Sold: sold.soldVelocity.day1Sold ?? ebay.soldVelocity.day1Sold,
+            day2Sold: sold.soldVelocity.day2Sold ?? ebay.soldVelocity.day2Sold,
+            day3Sold: sold.soldVelocity.day3Sold ?? ebay.soldVelocity.day3Sold,
+            day4Sold: sold.soldVelocity.day4Sold ?? ebay.soldVelocity.day4Sold,
+            day5Sold: sold.soldVelocity.day5Sold ?? ebay.soldVelocity.day5Sold,
+            daysTracked: sold.soldVelocity.daysTracked ?? ebay.soldVelocity.daysTracked,
+        };
+        const recommendation = buildValidationRecommendation(request, { ebay, sold, social, chart });
+        const mergedSignals = { ebay, sold, social, chart };
+        return {
+            status: 'ok',
+            validationId: request.validationId,
+            writes: {
+                avgWatchersPerListing: ebay.avgWatchersPerListing,
+                preOrderListingsCount: ebay.preOrderListingsCount,
+                twitterTrending: social.twitterTrending,
+                youtubeViews24hMillions: social.youtubeViews24hMillions,
+                redditPostsCount7d: social.redditPostsCount7d,
+                marketPriceUsd,
+                avgShippingCostUsd: ebay.avgShippingCostUsd,
+                competitionLevel: ebay.competitionLevel,
+                marketPriceTrend: ebay.marketPriceTrend,
+                day1Sold: soldVelocity.day1Sold,
+                day2Sold: soldVelocity.day2Sold,
+                day3Sold: soldVelocity.day3Sold,
+                day4Sold: soldVelocity.day4Sold,
+                day5Sold: soldVelocity.day5Sold,
+                daysTracked: soldVelocity.daysTracked,
+                monitoringNotes: recommendation.monitoringNotes,
+                lastDataSnapshot: JSON.stringify(mergedSignals),
+                latestAiRecommendation: recommendation.latestAiRecommendation,
+                latestAiConfidence: recommendation.latestAiConfidence,
+                validationError: '',
+            },
+            decision: {
+                buyDecision: recommendation.buyDecision,
+                automationStatus: recommendation.automationStatus,
+                trackingCadence: recommendation.trackingCadence,
+                shouldAutoTrack: recommendation.shouldAutoTrack,
+                nextCheckAt: recommendation.nextCheckAt,
+            },
+            debug: {
+                ebayQuery: ebay.ebayQuery,
+                soldQuery: sold.query,
+                sampleSize: ebay.sampleSize,
+                sourceSet: ['ebay', 'sold', 'social', 'chart'],
+                providers: buildProviderDebug(ebay, sold, social, chart),
+            },
+        };
+    }
+    catch (error) {
+        return {
+            status: 'error',
+            validationId: request.validationId,
+            errorCode: mapErrorCode(error),
+            message: error instanceof Error ? error.message : String(error),
+            retryable: true,
+            nextCheckAt: addMinutes(request.timestamp, 30),
+        };
+    }
+}