@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/experience/realtime-feedback.js

@@ -0,0 +1,94 @@
+import { distillIntent, extractSignals } from "./intent-distill.js";
+import { getProfile, updateFromOperation } from "./user-profile.js";
+import { findMatches, recordSignature } from "./experience-reuse.js";
+import { EXPERIENCE_LAYER_VERSION } from "./types.js";
+import { isEnabled as isRuntimeEnabled } from "../config/index.js";
+import { recordIndustrySignal } from "../knowledge/flywheel-loop.js";
+export { EXPERIENCE_LAYER_VERSION };
+export function getExperienceFeedback(operation_type, data, baseIntent) {
+    try {
+        const distilled = distillIntent(operation_type, data, baseIntent);
+        const matches = findMatches(distilled.primary_intent, operation_type, data, 3);
+        if (matches.length === 0)
+            return undefined;
+        const topMatch = matches[0];
+        const profile = getProfile();
+        return formatFeedback(topMatch, matches, distilled.scenario, profile);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function recordOperationOutcome(operation_type, data, baseIntent, outcome, errorCode, referencedObjects = []) {
+    try {
+        const distilled = distillIntent(operation_type, data, baseIntent);
+        const signals = extractSignals(operation_type, data);
+        recordSignature({
+            intent: distilled.primary_intent,
+            scenario: distilled.scenario,
+            signals,
+            timestamp: Date.now(),
+            outcome,
+            error_code: errorCode,
+        });
+        updateFromOperation(distilled.primary_intent, distilled.scenario, outcome, errorCode, referencedObjects);
+        try {
+            if (isRuntimeEnabled("industry_evolution")) {
+                const industryHint = (typeof data?.industry === "string" && data.industry.trim())
+                    ? data.industry.trim()
+                    : undefined;
+                if (industryHint) {
+                    const signalOutcome = outcome === "success"
+                        ? { success: true }
+                        : { success: false, error_code: errorCode };
+                    recordIndustrySignal(industryHint, { type: operation_type, data }, signalOutcome);
+                }
+            }
+        }
+        catch {
+        }
+    }
+    catch {
+    }
+}
+function formatFeedback(topMatch, allMatches, scenario, profile) {
+    const advice = buildAdviceText(topMatch, allMatches, profile);
+    const avoid = collectAvoidList(allMatches, profile);
+    const relevance = topMatch.relevance;
+    const matchedScenario = scenario ?? topMatch.signature.scenario;
+    const feedback = {};
+    if (advice)
+        feedback.advice = advice;
+    if (avoid.length > 0)
+        feedback.avoid = avoid;
+    if (relevance > 0)
+        feedback.relevance = Math.round(relevance * 100) / 100;
+    if (matchedScenario)
+        feedback.matched_scenario = matchedScenario;
+    return feedback;
+}
+function buildAdviceText(topMatch, allMatches, profile) {
+    const parts = [];
+    if (topMatch.signature.outcome === "success") {
+        parts.push(`Historically, ${topMatch.signature.intent} operation succeeded`);
+    }
+    else if (topMatch.signature.outcome === "failed") {
+        parts.push(`Historically, ${topMatch.signature.intent} operation failed (${topMatch.signature.error_code ?? "unknown error"}), pay special attention to parameters`);
+    }
+    if (profile.expertise_tier === "novice" && allMatches.length > 0) {
+        parts.push("It is recommended to carefully check parameters before executing");
+    }
+    return parts.join("; ") || topMatch.advice;
+}
+function collectAvoidList(matches, profile) {
+    const avoid = new Set();
+    for (const m of matches) {
+        for (const a of m.avoid) {
+            avoid.add(a);
+        }
+    }
+    for (const p of profile.frequent_pitfalls) {
+        avoid.add(`You often make mistakes at the ${p} step, please be especially careful`);
+    }
+    return Array.from(avoid).slice(0, 5);
+}

package/dist/experience/types.d.ts

@@ -0,0 +1,50 @@
+export interface UserIntentSignature {
+    intent: string;
+    scenario?: string;
+    signals: Record<string, any>;
+    timestamp: number;
+    outcome: "success" | "failed" | "partial";
+    error_code?: string;
+    recovery_path?: string[];
+}
+export interface UserProfile {
+    expertise_tier: "novice" | "advanced" | "expert";
+    preferred_industries: string[];
+    risk_appetite: "conservative" | "balanced" | "aggressive";
+    frequent_pitfalls: string[];
+    reused_objects: string[];
+    preferred_confirmation: "minimal" | "standard" | "verbose";
+    total_operations: number;
+    success_rate: number;
+    last_updated: number;
+    buyer_signals?: BuyerSignals;
+}
+export interface BuyerSignals {
+    purchase_count: number;
+    avg_purchase_price_ratio: number;
+    discount_usage_count: number;
+    referral_usage_count: number;
+    dispute_count: number;
+    inferred_price_sensitivity?: "low" | "medium" | "high";
+    inferred_bargain_hunting?: number;
+}
+export interface DistilledIntent {
+    primary_intent: string;
+    secondary_intents: string[];
+    confidence: number;
+    urgency: "low" | "normal" | "high" | "critical";
+    scenario?: string;
+}
+export interface ExperienceMatch {
+    signature: UserIntentSignature;
+    relevance: number;
+    advice: string;
+    avoid: string[];
+}
+export interface ExperienceFeedback {
+    advice?: string;
+    avoid?: string[];
+    relevance?: number;
+    matched_scenario?: string;
+}
+export declare const EXPERIENCE_LAYER_VERSION = 1;

package/dist/experience/types.js

@@ -0,0 +1 @@
+export const EXPERIENCE_LAYER_VERSION = 1;

package/dist/experience/user-profile.d.ts

@@ -0,0 +1,25 @@
+import type { UserProfile, BuyerSignals } from "./types.js";
+export declare function getProfile(): UserProfile;
+export interface PurchaseOutcomeInput {
+    price: bigint;
+    avg_market_price?: bigint;
+    used_discount?: boolean;
+    used_referral?: boolean;
+    has_dispute?: boolean;
+}
+export declare function recordPurchaseOutcome(input: PurchaseOutcomeInput): void;
+export declare function getBuyerSignals(): BuyerSignals;
+export declare function updateFromOperation(intent: string, scenario: string | undefined, outcome: "success" | "failed" | "partial", errorCode: string | undefined, referencedObjects: string[]): void;
+export declare function resetProfile(): void;
+export declare function getProfileStats(): {
+    total_operations: number;
+    success_rate: number;
+    top_scenarios: Array<{
+        scenario: string;
+        count: number;
+    }>;
+    top_pitfalls: Array<{
+        error_code: string;
+        count: number;
+    }>;
+};

package/dist/experience/user-profile.js

@@ -0,0 +1,171 @@
+let currentProfile = {
+    expertise_tier: "novice",
+    preferred_industries: [],
+    risk_appetite: "balanced",
+    frequent_pitfalls: [],
+    reused_objects: [],
+    preferred_confirmation: "standard",
+    total_operations: 0,
+    success_rate: 1.0,
+    last_updated: 0,
+};
+let buyerSignals = {
+    purchase_count: 0,
+    avg_purchase_price_ratio: 1.0,
+    discount_usage_count: 0,
+    referral_usage_count: 0,
+    dispute_count: 0,
+};
+let scenarioCounts = new Map();
+let pitfallCounts = new Map();
+let objectRefs = new Map();
+let successCount = 0;
+let totalCount = 0;
+export function getProfile() {
+    return { ...currentProfile, buyer_signals: { ...buyerSignals } };
+}
+export function recordPurchaseOutcome(input) {
+    try {
+        buyerSignals.purchase_count++;
+        if (input.used_discount)
+            buyerSignals.discount_usage_count++;
+        if (input.used_referral)
+            buyerSignals.referral_usage_count++;
+        if (input.has_dispute)
+            buyerSignals.dispute_count++;
+        if (input.avg_market_price && input.avg_market_price > 0n) {
+            const ratio = Number((input.price * 100n) / input.avg_market_price) / 100;
+            const prevAvg = buyerSignals.avg_purchase_price_ratio;
+            const n = buyerSignals.purchase_count;
+            buyerSignals.avg_purchase_price_ratio = (prevAvg * (n - 1) + ratio) / n;
+        }
+        recomputeBuyerInferences();
+    }
+    catch {
+    }
+}
+function recomputeBuyerInferences() {
+    const n = buyerSignals.purchase_count;
+    if (n >= 3) {
+        const avgRatio = buyerSignals.avg_purchase_price_ratio;
+        if (avgRatio < 0.9) {
+            buyerSignals.inferred_price_sensitivity = "high";
+        }
+        else if (avgRatio > 1.1) {
+            buyerSignals.inferred_price_sensitivity = "low";
+        }
+        else {
+            buyerSignals.inferred_price_sensitivity = "medium";
+        }
+    }
+    if (n >= 2) {
+        const signalCount = buyerSignals.discount_usage_count + buyerSignals.referral_usage_count;
+        const ratio = signalCount / n;
+        buyerSignals.inferred_bargain_hunting = Math.min(1, ratio);
+    }
+}
+export function getBuyerSignals() {
+    return { ...buyerSignals };
+}
+export function updateFromOperation(intent, scenario, outcome, errorCode, referencedObjects) {
+    try {
+        totalCount++;
+        if (outcome === "success")
+            successCount++;
+        if (scenario) {
+            scenarioCounts.set(scenario, (scenarioCounts.get(scenario) ?? 0) + 1);
+        }
+        if (outcome !== "success" && errorCode) {
+            pitfallCounts.set(errorCode, (pitfallCounts.get(errorCode) ?? 0) + 1);
+        }
+        for (const obj of referencedObjects) {
+            objectRefs.set(obj, (objectRefs.get(obj) ?? 0) + 1);
+        }
+        currentProfile = recomputeProfile();
+    }
+    catch {
+    }
+}
+function recomputeProfile() {
+    const total = totalCount;
+    const successRate = total > 0 ? successCount / total : 1.0;
+    let tier = "novice";
+    if (total >= 50 && successRate >= 0.9)
+        tier = "expert";
+    else if (total >= 10 && successRate >= 0.7)
+        tier = "advanced";
+    const topScenarios = Array.from(scenarioCounts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([s]) => s);
+    let riskAppetite = "balanced";
+    if (total > 20 && successRate < 0.6)
+        riskAppetite = "aggressive";
+    else if (total > 20 && successRate > 0.95)
+        riskAppetite = "conservative";
+    const topPitfalls = Array.from(pitfallCounts.entries())
+        .filter(([, count]) => count >= 2)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([code]) => code);
+    const topObjects = Array.from(objectRefs.entries())
+        .filter(([, count]) => count >= 2)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([obj]) => obj);
+    let preferredConfirmation = "standard";
+    if (tier === "expert")
+        preferredConfirmation = "minimal";
+    else if (tier === "novice")
+        preferredConfirmation = "verbose";
+    return {
+        expertise_tier: tier,
+        preferred_industries: topScenarios,
+        risk_appetite: riskAppetite,
+        frequent_pitfalls: topPitfalls,
+        reused_objects: topObjects,
+        preferred_confirmation: preferredConfirmation,
+        total_operations: total,
+        success_rate: successRate,
+        last_updated: Date.now(),
+    };
+}
+export function resetProfile() {
+    currentProfile = {
+        expertise_tier: "novice",
+        preferred_industries: [],
+        risk_appetite: "balanced",
+        frequent_pitfalls: [],
+        reused_objects: [],
+        preferred_confirmation: "verbose",
+        total_operations: 0,
+        success_rate: 1.0,
+        last_updated: 0,
+    };
+    scenarioCounts = new Map();
+    pitfallCounts = new Map();
+    objectRefs = new Map();
+    successCount = 0;
+    totalCount = 0;
+    buyerSignals = {
+        purchase_count: 0,
+        avg_purchase_price_ratio: 1.0,
+        discount_usage_count: 0,
+        referral_usage_count: 0,
+        dispute_count: 0,
+    };
+}
+export function getProfileStats() {
+    return {
+        total_operations: totalCount,
+        success_rate: totalCount > 0 ? successCount / totalCount : 1.0,
+        top_scenarios: Array.from(scenarioCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([scenario, count]) => ({ scenario, count })),
+        top_pitfalls: Array.from(pitfallCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([error_code, count]) => ({ error_code, count })),
+    };
+}