@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/customer/info-puzzle.js

@@ -0,0 +1,312 @@
+import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+export function assembleServiceBasics(serviceId, raw, wipVerified = false) {
+    const activeSales = (raw.sales ?? []).filter((s) => !s.suspension);
+    const hasWip = activeSales.some((s) => s.wip_hash && s.wip_hash.length > 0);
+    return {
+        service_id: serviceId,
+        name: raw.name ?? serviceId,
+        bPublished: raw.bPublished ?? false,
+        bPaused: raw.bPaused ?? false,
+        price: raw.price ?? "0",
+        price_raw: raw.priceRaw ?? 0n,
+        token_type: raw.token_type ?? "0x2::wow::WOW",
+        sales_count: activeSales.length,
+        machine_id: raw.machine,
+        buy_guard_id: raw.buy_guard,
+        customer_required_count: raw.customer_required?.length ?? 0,
+        arbitrations_count: raw.arbitrations?.length ?? 0,
+        compensation_fund_balance: raw.compensation_fund?.balance ?? 0n,
+        compensation_lock_duration: raw.compensation_lock_duration ?? 0,
+        um_id: raw.um,
+        has_wip: hasWip,
+        wip_verified: wipVerified,
+    };
+}
+export function assembleWorkflowAnalysis(nodes, isPublished, isPaused) {
+    const riskSignals = [];
+    const terminalNodes = [];
+    const deadEndNodes = [];
+    let userOperable = 0;
+    let providerOnly = 0;
+    let guardGated = 0;
+    let hasRefundPath = false;
+    let hasArbitrationPath = false;
+    let hasMilestone = false;
+    const totalForwards = nodes.reduce((sum, n) => sum + (n.forwards?.length ?? 0), 0);
+    for (const node of nodes) {
+        const outForwards = node.forwards ?? [];
+        if (outForwards.length === 0) {
+            terminalNodes.push(node.name);
+        }
+        for (const fwd of outForwards) {
+            const op = fwd.namedOperator;
+            const guard = fwd.guard;
+            if (op === "") {
+                if (guard) {
+                    guardGated++;
+                }
+                else {
+                    userOperable++;
+                }
+            }
+            else if (op === null || op === undefined) {
+                providerOnly++;
+            }
+            else {
+                providerOnly++;
+            }
+            const fwdName = (fwd.name ?? "").toLowerCase();
+            const target = (fwd.to ?? "").toLowerCase();
+            if (fwdName.includes("refund") || target.includes("refund")) {
+                hasRefundPath = true;
+            }
+            if (fwdName.includes("arb") || target.includes("arb")) {
+                hasArbitrationPath = true;
+            }
+            if (fwdName.includes("milestone") || target.includes("milestone")) {
+                hasMilestone = true;
+            }
+        }
+    }
+    for (const node of nodes) {
+        const outForwards = node.forwards ?? [];
+        if (outForwards.length > 0 && !terminalNodes.includes(node.name)) {
+            const allProviderOnly = outForwards.every((f) => f.namedOperator !== "" && f.namedOperator !== null);
+            if (allProviderOnly && userOperable === 0) {
+                deadEndNodes.push(node.name);
+            }
+        }
+    }
+    if (!hasRefundPath)
+        riskSignals.push("no_refund_path");
+    if (!hasArbitrationPath)
+        riskSignals.push("no_arbitration_path");
+    if (userOperable === 0)
+        riskSignals.push("no_user_operable_path");
+    if (deadEndNodes.length > 0)
+        riskSignals.push("potential_dead_ends");
+    return {
+        machine_published: isPublished,
+        machine_paused: isPaused,
+        total_nodes: nodes.length,
+        total_forwards: totalForwards,
+        user_operable_forwards: userOperable,
+        provider_only_forwards: providerOnly,
+        guard_gated_forwards: guardGated,
+        has_refund_path: hasRefundPath,
+        has_arbitration_path: hasArbitrationPath,
+        has_milestone_nodes: hasMilestone,
+        dead_end_nodes: deadEndNodes,
+        terminal_nodes: terminalNodes,
+        risk_signals: riskSignals,
+    };
+}
+export function assembleFundSafety(raw, orderAmount) {
+    const allocators = raw.order_allocators?.[0]?.allocators ?? [];
+    const compBalance = raw.compensation_fund?.balance ?? 0n;
+    const lockDuration = raw.compensation_lock_duration ?? 0;
+    const refundAllocator = allocators.find((a) => {
+        const amt = a.amount;
+        return amt?.type === "FixedValue" && amt.value === orderAmount;
+    });
+    const hasRefundAllocator = allocators.some((a) => a.surplus_to === "order" || a.surplus_to === "Order");
+    let priceAnomaly = "none";
+    if (orderAmount > 0n) {
+        if (compBalance > 0n && orderAmount > compBalance * 3n) {
+            priceAnomaly = "low";
+        }
+    }
+    const lockSafe = lockDuration === 0 || lockDuration > 7;
+    return {
+        has_order_allocator: allocators.length > 0,
+        has_refund_allocator: !!refundAllocator || hasRefundAllocator,
+        allocator_count: allocators.length,
+        refund_allocator_exists: hasRefundAllocator,
+        surplus_to_provider: allocators.some((a) => a.surplus_to !== "order" && a.surplus_to !== "Order"),
+        user_path_has_allocator: allocators.length > 0,
+        compensation_covers_order: compBalance >= orderAmount,
+        compensation_ratio: orderAmount > 0n
+            ? Math.min(1, Number((compBalance * 100n) / orderAmount) / 100)
+            : 0,
+        lock_duration_safe: lockSafe,
+        price_anomaly: priceAnomaly,
+    };
+}
+export function assembleTrustSignals(service, reviews, trustScore, arbitrationOwner, serviceOwner) {
+    const likes = reviews.filter((r) => r.rating === "like").length;
+    const dislikes = reviews.filter((r) => r.rating === "dislike").length;
+    const verified = reviews.filter((r) => r.verified || r.has_evidence).length;
+    const total = reviews.length;
+    const likeRate = total > 0 ? likes / total : 0;
+    const arbitrationIndependent = arbitrationOwner !== undefined && serviceOwner !== undefined
+        ? arbitrationOwner !== serviceOwner
+        : true;
+    return {
+        arbitration_independent: arbitrationIndependent,
+        arbitration_count: service.arbitrations?.length ?? 0,
+        arbitration_paused: false,
+        review_likes: likes,
+        review_dislikes: dislikes,
+        review_verified_count: verified,
+        review_total: total,
+        like_rate: likeRate,
+        trust_score: trustScore.score,
+        trust_level: trustScore.level,
+        has_contact: !!service.um,
+        has_messenger: !!service.um,
+    };
+}
+export function assembleMerchantBehavior(events, orderHistory) {
+    if (orderHistory && orderHistory.length > 0) {
+        const total = orderHistory.length;
+        const completed = orderHistory.filter((o) => o.status === "completed").length;
+        const disputed = orderHistory.filter((o) => o.has_dispute).length;
+        const repeated = orderHistory.filter((o) => o.is_repeat).length;
+        const completedRate = total > 0 ? completed / total : 0;
+        const disputeRate = total > 0 ? disputed / total : 0;
+        const repeatRate = total > 0 ? repeated / total : 0;
+        const half = Math.floor(total / 2);
+        let trend = "stable";
+        if (total >= 4 && half > 0) {
+            const firstHalfDisputes = orderHistory.slice(0, half).filter((o) => o.has_dispute).length;
+            const secondHalfDisputes = orderHistory.slice(half).filter((o) => o.has_dispute).length;
+            const firstRate = firstHalfDisputes / half;
+            const secondRate = secondHalfDisputes / (total - half);
+            if (secondRate < firstRate * 0.85)
+                trend = "improving";
+            else if (secondRate > firstRate * 1.15)
+                trend = "declining";
+        }
+        const redFlags = [];
+        if (disputeRate > 0.1)
+            redFlags.push("dispute_rate_high");
+        if (trend === "declining")
+            redFlags.push("declining_trend");
+        return {
+            total_orders: total,
+            completed_rate: completedRate,
+            dispute_rate: disputeRate,
+            refund_rate: 0,
+            arb_loss_rate: 0,
+            repeat_buyer_rate: repeatRate,
+            recent_trend: trend,
+            red_flags: redFlags,
+        };
+    }
+    const orderEvents = events.filter((e) => e.type.includes("Order") || e.type.includes("order"));
+    const disputeEvents = events.filter((e) => e.type.includes("Dispute") || e.type.includes("Arb"));
+    const total = orderEvents.length;
+    const disputes = disputeEvents.length;
+    const disputeRate = total > 0 ? disputes / total : 0;
+    const redFlags = [];
+    if (disputeRate > 0.1)
+        redFlags.push("dispute_rate_high");
+    return {
+        total_orders: total,
+        completed_rate: total > 0 ? Math.max(0, 1 - disputeRate) : 0,
+        dispute_rate: disputeRate,
+        refund_rate: 0,
+        arb_loss_rate: 0,
+        repeat_buyer_rate: 0,
+        recent_trend: "stable",
+        red_flags: redFlags,
+    };
+}
+export function assembleMarketContext(similarServices, currentPrice) {
+    if (similarServices.length === 0) {
+        return {
+            similar_services_count: 0,
+            avg_price: 0n,
+            min_price: 0n,
+            max_price: 0n,
+            price_percentile: 0,
+            supply_demand_ratio: 0,
+        };
+    }
+    const prices = similarServices.map((s) => s.price).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    const sum = prices.reduce((acc, p) => acc + p, 0n);
+    const avg = sum / BigInt(prices.length);
+    const min = prices[0];
+    const max = prices[prices.length - 1];
+    let below = 0;
+    for (const p of prices) {
+        if (p < currentPrice)
+            below++;
+    }
+    const percentile = prices.length > 0 ? below / prices.length : 0;
+    return {
+        similar_services_count: similarServices.length,
+        avg_price: avg,
+        min_price: min,
+        max_price: max,
+        price_percentile: percentile,
+        supply_demand_ratio: similarServices.length,
+    };
+}
+export function assembleInfoPuzzle(serviceId, raw, depth = "evaluate") {
+    const gaps = [];
+    const serviceBasics = assembleServiceBasics(serviceId, raw.service, raw.wip_verified ?? false);
+    let workflowAnalysis;
+    let fundSafety;
+    let trustSignals;
+    if (depth === "evaluate" || depth === "preorder" || depth === "monitor") {
+        if (raw.machine_nodes) {
+            workflowAnalysis = assembleWorkflowAnalysis(raw.machine_nodes, raw.machine_published ?? false, raw.machine_paused ?? false);
+        }
+        else {
+            gaps.push("machine_workflow");
+        }
+        const orderAmount = raw.order_amount ?? serviceBasics.price_raw;
+        fundSafety = assembleFundSafety(raw.service, orderAmount);
+        if (raw.reviews && raw.trust_score) {
+            trustSignals = assembleTrustSignals(raw.service, raw.reviews, raw.trust_score, raw.arbitration_owner, raw.service_owner);
+        }
+        else {
+            gaps.push("reviews_or_trust_score");
+        }
+    }
+    let merchantBehavior;
+    if (depth === "preorder" || depth === "monitor") {
+        if (raw.events || raw.order_history) {
+            merchantBehavior = assembleMerchantBehavior(raw.events ?? [], raw.order_history);
+        }
+        else {
+            gaps.push("merchant_behavior");
+        }
+    }
+    let marketContext;
+    if (depth === "evaluate" || depth === "preorder") {
+        if (raw.similar_services) {
+            marketContext = assembleMarketContext(raw.similar_services, serviceBasics.price_raw);
+        }
+        else {
+            gaps.push("market_context");
+        }
+    }
+    const expectedDimensions = depth === "browse" ? 1
+        : depth === "evaluate" ? 4
+            : depth === "preorder" ? 6
+                : 4;
+    const actualDimensions = [
+        serviceBasics,
+        workflowAnalysis,
+        fundSafety,
+        trustSignals,
+        merchantBehavior,
+        marketContext,
+    ].filter((d) => d !== undefined && d !== null).length;
+    const completeness = Math.min(1, actualDimensions / expectedDimensions);
+    return {
+        service_id: serviceId,
+        service_basics: serviceBasics,
+        workflow_analysis: workflowAnalysis,
+        fund_safety: fundSafety,
+        trust_signals: trustSignals,
+        merchant_behavior: merchantBehavior,
+        market_context: marketContext,
+        completeness,
+        gaps,
+        assembled_at: Date.now(),
+    };
+}
+export { CUSTOMER_INTELLIGENCE_VERSION };

package/dist/customer/order-monitor.d.ts

@@ -0,0 +1,75 @@
+import type { RiskLevel } from "./types.js";
+import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+export type AlertSeverity = "info" | "warning" | "critical";
+export type AlertCategory = "progress_stall" | "compensation_drop" | "compensation_insufficient" | "messenger_timeout" | "user_action_required" | "review_window" | "arb_window" | "refund_received" | "anomaly";
+export interface MonitorAlert {
+    id: string;
+    category: AlertCategory;
+    severity: AlertSeverity;
+    title: string;
+    message: string;
+    action?: string;
+    timestamp: number;
+    order_id?: string;
+    service_id?: string;
+    node?: string;
+    metric?: {
+        label: string;
+        value: number;
+        threshold?: number;
+        unit?: string;
+    };
+}
+export interface OrderSnapshot {
+    order_id: string;
+    service_id: string;
+    current_node?: string;
+    created_at: number;
+    last_progress_at?: number;
+    now: number;
+    expected_progress_hours?: number;
+    order_amount?: bigint;
+    compensation_balance?: bigint;
+    has_arbitration?: boolean;
+    has_messenger?: boolean;
+    last_merchant_reply_at?: number;
+    last_user_message_at?: number;
+    pending_user_action?: boolean;
+    completed?: boolean;
+    refunded?: boolean;
+    review_window_days?: number;
+    arb_window_days?: number;
+    risk_score?: number;
+    risk_level?: RiskLevel;
+}
+export interface OrderHistorySnapshot {
+    order_id: string;
+    previous_node?: string;
+    previous_compensation_balance?: bigint;
+    snapshot_at: number;
+}
+export interface OrderMonitorContext {
+    current: OrderSnapshot;
+    previous?: OrderHistorySnapshot;
+    thresholds?: MonitorThresholds;
+}
+export interface MonitorThresholds {
+    progress_stall_hours?: number;
+    compensation_drop_ratio?: number;
+    compensation_coverage_min?: number;
+    messenger_timeout_hours?: number;
+    review_window_closing_days?: number;
+    arb_window_closing_days?: number;
+}
+export declare function monitorOrder(ctx: OrderMonitorContext): MonitorAlert[];
+export declare function sortAlerts(alerts: MonitorAlert[]): MonitorAlert[];
+export declare function getCriticalAlerts(alerts: MonitorAlert[]): MonitorAlert[];
+export declare function getActionableAlerts(alerts: MonitorAlert[]): MonitorAlert[];
+export declare function summarizeAlerts(alerts: MonitorAlert[]): string;
+export declare function isBlockingAlert(alert: MonitorAlert): boolean;
+export declare function alertsToReminders(alerts: MonitorAlert[]): Array<{
+    id: string;
+    priority: "required" | "recommended" | "info" | "reminder";
+    message: string;
+}>;
+export { CUSTOMER_INTELLIGENCE_VERSION };