@wowok/agent-mcp 2.6.9 → 2.7.1

package/README.md

@@ -1,8 +1,6 @@
 # WoWok Agent (MCP Server)
 Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.
 
-GitHub: [https://github.com/wowok-ai/agent](https://github.com/wowok-ai/agent)    
-
 AI Skills: [https://github.com/wowok-ai/skills](https://github.com/wowok-ai/skills)     
 
 Docs: [https://github.com/wowok-ai/docs/](https://github.com/wowok-ai/docs/)    

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

@@ -1,8 +1,12 @@
-import type { InfoPuzzle, RiskScore, RiskLevel } from "./types.js";
+import type { InfoPuzzle, RiskScore, RiskLevel, RiskDimensionScore } 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 assessWorkflowRisk(puzzle: InfoPuzzle): RiskDimensionScore;
+export declare function assessFundRisk(puzzle: InfoPuzzle): RiskDimensionScore;
+export declare function assessTrustRisk(puzzle: InfoPuzzle): RiskDimensionScore;
+export declare function assessBehaviorRisk(puzzle: InfoPuzzle): RiskDimensionScore;
 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

@@ -11,7 +11,7 @@ export function riskLevelEmoji(level) {
     const entry = RISK_LEVELS.find((l) => l.level === level);
     return entry?.color ?? "🔴";
 }
-function assessWorkflowRisk(puzzle) {
+export function assessWorkflowRisk(puzzle) {
     const wf = puzzle.workflow_analysis;
     const checks = [];
     const hasArb = wf?.has_arbitration_binding ?? wf?.has_arbitration_path ?? false;
@@ -68,7 +68,7 @@ function assessWorkflowRisk(puzzle) {
     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) {
+export function assessFundRisk(puzzle) {
     const fund = puzzle.fund_safety;
     const checks = [];
     let compScore = 0;
@@ -130,7 +130,7 @@ function assessFundRisk(puzzle) {
         : naiveScore;
     return { name: "fund", score, max_score: RISK_DIMENSION_MAX.fund, checks };
 }
-function assessTrustRisk(puzzle) {
+export function assessTrustRisk(puzzle) {
     const trust = puzzle.trust_signals;
     const checks = [];
     const arbIndependent = trust?.arbitration_independent ?? true;
@@ -217,7 +217,7 @@ function assessTrustRisk(puzzle) {
     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) {
+export function assessBehaviorRisk(puzzle) {
     const beh = puzzle.merchant_behavior;
     const checks = [];
     let trendPassed = false;

package/dist/evaluation/arbitration-game.d.ts

@@ -0,0 +1,16 @@
+import type { ArbStatus } from "../knowledge/arbitration-ledger.js";
+export type ArbGamePerspective = "disputant" | "arbitrator" | "voter" | "both";
+export interface ArbGameAction {
+    action: string;
+    favorability: number;
+    is_optimal: boolean;
+    payoff_note: string;
+    risk: "low" | "medium" | "high";
+}
+export interface ArbGameAdvice {
+    status: ArbStatus;
+    perspective: ArbGamePerspective;
+    actions: ArbGameAction[];
+    summary: string;
+}
+export declare function evaluateArbGame(status: ArbStatus, perspective: ArbGamePerspective): ArbGameAdvice;

package/dist/evaluation/arbitration-game.js

@@ -0,0 +1,48 @@
+const GAME_MATRIX = {
+    Principal_confirming: [
+        { action: "principal_confirm", perspective: "disputant", favorability: 80, payoff: "confirm the proposition to move to arbitrator confirmation", risk: "low" },
+        { action: "proposition_change", perspective: "disputant", favorability: 50, payoff: "modify the proposition before confirming", risk: "medium" },
+    ],
+    Arbitrator_confirming: [
+        { action: "confirm", perspective: "arbitrator", favorability: 80, payoff: "confirm to open voting", risk: "low" },
+        { action: "reset", perspective: "arbitrator", favorability: 30, payoff: "reset back to principal confirmation (extends the case)", risk: "high" },
+    ],
+    Voting: [
+        { action: "vote", perspective: "voter", favorability: 80, payoff: "vote before the deadline", risk: "low" },
+    ],
+    Arbitrated: [
+        { action: "objection", perspective: "disputant", favorability: 60, payoff: "object the ruling (only window)", risk: "medium" },
+        { action: "accept", perspective: "disputant", favorability: 40, payoff: "accept and await compensation", risk: "low" },
+    ],
+    Objectionable: [
+        { action: "reset", perspective: "arbitrator", favorability: 60, payoff: "reset to re-review", risk: "medium" },
+    ],
+    Finished: [
+        { action: "arb_withdraw", perspective: "both", favorability: 80, payoff: "withdraw fees / compensation", risk: "low" },
+    ],
+    Withdrawn: [
+        { action: "done", perspective: "both", favorability: 100, payoff: "case closed", risk: "low" },
+    ],
+};
+export function evaluateArbGame(status, perspective) {
+    const entries = GAME_MATRIX[status] ?? [];
+    const visible = entries.filter((e) => e.perspective === "both" || e.perspective === perspective);
+    const actions = visible
+        .slice()
+        .sort((a, b) => b.favorability - a.favorability)
+        .map((e, i) => ({
+        action: e.action,
+        favorability: e.favorability,
+        is_optimal: i === 0,
+        payoff_note: e.payoff,
+        risk: e.risk,
+    }));
+    return {
+        status,
+        perspective,
+        actions,
+        summary: actions.length === 0
+            ? `No recommended moves for ${perspective} in status '${status}'`
+            : `Optimal for ${perspective} in '${status}': '${actions[0].action}' (${actions[0].payoff_note})`,
+    };
+}

package/dist/evaluation/builtins/demand-match.d.ts

@@ -0,0 +1,15 @@
+import { type CapabilityVector } from "../capability.js";
+import { type DemandExtractInput, type ServiceExtractInput } from "../extract.js";
+import type { EvaluationResult, UserInjection } from "../types.js";
+export declare const DEMAND_MATCH_EVALUATION = "demand_match";
+export declare function registerDemandMatchEvaluation(engine?: import("../engine.js").EvaluationEngine): void;
+export interface DemandMatch {
+    service: ServiceExtractInput;
+    result: EvaluationResult;
+}
+export declare function matchDemandToServices(demandCap: CapabilityVector, services: ServiceExtractInput[], injection?: UserInjection, limit?: number): Promise<DemandMatch[]>;
+export interface ServiceMatch {
+    demand: DemandExtractInput;
+    result: EvaluationResult;
+}
+export declare function matchServiceToDemands(serviceCap: CapabilityVector, demands: DemandExtractInput[], injection?: UserInjection, limit?: number): Promise<ServiceMatch[]>;

package/dist/evaluation/builtins/demand-match.js

@@ -0,0 +1,153 @@
+import { requiredCapabilities } from "../capability.js";
+import { getEvaluationEngine } from "../engine.js";
+import { extractDemandCapability, extractServiceCapability } from "../extract.js";
+import { relateRegion } from "../region.js";
+export const DEMAND_MATCH_EVALUATION = "demand_match";
+const REGION_SCORE = {
+    exact: 100,
+    contains: 85,
+    compatible: 60,
+    overlap: 40,
+    mismatch: 0,
+};
+const dsCaps = {
+    id: "ds_caps",
+    description: "Extract demand + service capability vectors (either may be pre-computed or raw)",
+    evaluation_ids: [DEMAND_MATCH_EVALUATION],
+    extract: (ctx) => ({
+        demand_cap: ctx.entities.demand_cap
+            ?? extractDemandCapability(ctx.entities.demand),
+        service_cap: ctx.entities.service_cap
+            ?? extractServiceCapability(ctx.entities.service),
+    }),
+};
+const regionRule = {
+    id: "region",
+    description: "Geographic region relation between demand and service",
+    dimension: "region",
+    weight: 15,
+    evaluation_ids: [DEMAND_MATCH_EVALUATION],
+    evaluate: (ctx) => {
+        const d = ctx.facts.demand_cap;
+        const s = ctx.facts.service_cap;
+        const rel = relateRegion(d.region, s.region);
+        return { score: REGION_SCORE[rel], weight: 15, reason: `region ${rel}` };
+    },
+};
+const industryRule = {
+    id: "industry",
+    description: "Industry scenario match",
+    dimension: "industry",
+    weight: 20,
+    evaluation_ids: [DEMAND_MATCH_EVALUATION],
+    evaluate: (ctx) => {
+        const d = ctx.facts.demand_cap;
+        const s = ctx.facts.service_cap;
+        if (d.industry === "general" || s.industry === "general") {
+            return { score: 50, weight: 20, reason: "industry unknown (neutral)" };
+        }
+        const score = d.industry === s.industry ? 100 : 0;
+        return { score, weight: 20, reason: `${d.industry} vs ${s.industry}` };
+    },
+};
+const priceRule = {
+    id: "price",
+    description: "Service price within demand budget",
+    dimension: "price",
+    weight: 15,
+    evaluation_ids: [DEMAND_MATCH_EVALUATION],
+    evaluate: (ctx) => {
+        const d = ctx.facts.demand_cap;
+        const s = ctx.facts.service_cap;
+        if (d.price_max === undefined || s.price_min === undefined) {
+            return { score: 50, weight: 15, reason: "price unknown (neutral)" };
+        }
+        if (s.price_min <= d.price_max) {
+            return { score: 100, weight: 15, reason: "within budget" };
+        }
+        if (s.price_min <= (d.price_max * 110n) / 100n) {
+            return { score: 50, weight: 15, reason: "slightly over budget" };
+        }
+        return { score: 0, weight: 15, reason: "over budget" };
+    },
+};
+const trustRule = {
+    id: "trust",
+    description: "Service trust score",
+    dimension: "trust",
+    weight: 15,
+    evaluation_ids: [DEMAND_MATCH_EVALUATION],
+    evaluate: (ctx) => {
+        const s = ctx.facts.service_cap;
+        const t = s.trust_score;
+        const score = t >= 75 ? 100 : t >= 50 ? 60 : t >= 25 ? 30 : 0;
+        return { score, weight: 15, reason: `trust ${t}` };
+    },
+};
+const capabilitiesRule = {
+    id: "capabilities",
+    description: "Demand capability requirements covered by the service",
+    dimension: "capabilities",
+    weight: 30,
+    evaluation_ids: [DEMAND_MATCH_EVALUATION],
+    evaluate: (ctx) => {
+        const d = ctx.facts.demand_cap;
+        const s = ctx.facts.service_cap;
+        const required = requiredCapabilities(d.capabilities);
+        if (required.length === 0) {
+            return { score: 50, weight: 30, reason: "no capability requirement (neutral)" };
+        }
+        const matched = required.filter((k) => s.capabilities[k]);
+        return {
+            score: Math.round((matched.length / required.length) * 100),
+            weight: 30,
+            matched: matched,
+            mismatched: required.filter((k) => !s.capabilities[k]),
+            reason: `${matched.length}/${required.length} required capabilities covered`,
+        };
+    },
+};
+const tagsRule = {
+    id: "tags",
+    description: "Keyword/tag overlap",
+    dimension: "tags",
+    weight: 5,
+    evaluation_ids: [DEMAND_MATCH_EVALUATION],
+    evaluate: (ctx) => {
+        const d = ctx.facts.demand_cap;
+        const s = ctx.facts.service_cap;
+        const demandSet = new Set((d.keywords ?? []).map((k) => k.toLowerCase()));
+        const serviceSet = new Set([...(s.tags ?? []), ...(s.keywords ?? [])].map((k) => k.toLowerCase()));
+        if (demandSet.size === 0) {
+            return { score: 50, weight: 5, reason: "no keywords (neutral)" };
+        }
+        const overlap = [...demandSet].filter((k) => serviceSet.has(k)).length;
+        return { score: Math.round((overlap / demandSet.size) * 100), weight: 5, reason: `${overlap}/${demandSet.size} keywords` };
+    },
+};
+export function registerDemandMatchEvaluation(engine = getEvaluationEngine()) {
+    engine.registerDataSource(dsCaps);
+    for (const r of [regionRule, industryRule, priceRule, trustRule, capabilitiesRule, tagsRule]) {
+        engine.registerRule(r);
+    }
+}
+export async function matchDemandToServices(demandCap, services, injection, limit = 5) {
+    const engine = getEvaluationEngine();
+    const matches = [];
+    for (const service of services) {
+        const result = await engine.evaluate(DEMAND_MATCH_EVALUATION, { demand_cap: demandCap, service }, injection);
+        matches.push({ service, result });
+    }
+    matches.sort((a, b) => b.result.total - a.result.total);
+    return matches.slice(0, limit);
+}
+export async function matchServiceToDemands(serviceCap, demands, injection, limit = 5) {
+    const engine = getEvaluationEngine();
+    const matches = [];
+    for (const demand of demands) {
+        const result = await engine.evaluate(DEMAND_MATCH_EVALUATION, { service_cap: serviceCap, demand }, injection);
+        matches.push({ demand, result });
+    }
+    matches.sort((a, b) => b.result.total - a.result.total);
+    return matches.slice(0, limit);
+}

package/dist/evaluation/builtins/index.d.ts

@@ -0,0 +1,3 @@
+export declare function registerBuiltinEvaluations(): void;
+export { registerDemandMatchEvaluation, matchDemandToServices, matchServiceToDemands, DEMAND_MATCH_EVALUATION, type DemandMatch, type ServiceMatch, } from "./demand-match.js";
+export { registerServiceRiskEvaluation, assessServiceRisk, SERVICE_RISK_EVALUATION, } from "./service-risk.js";

package/dist/evaluation/builtins/index.js

@@ -0,0 +1,10 @@
+import { getEvaluationEngine } from "../engine.js";
+import { registerDemandMatchEvaluation } from "./demand-match.js";
+import { registerServiceRiskEvaluation } from "./service-risk.js";
+export function registerBuiltinEvaluations() {
+    const engine = getEvaluationEngine();
+    registerDemandMatchEvaluation(engine);
+    registerServiceRiskEvaluation(engine);
+}
+export { registerDemandMatchEvaluation, matchDemandToServices, matchServiceToDemands, DEMAND_MATCH_EVALUATION, } from "./demand-match.js";
+export { registerServiceRiskEvaluation, assessServiceRisk, SERVICE_RISK_EVALUATION, } from "./service-risk.js";

package/dist/evaluation/builtins/service-risk.d.ts

@@ -0,0 +1,6 @@
+import { type PuzzleRawData } from "../../customer/info-puzzle.js";
+import type { PuzzleDepth } from "../../customer/types.js";
+import type { EvaluationResult, UserInjection } from "../types.js";
+export declare const SERVICE_RISK_EVALUATION = "service_risk";
+export declare function registerServiceRiskEvaluation(engine?: import("../engine.js").EvaluationEngine): void;
+export declare function assessServiceRisk(serviceId: string, raw: PuzzleRawData, injection?: UserInjection, depth?: PuzzleDepth): Promise<EvaluationResult>;

package/dist/evaluation/builtins/service-risk.js

@@ -0,0 +1,55 @@
+import { assembleInfoPuzzle } from "../../customer/info-puzzle.js";
+import { assessWorkflowRisk, assessFundRisk, assessTrustRisk, assessBehaviorRisk, } from "../../customer/risk-assessment.js";
+import { getEvaluationEngine } from "../engine.js";
+export const SERVICE_RISK_EVALUATION = "service_risk";
+const dsPuzzle = {
+    id: "ds_puzzle",
+    description: "Assemble the service info puzzle from raw chain data",
+    evaluation_ids: [SERVICE_RISK_EVALUATION],
+    extract: (ctx) => {
+        const serviceId = ctx.entities.service_id;
+        const raw = ctx.entities.puzzle_raw;
+        const depth = ctx.entities.depth ?? "preorder";
+        return { puzzle: assembleInfoPuzzle(serviceId, raw, depth) };
+    },
+};
+function dimensionRule(id, dimension, weight, assess) {
+    return {
+        id,
+        description: `${dimension} risk dimension`,
+        dimension,
+        weight,
+        evaluation_ids: [SERVICE_RISK_EVALUATION],
+        evaluate: (ctx) => {
+            const puzzle = ctx.facts.puzzle;
+            const d = assess(puzzle);
+            const normalized = d.max_score > 0 ? Math.round((d.score / d.max_score) * 100) : 0;
+            const passed = d.checks.filter((c) => c.passed);
+            const failed = d.checks.filter((c) => !c.passed);
+            const critical = failed.filter((c) => c.advice?.startsWith("🔴"));
+            return {
+                score: normalized,
+                weight,
+                reason: critical.length > 0
+                    ? critical.map((c) => `[${d.name}] ${c.description}: ${c.advice}`).join("; ")
+                    : `${d.name} ${d.score}/${d.max_score}`,
+                matched: passed.map((c) => c.id),
+                mismatched: failed.map((c) => c.id),
+                red_flag: critical.length > 0,
+            };
+        },
+    };
+}
+const workflowRule = dimensionRule("workflow", "workflow", 35, assessWorkflowRisk);
+const fundRule = dimensionRule("fund", "fund", 25, assessFundRisk);
+const trustRule = dimensionRule("trust", "trust", 20, assessTrustRisk);
+const behaviorRule = dimensionRule("behavior", "behavior", 20, assessBehaviorRisk);
+export function registerServiceRiskEvaluation(engine = getEvaluationEngine()) {
+    engine.registerDataSource(dsPuzzle);
+    for (const r of [workflowRule, fundRule, trustRule, behaviorRule]) {
+        engine.registerRule(r);
+    }
+}
+export async function assessServiceRisk(serviceId, raw, injection, depth = "preorder") {
+    return getEvaluationEngine().evaluate(SERVICE_RISK_EVALUATION, { service_id: serviceId, puzzle_raw: raw, depth }, injection);
+}

package/dist/evaluation/capability.d.ts

@@ -0,0 +1,50 @@
+import type { Region } from "./region.js";
+export type IndustryScenario = "freelance" | "rental" | "education" | "travel" | "subscription" | "retail" | "general" | "custom";
+export interface WorkflowCapabilities {
+    has_arbitration: boolean;
+    has_refund_path: boolean;
+    has_milestone_nodes: boolean;
+    has_compensation_fund: boolean;
+    has_wip_verification: boolean;
+    has_messenger: boolean;
+    has_buy_guard: boolean;
+    has_dynamic_pricing: boolean;
+    is_published: boolean;
+    is_paused: boolean;
+}
+export interface CapabilityVector {
+    id: string;
+    kind: "service" | "demand";
+    owner: string;
+    industry: IndustryScenario;
+    industry_confidence: number;
+    region: Region;
+    price_min?: bigint;
+    price_max?: bigint;
+    token_type: string;
+    ticket_size: "micro" | "small" | "medium" | "large";
+    trust_score: number;
+    reputation_like_ratio: number;
+    arbitration_independent: boolean;
+    merchant_history_count: number;
+    capabilities: WorkflowCapabilities;
+    tags: string[];
+    keywords: string[];
+}
+export interface CapabilityGap {
+    dimension: keyof WorkflowCapabilities | "industry" | "region" | "price" | "trust";
+    requirement: string;
+    provided: string;
+    status: "satisfied" | "partial" | "missing";
+    impact: "critical" | "major" | "minor";
+    suggestion: string;
+}
+export interface CapabilityGapReport {
+    entity_id: string;
+    satisfied: CapabilityGap[];
+    missing: CapabilityGap[];
+    coverage_score: number;
+    summary: string;
+}
+export declare const REQUIREMENT_CAPABILITY_KEYS: Array<keyof WorkflowCapabilities>;
+export declare function requiredCapabilities(c: WorkflowCapabilities): Array<keyof WorkflowCapabilities>;

package/dist/evaluation/capability.js

@@ -0,0 +1,13 @@
+export const REQUIREMENT_CAPABILITY_KEYS = [
+    "has_arbitration",
+    "has_refund_path",
+    "has_milestone_nodes",
+    "has_compensation_fund",
+    "has_wip_verification",
+    "has_messenger",
+    "has_buy_guard",
+    "has_dynamic_pricing",
+];
+export function requiredCapabilities(c) {
+    return REQUIREMENT_CAPABILITY_KEYS.filter((k) => c[k] === true);
+}

package/dist/evaluation/composer.d.ts

@@ -0,0 +1,13 @@
+import type { CapabilityVector, WorkflowCapabilities } from "./capability.js";
+export interface CompositePlan {
+    demand: string;
+    services: Array<{
+        id: string;
+        covered: Array<keyof WorkflowCapabilities>;
+    }>;
+    coverage_score: number;
+    remaining_missing: Array<keyof WorkflowCapabilities>;
+    feasibility: "ready" | "needs_supply_chain" | "infeasible";
+    summary: string;
+}
+export declare function composeServicesForDemand(demand: CapabilityVector, services: CapabilityVector[]): CompositePlan;

package/dist/evaluation/composer.js

@@ -0,0 +1,40 @@
+import { requiredCapabilities } from "./capability.js";
+import { relateRegion } from "./region.js";
+export function composeServicesForDemand(demand, services) {
+    const required = requiredCapabilities(demand.capabilities);
+    const remaining = new Set(required);
+    const chosen = [];
+    const candidates = services.filter((s) => relateRegion(demand.region, s.region) !== "mismatch");
+    while (remaining.size > 0) {
+        let best = null;
+        for (const s of candidates) {
+            if (chosen.some((c) => c.id === s.id))
+                continue;
+            const covered = required.filter((k) => remaining.has(k) && s.capabilities[k]);
+            if (!best || covered.length > best.covered.length) {
+                best = { id: s.id, covered };
+            }
+        }
+        if (!best || best.covered.length === 0)
+            break;
+        chosen.push(best);
+        for (const k of best.covered)
+            remaining.delete(k);
+    }
+    const coverage = required.length === 0
+        ? 100
+        : Math.round(((required.length - remaining.size) / required.length) * 100);
+    const feasibility = remaining.size === 0 ? "ready"
+        : chosen.length > 0 ? "needs_supply_chain"
+            : "infeasible";
+    return {
+        demand: demand.id,
+        services: chosen,
+        coverage_score: coverage,
+        remaining_missing: [...remaining],
+        feasibility,
+        summary: remaining.size === 0
+            ? `Composite of ${chosen.length} service(s) covers all ${required.length} requirements`
+            : `Composite of ${chosen.length} service(s) covers ${coverage}/100; missing: ${[...remaining].join(", ") || "none"}`,
+    };
+}

package/dist/evaluation/engine.d.ts

@@ -0,0 +1,18 @@
+import type { DataSource, EvaluationLevel, EvaluationResult, EvaluationRule, UserInjection } from "./types.js";
+export declare function levelFromScore(score: number): EvaluationLevel;
+export declare class EvaluationEngine {
+    private static instance;
+    private dataSources;
+    private rules;
+    static Instance(): EvaluationEngine;
+    registerDataSource(ds: DataSource): boolean;
+    unregisterDataSource(id: string): boolean;
+    registerRule(rule: EvaluationRule): boolean;
+    unregisterRule(id: string): boolean;
+    getRule(id: string): EvaluationRule | undefined;
+    listRules(): EvaluationRule[];
+    getDataSource(id: string): DataSource | undefined;
+    listDataSources(): DataSource[];
+    evaluate(evaluationId: string, entities: Record<string, unknown>, injection?: UserInjection): Promise<EvaluationResult>;
+}
+export declare function getEvaluationEngine(): EvaluationEngine;