@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/knowledge/safety-rules.js

@@ -0,0 +1,232 @@
+export const DEFAULT_VALUE_WARNINGS = {
+    defaultAccount: 'Using default account (env.account="")',
+    mainnet: "Operating on mainnet — irreversible",
+    replaceExistName: "replaceExistName=true will unbind the existing name (breaking refs)",
+    defaultToken: "Using default token 0x2::wow::WOW",
+};
+export const DEFAULT_AMOUNT_THRESHOLD = BigInt(100_000_000_000);
+export function getAmountThreshold() {
+    const raw = process.env.WOWOK_AMOUNT_THRESHOLD;
+    if (!raw)
+        return DEFAULT_AMOUNT_THRESHOLD;
+    try {
+        return BigInt(raw);
+    }
+    catch {
+        return DEFAULT_AMOUNT_THRESHOLD;
+    }
+}
+const WOW_PRECISION = 1000000000n;
+export function formatAmount(value, precision = WOW_PRECISION) {
+    const v = typeof value === "string" ? BigInt(value) : value;
+    const whole = v / precision;
+    const frac = v % precision;
+    if (frac === 0n)
+        return `${whole.toString()}`;
+    const fracStr = frac.toString().padStart(Number(precision.toString().length) - 1, "0");
+    return `${whole.toString()}.${fracStr}`;
+}
+export function collectDefaultWarnings(env, data) {
+    const w = [];
+    const acc = env?.account;
+    if (acc === undefined || acc === "") {
+        w.push(DEFAULT_VALUE_WARNINGS.defaultAccount);
+    }
+    const net = env?.network;
+    if (net && /mainnet/i.test(String(net))) {
+        w.push(DEFAULT_VALUE_WARNINGS.mainnet);
+    }
+    const nn = data?.namedNew ?? data?.object;
+    if (nn && typeof nn === "object" && nn.replaceExistName === true) {
+        w.push(DEFAULT_VALUE_WARNINGS.replaceExistName);
+    }
+    return w;
+}
+export const CONFIRMATION_RULES = [
+    {
+        id: "irreversible_fund_or_verdict",
+        when: (ot, data, _env) => {
+            if (ot === "payment")
+                return true;
+            if (ot === "arbitration" && data?.arbitration !== undefined)
+                return true;
+            if (ot === "treasury" && /withdraw|receive/i.test(JSON.stringify(data)))
+                return true;
+            return false;
+        },
+        level: "irreversible",
+        preview: (ot, data, env) => ({
+            level: "irreversible",
+            operation: ot,
+            irreversible: true,
+            network: env?.network,
+            account: env?.account ?? "",
+            warnings: collectDefaultWarnings(env, data),
+            amount: ot === "payment" && data?.amount
+                ? {
+                    value: String(data.amount.amount ?? data.amount.balance ?? ""),
+                    token: data?.token_type ?? "0x2::wow::WOW",
+                    human_readable: formatAmount(String(data.amount.amount ?? data.amount.balance ?? "0")),
+                    recipient: data?.to ?? data?.recipient,
+                }
+                : undefined,
+        }),
+        bypass_on_explicit_intent: [],
+    },
+    {
+        id: "publish_immutable",
+        when: (ot, data, _env) => {
+            if (ot === "service" && (data?.publish === true || data?.bPublished === true))
+                return true;
+            if (ot === "machine" && data?.publish === true)
+                return true;
+            return false;
+        },
+        level: "publish",
+        preview: (ot, data, env) => ({
+            level: "publish",
+            operation: ot,
+            object: data?.object ?? data?.namedNew?.name,
+            network: env?.network,
+            account: env?.account ?? "",
+            immutable_after: ot === "service"
+                ? ["machine", "order_allocators"]
+                : ["nodes", "pairs", "forwards"],
+            warnings: collectDefaultWarnings(env, data),
+        }),
+        bypass_on_explicit_intent: ["force publish", "publish now"],
+    },
+    {
+        id: "amount_sensitive",
+        when: (ot, data, _env) => {
+            const amt = extractAmount(data);
+            if (amt === null)
+                return false;
+            if (ot === "reward" || ot === "treasury")
+                return true;
+            if (ot === "service" && data?.compensation_fund_add)
+                return true;
+            return false;
+        },
+        level: "amount",
+        preview: (ot, data, env) => {
+            const amt = extractAmount(data);
+            return {
+                level: "amount",
+                operation: ot,
+                object: data?.object ?? data?.namedNew?.name,
+                network: env?.network,
+                account: env?.account ?? "",
+                amount: amt
+                    ? {
+                        value: amt,
+                        token: data?.token_type ?? "0x2::wow::WOW",
+                        human_readable: formatAmount(amt),
+                    }
+                    : undefined,
+                warnings: collectDefaultWarnings(env, data),
+            };
+        },
+        bypass_on_explicit_intent: [],
+    },
+    {
+        id: "default_values",
+        when: (_ot, _data, env) => {
+            return collectDefaultWarnings(env, _data).length > 0;
+        },
+        level: "standard",
+        preview: (ot, data, env) => ({
+            level: "standard",
+            operation: ot,
+            object: data?.object ?? data?.namedNew?.name,
+            network: env?.network,
+            account: env?.account ?? "",
+            warnings: collectDefaultWarnings(env, data),
+        }),
+        bypass_on_explicit_intent: [
+            "use default account",
+            "default account is fine",
+            "用默认账户",
+            "用默认账户即可",
+        ],
+    },
+    {
+        id: "guard_create_immutable",
+        when: (ot, data, _env) => {
+            if (ot === "guard")
+                return true;
+            return false;
+        },
+        level: "irreversible",
+        preview: (ot, data, env) => {
+            const table = data?.table ?? [];
+            const root = data?.root;
+            const rely = data?.rely;
+            const rootType = typeof root === 'object' && root !== null && 'type' in root
+                ? root.type
+                : typeof root === 'object' && root !== null && 'type' in root && root.type === 'file'
+                    ? 'file'
+                    : 'unknown';
+            const immutable_fields = ['table', 'root'];
+            if (rely)
+                immutable_fields.push('rely');
+            return {
+                level: "irreversible",
+                operation: ot,
+                object: data?.namedNew?.name,
+                network: env?.network,
+                account: env?.account ?? "",
+                immutable_after: immutable_fields,
+                irreversible: true,
+                warnings: [
+                    ...collectDefaultWarnings(env, data),
+                    `Guard is CREATE-only and immutable — cannot be edited or deleted after creation`,
+                    `Table entries: ${table.length} (max 256)`,
+                    `Root node type: ${rootType} (must return Bool)`,
+                    ...(rely ? [`Rely dependencies: ${rely.guards?.length ?? 0} (max 4, AND/OR logic)`] : []),
+                    `To modify later: export via guard2file → edit → CREATE new → rebind`,
+                ],
+            };
+        },
+        bypass_on_explicit_intent: [],
+    },
+    {
+        id: "guard_gen_passport_test",
+        when: (ot, _data, _env) => {
+            if (ot === "gen_passport")
+                return true;
+            return false;
+        },
+        level: "standard",
+        preview: (ot, data, env) => ({
+            level: "standard",
+            operation: ot,
+            object: data?.guard,
+            network: env?.network,
+            account: env?.account ?? "",
+            warnings: [
+                ...collectDefaultWarnings(env, data),
+                "gen_passport will consume gas for static testing",
+            ],
+        }),
+        bypass_on_explicit_intent: ["test guard", "测试 guard", "gen passport", "生成 passport"],
+    },
+];
+function extractAmount(data) {
+    if (!data)
+        return null;
+    const candidates = [
+        data?.amount?.amount,
+        data?.amount?.balance,
+        data?.balance,
+        data?.amount,
+        data?.compensation_fund_add,
+        data?.deposit,
+    ];
+    for (const c of candidates) {
+        if (c !== undefined && c !== null && c !== "")
+            return String(c);
+    }
+    return null;
+}
+export const SAFETY_RULES_VERSION = 1;

package/dist/knowledge/tool-constraints.d.ts

@@ -0,0 +1,30 @@
+export type ConstraintSeverity = "error" | "warning";
+export interface FieldConstraint {
+    field: string;
+    description: string;
+    severity: ConstraintSeverity;
+    check: (data: any) => boolean;
+    message: (data: any) => string;
+}
+export interface OperationConstraint {
+    operation_type: string;
+    constraints: FieldConstraint[];
+    mutuallyExclusive?: Array<{
+        fields: string[];
+        reason: string;
+    }>;
+    requireOneOf?: Array<{
+        fields: string[];
+        reason: string;
+    }>;
+}
+export declare const TOOL_CONSTRAINTS: OperationConstraint[];
+export interface ConstraintViolation {
+    field: string;
+    severity: ConstraintSeverity;
+    message: string;
+}
+export declare function validateOperation(operation_type: string, data: any): ConstraintViolation[];
+export declare function hasBlockingViolations(violations: ConstraintViolation[]): boolean;
+export declare function getWarningViolations(violations: ConstraintViolation[]): ConstraintViolation[];
+export declare const TOOL_CONSTRAINTS_VERSION = 1;

package/dist/knowledge/tool-constraints.js

@@ -0,0 +1,175 @@
+export const TOOL_CONSTRAINTS = [
+    {
+        operation_type: "service",
+        constraints: [
+            {
+                field: "namedNew.name",
+                description: "Service should have a name for easy reference",
+                severity: "warning",
+                check: (d) => !!d?.namedNew?.name || typeof d?.object === "string",
+                message: () => "Service without a name is hard to reference later. Consider setting namedNew.name.",
+            },
+            {
+                field: "price",
+                description: "Service price should be set before publish",
+                severity: "warning",
+                check: (d) => d?.price !== undefined || !d?.publish,
+                message: () => "Publishing a service without a price — customers won't know the cost.",
+            },
+        ],
+        requireOneOf: [
+            { fields: ["object", "namedNew"], reason: "Must specify either an existing object (string) or create new (namedNew)" },
+        ],
+    },
+    {
+        operation_type: "machine",
+        constraints: [
+            {
+                field: "node.nodes",
+                description: "Machine should have at least one node when published",
+                severity: "warning",
+                check: (d) => {
+                    if (typeof d?.object === "string")
+                        return true;
+                    if (!d?.publish)
+                        return true;
+                    return Array.isArray(d?.node?.nodes) && d.node.nodes.length > 0;
+                },
+                message: () => "Publishing a Machine without nodes — a workflow template requires at least one node. Consider adding nodes before publish, or publish later after adding nodes.",
+            },
+        ],
+    },
+    {
+        operation_type: "payment",
+        constraints: [
+            {
+                field: "revenue",
+                description: "Payment requires at least one revenue entry",
+                severity: "error",
+                check: (d) => Array.isArray(d?.revenue) && d.revenue.length > 0,
+                message: () => "Payment requires a non-empty 'revenue' array (payment recipients and amounts).",
+            },
+            {
+                field: "revenue[0].amount",
+                description: "Payment revenue amount must be specified",
+                severity: "error",
+                check: (d) => Array.isArray(d?.revenue) && d.revenue.length > 0 &&
+                    (!!d.revenue[0]?.amount?.balance || !!d.revenue[0]?.amount?.coin),
+                message: () => "Payment revenue[0].amount must specify either 'balance' value or 'coin' object (see CoinParamSchema).",
+            },
+        ],
+    },
+    {
+        operation_type: "order",
+        constraints: [],
+    },
+    {
+        operation_type: "reward",
+        constraints: [
+            {
+                field: "coin_add",
+                description: "Reward funding requires coin_add",
+                severity: "warning",
+                check: (d) => {
+                    if (d?.claim || d?.guard_add || d?.guard_remove_expired || d?.owner_receive || d?.receive) {
+                        return true;
+                    }
+                    return !!d?.coin_add?.balance || !!d?.coin_add?.coin;
+                },
+                message: () => "Reward funding requires 'coin_add' with either 'balance' value or 'coin' object (see CoinParamSchema). Other operations (claim, guard_add, etc.) don't need coin_add.",
+            },
+        ],
+    },
+    {
+        operation_type: "guard",
+        constraints: [
+            {
+                field: "root",
+                description: "Guard must specify root (node tree or file)",
+                severity: "error",
+                check: (d) => !!d?.root,
+                message: () => "Guard requires a 'root' field (type='node' for tree or type='file' to load from file).",
+            },
+        ],
+    },
+    {
+        operation_type: "permission",
+        constraints: [
+            {
+                field: "with_forbidden",
+                description: "Permission should have at least one rule",
+                severity: "warning",
+                check: (d) => Array.isArray(d?.with_forbidden) && d.with_forbidden.length > 0 || Array.isArray(d?.with_allowed) && d.with_allowed.length > 0,
+                message: () => "Permission has no rules (with_forbidden/with_allowed). An empty permission allows nothing.",
+            },
+        ],
+    },
+    {
+        operation_type: "demand",
+        constraints: [
+            {
+                field: "reward",
+                description: "Demand should have a reward to attract solutions",
+                severity: "warning",
+                check: (d) => !!d?.reward,
+                message: () => "Demand without a reward pool may not attract solution providers.",
+            },
+        ],
+    },
+    {
+        operation_type: "progress",
+        constraints: [],
+    },
+];
+const CONSTRAINT_INDEX = new Map(TOOL_CONSTRAINTS.map((c) => [c.operation_type, c]));
+export function validateOperation(operation_type, data) {
+    const constraint = CONSTRAINT_INDEX.get(operation_type);
+    if (!constraint)
+        return [];
+    const violations = [];
+    for (const c of constraint.constraints) {
+        try {
+            if (!c.check(data)) {
+                violations.push({
+                    field: c.field,
+                    severity: c.severity,
+                    message: c.message(data),
+                });
+            }
+        }
+        catch {
+        }
+    }
+    if (constraint.requireOneOf) {
+        for (const req of constraint.requireOneOf) {
+            const hasAtLeastOne = req.fields.some((f) => data?.[f] !== undefined && data?.[f] !== null);
+            if (!hasAtLeastOne) {
+                violations.push({
+                    field: req.fields.join("|"),
+                    severity: "error",
+                    message: req.reason,
+                });
+            }
+        }
+    }
+    if (constraint.mutuallyExclusive) {
+        for (const mex of constraint.mutuallyExclusive) {
+            const setFields = mex.fields.filter((f) => data?.[f] !== undefined && data?.[f] !== null);
+            if (setFields.length > 1) {
+                violations.push({
+                    field: setFields.join("|"),
+                    severity: "error",
+                    message: `Fields are mutually exclusive: ${setFields.join(", ")}. ${mex.reason}`,
+                });
+            }
+        }
+    }
+    return violations;
+}
+export function hasBlockingViolations(violations) {
+    return violations.some((v) => v.severity === "error");
+}
+export function getWarningViolations(violations) {
+    return violations.filter((v) => v.severity === "warning");
+}
+export const TOOL_CONSTRAINTS_VERSION = 1;

package/dist/knowledge/trust-metrics.d.ts

@@ -0,0 +1,37 @@
+export interface ServiceTrustMetrics {
+    arbitrationScore?: number;
+    arbitrationCases?: number;
+    reviewStats?: {
+        likes: number;
+        dislikes: number;
+        verifiedReviews: number;
+        totalReviews: number;
+    };
+    orderCount?: number;
+    completedRate?: number;
+    avgCompletionTime?: number;
+    compensationFundBalance?: bigint;
+    hasPublishedEvents?: boolean;
+    hasMachineBound?: boolean;
+    hasBuyGuard?: boolean;
+}
+export interface TrustDimension {
+    name: string;
+    score: number;
+    maxScore: number;
+    description: string;
+    humanReadable: string;
+}
+export interface ServiceTrustScore {
+    score: number;
+    level: "high_risk" | "caution" | "moderate" | "trusted";
+    breakdown: TrustDimension[];
+    summary: string;
+    warnings: string[];
+}
+export declare const TRUST_METRICS_VERSION = 1;
+export declare function computeServiceTrustScore(metrics: ServiceTrustMetrics): ServiceTrustScore;
+export declare function quickTrustCheck(metrics: ServiceTrustMetrics): {
+    pass: boolean;
+    reason: string;
+};

package/dist/knowledge/trust-metrics.js

@@ -0,0 +1,138 @@
+export const TRUST_METRICS_VERSION = 1;
+const TRUST_LEVELS = [
+    { min: 75, level: "trusted", label: "高信任" },
+    { min: 50, level: "moderate", label: "中等信任" },
+    { min: 25, level: "caution", label: "需注意" },
+    { min: 0, level: "high_risk", label: "高风险" },
+];
+export function computeServiceTrustScore(metrics) {
+    const breakdown = [];
+    const warnings = [];
+    const arbScore = computeArbitrationDimension(metrics);
+    breakdown.push(arbScore);
+    if (arbScore.score < arbScore.maxScore * 0.3) {
+        warnings.push("仲裁信任分较低，建议检查仲裁记录");
+    }
+    const reviewScore = computeReviewDimension(metrics);
+    breakdown.push(reviewScore);
+    if (reviewScore.score < reviewScore.maxScore * 0.3 && metrics.reviewStats) {
+        warnings.push(`好评率较低 (${metrics.reviewStats.likes}/${metrics.reviewStats.totalReviews})`);
+    }
+    const fulfillmentScore = computeFulfillmentDimension(metrics);
+    breakdown.push(fulfillmentScore);
+    if (metrics.completedRate !== undefined && metrics.completedRate < 0.7) {
+        warnings.push(`完成率仅 ${Math.round(metrics.completedRate * 100)}%`);
+    }
+    const fundScore = computeFundDimension(metrics);
+    breakdown.push(fundScore);
+    if (metrics.compensationFundBalance === undefined || metrics.compensationFundBalance === 0n) {
+        warnings.push("无赔偿金，客户权益保障不足");
+    }
+    const transparencyScore = computeTransparencyDimension(metrics);
+    breakdown.push(transparencyScore);
+    const totalScore = breakdown.reduce((sum, d) => sum + d.score, 0);
+    const level = TRUST_LEVELS.find((l) => totalScore >= l.min)?.level ?? "high_risk";
+    const label = TRUST_LEVELS.find((l) => totalScore >= l.min)?.label ?? "高风险";
+    const summary = buildSummary(totalScore, label, metrics, breakdown);
+    return { score: totalScore, level, breakdown, summary, warnings };
+}
+function computeArbitrationDimension(metrics) {
+    const maxScore = 30;
+    if (metrics.arbitrationScore === undefined) {
+        return { name: "arbitration", score: maxScore * 0.5, maxScore, description: "仲裁信任分（无数据，默认中等）", humanReadable: "仲裁记录: 无数据" };
+    }
+    const score = Math.round((metrics.arbitrationScore / 100) * maxScore);
+    return {
+        name: "arbitration",
+        score,
+        maxScore,
+        description: `仲裁信任分 ${metrics.arbitrationScore}/100`,
+        humanReadable: `仲裁信任: ${metrics.arbitrationScore}/100${metrics.arbitrationCases !== undefined ? ` (${metrics.arbitrationCases} 案件)` : ""}`,
+    };
+}
+function computeReviewDimension(metrics) {
+    const maxScore = 25;
+    if (!metrics.reviewStats || metrics.reviewStats.totalReviews === 0) {
+        return { name: "reviews", score: maxScore * 0.5, maxScore, description: "评价声誉（无评价数据）", humanReadable: "评价: 无数据" };
+    }
+    const { likes, dislikes, verifiedReviews, totalReviews } = metrics.reviewStats;
+    const likeRate = likes / Math.max(1, totalReviews);
+    const verifiedBoost = Math.min(5, verifiedReviews);
+    const score = Math.round(likeRate * (maxScore - 5) + verifiedBoost);
+    return {
+        name: "reviews",
+        score: Math.min(maxScore, score),
+        maxScore,
+        description: `好评率 ${Math.round(likeRate * 100)}% (${totalReviews} 条评价, ${verifiedReviews} 条带凭证)`,
+        humanReadable: `好评率 ${Math.round(likeRate * 100)}% (${totalReviews} 评价)`,
+    };
+}
+function computeFulfillmentDimension(metrics) {
+    const maxScore = 20;
+    if (metrics.orderCount === undefined) {
+        return { name: "fulfillment", score: maxScore * 0.5, maxScore, description: "履约记录（无订单数据）", humanReadable: "履约: 无数据" };
+    }
+    let score = 0;
+    const orderScore = Math.min(10, Math.floor(metrics.orderCount / 5));
+    score += orderScore;
+    if (metrics.completedRate !== undefined) {
+        score += Math.round(metrics.completedRate * 10);
+    }
+    else {
+        score += 5;
+    }
+    return {
+        name: "fulfillment",
+        score: Math.min(maxScore, score),
+        maxScore,
+        description: `已完成 ${metrics.orderCount} 单, 完成率 ${metrics.completedRate !== undefined ? Math.round(metrics.completedRate * 100) + "%" : "未知"}`,
+        humanReadable: `履约: ${metrics.orderCount} 单${metrics.avgCompletionTime !== undefined ? `, 平均 ${metrics.avgCompletionTime}h` : ""}`,
+    };
+}
+function computeFundDimension(metrics) {
+    const maxScore = 15;
+    if (metrics.compensationFundBalance === undefined || metrics.compensationFundBalance === 0n) {
+        return { name: "fund_safety", score: 0, maxScore, description: "无赔偿金", humanReadable: "赔偿金: 无" };
+    }
+    const threshold = 1000000000000n;
+    const ratio = Number(metrics.compensationFundBalance * 100n / threshold) / 100;
+    const score = Math.min(maxScore, Math.round(ratio * maxScore));
+    return {
+        name: "fund_safety",
+        score,
+        maxScore,
+        description: `赔偿金 ${metrics.compensationFundBalance} 最小单位`,
+        humanReadable: `赔偿金: 充足`,
+    };
+}
+function computeTransparencyDimension(metrics) {
+    const maxScore = 10;
+    let score = 0;
+    if (metrics.hasPublishedEvents)
+        score += 4;
+    if (metrics.hasMachineBound)
+        score += 3;
+    if (metrics.hasBuyGuard)
+        score += 3;
+    return {
+        name: "transparency",
+        score: Math.min(maxScore, score),
+        maxScore,
+        description: `链上事件 ${metrics.hasPublishedEvents ? "✓" : "✗"}, Machine ${metrics.hasMachineBound ? "✓" : "✗"}, Guard ${metrics.hasBuyGuard ? "✓" : "✗"}`,
+        humanReadable: `透明度: ${["事件", "Machine", "Guard"].filter((_, i) => [metrics.hasPublishedEvents, metrics.hasMachineBound, metrics.hasBuyGuard][i]).join("+") || "无"}`,
+    };
+}
+function buildSummary(score, label, metrics, breakdown) {
+    const parts = [`信任分 ${score}/100 (${label})`];
+    for (const d of breakdown) {
+        parts.push(`${d.humanReadable}`);
+    }
+    return parts.join("; ");
+}
+export function quickTrustCheck(metrics) {
+    const result = computeServiceTrustScore(metrics);
+    if (result.score < 25) {
+        return { pass: false, reason: `信任分 ${result.score}/100，高风险: ${result.warnings.join("; ")}` };
+    }
+    return { pass: true, reason: `信任分 ${result.score}/100 (${result.level})` };
+}

package/dist/loop-engineering/diagnose.d.ts

@@ -1,5 +1,5 @@
 import type { AggregatedStats } from "./aggregate.js";
-export type DiagnosisType = "rule_gap" | "description_quality" | "skill_need" | "recovery_ineffectiveness" | "latency_anomaly";
+export type DiagnosisType = "rule_gap" | "description_quality" | "skill_need" | "recovery_ineffectiveness" | "latency_anomaly" | "industry_health_anomaly";
 export type DiagnosisSeverity = "P0" | "P1" | "P2" | "P3";
 export interface Diagnosis {
     diagnosis_id: string;
@@ -9,7 +9,7 @@ export interface Diagnosis {
     description: string;
     evidence: Record<string, unknown>;
     target: string;
-    proposed_improvement_type: "rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation";
+    proposed_improvement_type: "rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation" | "industry_update_application";
 }
 export interface DiagnosisReport {
     report_id: string;
@@ -18,4 +18,5 @@ export interface DiagnosisReport {
     diagnoses: Diagnosis[];
     summary: string;
 }
+export declare function diagnoseIndustryHealth(industries?: string[]): Diagnosis[];
 export declare function diagnose(stats: AggregatedStats): DiagnosisReport;