@wowok/agent-mcp 2.3.14 → 2.3.16

package/dist/customer/risk-assessment.d.ts

@@ -0,0 +1,8 @@
+import type { InfoPuzzle, RiskScore, RiskLevel } from "./types.js";
+import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+export declare function riskLevelFromScore(score: number): RiskLevel;
+export declare function riskLevelLabel(level: RiskLevel): string;
+export declare function riskLevelEmoji(level: RiskLevel): string;
+export declare function assessRisk(puzzle: InfoPuzzle): RiskScore;
+export declare function passesRiskThreshold(score: RiskScore, minLevel?: RiskLevel): boolean;
+export { CUSTOMER_INTELLIGENCE_VERSION };

package/dist/customer/risk-assessment.js

@@ -0,0 +1,337 @@
+import { RISK_LEVELS, RISK_DIMENSION_MAX, CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+export function riskLevelFromScore(score) {
+    const entry = RISK_LEVELS.find((l) => score >= l.min);
+    return entry?.level ?? "high";
+}
+export function riskLevelLabel(level) {
+    const entry = RISK_LEVELS.find((l) => l.level === level);
+    return entry ? `${entry.color} ${entry.label}` : "🔴 高风险";
+}
+export function riskLevelEmoji(level) {
+    const entry = RISK_LEVELS.find((l) => l.level === level);
+    return entry?.color ?? "🔴";
+}
+function assessWorkflowRisk(puzzle) {
+    const wf = puzzle.workflow_analysis;
+    const checks = [];
+    const hasRefund = wf?.has_refund_path ?? false;
+    checks.push({
+        id: "wf_refund_path",
+        dimension: "workflow",
+        description: "存在退款路径（100%→Order Allocator）",
+        weight: 10,
+        passed: hasRefund,
+        advice: hasRefund ? undefined : "⚠️ 无退款路径：若交付失败，资金可能无法回收。建议下单前通过 Messenger 与商家协商退款条款并写入 WTS。",
+    });
+    const hasArb = wf?.has_arbitration_path ?? false;
+    checks.push({
+        id: "wf_arbitration_path",
+        dimension: "workflow",
+        description: "存在仲裁路径",
+        weight: 10,
+        passed: hasArb,
+        advice: hasArb ? undefined : "⚠️ 无仲裁路径：纠纷无法升级到第三方仲裁。建议要求商家绑定 Arbitration 服务后再下单。",
+    });
+    const userOps = wf?.user_operable_forwards ?? 0;
+    checks.push({
+        id: "wf_user_operable",
+        dimension: "workflow",
+        description: "至少 1 条用户可操作 Forward",
+        weight: 8,
+        passed: userOps > 0,
+        advice: userOps > 0 ? undefined : "🔴 流程中无任何用户可操作步骤：订单进度完全依赖商家，你将处于被动地位。",
+    });
+    const deadEnds = wf?.dead_end_nodes ?? [];
+    const noDeadEnds = deadEnds.length === 0;
+    checks.push({
+        id: "wf_no_dead_ends",
+        dimension: "workflow",
+        description: "无潜在死端节点",
+        weight: 4,
+        passed: noDeadEnds,
+        advice: noDeadEnds ? undefined : `⚠️ 检测到 ${deadEnds.length} 个潜在死端节点：${deadEnds.join(", ")}。这些节点的所有出口都依赖商家操作。`,
+    });
+    const machineUsable = wf ? (wf.machine_published && !wf.machine_paused) : false;
+    checks.push({
+        id: "wf_machine_usable",
+        dimension: "workflow",
+        description: "Machine 已发布且未暂停",
+        weight: 3,
+        passed: machineUsable,
+        advice: machineUsable ? undefined : "⚠️ Machine 未发布或已暂停：流程可能尚未生效或被商家主动暂停。",
+    });
+    const score = checks.reduce((sum, c) => sum + (c.passed ? c.weight : 0), 0);
+    return { name: "workflow", score, max_score: RISK_DIMENSION_MAX.workflow, checks };
+}
+function assessFundRisk(puzzle) {
+    const fund = puzzle.fund_safety;
+    const checks = [];
+    let compScore = 0;
+    let compAdvice;
+    if (fund) {
+        if (fund.compensation_covers_order) {
+            compScore = 10;
+        }
+        else if (fund.compensation_ratio > 0) {
+            compScore = Math.round(fund.compensation_ratio * 10);
+            compAdvice = `⚠️ 赔偿金仅覆盖订单金额的 ${Math.round(fund.compensation_ratio * 100)}%，不足以全额赔付。`;
+        }
+        else {
+            compScore = 0;
+            compAdvice = "🔴 无赔偿金：商家未设置 compensation_fund，订单失败时无自动赔付来源。";
+        }
+    }
+    else {
+        compScore = 5;
+    }
+    checks.push({
+        id: "fund_compensation",
+        dimension: "fund",
+        description: "赔偿金充足度（覆盖订单金额）",
+        weight: 10,
+        passed: compScore >= 7,
+        advice: compAdvice,
+    });
+    const hasRefundAllocator = fund?.refund_allocator_exists ?? false;
+    checks.push({
+        id: "fund_refund_allocator",
+        dimension: "fund",
+        description: "存在 100%→Order 退款 Allocator",
+        weight: 8,
+        passed: hasRefundAllocator,
+        advice: hasRefundAllocator ? undefined : "⚠️ 未检测到 100%→Order Allocator：退款需要商家手动操作或通过仲裁裁定。",
+    });
+    const priceOk = fund ? fund.price_anomaly === "none" : true;
+    checks.push({
+        id: "fund_price_normal",
+        dimension: "fund",
+        description: "价格无异常（与赔偿金和市场价比对）",
+        weight: 4,
+        passed: priceOk,
+        advice: priceOk ? undefined : `⚠️ 价格异常（${fund?.price_anomaly}）：可能存在欺诈定价或异常低价诱惑。`,
+    });
+    const lockSafe = fund?.lock_duration_safe ?? true;
+    checks.push({
+        id: "fund_lock_safe",
+        dimension: "fund",
+        description: "赔偿金锁定期合理（≥7天或无锁定）",
+        weight: 3,
+        passed: lockSafe,
+        advice: lockSafe ? undefined : "⚠️ 赔偿金锁定期过短：商家可能随时撤回资金。",
+    });
+    const naiveScore = checks.reduce((sum, c) => sum + (c.passed ? c.weight : 0), 0);
+    const score = fund && !fund.compensation_covers_order && fund.compensation_ratio > 0
+        ? Math.min(RISK_DIMENSION_MAX.fund, naiveScore + compScore - (compScore >= 7 ? 10 : 0))
+        : naiveScore;
+    return { name: "fund", score, max_score: RISK_DIMENSION_MAX.fund, checks };
+}
+function assessTrustRisk(puzzle) {
+    const trust = puzzle.trust_signals;
+    const checks = [];
+    const arbIndependent = trust?.arbitration_independent ?? true;
+    checks.push({
+        id: "trust_arb_independent",
+        dimension: "trust",
+        description: "仲裁方与商家无利益关联",
+        weight: 6,
+        passed: arbIndependent,
+        advice: arbIndependent ? undefined : "🔴 仲裁方与商家为同一地址：仲裁公正性无法保证。",
+    });
+    let reviewPassed = false;
+    let reviewAdvice;
+    if (trust && trust.review_total > 0) {
+        const likeRate = trust.like_rate;
+        if (likeRate >= 0.85) {
+            reviewPassed = true;
+        }
+        else if (likeRate >= 0.6) {
+            reviewPassed = true;
+            reviewAdvice = `⚠️ 好评率 ${Math.round(likeRate * 100)}%，存在一定争议。`;
+        }
+        else {
+            reviewPassed = false;
+            reviewAdvice = `🔴 好评率仅 ${Math.round(likeRate * 100)}%（${trust.review_likes}/${trust.review_total}），差评较多。`;
+        }
+    }
+    else if (trust) {
+        reviewPassed = true;
+    }
+    else {
+        reviewPassed = true;
+    }
+    checks.push({
+        id: "trust_review_reputation",
+        dimension: "trust",
+        description: "评价声誉良好（好评率 ≥60%）",
+        weight: 5,
+        passed: reviewPassed,
+        advice: reviewAdvice,
+    });
+    const trustScore = trust?.trust_score ?? 50;
+    const trustPassed = trustScore >= 50;
+    checks.push({
+        id: "trust_score",
+        dimension: "trust",
+        description: `综合信任分 ≥50（当前 ${trustScore}）`,
+        weight: 4,
+        passed: trustPassed,
+        advice: trustPassed ? undefined : `🔴 综合信任分仅 ${trustScore}/100，建议寻找更高信任度的商家。`,
+    });
+    const hasContact = trust?.has_contact ?? false;
+    const hasMessenger = trust?.has_messenger ?? false;
+    checks.push({
+        id: "trust_contact",
+        dimension: "trust",
+        description: "商家有可联系的 Messenger 通道",
+        weight: 5,
+        passed: hasContact && hasMessenger,
+        advice: (hasContact && hasMessenger) ? undefined : "🔴 商家无可联系通道（um 为空）：无法进行 pre-order 协商或售后沟通。",
+    });
+    const score = checks.reduce((sum, c) => sum + (c.passed ? c.weight : 0), 0);
+    return { name: "trust", score, max_score: RISK_DIMENSION_MAX.trust, checks };
+}
+function assessBehaviorRisk(puzzle) {
+    const beh = puzzle.merchant_behavior;
+    const checks = [];
+    let trendPassed = false;
+    let trendAdvice;
+    if (beh) {
+        if (beh.recent_trend === "improving") {
+            trendPassed = true;
+        }
+        else if (beh.recent_trend === "stable") {
+            trendPassed = true;
+        }
+        else {
+            trendPassed = false;
+            trendAdvice = "🔴 商家近期争议率上升：履约质量可能在恶化。";
+        }
+    }
+    else {
+        trendPassed = true;
+    }
+    checks.push({
+        id: "behavior_trend",
+        dimension: "behavior",
+        description: "近期履约趋势稳定或改善",
+        weight: 6,
+        passed: trendPassed,
+        advice: trendAdvice,
+    });
+    const completionPassed = beh ? beh.completed_rate >= 0.85 : true;
+    checks.push({
+        id: "behavior_completion_rate",
+        dimension: "behavior",
+        description: "订单完成率 ≥85%",
+        weight: 4,
+        passed: completionPassed,
+        advice: completionPassed ? undefined : `🔴 完成率仅 ${Math.round((beh?.completed_rate ?? 0) * 100)}%：高于平均的订单以失败告终。`,
+    });
+    const disputeOk = beh ? beh.dispute_rate <= 0.1 : true;
+    checks.push({
+        id: "behavior_low_dispute",
+        dimension: "behavior",
+        description: "争议率 ≤10%",
+        weight: 4,
+        passed: disputeOk,
+        advice: disputeOk ? undefined : `⚠️ 争议率 ${Math.round((beh?.dispute_rate ?? 0) * 100)}%：高于行业平均水平。`,
+    });
+    const arbLossOk = beh ? beh.arb_loss_rate <= 0.3 : true;
+    checks.push({
+        id: "behavior_arb_loss",
+        dimension: "behavior",
+        description: "仲裁败诉率 ≤30%",
+        weight: 3,
+        passed: arbLossOk,
+        advice: arbLossOk ? undefined : `🔴 仲裁败诉率 ${Math.round((beh?.arb_loss_rate ?? 0) * 100)}%：商家多次在仲裁中败诉，存在违规倾向。`,
+    });
+    const noRedFlags = beh ? beh.red_flags.length === 0 : true;
+    checks.push({
+        id: "behavior_no_red_flags",
+        dimension: "behavior",
+        description: "无行为 red_flags",
+        weight: 3,
+        passed: noRedFlags,
+        advice: noRedFlags ? undefined : `⚠️ 检测到行为警示信号：${beh?.red_flags.join(", ")}`,
+    });
+    const score = checks.reduce((sum, c) => sum + (c.passed ? c.weight : 0), 0);
+    return { name: "behavior", score, max_score: RISK_DIMENSION_MAX.behavior, checks };
+}
+export function assessRisk(puzzle) {
+    const dimensions = [
+        assessWorkflowRisk(puzzle),
+        assessFundRisk(puzzle),
+        assessTrustRisk(puzzle),
+        assessBehaviorRisk(puzzle),
+    ];
+    const total = dimensions.reduce((sum, d) => sum + d.score, 0);
+    const level = riskLevelFromScore(total);
+    const redFlags = [];
+    for (const dim of dimensions) {
+        for (const check of dim.checks) {
+            if (!check.passed && check.advice && check.advice.startsWith("🔴")) {
+                redFlags.push(`[${dim.name}] ${check.description}: ${check.advice}`);
+            }
+        }
+    }
+    if (puzzle.workflow_analysis?.risk_signals.length) {
+        for (const sig of puzzle.workflow_analysis.risk_signals) {
+            redFlags.push(`[workflow_signal] ${sig}`);
+        }
+    }
+    if (puzzle.merchant_behavior?.red_flags.length) {
+        for (const f of puzzle.merchant_behavior.red_flags) {
+            redFlags.push(`[behavior_flag] ${f}`);
+        }
+    }
+    const advice = generateAdvice(puzzle, total, level, dimensions);
+    return {
+        total,
+        level,
+        dimensions,
+        red_flags: redFlags,
+        advice,
+    };
+}
+function generateAdvice(puzzle, total, level, dimensions) {
+    const advice = [];
+    const emoji = riskLevelEmoji(level);
+    const levelEntry = RISK_LEVELS.find((l) => l.level === level);
+    advice.push(`${emoji} 综合风险评分：${total}/100（${levelEntry?.label ?? "未知"}）`);
+    if (level === "high") {
+        advice.push("🚫 建议放弃此订单：风险水平过高，资金安全无法保证。");
+    }
+    else if (level === "medium_high") {
+        advice.push("⚠️ 建议谨慎下单：务必通过 Messenger 协商补充条款，并要求生成 WTS 凭证。");
+    }
+    else if (level === "medium_low") {
+        advice.push("✅ 可以下单：建议持续关注订单进度，保留沟通记录。");
+    }
+    else {
+        advice.push("✅ 安全订单：可放心下单，仍建议启用订单监控提醒。");
+    }
+    const sortedDims = [...dimensions].sort((a, b) => (a.score / a.max_score) - (b.score / b.max_score));
+    for (const dim of sortedDims) {
+        const ratio = dim.max_score > 0 ? dim.score / dim.max_score : 0;
+        if (ratio < 0.5) {
+            const failedChecks = dim.checks.filter((c) => !c.passed);
+            if (failedChecks.length > 0) {
+                advice.push(`📊 ${dim.name} 维度 ${dim.score}/${dim.max_score}：${failedChecks.length} 项未通过。`);
+                const critical = failedChecks.find((c) => c.advice?.startsWith("🔴"));
+                if (critical?.advice)
+                    advice.push(critical.advice);
+            }
+        }
+    }
+    if (puzzle.completeness < 0.8) {
+        advice.push(`ℹ️ 信息完整度仅 ${Math.round(puzzle.completeness * 100)}%，缺失：${puzzle.gaps.join(", ") || "无"}。建议补充数据后再决策。`);
+    }
+    return advice;
+}
+export function passesRiskThreshold(score, minLevel = "medium_high") {
+    const order = ["high", "medium_high", "medium_low", "low"];
+    const minIdx = order.indexOf(minLevel);
+    const actualIdx = order.indexOf(score.level);
+    return actualIdx >= minIdx;
+}
+export { CUSTOMER_INTELLIGENCE_VERSION };

package/dist/customer/types.d.ts

@@ -0,0 +1,193 @@
+export type PuzzleDepth = "browse" | "evaluate" | "preorder" | "monitor";
+export interface ServiceBasics {
+    service_id: string;
+    name: string;
+    bPublished: boolean;
+    bPaused: boolean;
+    price: string;
+    price_raw: bigint;
+    token_type: string;
+    sales_count: number;
+    machine_id?: string;
+    buy_guard_id?: string;
+    customer_required_count: number;
+    arbitrations_count: number;
+    compensation_fund_balance: bigint;
+    compensation_lock_duration: number;
+    um_id?: string;
+    has_wip: boolean;
+    wip_verified: boolean;
+}
+export interface WorkflowAnalysis {
+    machine_published: boolean;
+    machine_paused: boolean;
+    total_nodes: number;
+    total_forwards: number;
+    user_operable_forwards: number;
+    provider_only_forwards: number;
+    guard_gated_forwards: number;
+    has_refund_path: boolean;
+    has_arbitration_path: boolean;
+    has_milestone_nodes: boolean;
+    dead_end_nodes: string[];
+    terminal_nodes: string[];
+    risk_signals: string[];
+}
+export interface FundSafety {
+    has_order_allocator: boolean;
+    has_refund_allocator: boolean;
+    allocator_count: number;
+    refund_allocator_exists: boolean;
+    surplus_to_provider: boolean;
+    user_path_has_allocator: boolean;
+    compensation_covers_order: boolean;
+    compensation_ratio: number;
+    lock_duration_safe: boolean;
+    price_anomaly: "none" | "low" | "high";
+}
+export interface TrustSignals {
+    arbitration_independent: boolean;
+    arbitration_count: number;
+    arbitration_paused: boolean;
+    review_likes: number;
+    review_dislikes: number;
+    review_verified_count: number;
+    review_total: number;
+    like_rate: number;
+    trust_score: number;
+    trust_level: "high_risk" | "caution" | "moderate" | "trusted";
+    has_contact: boolean;
+    has_messenger: boolean;
+}
+export interface MerchantBehavior {
+    total_orders: number;
+    completed_rate: number;
+    dispute_rate: number;
+    refund_rate: number;
+    arb_loss_rate: number;
+    repeat_buyer_rate: number;
+    recent_trend: "improving" | "stable" | "declining";
+    red_flags: string[];
+}
+export interface MarketContext {
+    similar_services_count: number;
+    avg_price: bigint;
+    min_price: bigint;
+    max_price: bigint;
+    price_percentile: number;
+    supply_demand_ratio: number;
+}
+export interface InfoPuzzle {
+    service_id: string;
+    service_basics: ServiceBasics;
+    workflow_analysis?: WorkflowAnalysis;
+    fund_safety?: FundSafety;
+    trust_signals?: TrustSignals;
+    merchant_behavior?: MerchantBehavior;
+    market_context?: MarketContext;
+    completeness: number;
+    gaps: string[];
+    assembled_at: number;
+}
+export type RiskDimensionName = "workflow" | "fund" | "trust" | "behavior";
+export interface RiskCheck {
+    id: string;
+    dimension: RiskDimensionName;
+    description: string;
+    weight: number;
+    passed: boolean;
+    advice?: string;
+}
+export interface RiskDimensionScore {
+    name: RiskDimensionName;
+    score: number;
+    max_score: number;
+    checks: RiskCheck[];
+}
+export type RiskLevel = "low" | "medium_low" | "medium_high" | "high";
+export interface RiskScore {
+    total: number;
+    level: RiskLevel;
+    dimensions: RiskDimensionScore[];
+    red_flags: string[];
+    advice: string[];
+}
+export interface UserPreferences {
+    price_sensitivity: "low" | "medium" | "high";
+    budget_range?: {
+        min: bigint;
+        max: bigint;
+    };
+    value_orientation: "quality" | "balanced" | "budget";
+    discount_sensitivity: number;
+    delivery_speed_priority: "urgent" | "normal" | "flexible";
+    max_acceptable_cycle: number;
+    response_time_expectation: number;
+    preferred_region?: string;
+    timezone?: string;
+    language?: string;
+    merchant_preference: "established" | "emerging" | "neutral";
+    min_order_history: number;
+    bargain_hunting: number;
+    reward_seeking: boolean;
+    referral_participation: boolean;
+    communication_style: "formal" | "casual" | "friendly";
+    transparency_demand: number;
+    after_sales_expectation: "full" | "basic" | "minimal";
+    risk_appetite: "conservative" | "balanced" | "aggressive";
+    min_trust_score: number;
+    require_arbitration: boolean;
+    require_compensation_fund: boolean;
+    preferred_industries: string[];
+    preferred_tokens: string[];
+    preferred_merchants: string[];
+}
+export type ReminderPriority = "required" | "recommended" | "info" | "reminder";
+export interface Reminder {
+    id: string;
+    stage: "browse" | "evaluate" | "preorder" | "in_progress" | "complete" | "after_sale";
+    priority: ReminderPriority;
+    message: string;
+    action?: string;
+}
+export type GameScenario = "info_asymmetry" | "fund_safety" | "refund_dispute" | "arbitration_fairness" | "pricing" | "delivery_sla" | "quality_verification" | "after_sales";
+export interface GameStrategy {
+    scenario: GameScenario;
+    merchant_tactic: string;
+    user_strategy: string;
+    nash_equilibrium: string;
+}
+export interface CustomerAdvice {
+    risk_score?: number;
+    risk_level?: RiskLevel;
+    recommendations: string[];
+    reminders: Reminder[];
+    preference_match?: {
+        score: number;
+        matches: string[];
+        mismatches: string[];
+    };
+}
+export declare const CUSTOMER_INTELLIGENCE_VERSION = 1;
+export declare const RISK_LEVELS: readonly [{
+    readonly min: 85;
+    readonly level: "low";
+    readonly label: "低风险";
+    readonly color: "🟢";
+}, {
+    readonly min: 70;
+    readonly level: "medium_low";
+    readonly label: "中低风险";
+    readonly color: "🟡";
+}, {
+    readonly min: 50;
+    readonly level: "medium_high";
+    readonly label: "中高风险";
+    readonly color: "🟠";
+}, {
+    readonly min: 0;
+    readonly level: "high";
+    readonly label: "高风险";
+    readonly color: "🔴";
+}];
+export declare const RISK_DIMENSION_MAX: Record<RiskDimensionName, number>;

package/dist/customer/types.js

@@ -0,0 +1,13 @@
+export const CUSTOMER_INTELLIGENCE_VERSION = 1;
+export const RISK_LEVELS = [
+    { min: 85, level: "low", label: "低风险", color: "🟢" },
+    { min: 70, level: "medium_low", label: "中低风险", color: "🟡" },
+    { min: 50, level: "medium_high", label: "中高风险", color: "🟠" },
+    { min: 0, level: "high", label: "高风险", color: "🔴" },
+];
+export const RISK_DIMENSION_MAX = {
+    workflow: 35,
+    fund: 25,
+    trust: 20,
+    behavior: 20,
+};

package/dist/customer/user-preferences.d.ts

@@ -0,0 +1,67 @@
+import type { UserPreferences } from "./types.js";
+import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+export type Industry = "freelance" | "rental" | "education" | "travel" | "subscription" | "retail";
+export declare const SUPPORTED_INDUSTRIES: Industry[];
+export interface IndustryTemplate {
+    max_acceptable_cycle: number;
+    response_time_expectation: number;
+    require_arbitration: boolean;
+    require_compensation_fund: boolean;
+    risk_appetite: UserPreferences["risk_appetite"];
+    delivery_speed_priority: UserPreferences["delivery_speed_priority"];
+    after_sales_expectation: UserPreferences["after_sales_expectation"];
+}
+export declare function getDefaultPreferences(industry?: Industry): UserPreferences;
+export declare function getIndustryTemplate(industry: Industry): IndustryTemplate;
+export interface OrderHistoryEntry {
+    service_id: string;
+    service_owner?: string;
+    industry?: string;
+    price: bigint;
+    avg_market_price: bigint;
+    used_discount: boolean;
+    used_referral: boolean;
+    has_arbitration: boolean;
+    has_compensation: boolean;
+    risk_score_at_purchase?: number;
+    used_messenger: boolean;
+    messenger_messages?: number;
+    completed: boolean;
+    has_dispute: boolean;
+    timestamp: number;
+}
+export interface PreferenceInference {
+    preferences: UserPreferences;
+    confidence: Record<keyof UserPreferences, number>;
+    signals: string[];
+}
+export declare function inferPreferences(history: OrderHistoryEntry[], basePrefs?: UserPreferences): PreferenceInference;
+export interface ServiceForMatching {
+    service_id: string;
+    price: bigint;
+    token_type: string;
+    avg_market_price?: bigint;
+    estimated_cycle_days?: number;
+    estimated_response_hours?: number;
+    merchant_region?: string;
+    merchant_order_history_count: number;
+    merchant_age: "established" | "emerging" | "unknown";
+    has_arbitration: boolean;
+    has_compensation_fund: boolean;
+    has_reward_activity: boolean;
+    has_discount: boolean;
+    risk_score: number;
+    trust_score: number;
+    requires_messenger: boolean;
+    after_sales_support_level: "full" | "basic" | "minimal";
+}
+export interface PreferenceMatchResult {
+    score: number;
+    matches: string[];
+    mismatches: string[];
+    warnings: string[];
+}
+export declare function matchServiceToPreferences(service: ServiceForMatching, prefs: UserPreferences): PreferenceMatchResult;
+export declare function mergePreferences(inferred: UserPreferences, manual: Partial<UserPreferences>): UserPreferences;
+export declare function validatePreferences(prefs: UserPreferences): string[];
+export { CUSTOMER_INTELLIGENCE_VERSION };