@wowok/agent-mcp 2.3.13 → 2.3.16

package/dist/customer/user-preferences.js

@@ -0,0 +1,451 @@
+import { CUSTOMER_INTELLIGENCE_VERSION } from "./types.js";
+export const SUPPORTED_INDUSTRIES = [
+    "freelance", "rental", "education", "travel", "subscription", "retail",
+];
+const INDUSTRY_TEMPLATES = {
+    freelance: {
+        max_acceptable_cycle: 30, response_time_expectation: 4,
+        require_arbitration: true, require_compensation_fund: true,
+        risk_appetite: "balanced", delivery_speed_priority: "normal",
+        after_sales_expectation: "full",
+    },
+    rental: {
+        max_acceptable_cycle: 7, response_time_expectation: 8,
+        require_arbitration: true, require_compensation_fund: true,
+        risk_appetite: "conservative", delivery_speed_priority: "normal",
+        after_sales_expectation: "full",
+    },
+    education: {
+        max_acceptable_cycle: 90, response_time_expectation: 24,
+        require_arbitration: true, require_compensation_fund: true,
+        risk_appetite: "conservative", delivery_speed_priority: "flexible",
+        after_sales_expectation: "full",
+    },
+    travel: {
+        max_acceptable_cycle: 14, response_time_expectation: 2,
+        require_arbitration: true, require_compensation_fund: true,
+        risk_appetite: "conservative", delivery_speed_priority: "urgent",
+        after_sales_expectation: "full",
+    },
+    subscription: {
+        max_acceptable_cycle: 30, response_time_expectation: 24,
+        require_arbitration: false, require_compensation_fund: false,
+        risk_appetite: "aggressive", delivery_speed_priority: "normal",
+        after_sales_expectation: "basic",
+    },
+    retail: {
+        max_acceptable_cycle: 7, response_time_expectation: 8,
+        require_arbitration: true, require_compensation_fund: true,
+        risk_appetite: "balanced", delivery_speed_priority: "normal",
+        after_sales_expectation: "full",
+    },
+};
+const BASE_DEFAULTS = {
+    price_sensitivity: "medium",
+    value_orientation: "balanced",
+    discount_sensitivity: 0.3,
+    delivery_speed_priority: "normal",
+    max_acceptable_cycle: 14,
+    response_time_expectation: 8,
+    merchant_preference: "neutral",
+    min_order_history: 3,
+    bargain_hunting: 0.3,
+    reward_seeking: false,
+    referral_participation: false,
+    communication_style: "friendly",
+    transparency_demand: 0.5,
+    after_sales_expectation: "basic",
+    risk_appetite: "balanced",
+    min_trust_score: 50,
+    require_arbitration: true,
+    require_compensation_fund: true,
+    preferred_industries: [],
+    preferred_tokens: ["0x2::wow::WOW"],
+    preferred_merchants: [],
+};
+export function getDefaultPreferences(industry) {
+    if (!industry || !INDUSTRY_TEMPLATES[industry]) {
+        return { ...BASE_DEFAULTS };
+    }
+    const tpl = INDUSTRY_TEMPLATES[industry];
+    return {
+        ...BASE_DEFAULTS,
+        max_acceptable_cycle: tpl.max_acceptable_cycle,
+        response_time_expectation: tpl.response_time_expectation,
+        require_arbitration: tpl.require_arbitration,
+        require_compensation_fund: tpl.require_compensation_fund,
+        risk_appetite: tpl.risk_appetite,
+        delivery_speed_priority: tpl.delivery_speed_priority,
+        after_sales_expectation: tpl.after_sales_expectation,
+    };
+}
+export function getIndustryTemplate(industry) {
+    return { ...INDUSTRY_TEMPLATES[industry] };
+}
+export function inferPreferences(history, basePrefs) {
+    const prefs = { ...(basePrefs ?? getDefaultPreferences()) };
+    const confidence = {};
+    const signals = [];
+    if (history.length < 3) {
+        signals.push(`history=${history.length} < 3，沿用默认偏好`);
+        return { preferences: prefs, confidence, signals };
+    }
+    const lowPricePicks = history.filter((h) => h.avg_market_price > 0n && h.price < (h.avg_market_price * 90n) / 100n);
+    if (lowPricePicks.length >= 3) {
+        prefs.price_sensitivity = "high";
+        prefs.value_orientation = "budget";
+        confidence.price_sensitivity = 0.8;
+        confidence.value_orientation = 0.7;
+        signals.push(`连续 ${lowPricePicks.length} 次选择低于均价 10%+ 的 Service → price_sensitivity=high`);
+    }
+    else if (lowPricePicks.length >= 1) {
+        prefs.price_sensitivity = "medium";
+        confidence.price_sensitivity = 0.5;
+        signals.push(`${lowPricePicks.length} 次低价选择 → price_sensitivity=medium`);
+    }
+    const discountUsers = history.filter((h) => h.used_discount);
+    if (discountUsers.length >= 2) {
+        prefs.discount_sensitivity = 0.8;
+        confidence.discount_sensitivity = 0.85;
+        signals.push(`使用折扣 ${discountUsers.length} 次 → discount_sensitivity=0.8`);
+    }
+    if (history.some((h) => h.used_referral)) {
+        prefs.referral_participation = true;
+        confidence.referral_participation = 1.0;
+        signals.push("使用过推荐码 → referral_participation=true");
+    }
+    if (discountUsers.length >= 2 || history.some((h) => h.used_referral)) {
+        prefs.reward_seeking = true;
+        confidence.reward_seeking = 0.75;
+        signals.push("Reward 行为检测到 → reward_seeking=true");
+    }
+    const bargainSignals = discountUsers.length + (history.some((h) => h.used_referral) ? 1 : 0);
+    if (bargainSignals >= 3) {
+        prefs.bargain_hunting = 0.8;
+        confidence.bargain_hunting = 0.8;
+    }
+    else if (bargainSignals >= 1) {
+        prefs.bargain_hunting = 0.5;
+        confidence.bargain_hunting = 0.6;
+    }
+    const industryCounts = new Map();
+    for (const h of history) {
+        if (h.industry) {
+            industryCounts.set(h.industry, (industryCounts.get(h.industry) ?? 0) + 1);
+        }
+    }
+    const preferredIndustries = Array.from(industryCounts.entries())
+        .filter(([, c]) => c >= 1)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([ind]) => ind);
+    if (preferredIndustries.length > 0) {
+        prefs.preferred_industries = preferredIndustries;
+        confidence.preferred_industries = Math.min(1, (industryCounts.get(preferredIndustries[0]) ?? 0) / 5);
+        signals.push(`偏好行业：${preferredIndustries.join(", ")}`);
+    }
+    const arbPicks = history.filter((h) => h.has_arbitration);
+    if (arbPicks.length >= 3 && arbPicks.length === history.length) {
+        prefs.require_arbitration = true;
+        confidence.require_arbitration = 0.85;
+        signals.push("100% 历史订单选择有仲裁的 Service → require_arbitration=true (confirmed)");
+    }
+    else if (arbPicks.length < history.length / 2) {
+        prefs.require_arbitration = false;
+        confidence.require_arbitration = 0.5;
+        signals.push(`${arbPicks.length}/${history.length} 订单有仲裁 → require_arbitration=false`);
+    }
+    const compPicks = history.filter((h) => h.has_compensation);
+    if (compPicks.length >= 3 && compPicks.length === history.length) {
+        prefs.require_compensation_fund = true;
+        confidence.require_compensation_fund = 0.85;
+        signals.push("100% 历史订单有赔偿金 → require_compensation_fund=true (confirmed)");
+    }
+    else if (compPicks.length < history.length / 2) {
+        prefs.require_compensation_fund = false;
+        confidence.require_compensation_fund = 0.5;
+    }
+    const riskScores = history
+        .map((h) => h.risk_score_at_purchase)
+        .filter((s) => typeof s === "number");
+    if (riskScores.length >= 5) {
+        const minRisk = Math.min(...riskScores);
+        if (minRisk >= 70) {
+            prefs.risk_appetite = "conservative";
+            prefs.min_trust_score = 70;
+            confidence.risk_appetite = 0.8;
+            confidence.min_trust_score = 0.7;
+            signals.push(`历史订单最低风险分 ${minRisk} ≥ 70 → risk_appetite=conservative`);
+        }
+        else if (minRisk < 50) {
+            prefs.risk_appetite = "aggressive";
+            prefs.min_trust_score = Math.max(0, minRisk - 10);
+            confidence.risk_appetite = 0.7;
+            signals.push(`历史订单最低风险分 ${minRisk} < 50 → risk_appetite=aggressive`);
+        }
+    }
+    const messengerUsers = history.filter((h) => h.used_messenger);
+    if (messengerUsers.length >= 2) {
+        const avgMsgs = messengerUsers.reduce((s, h) => s + (h.messenger_messages ?? 0), 0) / messengerUsers.length;
+        if (avgMsgs >= 10) {
+            prefs.communication_style = "formal";
+            confidence.communication_style = 0.6;
+            signals.push(`平均 ${avgMsgs.toFixed(1)} 条 Messenger 消息 → communication_style=formal`);
+        }
+        else if (avgMsgs <= 3) {
+            prefs.communication_style = "casual";
+            confidence.communication_style = 0.5;
+            signals.push(`平均 ${avgMsgs.toFixed(1)} 条 Messenger 消息 → communication_style=casual`);
+        }
+        prefs.transparency_demand = Math.min(1, avgMsgs / 20);
+        confidence.transparency_demand = 0.6;
+    }
+    const disputedCount = history.filter((h) => h.has_dispute).length;
+    if (disputedCount > 0) {
+        prefs.transparency_demand = Math.max(prefs.transparency_demand, 0.7);
+        prefs.after_sales_expectation = "full";
+        confidence.transparency_demand = Math.max(confidence.transparency_demand ?? 0, 0.7);
+        confidence.after_sales_expectation = 0.7;
+        signals.push(`${disputedCount} 次争议 → transparency_demand 提升，after_sales=full`);
+    }
+    const merchantCounts = new Map();
+    for (const h of history) {
+        if (h.service_owner) {
+            merchantCounts.set(h.service_owner, (merchantCounts.get(h.service_owner) ?? 0) + 1);
+        }
+    }
+    prefs.preferred_merchants = Array.from(merchantCounts.entries())
+        .filter(([, c]) => c >= 2)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([m]) => m);
+    if (prefs.preferred_merchants.length > 0) {
+        confidence.preferred_merchants = 0.8;
+        signals.push(`惠顾 ${prefs.preferred_merchants.length} 个商家 ≥2 次`);
+    }
+    return { preferences: prefs, confidence, signals };
+}
+export function matchServiceToPreferences(service, prefs) {
+    const matches = [];
+    const mismatches = [];
+    const warnings = [];
+    let score = 0;
+    let maxScore = 0;
+    maxScore += 25;
+    if (prefs.budget_range) {
+        if (service.price >= prefs.budget_range.min && service.price <= prefs.budget_range.max) {
+            score += 20;
+            matches.push("价格在预算区间内");
+        }
+        else if (service.price < prefs.budget_range.min) {
+            score += 15;
+            matches.push("价格低于预算下限");
+        }
+        else {
+            mismatches.push("价格超出预算上限");
+        }
+    }
+    else if (service.avg_market_price && service.avg_market_price > 0n) {
+        const ratio = Number((service.price * 100n) / service.avg_market_price) / 100;
+        if (prefs.price_sensitivity === "high") {
+            if (ratio <= 0.9) {
+                score += 25;
+                matches.push(`价格低于均价 ${(1 - ratio) * 100 | 0}%（高敏感度用户加分）`);
+            }
+            else if (ratio <= 1.1) {
+                score += 15;
+                matches.push("价格与均价持平");
+            }
+            else {
+                mismatches.push(`价格高于均价 ${((ratio - 1) * 100 | 0)}%（高敏感度用户）`);
+            }
+        }
+        else if (prefs.price_sensitivity === "low") {
+            score += 20;
+            matches.push("低价格敏感度");
+        }
+        else {
+            if (ratio <= 1.0) {
+                score += 20;
+                matches.push("价格不高于均价");
+            }
+            else if (ratio <= 1.2) {
+                score += 12;
+            }
+            else {
+                mismatches.push("价格显著高于均价");
+            }
+        }
+    }
+    else {
+        score += 12;
+    }
+    maxScore += 15;
+    const cycle = service.estimated_cycle_days ?? 0;
+    if (cycle > 0) {
+        if (cycle <= prefs.max_acceptable_cycle) {
+            score += 10;
+            matches.push(`交付周期 ${cycle}天 ≤ 期望 ${prefs.max_acceptable_cycle}天`);
+            if (prefs.delivery_speed_priority === "urgent" && cycle <= Math.max(1, prefs.max_acceptable_cycle / 3)) {
+                score += 5;
+                matches.push("紧急交付需求得到满足");
+            }
+            else if (prefs.delivery_speed_priority === "urgent") {
+                warnings.push("紧急交付需求但周期较长");
+            }
+        }
+        else {
+            mismatches.push(`交付周期 ${cycle}天 > 期望 ${prefs.max_acceptable_cycle}天`);
+        }
+    }
+    else {
+        score += 7;
+    }
+    maxScore += 10;
+    if (prefs.preferred_region) {
+        if (service.merchant_region && service.merchant_region === prefs.preferred_region) {
+            score += 10;
+            matches.push(`商家地域 ${service.merchant_region} 与偏好一致`);
+        }
+        else if (service.merchant_region) {
+            mismatches.push(`商家地域 ${service.merchant_region} 与偏好 ${prefs.preferred_region} 不符`);
+        }
+        else {
+            score += 5;
+        }
+    }
+    else {
+        score += 7;
+    }
+    maxScore += 10;
+    if (service.merchant_order_history_count >= prefs.min_order_history) {
+        score += 7;
+        matches.push(`商家历史 ${service.merchant_order_history_count} 单 ≥ 要求 ${prefs.min_order_history} 单`);
+    }
+    else {
+        mismatches.push(`商家历史 ${service.merchant_order_history_count} 单 < 要求 ${prefs.min_order_history} 单`);
+    }
+    if (prefs.merchant_preference !== "neutral") {
+        if (service.merchant_age === prefs.merchant_preference) {
+            score += 3;
+            matches.push(`商家类型 ${service.merchant_age} 符合偏好`);
+        }
+        else if (service.merchant_age !== "unknown") {
+            mismatches.push(`商家类型 ${service.merchant_age} ≠ 偏好 ${prefs.merchant_preference}`);
+        }
+    }
+    else {
+        score += 3;
+    }
+    maxScore += 15;
+    let bargainScore = 0;
+    if (service.has_reward_activity) {
+        bargainScore += 8;
+        matches.push("有 Reward 活动");
+    }
+    if (service.has_discount) {
+        bargainScore += 7;
+        matches.push("有折扣");
+    }
+    if (prefs.bargain_hunting >= 0.7 && bargainScore === 0) {
+        mismatches.push("用户高 bargain_hunting 但无 Reward/折扣");
+    }
+    else if (prefs.bargain_hunting < 0.3) {
+        if (bargainScore === 0)
+            bargainScore = 10;
+        else
+            bargainScore = Math.min(bargainScore, 5);
+    }
+    else if (prefs.bargain_hunting < 0.7 && bargainScore === 0) {
+        bargainScore = 5;
+    }
+    score += bargainScore;
+    maxScore += 10;
+    if (service.after_sales_support_level === prefs.after_sales_expectation) {
+        score += 5;
+        matches.push(`售后支持 ${service.after_sales_support_level} 符合期望`);
+    }
+    else if ((prefs.after_sales_expectation === "full" && service.after_sales_support_level === "basic") ||
+        (prefs.after_sales_expectation === "full" && service.after_sales_support_level === "minimal") ||
+        (prefs.after_sales_expectation === "basic" && service.after_sales_support_level === "minimal")) {
+        mismatches.push(`售后支持 ${service.after_sales_support_level} < 期望 ${prefs.after_sales_expectation}`);
+    }
+    else {
+        score += 3;
+    }
+    if (prefs.transparency_demand >= 0.7 && service.requires_messenger) {
+        score += 5;
+        matches.push("商家支持 Messenger 沟通（高透明度需求）");
+    }
+    else if (prefs.transparency_demand >= 0.7 && !service.requires_messenger) {
+        mismatches.push("高透明度需求但商家无 Messenger");
+    }
+    else {
+        score += 3;
+    }
+    maxScore += 15;
+    if (service.risk_score >= prefs.min_trust_score) {
+        score += 8;
+        matches.push(`风险分 ${service.risk_score} ≥ 要求 ${prefs.min_trust_score}`);
+    }
+    else {
+        mismatches.push(`风险分 ${service.risk_score} < 要求 ${prefs.min_trust_score}`);
+    }
+    if (prefs.require_arbitration) {
+        if (service.has_arbitration) {
+            score += 4;
+            matches.push("配置了仲裁");
+        }
+        else {
+            mismatches.push("用户要求仲裁但 Service 未配置");
+            warnings.push("⚠️ 无仲裁：用户偏好要求必备仲裁");
+        }
+    }
+    else {
+        score += 4;
+    }
+    if (prefs.require_compensation_fund) {
+        if (service.has_compensation_fund) {
+            score += 3;
+            matches.push("有赔偿金");
+        }
+        else {
+            mismatches.push("用户要求赔偿金但 Service 无");
+            warnings.push("⚠️ 无赔偿金：用户偏好要求必备");
+        }
+    }
+    else {
+        score += 3;
+    }
+    const normalized = maxScore > 0 ? Math.round((score / maxScore) * 100) : 0;
+    return { score: normalized, matches, mismatches, warnings };
+}
+export function mergePreferences(inferred, manual) {
+    return { ...inferred, ...manual };
+}
+export function validatePreferences(prefs) {
+    const issues = [];
+    if (prefs.budget_range && prefs.budget_range.min > prefs.budget_range.max) {
+        issues.push("budget_range.min > budget_range.max");
+    }
+    if (prefs.discount_sensitivity < 0 || prefs.discount_sensitivity > 1) {
+        issues.push("discount_sensitivity must be in [0,1]");
+    }
+    if (prefs.bargain_hunting < 0 || prefs.bargain_hunting > 1) {
+        issues.push("bargain_hunting must be in [0,1]");
+    }
+    if (prefs.transparency_demand < 0 || prefs.transparency_demand > 1) {
+        issues.push("transparency_demand must be in [0,1]");
+    }
+    if (prefs.min_trust_score < 0 || prefs.min_trust_score > 100) {
+        issues.push("min_trust_score must be in [0,100]");
+    }
+    if (prefs.max_acceptable_cycle < 0) {
+        issues.push("max_acceptable_cycle must be ≥ 0");
+    }
+    if (prefs.response_time_expectation < 0) {
+        issues.push("response_time_expectation must be ≥ 0");
+    }
+    return issues;
+}
+export { CUSTOMER_INTELLIGENCE_VERSION };

package/dist/experience/experience-reuse.d.ts

@@ -0,0 +1,10 @@
+import type { UserIntentSignature, ExperienceMatch } from "./types.js";
+export declare function recordSignature(sig: UserIntentSignature): void;
+export declare function findMatches(intent: string, operation_type: string, data: any, limit?: number): ExperienceMatch[];
+export declare function getHistory(intent?: string): UserIntentSignature[];
+export declare function clearHistory(): void;
+export declare function getHistoryStats(): {
+    total: number;
+    by_outcome: Record<string, number>;
+    by_intent: Record<string, number>;
+};

package/dist/experience/experience-reuse.js

@@ -0,0 +1,103 @@
+import { extractSignals } from "./intent-distill.js";
+const MAX_HISTORY = 200;
+const history = [];
+export function recordSignature(sig) {
+    try {
+        history.push(sig);
+        if (history.length > MAX_HISTORY) {
+            history.shift();
+        }
+    }
+    catch {
+    }
+}
+export function findMatches(intent, operation_type, data, limit = 3) {
+    try {
+        const currentSignals = extractSignals(operation_type, data);
+        const now = Date.now();
+        const scored = history
+            .map((sig) => {
+            const relevance = computeRelevance(sig, intent, currentSignals, now);
+            return { signature: sig, relevance };
+        })
+            .filter((s) => s.relevance > 0.3)
+            .sort((a, b) => b.relevance - a.relevance)
+            .slice(0, limit);
+        return scored.map((s) => formatMatch(s.signature, s.relevance));
+    }
+    catch {
+        return [];
+    }
+}
+function computeRelevance(sig, currentIntent, currentSignals, now) {
+    let score = 0;
+    if (sig.intent === currentIntent) {
+        score += 0.5;
+    }
+    else if (sig.intent.startsWith(currentIntent.split("_")[0])) {
+        score += 0.2;
+    }
+    const sigKeys = Object.keys(sig.signals);
+    if (sigKeys.length > 0) {
+        const overlap = sigKeys.filter((k) => {
+            const sigVal = JSON.stringify(sig.signals[k]);
+            const curVal = JSON.stringify(currentSignals[k]);
+            return sigVal === curVal;
+        }).length;
+        score += (overlap / sigKeys.length) * 0.3;
+    }
+    const ageDays = (now - sig.timestamp) / (1000 * 60 * 60 * 24);
+    const decay = Math.exp(-ageDays / 30);
+    score *= decay;
+    return Math.min(1, score);
+}
+function formatMatch(sig, relevance) {
+    const advice = buildAdvice(sig);
+    const avoid = buildAvoid(sig);
+    return {
+        signature: sig,
+        relevance,
+        advice,
+        avoid,
+    };
+}
+function buildAdvice(sig) {
+    if (sig.outcome === "success") {
+        if (sig.recovery_path && sig.recovery_path.length > 0) {
+            return `Last ${sig.intent} succeeded (after ${sig.recovery_path.length} recovery steps), you can follow the same path.`;
+        }
+        return `Last ${sig.intent} succeeded, parameter configuration is valid.`;
+    }
+    if (sig.outcome === "failed" && sig.error_code) {
+        return `Last ${sig.intent} failed (${sig.error_code}), please check the relevant parameters.`;
+    }
+    return `Last ${sig.intent} partially succeeded, check result completeness.`;
+}
+function buildAvoid(sig) {
+    const avoid = [];
+    if (sig.outcome !== "success" && sig.error_code) {
+        avoid.push(`Avoid triggering ${sig.error_code} error`);
+    }
+    if (sig.recovery_path && sig.recovery_path.length > 0) {
+        avoid.push(`Note: last time required ${sig.recovery_path.length} recovery steps to succeed`);
+    }
+    return avoid;
+}
+export function getHistory(intent) {
+    if (intent) {
+        return history.filter((h) => h.intent === intent);
+    }
+    return [...history];
+}
+export function clearHistory() {
+    history.length = 0;
+}
+export function getHistoryStats() {
+    const byOutcome = {};
+    const byIntent = {};
+    for (const h of history) {
+        byOutcome[h.outcome] = (byOutcome[h.outcome] ?? 0) + 1;
+        byIntent[h.intent] = (byIntent[h.intent] ?? 0) + 1;
+    }
+    return { total: history.length, by_outcome: byOutcome, by_intent: byIntent };
+}

package/dist/experience/index.d.ts

@@ -0,0 +1,6 @@
+import { distillIntent, extractSignals } from "./intent-distill.js";
+import { getProfile, updateFromOperation, resetProfile, getProfileStats } from "./user-profile.js";
+import { findMatches, recordSignature, getHistory, clearHistory, getHistoryStats } from "./experience-reuse.js";
+import { getExperienceFeedback, recordOperationOutcome, EXPERIENCE_LAYER_VERSION } from "./realtime-feedback.js";
+import type { DistilledIntent, ExperienceMatch, ExperienceFeedback, UserProfile, UserIntentSignature } from "./types.js";
+export { distillIntent, extractSignals, getProfile, updateFromOperation, resetProfile, getProfileStats, findMatches, recordSignature, getHistory, clearHistory, getHistoryStats, getExperienceFeedback, recordOperationOutcome, EXPERIENCE_LAYER_VERSION, type DistilledIntent, type ExperienceMatch, type ExperienceFeedback, type UserProfile, type UserIntentSignature, };

package/dist/experience/index.js

@@ -0,0 +1,5 @@
+import { distillIntent, extractSignals, } from "./intent-distill.js";
+import { getProfile, updateFromOperation, resetProfile, getProfileStats, } from "./user-profile.js";
+import { findMatches, recordSignature, getHistory, clearHistory, getHistoryStats, } from "./experience-reuse.js";
+import { getExperienceFeedback, recordOperationOutcome, EXPERIENCE_LAYER_VERSION, } from "./realtime-feedback.js";
+export { distillIntent, extractSignals, getProfile, updateFromOperation, resetProfile, getProfileStats, findMatches, recordSignature, getHistory, clearHistory, getHistoryStats, getExperienceFeedback, recordOperationOutcome, EXPERIENCE_LAYER_VERSION, };

package/dist/experience/intent-distill.d.ts

@@ -0,0 +1,3 @@
+import type { DistilledIntent } from "./types.js";
+export declare function distillIntent(operation_type: string, data: any, baseIntent: string): DistilledIntent;
+export declare function extractSignals(operation_type: string, data: any): Record<string, any>;

package/dist/experience/intent-distill.js

@@ -0,0 +1,83 @@
+const URGENCY_RULES = [
+    { operation_type: "payment", urgency: "critical" },
+    { operation_type: "service", signals: (d) => d?.publish === true, urgency: "critical" },
+    { operation_type: "arbitration", signals: (d) => d?.arb === true || d?.arb_operation === "raise", urgency: "critical" },
+    { operation_type: "reward", urgency: "high" },
+    { operation_type: "allocation", urgency: "high" },
+    { operation_type: "treasury", urgency: "high" },
+    { operation_type: "order", urgency: "high" },
+    { operation_type: "service", urgency: "normal" },
+    { operation_type: "machine", urgency: "normal" },
+    { operation_type: "guard", urgency: "normal" },
+    { operation_type: "permission", urgency: "normal" },
+    { operation_type: "progress", urgency: "normal" },
+    { operation_type: "repository", urgency: "normal" },
+    { operation_type: "personal", urgency: "normal" },
+    { operation_type: "contact", urgency: "normal" },
+    { operation_type: "demand", urgency: "normal" },
+    { operation_type: "query_toolkit", urgency: "low" },
+    { operation_type: "onchain_events", urgency: "low" },
+    { operation_type: "onchain_table_data", urgency: "low" },
+    { operation_type: "account_balance", urgency: "low" },
+    { operation_type: "mark_query", urgency: "low" },
+    { operation_type: "local_info", urgency: "low" },
+];
+const SCENARIO_RULES = [
+    { signals: (d) => typeof d?.description === "string" && /freelance|自由职业|设计|开发|外包/i.test(d.description), scenario: "freelance" },
+    { signals: (d) => typeof d?.description === "string" && /rental|租赁|出租/i.test(d.description), scenario: "rental" },
+    { signals: (d) => typeof d?.description === "string" && /course|课程|教育|培训/i.test(d.description), scenario: "education" },
+    { signals: (d) => typeof d?.description === "string" && /travel|旅游|旅行/i.test(d.description), scenario: "travel" },
+    { signals: (d) => typeof d?.description === "string" && /subscri|订阅|会员/i.test(d.description), scenario: "subscription" },
+    { signals: (d) => typeof d?.namedNew?.name === "string" && /shop|store|店|铺/i.test(d.namedNew.name), scenario: "retail" },
+];
+const SECONDARY_INTENT_RULES = [
+    { signals: (d) => d?.publish === true, intent: "immutable_commit" },
+    { signals: (d) => d?.amount?.amount !== undefined && BigInt(d.amount.amount) > 100000000000n, intent: "large_amount" },
+    { signals: (d) => d?.replaceExistName === true, intent: "force_claim_name" },
+    { signals: (d) => d?.arb !== undefined, intent: "dispute_resolution" },
+    { signals: (d) => d?.onChain === true, intent: "public_identity" },
+];
+export function distillIntent(operation_type, data, baseIntent) {
+    const urgencyRules = URGENCY_RULES.filter((r) => r.operation_type === operation_type);
+    const signaled = urgencyRules.find((r) => r.signals && r.signals(data));
+    const urgency = (signaled ?? urgencyRules.find((r) => !r.signals))?.urgency ?? "normal";
+    const scenarioRule = SCENARIO_RULES.find((r) => r.signals(data));
+    const scenario = scenarioRule?.scenario;
+    const secondary_intents = SECONDARY_INTENT_RULES
+        .filter((r) => r.signals(data))
+        .map((r) => r.intent);
+    let confidence = 0.8;
+    if (scenario)
+        confidence = Math.min(1, confidence + 0.1);
+    if (secondary_intents.length > 0)
+        confidence = Math.min(1, confidence + 0.05);
+    if (baseIntent === operation_type)
+        confidence -= 0.15;
+    return {
+        primary_intent: baseIntent,
+        secondary_intents,
+        confidence: Math.max(0, confidence),
+        urgency,
+        scenario,
+    };
+}
+export function extractSignals(operation_type, data) {
+    const signals = {};
+    if (!data || typeof data !== "object")
+        return signals;
+    const keys = ["publish", "amount", "price", "arb", "service", "machine", "order", "reward", "guard", "permission", "replaceExistName", "onChain", "type_parameter"];
+    for (const k of keys) {
+        if (data[k] !== undefined) {
+            signals[k] = data[k];
+        }
+    }
+    if (operation_type === "service") {
+        if (data.namedNew?.name)
+            signals.name = data.namedNew.name;
+    }
+    if (operation_type === "payment" || operation_type === "reward") {
+        if (data.amount?.amount)
+            signals.amount_value = data.amount.amount;
+    }
+    return signals;
+}

package/dist/experience/realtime-feedback.d.ts

@@ -0,0 +1,5 @@
+import type { ExperienceFeedback } from "./types.js";
+import { EXPERIENCE_LAYER_VERSION } from "./types.js";
+export { EXPERIENCE_LAYER_VERSION };
+export declare function getExperienceFeedback(operation_type: string, data: any, baseIntent: string): ExperienceFeedback | undefined;
+export declare function recordOperationOutcome(operation_type: string, data: any, baseIntent: string, outcome: "success" | "failed" | "partial", errorCode?: string, referencedObjects?: string[]): void;