@ucptools/validator 1.0.0 → 1.0.1

package/{src/simulator/agent-simulator.ts → dist/simulator/agent-simulator.js}

@@ -1,941 +1,650 @@
-/**
- * AI Agent Simulator
- * Simulates how an AI agent discovers and interacts with UCP-enabled merchants
- * 
- * The goal is to test real-world functionality, not just spec compliance.
- * This proves that a UCP implementation actually works for AI agent commerce.
- */
-
-import type { UcpProfile, UcpCapability, UcpService } from '../types/ucp-profile.js';
-import type {
-    AgentSimulationResult,
-    SimulationOptions,
-    SimulationStepResult,
-    SimulationStepStatus,
-    DiscoveryFlowResult,
-    CapabilityInspectionResult,
-    ServiceInspectionResult,
-    RestApiSimulationResult,
-    CheckoutSimulationResult,
-    PaymentReadinessResult,
-    OperationTestResult,
-    DEFAULT_SIMULATION_OPTIONS,
-} from './types.js';
-
-const DEFAULT_TIMEOUT_MS = 30000;
-const DEFAULT_FETCH_TIMEOUT_MS = 10000;
-
-/**
- * Normalize capability to extract the name string
- * Handles both string format and object format capabilities
- */
-function getCapabilityName(cap: unknown): string {
-    if (typeof cap === 'string') {
-        return cap;
-    }
-    if (cap && typeof cap === 'object' && 'name' in cap) {
-        return String((cap as { name: unknown }).name);
-    }
-    return '';
-}
-
-/**
- * Get capability object (for accessing schema, version, etc.)
- * Returns null for string-only capabilities
- */
-function getCapabilityObject(cap: unknown): UcpCapability | null {
-    if (cap && typeof cap === 'object' && 'name' in cap) {
-        return cap as UcpCapability;
-    }
-    return null;
-}
-
-/**
- * Step builder helper
- */
-function createStep(
-    step: string,
-    status: SimulationStepStatus,
-    message: string,
-    details?: string,
-    durationMs?: number,
-    data?: Record<string, unknown>
-): SimulationStepResult {
-    return { step, status, message, details, durationMs, data };
-}
-
-/**
- * Fetch with timeout
- */
-async function fetchWithTimeout(
-    url: string,
-    timeoutMs: number = DEFAULT_FETCH_TIMEOUT_MS
-): Promise<{ ok: boolean; status?: number; data?: unknown; error?: string }> {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-
-    try {
-        const response = await fetch(url, {
-            signal: controller.signal,
-            headers: {
-                'User-Agent': 'UCP-Agent-Simulator/1.0',
-                'Accept': 'application/json',
-            },
-        });
-
-        clearTimeout(timeoutId);
-
-        if (!response.ok) {
-            return { ok: false, status: response.status, error: `HTTP ${response.status}` };
-        }
-
-        const contentType = response.headers.get('content-type') || '';
-        if (contentType.includes('application/json')) {
-            const data = await response.json();
-            return { ok: true, status: response.status, data };
-        }
-
-        return { ok: true, status: response.status };
-    } catch (error) {
-        clearTimeout(timeoutId);
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        return { ok: false, error: message };
-    }
-}
-
-/**
- * HEAD request to check endpoint responsiveness
- */
-async function checkEndpointResponsive(
-    url: string,
-    timeoutMs: number = DEFAULT_FETCH_TIMEOUT_MS
-): Promise<{ ok: boolean; status?: number; error?: string }> {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-
-    try {
-        const response = await fetch(url, {
-            method: 'HEAD',
-            signal: controller.signal,
-            headers: {
-                'User-Agent': 'UCP-Agent-Simulator/1.0',
-            },
-        });
-
-        clearTimeout(timeoutId);
-        // Accept various success codes - we just want to know endpoint exists
-        return { ok: response.status < 500, status: response.status };
-    } catch (error) {
-        clearTimeout(timeoutId);
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        return { ok: false, error: message };
-    }
-}
-
-/**
- * Simulate discovery flow - how an AI agent discovers a UCP merchant
- */
-export async function simulateDiscoveryFlow(
-    domain: string,
-    timeoutMs: number = DEFAULT_FETCH_TIMEOUT_MS
-): Promise<DiscoveryFlowResult> {
-    const steps: SimulationStepResult[] = [];
-    let profileUrl: string | undefined;
-    let profile: UcpProfile | null = null;
-    const capabilities: string[] = [];
-    const services: string[] = [];
-    const transports: string[] = [];
-
-    // Step 1: Try to fetch /.well-known/ucp
-    const startTime = Date.now();
-    const urls = [
-        `https://${domain}/.well-known/ucp`,
-        `https://${domain}/.well-known/ucp.json`,
-    ];
-
-    let foundProfile = false;
-    for (const url of urls) {
-        const fetchStart = Date.now();
-        const result = await fetchWithTimeout(url, timeoutMs);
-        const fetchDuration = Date.now() - fetchStart;
-
-        if (result.ok && result.data && typeof result.data === 'object') {
-            const data = result.data as Record<string, unknown>;
-            if (data.ucp) {
-                profile = data as UcpProfile;
-                profileUrl = url;
-                foundProfile = true;
-                steps.push(createStep(
-                    'discover_profile',
-                    'passed',
-                    `Found UCP profile at ${url}`,
-                    `Response time: ${fetchDuration}ms`,
-                    fetchDuration,
-                    { url, responseTime: fetchDuration }
-                ));
-                break;
-            }
-        }
-    }
-
-    if (!foundProfile) {
-        steps.push(createStep(
-            'discover_profile',
-            'failed',
-            'Could not find UCP profile',
-            `Tried: ${urls.join(', ')}`
-        ));
-        return { success: false, steps, capabilities, services, transports };
-    }
-
-    // Step 2: Parse UCP version
-    if (profile?.ucp?.version) {
-        steps.push(createStep(
-            'parse_version',
-            'passed',
-            `UCP version: ${profile.ucp.version}`,
-            undefined,
-            undefined,
-            { version: profile.ucp.version }
-        ));
-    } else {
-        steps.push(createStep(
-            'parse_version',
-            'failed',
-            'Missing UCP version',
-            'AI agent cannot determine protocol version'
-        ));
-    }
-
-    // Step 3: Enumerate services
-    const serviceEntries = Object.entries(profile?.ucp?.services || {});
-    if (serviceEntries.length > 0) {
-        for (const [serviceName, service] of serviceEntries) {
-            services.push(serviceName);
-
-            // Track transports
-            if ((service as UcpService).rest) transports.push('rest');
-            if ((service as UcpService).mcp) transports.push('mcp');
-            if ((service as UcpService).a2a) transports.push('a2a');
-            if ((service as UcpService).embedded) transports.push('embedded');
-        }
-
-        steps.push(createStep(
-            'enumerate_services',
-            'passed',
-            `Found ${serviceEntries.length} service(s): ${services.join(', ')}`,
-            `Available transports: ${[...new Set(transports)].join(', ')}`,
-            undefined,
-            { services, transports: [...new Set(transports)] }
-        ));
-    } else {
-        steps.push(createStep(
-            'enumerate_services',
-            'failed',
-            'No services found',
-            'AI agent has no entry point for commerce operations'
-        ));
-    }
-
-    // Step 4: Enumerate capabilities
-    const capList = profile?.ucp?.capabilities || [];
-    if (capList.length > 0) {
-        for (const cap of capList) {
-            const capName = getCapabilityName(cap);
-            if (capName) capabilities.push(capName);
-        }
-
-        // Check for required checkout capability
-        const hasCheckout = capabilities.some(c => c && c.includes('checkout'));
-        const hasOrder = capabilities.some(c => c && c.includes('order'));
-
-        steps.push(createStep(
-            'enumerate_capabilities',
-            'passed',
-            `Found ${capList.length} capability/ies: ${capabilities.join(', ')}`,
-            hasCheckout ? 'Checkout capability present - commerce ready' : 'No checkout capability - limited commerce support',
-            undefined,
-            { capabilities, hasCheckout, hasOrder }
-        ));
-    } else {
-        steps.push(createStep(
-            'enumerate_capabilities',
-            'warning',
-            'No capabilities declared',
-            'AI agent cannot determine supported operations'
-        ));
-    }
-
-    const totalDuration = Date.now() - startTime;
-
-    return {
-        success: foundProfile && serviceEntries.length > 0,
-        steps,
-        profileUrl,
-        capabilities,
-        services,
-        transports: [...new Set(transports)],
-    };
-}
-
-/**
- * Inspect capabilities in detail
- */
-export async function inspectCapabilities(
-    profile: UcpProfile,
-    timeoutMs: number = DEFAULT_FETCH_TIMEOUT_MS
-): Promise<CapabilityInspectionResult[]> {
-    const results: CapabilityInspectionResult[] = [];
-    const capList = profile.ucp?.capabilities || [];
-
-    for (const cap of capList) {
-        const capName = getCapabilityName(cap);
-        const capObj = getCapabilityObject(cap);
-        
-        let schemaAccessible = false;
-        let specAccessible = false;
-
-        // Check schema URL (only for object-format capabilities)
-        if (capObj?.schema) {
-            const schemaResult = await fetchWithTimeout(capObj.schema, timeoutMs);
-            schemaAccessible = schemaResult.ok;
-        }
-
-        // Check spec URL (only for object-format capabilities)
-        if (capObj?.spec) {
-            const specResult = await checkEndpointResponsive(capObj.spec, timeoutMs);
-            specAccessible = specResult.ok;
-        }
-
-        results.push({
-            name: capName,
-            version: capObj?.version || 'unknown',
-            schemaAccessible,
-            specAccessible,
-            isExtension: !!capObj?.extends,
-            parentCapability: capObj?.extends,
-        });
-    }
-
-    return results;
-}
-
-/**
- * Inspect services and their transports
- */
-export async function inspectServices(
-    profile: UcpProfile,
-    timeoutMs: number = DEFAULT_FETCH_TIMEOUT_MS
-): Promise<ServiceInspectionResult[]> {
-    const results: ServiceInspectionResult[] = [];
-    const serviceEntries = Object.entries(profile.ucp?.services || {});
-
-    for (const [name, service] of serviceEntries) {
-        const svc = service as UcpService;
-        const result: ServiceInspectionResult = {
-            name,
-            version: svc.version,
-            transports: {},
-        };
-
-        // Check REST transport
-        if (svc.rest) {
-            const schemaCheck = svc.rest.schema
-                ? await fetchWithTimeout(svc.rest.schema, timeoutMs)
-                : { ok: false };
-            const endpointCheck = await checkEndpointResponsive(svc.rest.endpoint, timeoutMs);
-
-            result.transports.rest = {
-                endpoint: svc.rest.endpoint,
-                schemaAccessible: schemaCheck.ok,
-                endpointResponsive: endpointCheck.ok,
-            };
-        }
-
-        // Check MCP transport
-        if (svc.mcp) {
-            const schemaCheck = svc.mcp.schema
-                ? await fetchWithTimeout(svc.mcp.schema, timeoutMs)
-                : { ok: false };
-
-            result.transports.mcp = {
-                endpoint: svc.mcp.endpoint,
-                schemaAccessible: schemaCheck.ok,
-            };
-        }
-
-        // Check A2A transport
-        if (svc.a2a) {
-            const agentCardCheck = await fetchWithTimeout(svc.a2a.agentCard, timeoutMs);
-
-            result.transports.a2a = {
-                agentCard: svc.a2a.agentCard,
-                agentCardAccessible: agentCardCheck.ok,
-            };
-        }
-
-        results.push(result);
-    }
-
-    return results;
-}
-
-/**
- * Simulate REST API interaction
- */
-export async function simulateRestApi(
-    profile: UcpProfile,
-    timeoutMs: number = DEFAULT_FETCH_TIMEOUT_MS
-): Promise<RestApiSimulationResult> {
-    const steps: SimulationStepResult[] = [];
-    const sampleOperations: OperationTestResult[] = [];
-    let schemaLoaded = false;
-    let endpointAccessible = false;
-
-    // Find REST service
-    const shoppingService = profile.ucp?.services?.['dev.ucp.shopping'] as UcpService | undefined;
-    if (!shoppingService?.rest) {
-        steps.push(createStep(
-            'find_rest_service',
-            'skipped',
-            'No REST service configured',
-            'Merchant may use MCP or A2A transport instead'
-        ));
-        return { success: false, steps, schemaLoaded, endpointAccessible, sampleOperations };
-    }
-
-    // Step 1: Load OpenAPI schema
-    if (shoppingService.rest.schema) {
-        const schemaStart = Date.now();
-        const schemaResult = await fetchWithTimeout(shoppingService.rest.schema, timeoutMs);
-        const schemaDuration = Date.now() - schemaStart;
-
-        if (schemaResult.ok && schemaResult.data) {
-            schemaLoaded = true;
-            const schema = schemaResult.data as Record<string, unknown>;
-
-            steps.push(createStep(
-                'load_openapi_schema',
-                'passed',
-                `Loaded OpenAPI schema from ${shoppingService.rest.schema}`,
-                `Response time: ${schemaDuration}ms`,
-                schemaDuration,
-                { schemaUrl: shoppingService.rest.schema }
-            ));
-
-            // Check for expected paths in schema
-            const paths = schema.paths as Record<string, unknown> | undefined;
-            if (paths) {
-                const pathCount = Object.keys(paths).length;
-                steps.push(createStep(
-                    'analyze_schema_paths',
-                    pathCount > 0 ? 'passed' : 'warning',
-                    `Schema defines ${pathCount} operation path(s)`,
-                    pathCount > 0 ? `Paths: ${Object.keys(paths).slice(0, 5).join(', ')}${pathCount > 5 ? '...' : ''}` : undefined
-                ));
-            }
-        } else {
-            steps.push(createStep(
-                'load_openapi_schema',
-                'failed',
-                'Could not load OpenAPI schema',
-                schemaResult.error || 'Unknown error'
-            ));
-        }
-    } else {
-        steps.push(createStep(
-            'load_openapi_schema',
-            'warning',
-            'No schema URL provided',
-            'AI agent cannot discover available operations'
-        ));
-    }
-
-    // Step 2: Check endpoint responsiveness
-    const endpointStart = Date.now();
-    const endpointResult = await checkEndpointResponsive(shoppingService.rest.endpoint, timeoutMs);
-    const endpointDuration = Date.now() - endpointStart;
-
-    if (endpointResult.ok) {
-        endpointAccessible = true;
-        steps.push(createStep(
-            'check_endpoint',
-            'passed',
-            `REST endpoint responsive: ${shoppingService.rest.endpoint}`,
-            `Status: ${endpointResult.status}, Response time: ${endpointDuration}ms`,
-            endpointDuration
-        ));
-    } else {
-        steps.push(createStep(
-            'check_endpoint',
-            'failed',
-            `REST endpoint not accessible: ${shoppingService.rest.endpoint}`,
-            endpointResult.error || `Status: ${endpointResult.status}`
-        ));
-    }
-
-    return {
-        success: schemaLoaded && endpointAccessible,
-        steps,
-        schemaLoaded,
-        endpointAccessible,
-        sampleOperations,
-    };
-}
-
-/**
- * Simulate checkout flow capability
- */
-export async function simulateCheckoutFlow(
-    profile: UcpProfile,
-    timeoutMs: number = DEFAULT_FETCH_TIMEOUT_MS
-): Promise<CheckoutSimulationResult> {
-    const steps: SimulationStepResult[] = [];
-    let canCreateCheckout = false;
-    let checkoutSchemaValid = false;
-    let orderFlowSupported = false;
-    let fulfillmentSupported = false;
-
-    const capabilities = profile.ucp?.capabilities || [];
-
-    // Check for checkout capability (handle both string and object formats)
-    const checkoutCapRaw = capabilities.find(c => getCapabilityName(c).includes('checkout'));
-    const checkoutCapName = checkoutCapRaw ? getCapabilityName(checkoutCapRaw) : null;
-    const checkoutCapObj = checkoutCapRaw ? getCapabilityObject(checkoutCapRaw) : null;
-    
-    if (checkoutCapName) {
-        canCreateCheckout = true;
-        steps.push(createStep(
-            'find_checkout_capability',
-            'passed',
-            `Found checkout capability: ${checkoutCapName}`,
-            checkoutCapObj?.version ? `Version: ${checkoutCapObj.version}` : 'String-format capability'
-        ));
-
-        // Validate checkout schema (only for object-format capabilities)
-        if (checkoutCapObj?.schema) {
-            const schemaResult = await fetchWithTimeout(checkoutCapObj.schema, timeoutMs);
-            if (schemaResult.ok && schemaResult.data) {
-                checkoutSchemaValid = true;
-                const schema = schemaResult.data as Record<string, unknown>;
-
-                // Check for required checkout properties
-                const properties = (schema.properties || schema.$defs) as Record<string, unknown> | undefined;
-                const hasCheckoutProps = properties && (
-                    properties.checkout_id ||
-                    properties.items ||
-                    properties.CheckoutSession
-                );
-
-                steps.push(createStep(
-                    'validate_checkout_schema',
-                    hasCheckoutProps ? 'passed' : 'warning',
-                    `Checkout schema ${hasCheckoutProps ? 'has expected structure' : 'loaded but structure unclear'}`,
-                    hasCheckoutProps ? 'AI agent can create checkout sessions' : 'Schema may need review'
-                ));
-            } else {
-                steps.push(createStep(
-                    'validate_checkout_schema',
-                    'failed',
-                    'Could not load checkout schema',
-                    schemaResult.error || 'Unknown error'
-                ));
-            }
-        } else {
-            // String-format capability - no schema to validate, mark as valid for basic functionality
-            checkoutSchemaValid = true;
-            steps.push(createStep(
-                'validate_checkout_schema',
-                'info' as SimulationStepStatus,
-                'No schema URL in capability (string format)',
-                'Capability declared but schema validation skipped'
-            ));
-        }
-    } else {
-        steps.push(createStep(
-            'find_checkout_capability',
-            'failed',
-            'No checkout capability found',
-            'AI agent cannot create checkout sessions'
-        ));
-    }
-
-    // Check for order capability
-    const orderCapRaw = capabilities.find(c => getCapabilityName(c).includes('order'));
-    const orderCapName = orderCapRaw ? getCapabilityName(orderCapRaw) : null;
-    if (orderCapName) {
-        orderFlowSupported = true;
-        steps.push(createStep(
-            'find_order_capability',
-            'passed',
-            `Found order capability: ${orderCapName}`,
-            'AI agent can track order status'
-        ));
-    } else {
-        steps.push(createStep(
-            'find_order_capability',
-            'warning',
-            'No order capability found',
-            'Order tracking may not be available'
-        ));
-    }
-
-    // Check for fulfillment capability
-    const fulfillmentCapRaw = capabilities.find(c => getCapabilityName(c).includes('fulfillment'));
-    const fulfillmentCapName = fulfillmentCapRaw ? getCapabilityName(fulfillmentCapRaw) : null;
-    if (fulfillmentCapName) {
-        fulfillmentSupported = true;
-        steps.push(createStep(
-            'find_fulfillment_capability',
-            'passed',
-            `Found fulfillment capability: ${fulfillmentCapName}`,
-            'AI agent can track shipping and delivery'
-        ));
-    } else {
-        steps.push(createStep(
-            'find_fulfillment_capability',
-            'info' as SimulationStepStatus,
-            'No fulfillment capability found',
-            'Fulfillment tracking not available via UCP'
-        ));
-    }
-
-    return {
-        success: canCreateCheckout && checkoutSchemaValid,
-        steps,
-        canCreateCheckout,
-        checkoutSchemaValid,
-        orderFlowSupported,
-        fulfillmentSupported,
-    };
-}
-
-/**
- * Check payment readiness
- */
-export async function simulatePaymentReadiness(
-    profile: UcpProfile,
-    timeoutMs: number = DEFAULT_FETCH_TIMEOUT_MS
-): Promise<PaymentReadinessResult> {
-    const steps: SimulationStepResult[] = [];
-    let handlersFound = 0;
-    let webhookVerifiable = false;
-    let signingKeyValid = false;
-
-    // Check payment handlers
-    const handlers = profile.payment?.handlers || [];
-    handlersFound = handlers.length;
-
-    if (handlersFound > 0) {
-        const handlerNames = handlers.map(h => h.name).join(', ');
-        steps.push(createStep(
-            'find_payment_handlers',
-            'passed',
-            `Found ${handlersFound} payment handler(s): ${handlerNames}`,
-            'AI agent can initiate payments'
-        ));
-
-        // Check handler configs
-        for (const handler of handlers) {
-            if (handler.config_schema) {
-                const schemaResult = await checkEndpointResponsive(handler.config_schema, timeoutMs);
-                steps.push(createStep(
-                    `check_handler_${handler.id}`,
-                    schemaResult.ok ? 'passed' : 'warning',
-                    `Payment handler "${handler.name}" config schema ${schemaResult.ok ? 'accessible' : 'not accessible'}`,
-                    handler.config_schema
-                ));
-            }
-        }
-    } else {
-        steps.push(createStep(
-            'find_payment_handlers',
-            'warning',
-            'No payment handlers configured',
-            'Payment processing may use external flow'
-        ));
-    }
-
-    // Check signing keys for webhook verification
-    const signingKeys = profile.signing_keys;
-    if (signingKeys && Array.isArray(signingKeys) && signingKeys.length > 0) {
-        webhookVerifiable = true;
-
-        // Validate key structure
-        const validKeys = signingKeys.filter(key =>
-            key.kty && key.kid && (
-                (key.kty === 'EC' && key.crv && key.x && key.y) ||
-                (key.kty === 'RSA' && key.n && key.e)
-            )
-        );
-
-        signingKeyValid = validKeys.length > 0;
-
-        steps.push(createStep(
-            'check_signing_keys',
-            signingKeyValid ? 'passed' : 'warning',
-            `Found ${signingKeys.length} signing key(s), ${validKeys.length} valid`,
-            signingKeyValid
-                ? 'AI agent can verify webhook signatures'
-                : 'Signing keys present but may be incomplete'
-        ));
-    } else {
-        steps.push(createStep(
-            'check_signing_keys',
-            'warning',
-            'No signing keys found',
-            'Webhook verification not available'
-        ));
-    }
-
-    return {
-        success: handlersFound > 0 || webhookVerifiable,
-        steps,
-        handlersFound,
-        webhookVerifiable,
-        signingKeyValid,
-    };
-}
-
-/**
- * Generate recommendations based on simulation results
- */
-function generateRecommendations(
-    discovery: DiscoveryFlowResult,
-    capabilities: CapabilityInspectionResult[],
-    services: ServiceInspectionResult[],
-    restApi?: RestApiSimulationResult,
-    checkout?: CheckoutSimulationResult,
-    payment?: PaymentReadinessResult
-): string[] {
-    const recommendations: string[] = [];
-
-    // Discovery issues
-    if (!discovery.success) {
-        recommendations.push('Ensure UCP profile is accessible at /.well-known/ucp');
-    }
-
-    // Service issues
-    if (discovery.services.length === 0) {
-        recommendations.push('Add at least one service (e.g., dev.ucp.shopping) to enable commerce');
-    }
-
-    // Transport issues
-    if (discovery.transports.length === 0) {
-        recommendations.push('Configure at least one transport binding (REST, MCP, or A2A)');
-    }
-
-    // Capability issues
-    const inaccessibleSchemas = capabilities.filter(c => !c.schemaAccessible);
-    if (inaccessibleSchemas.length > 0) {
-        recommendations.push(`Fix inaccessible capability schemas: ${inaccessibleSchemas.map(c => c.name).join(', ')}`);
-    }
-
-    // REST API issues
-    if (restApi && !restApi.schemaLoaded) {
-        recommendations.push('Provide accessible OpenAPI schema for REST service');
-    }
-    if (restApi && !restApi.endpointAccessible) {
-        recommendations.push('Ensure REST endpoint is publicly accessible');
-    }
-
-    // Checkout issues
-    if (checkout && !checkout.canCreateCheckout) {
-        recommendations.push('Add checkout capability (dev.ucp.shopping.checkout) to enable purchases');
-    }
-    if (checkout && checkout.canCreateCheckout && !checkout.checkoutSchemaValid) {
-        recommendations.push('Ensure checkout schema is accessible and valid');
-    }
-
-    // Payment issues
-    if (payment && payment.handlersFound === 0) {
-        recommendations.push('Configure payment handlers in the profile');
-    }
-    if (payment && !payment.signingKeyValid) {
-        recommendations.push('Add valid signing keys (EC or RSA JWK) for webhook verification');
-    }
-
-    // Add positive note if everything looks good
-    if (recommendations.length === 0) {
-        recommendations.push('Profile is well-configured for AI agent commerce!');
-    }
-
-    return recommendations;
-}
-
-/**
- * Calculate overall AI readiness score
- */
-function calculateScore(
-    discovery: DiscoveryFlowResult,
-    capabilities: CapabilityInspectionResult[],
-    services: ServiceInspectionResult[],
-    restApi?: RestApiSimulationResult,
-    checkout?: CheckoutSimulationResult,
-    payment?: PaymentReadinessResult
-): number {
-    let score = 0;
-    const maxScore = 100;
-
-    // Discovery (25 points)
-    if (discovery.success) score += 15;
-    if (discovery.services.length > 0) score += 5;
-    if (discovery.capabilities.length > 0) score += 5;
-
-    // Capabilities (25 points)
-    const accessibleCapabilities = capabilities.filter(c => c.schemaAccessible);
-    if (capabilities.length > 0) {
-        score += Math.round((accessibleCapabilities.length / capabilities.length) * 15);
-    }
-    // Bonus for having checkout
-    if (capabilities.some(c => c.name.includes('checkout'))) score += 10;
-
-    // Services & Transport (25 points)
-    for (const service of services) {
-        if (service.transports.rest?.endpointResponsive) score += 10;
-        if (service.transports.rest?.schemaAccessible) score += 5;
-        if (service.transports.mcp) score += 5;
-        if (service.transports.a2a?.agentCardAccessible) score += 5;
-    }
-    // Cap at 25
-    score = Math.min(score, 75);
-
-    // Checkout (15 points)
-    if (checkout?.canCreateCheckout) score += 8;
-    if (checkout?.checkoutSchemaValid) score += 4;
-    if (checkout?.orderFlowSupported) score += 3;
-
-    // Payment (10 points)
-    if (payment?.handlersFound || 0 > 0) score += 5;
-    if (payment?.signingKeyValid) score += 5;
-
-    return Math.min(score, maxScore);
-}
-
-/**
- * Get grade from score (aligned with all other scoring models)
- */
-function getGrade(score: number): 'A' | 'B' | 'C' | 'D' | 'F' {
-    if (score >= 90) return 'A';
-    if (score >= 80) return 'B';
-    if (score >= 70) return 'C';
-    if (score >= 60) return 'D';
-    return 'F';
-}
-
-/**
- * Main simulation entry point
- * Simulates a complete AI agent interaction with a UCP-enabled merchant
- */
-export async function simulateAgentInteraction(
-    domain: string,
-    options: SimulationOptions = {}
-): Promise<AgentSimulationResult> {
-    const startTime = Date.now();
-    const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
-    const fetchTimeout = Math.min(timeoutMs / 3, DEFAULT_FETCH_TIMEOUT_MS);
-
-    // Step 1: Discovery flow
-    const discovery = await simulateDiscoveryFlow(domain, fetchTimeout);
-
-    // Early exit if discovery failed
-    if (!discovery.success || !discovery.profileUrl) {
-        const durationMs = Date.now() - startTime;
-        return {
-            ok: false,
-            domain,
-            simulatedAt: new Date().toISOString(),
-            durationMs,
-            overallScore: 0,
-            grade: 'F' as const,
-            discovery,
-            capabilities: [],
-            services: [],
-            summary: {
-                totalSteps: discovery.steps.length,
-                passedSteps: discovery.steps.filter(s => s.status === 'passed').length,
-                failedSteps: discovery.steps.filter(s => s.status === 'failed').length,
-                warningSteps: discovery.steps.filter(s => s.status === 'warning').length,
-                skippedSteps: discovery.steps.filter(s => s.status === 'skipped').length,
-            },
-            recommendations: ['Ensure UCP profile is accessible at /.well-known/ucp or /.well-known/ucp.json'],
-        };
-    }
-
-    // Fetch full profile for detailed inspection
-    const profileResult = await fetchWithTimeout(discovery.profileUrl, fetchTimeout);
-    const profile = profileResult.data as UcpProfile;
-
-    // Step 2: Inspect capabilities
-    const capabilities = await inspectCapabilities(profile, fetchTimeout);
-
-    // Step 3: Inspect services
-    const services = await inspectServices(profile, fetchTimeout);
-
-    // Step 4: REST API simulation (if applicable)
-    let restApi: RestApiSimulationResult | undefined;
-    if (!options.skipRestApiTest) {
-        restApi = await simulateRestApi(profile, fetchTimeout);
-    }
-
-    // Step 5: Checkout flow simulation
-    let checkout: CheckoutSimulationResult | undefined;
-    if (options.testCheckoutFlow !== false) {
-        checkout = await simulateCheckoutFlow(profile, fetchTimeout);
-    }
-
-    // Step 6: Payment readiness check
-    const payment = await simulatePaymentReadiness(profile, fetchTimeout);
-
-    // Collect all steps
-    const allSteps = [
-        ...discovery.steps,
-        ...(restApi?.steps || []),
-        ...(checkout?.steps || []),
-        ...payment.steps,
-    ];
-
-    const durationMs = Date.now() - startTime;
-
-    // Generate recommendations
-    const recommendations = generateRecommendations(
-        discovery, capabilities, services, restApi, checkout, payment
-    );
-
-    // Calculate score
-    const overallScore = calculateScore(
-        discovery, capabilities, services, restApi, checkout, payment
-    );
-
-    return {
-        ok: discovery.success && (checkout?.success ?? true),
-        domain,
-        simulatedAt: new Date().toISOString(),
-        durationMs,
-        overallScore,
-        grade: getGrade(overallScore),
-        discovery,
-        capabilities,
-        services,
-        restApi,
-        checkout,
-        payment,
-        summary: {
-            totalSteps: allSteps.length,
-            passedSteps: allSteps.filter(s => s.status === 'passed').length,
-            failedSteps: allSteps.filter(s => s.status === 'failed').length,
-            warningSteps: allSteps.filter(s => s.status === 'warning').length,
-            skippedSteps: allSteps.filter(s => s.status === 'skipped').length,
-        },
-        recommendations,
-    };
-}
-
-// Export helper functions for testing
-export {
-    fetchWithTimeout,
-    checkEndpointResponsive,
-    generateRecommendations,
-    calculateScore,
-    getGrade,
-};
+"use strict";
+/**
+ * AI Agent Simulator
+ * Simulates how an AI agent discovers and interacts with UCP-enabled merchants
+ *
+ * The goal is to test real-world functionality, not just spec compliance.
+ * This proves that a UCP implementation actually works for AI agent commerce.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simulateDiscoveryFlow = simulateDiscoveryFlow;
+exports.inspectCapabilities = inspectCapabilities;
+exports.inspectServices = inspectServices;
+exports.simulateRestApi = simulateRestApi;
+exports.simulateCheckoutFlow = simulateCheckoutFlow;
+exports.simulatePaymentReadiness = simulatePaymentReadiness;
+exports.simulateAgentInteraction = simulateAgentInteraction;
+exports.fetchWithTimeout = fetchWithTimeout;
+exports.checkEndpointResponsive = checkEndpointResponsive;
+exports.generateRecommendations = generateRecommendations;
+exports.calculateScore = calculateScore;
+exports.getGrade = getGrade;
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_FETCH_TIMEOUT_MS = 10000;
+/**
+ * Normalize capability to extract the name string
+ * Handles both string format and object format capabilities
+ */
+function getCapabilityName(cap) {
+    if (typeof cap === 'string') {
+        return cap;
+    }
+    if (cap && typeof cap === 'object' && 'name' in cap) {
+        return String(cap.name);
+    }
+    return '';
+}
+/**
+ * Get capability object (for accessing schema, version, etc.)
+ * Returns null for string-only capabilities
+ */
+function getCapabilityObject(cap) {
+    if (cap && typeof cap === 'object' && 'name' in cap) {
+        return cap;
+    }
+    return null;
+}
+/**
+ * Step builder helper
+ */
+function createStep(step, status, message, details, durationMs, data) {
+    return { step, status, message, details, durationMs, data };
+}
+/**
+ * Fetch with timeout
+ */
+async function fetchWithTimeout(url, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                'User-Agent': 'UCP-Agent-Simulator/1.0',
+                'Accept': 'application/json',
+            },
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            return { ok: false, status: response.status, error: `HTTP ${response.status}` };
+        }
+        const contentType = response.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+            const data = await response.json();
+            return { ok: true, status: response.status, data };
+        }
+        return { ok: true, status: response.status };
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return { ok: false, error: message };
+    }
+}
+/**
+ * HEAD request to check endpoint responsiveness
+ */
+async function checkEndpointResponsive(url, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method: 'HEAD',
+            signal: controller.signal,
+            headers: {
+                'User-Agent': 'UCP-Agent-Simulator/1.0',
+            },
+        });
+        clearTimeout(timeoutId);
+        // Accept various success codes - we just want to know endpoint exists
+        return { ok: response.status < 500, status: response.status };
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return { ok: false, error: message };
+    }
+}
+/**
+ * Simulate discovery flow - how an AI agent discovers a UCP merchant
+ */
+async function simulateDiscoveryFlow(domain, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    const steps = [];
+    let profileUrl;
+    let profile = null;
+    const capabilities = [];
+    const services = [];
+    const transports = [];
+    // Step 1: Try to fetch /.well-known/ucp
+    const startTime = Date.now();
+    const urls = [
+        `https://${domain}/.well-known/ucp`,
+        `https://${domain}/.well-known/ucp.json`,
+    ];
+    let foundProfile = false;
+    for (const url of urls) {
+        const fetchStart = Date.now();
+        const result = await fetchWithTimeout(url, timeoutMs);
+        const fetchDuration = Date.now() - fetchStart;
+        if (result.ok && result.data && typeof result.data === 'object') {
+            const data = result.data;
+            if (data.ucp) {
+                profile = data;
+                profileUrl = url;
+                foundProfile = true;
+                steps.push(createStep('discover_profile', 'passed', `Found UCP profile at ${url}`, `Response time: ${fetchDuration}ms`, fetchDuration, { url, responseTime: fetchDuration }));
+                break;
+            }
+        }
+    }
+    if (!foundProfile) {
+        steps.push(createStep('discover_profile', 'failed', 'Could not find UCP profile', `Tried: ${urls.join(', ')}`));
+        return { success: false, steps, capabilities, services, transports };
+    }
+    // Step 2: Parse UCP version
+    if (profile?.ucp?.version) {
+        steps.push(createStep('parse_version', 'passed', `UCP version: ${profile.ucp.version}`, undefined, undefined, { version: profile.ucp.version }));
+    }
+    else {
+        steps.push(createStep('parse_version', 'failed', 'Missing UCP version', 'AI agent cannot determine protocol version'));
+    }
+    // Step 3: Enumerate services
+    const serviceEntries = Object.entries(profile?.ucp?.services || {});
+    if (serviceEntries.length > 0) {
+        for (const [serviceName, service] of serviceEntries) {
+            services.push(serviceName);
+            // Track transports
+            if (service.rest)
+                transports.push('rest');
+            if (service.mcp)
+                transports.push('mcp');
+            if (service.a2a)
+                transports.push('a2a');
+            if (service.embedded)
+                transports.push('embedded');
+        }
+        steps.push(createStep('enumerate_services', 'passed', `Found ${serviceEntries.length} service(s): ${services.join(', ')}`, `Available transports: ${[...new Set(transports)].join(', ')}`, undefined, { services, transports: [...new Set(transports)] }));
+    }
+    else {
+        steps.push(createStep('enumerate_services', 'failed', 'No services found', 'AI agent has no entry point for commerce operations'));
+    }
+    // Step 4: Enumerate capabilities
+    const capList = profile?.ucp?.capabilities || [];
+    if (capList.length > 0) {
+        for (const cap of capList) {
+            const capName = getCapabilityName(cap);
+            if (capName)
+                capabilities.push(capName);
+        }
+        // Check for required checkout capability
+        const hasCheckout = capabilities.some(c => c && c.includes('checkout'));
+        const hasOrder = capabilities.some(c => c && c.includes('order'));
+        steps.push(createStep('enumerate_capabilities', 'passed', `Found ${capList.length} capability/ies: ${capabilities.join(', ')}`, hasCheckout ? 'Checkout capability present - commerce ready' : 'No checkout capability - limited commerce support', undefined, { capabilities, hasCheckout, hasOrder }));
+    }
+    else {
+        steps.push(createStep('enumerate_capabilities', 'warning', 'No capabilities declared', 'AI agent cannot determine supported operations'));
+    }
+    const totalDuration = Date.now() - startTime;
+    return {
+        success: foundProfile && serviceEntries.length > 0,
+        steps,
+        profileUrl,
+        capabilities,
+        services,
+        transports: [...new Set(transports)],
+    };
+}
+/**
+ * Inspect capabilities in detail
+ */
+async function inspectCapabilities(profile, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    const results = [];
+    const capList = profile.ucp?.capabilities || [];
+    for (const cap of capList) {
+        const capName = getCapabilityName(cap);
+        const capObj = getCapabilityObject(cap);
+        let schemaAccessible = false;
+        let specAccessible = false;
+        // Check schema URL (only for object-format capabilities)
+        if (capObj?.schema) {
+            const schemaResult = await fetchWithTimeout(capObj.schema, timeoutMs);
+            schemaAccessible = schemaResult.ok;
+        }
+        // Check spec URL (only for object-format capabilities)
+        if (capObj?.spec) {
+            const specResult = await checkEndpointResponsive(capObj.spec, timeoutMs);
+            specAccessible = specResult.ok;
+        }
+        results.push({
+            name: capName,
+            version: capObj?.version || 'unknown',
+            schemaAccessible,
+            specAccessible,
+            isExtension: !!capObj?.extends,
+            parentCapability: capObj?.extends,
+        });
+    }
+    return results;
+}
+/**
+ * Inspect services and their transports
+ */
+async function inspectServices(profile, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    const results = [];
+    const serviceEntries = Object.entries(profile.ucp?.services || {});
+    for (const [name, service] of serviceEntries) {
+        const svc = service;
+        const result = {
+            name,
+            version: svc.version,
+            transports: {},
+        };
+        // Check REST transport
+        if (svc.rest) {
+            const schemaCheck = svc.rest.schema
+                ? await fetchWithTimeout(svc.rest.schema, timeoutMs)
+                : { ok: false };
+            const endpointCheck = await checkEndpointResponsive(svc.rest.endpoint, timeoutMs);
+            result.transports.rest = {
+                endpoint: svc.rest.endpoint,
+                schemaAccessible: schemaCheck.ok,
+                endpointResponsive: endpointCheck.ok,
+            };
+        }
+        // Check MCP transport
+        if (svc.mcp) {
+            const schemaCheck = svc.mcp.schema
+                ? await fetchWithTimeout(svc.mcp.schema, timeoutMs)
+                : { ok: false };
+            result.transports.mcp = {
+                endpoint: svc.mcp.endpoint,
+                schemaAccessible: schemaCheck.ok,
+            };
+        }
+        // Check A2A transport
+        if (svc.a2a) {
+            const agentCardCheck = await fetchWithTimeout(svc.a2a.agentCard, timeoutMs);
+            result.transports.a2a = {
+                agentCard: svc.a2a.agentCard,
+                agentCardAccessible: agentCardCheck.ok,
+            };
+        }
+        results.push(result);
+    }
+    return results;
+}
+/**
+ * Simulate REST API interaction
+ */
+async function simulateRestApi(profile, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    const steps = [];
+    const sampleOperations = [];
+    let schemaLoaded = false;
+    let endpointAccessible = false;
+    // Find REST service
+    const shoppingService = profile.ucp?.services?.['dev.ucp.shopping'];
+    if (!shoppingService?.rest) {
+        steps.push(createStep('find_rest_service', 'skipped', 'No REST service configured', 'Merchant may use MCP or A2A transport instead'));
+        return { success: false, steps, schemaLoaded, endpointAccessible, sampleOperations };
+    }
+    // Step 1: Load OpenAPI schema
+    if (shoppingService.rest.schema) {
+        const schemaStart = Date.now();
+        const schemaResult = await fetchWithTimeout(shoppingService.rest.schema, timeoutMs);
+        const schemaDuration = Date.now() - schemaStart;
+        if (schemaResult.ok && schemaResult.data) {
+            schemaLoaded = true;
+            const schema = schemaResult.data;
+            steps.push(createStep('load_openapi_schema', 'passed', `Loaded OpenAPI schema from ${shoppingService.rest.schema}`, `Response time: ${schemaDuration}ms`, schemaDuration, { schemaUrl: shoppingService.rest.schema }));
+            // Check for expected paths in schema
+            const paths = schema.paths;
+            if (paths) {
+                const pathCount = Object.keys(paths).length;
+                steps.push(createStep('analyze_schema_paths', pathCount > 0 ? 'passed' : 'warning', `Schema defines ${pathCount} operation path(s)`, pathCount > 0 ? `Paths: ${Object.keys(paths).slice(0, 5).join(', ')}${pathCount > 5 ? '...' : ''}` : undefined));
+            }
+        }
+        else {
+            steps.push(createStep('load_openapi_schema', 'failed', 'Could not load OpenAPI schema', schemaResult.error || 'Unknown error'));
+        }
+    }
+    else {
+        steps.push(createStep('load_openapi_schema', 'warning', 'No schema URL provided', 'AI agent cannot discover available operations'));
+    }
+    // Step 2: Check endpoint responsiveness
+    const endpointStart = Date.now();
+    const endpointResult = await checkEndpointResponsive(shoppingService.rest.endpoint, timeoutMs);
+    const endpointDuration = Date.now() - endpointStart;
+    if (endpointResult.ok) {
+        endpointAccessible = true;
+        steps.push(createStep('check_endpoint', 'passed', `REST endpoint responsive: ${shoppingService.rest.endpoint}`, `Status: ${endpointResult.status}, Response time: ${endpointDuration}ms`, endpointDuration));
+    }
+    else {
+        steps.push(createStep('check_endpoint', 'failed', `REST endpoint not accessible: ${shoppingService.rest.endpoint}`, endpointResult.error || `Status: ${endpointResult.status}`));
+    }
+    return {
+        success: schemaLoaded && endpointAccessible,
+        steps,
+        schemaLoaded,
+        endpointAccessible,
+        sampleOperations,
+    };
+}
+/**
+ * Simulate checkout flow capability
+ */
+async function simulateCheckoutFlow(profile, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    const steps = [];
+    let canCreateCheckout = false;
+    let checkoutSchemaValid = false;
+    let orderFlowSupported = false;
+    let fulfillmentSupported = false;
+    const capabilities = profile.ucp?.capabilities || [];
+    // Check for checkout capability (handle both string and object formats)
+    const checkoutCapRaw = capabilities.find(c => getCapabilityName(c).includes('checkout'));
+    const checkoutCapName = checkoutCapRaw ? getCapabilityName(checkoutCapRaw) : null;
+    const checkoutCapObj = checkoutCapRaw ? getCapabilityObject(checkoutCapRaw) : null;
+    if (checkoutCapName) {
+        canCreateCheckout = true;
+        steps.push(createStep('find_checkout_capability', 'passed', `Found checkout capability: ${checkoutCapName}`, checkoutCapObj?.version ? `Version: ${checkoutCapObj.version}` : 'String-format capability'));
+        // Validate checkout schema (only for object-format capabilities)
+        if (checkoutCapObj?.schema) {
+            const schemaResult = await fetchWithTimeout(checkoutCapObj.schema, timeoutMs);
+            if (schemaResult.ok && schemaResult.data) {
+                checkoutSchemaValid = true;
+                const schema = schemaResult.data;
+                // Check for required checkout properties
+                const properties = (schema.properties || schema.$defs);
+                const hasCheckoutProps = properties && (properties.checkout_id ||
+                    properties.items ||
+                    properties.CheckoutSession);
+                steps.push(createStep('validate_checkout_schema', hasCheckoutProps ? 'passed' : 'warning', `Checkout schema ${hasCheckoutProps ? 'has expected structure' : 'loaded but structure unclear'}`, hasCheckoutProps ? 'AI agent can create checkout sessions' : 'Schema may need review'));
+            }
+            else {
+                steps.push(createStep('validate_checkout_schema', 'failed', 'Could not load checkout schema', schemaResult.error || 'Unknown error'));
+            }
+        }
+        else {
+            // String-format capability - no schema to validate, mark as valid for basic functionality
+            checkoutSchemaValid = true;
+            steps.push(createStep('validate_checkout_schema', 'info', 'No schema URL in capability (string format)', 'Capability declared but schema validation skipped'));
+        }
+    }
+    else {
+        steps.push(createStep('find_checkout_capability', 'failed', 'No checkout capability found', 'AI agent cannot create checkout sessions'));
+    }
+    // Check for order capability
+    const orderCapRaw = capabilities.find(c => getCapabilityName(c).includes('order'));
+    const orderCapName = orderCapRaw ? getCapabilityName(orderCapRaw) : null;
+    if (orderCapName) {
+        orderFlowSupported = true;
+        steps.push(createStep('find_order_capability', 'passed', `Found order capability: ${orderCapName}`, 'AI agent can track order status'));
+    }
+    else {
+        steps.push(createStep('find_order_capability', 'warning', 'No order capability found', 'Order tracking may not be available'));
+    }
+    // Check for fulfillment capability
+    const fulfillmentCapRaw = capabilities.find(c => getCapabilityName(c).includes('fulfillment'));
+    const fulfillmentCapName = fulfillmentCapRaw ? getCapabilityName(fulfillmentCapRaw) : null;
+    if (fulfillmentCapName) {
+        fulfillmentSupported = true;
+        steps.push(createStep('find_fulfillment_capability', 'passed', `Found fulfillment capability: ${fulfillmentCapName}`, 'AI agent can track shipping and delivery'));
+    }
+    else {
+        steps.push(createStep('find_fulfillment_capability', 'info', 'No fulfillment capability found', 'Fulfillment tracking not available via UCP'));
+    }
+    return {
+        success: canCreateCheckout && checkoutSchemaValid,
+        steps,
+        canCreateCheckout,
+        checkoutSchemaValid,
+        orderFlowSupported,
+        fulfillmentSupported,
+    };
+}
+/**
+ * Check payment readiness
+ */
+async function simulatePaymentReadiness(profile, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    const steps = [];
+    let handlersFound = 0;
+    let webhookVerifiable = false;
+    let signingKeyValid = false;
+    // Check payment handlers
+    const handlers = profile.payment?.handlers || [];
+    handlersFound = handlers.length;
+    if (handlersFound > 0) {
+        const handlerNames = handlers.map(h => h.name).join(', ');
+        steps.push(createStep('find_payment_handlers', 'passed', `Found ${handlersFound} payment handler(s): ${handlerNames}`, 'AI agent can initiate payments'));
+        // Check handler configs
+        for (const handler of handlers) {
+            if (handler.config_schema) {
+                const schemaResult = await checkEndpointResponsive(handler.config_schema, timeoutMs);
+                steps.push(createStep(`check_handler_${handler.id}`, schemaResult.ok ? 'passed' : 'warning', `Payment handler "${handler.name}" config schema ${schemaResult.ok ? 'accessible' : 'not accessible'}`, handler.config_schema));
+            }
+        }
+    }
+    else {
+        steps.push(createStep('find_payment_handlers', 'warning', 'No payment handlers configured', 'Payment processing may use external flow'));
+    }
+    // Check signing keys for webhook verification
+    const signingKeys = profile.signing_keys;
+    if (signingKeys && Array.isArray(signingKeys) && signingKeys.length > 0) {
+        webhookVerifiable = true;
+        // Validate key structure
+        const validKeys = signingKeys.filter(key => key.kty && key.kid && ((key.kty === 'EC' && key.crv && key.x && key.y) ||
+            (key.kty === 'RSA' && key.n && key.e)));
+        signingKeyValid = validKeys.length > 0;
+        steps.push(createStep('check_signing_keys', signingKeyValid ? 'passed' : 'warning', `Found ${signingKeys.length} signing key(s), ${validKeys.length} valid`, signingKeyValid
+            ? 'AI agent can verify webhook signatures'
+            : 'Signing keys present but may be incomplete'));
+    }
+    else {
+        steps.push(createStep('check_signing_keys', 'warning', 'No signing keys found', 'Webhook verification not available'));
+    }
+    return {
+        success: handlersFound > 0 || webhookVerifiable,
+        steps,
+        handlersFound,
+        webhookVerifiable,
+        signingKeyValid,
+    };
+}
+/**
+ * Generate recommendations based on simulation results
+ */
+function generateRecommendations(discovery, capabilities, services, restApi, checkout, payment) {
+    const recommendations = [];
+    // Discovery issues
+    if (!discovery.success) {
+        recommendations.push('Ensure UCP profile is accessible at /.well-known/ucp');
+    }
+    // Service issues
+    if (discovery.services.length === 0) {
+        recommendations.push('Add at least one service (e.g., dev.ucp.shopping) to enable commerce');
+    }
+    // Transport issues
+    if (discovery.transports.length === 0) {
+        recommendations.push('Configure at least one transport binding (REST, MCP, or A2A)');
+    }
+    // Capability issues
+    const inaccessibleSchemas = capabilities.filter(c => !c.schemaAccessible);
+    if (inaccessibleSchemas.length > 0) {
+        recommendations.push(`Fix inaccessible capability schemas: ${inaccessibleSchemas.map(c => c.name).join(', ')}`);
+    }
+    // REST API issues
+    if (restApi && !restApi.schemaLoaded) {
+        recommendations.push('Provide accessible OpenAPI schema for REST service');
+    }
+    if (restApi && !restApi.endpointAccessible) {
+        recommendations.push('Ensure REST endpoint is publicly accessible');
+    }
+    // Checkout issues
+    if (checkout && !checkout.canCreateCheckout) {
+        recommendations.push('Add checkout capability (dev.ucp.shopping.checkout) to enable purchases');
+    }
+    if (checkout && checkout.canCreateCheckout && !checkout.checkoutSchemaValid) {
+        recommendations.push('Ensure checkout schema is accessible and valid');
+    }
+    // Payment issues
+    if (payment && payment.handlersFound === 0) {
+        recommendations.push('Configure payment handlers in the profile');
+    }
+    if (payment && !payment.signingKeyValid) {
+        recommendations.push('Add valid signing keys (EC or RSA JWK) for webhook verification');
+    }
+    // Add positive note if everything looks good
+    if (recommendations.length === 0) {
+        recommendations.push('Profile is well-configured for AI agent commerce!');
+    }
+    return recommendations;
+}
+/**
+ * Calculate overall AI readiness score
+ */
+function calculateScore(discovery, capabilities, services, restApi, checkout, payment) {
+    let score = 0;
+    const maxScore = 100;
+    // Discovery (25 points)
+    if (discovery.success)
+        score += 15;
+    if (discovery.services.length > 0)
+        score += 5;
+    if (discovery.capabilities.length > 0)
+        score += 5;
+    // Capabilities (25 points)
+    const accessibleCapabilities = capabilities.filter(c => c.schemaAccessible);
+    if (capabilities.length > 0) {
+        score += Math.round((accessibleCapabilities.length / capabilities.length) * 15);
+    }
+    // Bonus for having checkout
+    if (capabilities.some(c => c.name.includes('checkout')))
+        score += 10;
+    // Services & Transport (25 points)
+    for (const service of services) {
+        if (service.transports.rest?.endpointResponsive)
+            score += 10;
+        if (service.transports.rest?.schemaAccessible)
+            score += 5;
+        if (service.transports.mcp)
+            score += 5;
+        if (service.transports.a2a?.agentCardAccessible)
+            score += 5;
+    }
+    // Cap at 25
+    score = Math.min(score, 75);
+    // Checkout (15 points)
+    if (checkout?.canCreateCheckout)
+        score += 8;
+    if (checkout?.checkoutSchemaValid)
+        score += 4;
+    if (checkout?.orderFlowSupported)
+        score += 3;
+    // Payment (10 points)
+    if (payment?.handlersFound || 0 > 0)
+        score += 5;
+    if (payment?.signingKeyValid)
+        score += 5;
+    return Math.min(score, maxScore);
+}
+/**
+ * Get grade from score (aligned with all other scoring models)
+ */
+function getGrade(score) {
+    if (score >= 90)
+        return 'A';
+    if (score >= 80)
+        return 'B';
+    if (score >= 70)
+        return 'C';
+    if (score >= 60)
+        return 'D';
+    return 'F';
+}
+/**
+ * Main simulation entry point
+ * Simulates a complete AI agent interaction with a UCP-enabled merchant
+ */
+async function simulateAgentInteraction(domain, options = {}) {
+    const startTime = Date.now();
+    const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+    const fetchTimeout = Math.min(timeoutMs / 3, DEFAULT_FETCH_TIMEOUT_MS);
+    // Step 1: Discovery flow
+    const discovery = await simulateDiscoveryFlow(domain, fetchTimeout);
+    // Early exit if discovery failed
+    if (!discovery.success || !discovery.profileUrl) {
+        const durationMs = Date.now() - startTime;
+        return {
+            ok: false,
+            domain,
+            simulatedAt: new Date().toISOString(),
+            durationMs,
+            overallScore: 0,
+            grade: 'F',
+            discovery,
+            capabilities: [],
+            services: [],
+            summary: {
+                totalSteps: discovery.steps.length,
+                passedSteps: discovery.steps.filter(s => s.status === 'passed').length,
+                failedSteps: discovery.steps.filter(s => s.status === 'failed').length,
+                warningSteps: discovery.steps.filter(s => s.status === 'warning').length,
+                skippedSteps: discovery.steps.filter(s => s.status === 'skipped').length,
+            },
+            recommendations: ['Ensure UCP profile is accessible at /.well-known/ucp or /.well-known/ucp.json'],
+        };
+    }
+    // Fetch full profile for detailed inspection
+    const profileResult = await fetchWithTimeout(discovery.profileUrl, fetchTimeout);
+    const profile = profileResult.data;
+    // Step 2: Inspect capabilities
+    const capabilities = await inspectCapabilities(profile, fetchTimeout);
+    // Step 3: Inspect services
+    const services = await inspectServices(profile, fetchTimeout);
+    // Step 4: REST API simulation (if applicable)
+    let restApi;
+    if (!options.skipRestApiTest) {
+        restApi = await simulateRestApi(profile, fetchTimeout);
+    }
+    // Step 5: Checkout flow simulation
+    let checkout;
+    if (options.testCheckoutFlow !== false) {
+        checkout = await simulateCheckoutFlow(profile, fetchTimeout);
+    }
+    // Step 6: Payment readiness check
+    const payment = await simulatePaymentReadiness(profile, fetchTimeout);
+    // Collect all steps
+    const allSteps = [
+        ...discovery.steps,
+        ...(restApi?.steps || []),
+        ...(checkout?.steps || []),
+        ...payment.steps,
+    ];
+    const durationMs = Date.now() - startTime;
+    // Generate recommendations
+    const recommendations = generateRecommendations(discovery, capabilities, services, restApi, checkout, payment);
+    // Calculate score
+    const overallScore = calculateScore(discovery, capabilities, services, restApi, checkout, payment);
+    return {
+        ok: discovery.success && (checkout?.success ?? true),
+        domain,
+        simulatedAt: new Date().toISOString(),
+        durationMs,
+        overallScore,
+        grade: getGrade(overallScore),
+        discovery,
+        capabilities,
+        services,
+        restApi,
+        checkout,
+        payment,
+        summary: {
+            totalSteps: allSteps.length,
+            passedSteps: allSteps.filter(s => s.status === 'passed').length,
+            failedSteps: allSteps.filter(s => s.status === 'failed').length,
+            warningSteps: allSteps.filter(s => s.status === 'warning').length,
+            skippedSteps: allSteps.filter(s => s.status === 'skipped').length,
+        },
+        recommendations,
+    };
+}
+//# sourceMappingURL=agent-simulator.js.map