@wowok/agent-mcp 2.3.13 → 2.3.16

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,185 @@
+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 must have at least one node",
+                severity: "error",
+                check: (d) => Array.isArray(d?.node?.nodes) && d.node.nodes.length > 0,
+                message: () => "Machine has no nodes. A workflow template requires at least one node.",
+            },
+        ],
+    },
+    {
+        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: [
+            {
+                field: "service",
+                description: "Order must reference a service",
+                severity: "error",
+                check: (d) => !!d?.service,
+                message: () => "Order requires a 'service' field pointing to the service being ordered.",
+            },
+        ],
+    },
+    {
+        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: [
+            {
+                field: "parent",
+                description: "Progress must reference a parent machine",
+                severity: "error",
+                check: (d) => !!d?.parent,
+                message: () => "Progress requires a 'parent' field pointing to the Machine.",
+            },
+        ],
+    },
+];
+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/aggregate.d.ts

@@ -0,0 +1,50 @@
+import type { TelemetryEvent } from "../telemetry/index.js";
+export interface ToolStats {
+    tool_name: string;
+    total_calls: number;
+    success_count: number;
+    failed_count: number;
+    pending_input_count: number;
+    success_rate: number;
+    avg_duration_ms: number;
+    p50_duration_ms: number;
+    p95_duration_ms: number;
+    semantic_hit_rate: number;
+    error_distribution: Record<string, number>;
+    top_error_messages: Array<{
+        message: string;
+        count: number;
+    }>;
+}
+export interface OperationStats {
+    operation_type: string;
+    total_calls: number;
+    success_rate: number;
+    semantic_hit_rate: number;
+    error_distribution: Record<string, number>;
+}
+export interface AggregatedStats {
+    aggregation_date: string;
+    total_events: number;
+    date_range: {
+        earliest: string;
+        latest: string;
+    };
+    per_tool: ToolStats[];
+    per_operation: OperationStats[];
+    overall: {
+        total_calls: number;
+        success_count: number;
+        failed_count: number;
+        success_rate: number;
+        semantic_hit_rate: number;
+        unknown_error_count: number;
+        unknown_error_rate: number;
+        avg_duration_ms: number;
+    };
+    error_code_distribution: Record<string, number>;
+    intent_distribution: Record<string, number>;
+}
+export declare function aggregateByTool(events: TelemetryEvent[]): ToolStats[];
+export declare function aggregateByOperation(events: TelemetryEvent[]): OperationStats[];
+export declare function aggregate(events: TelemetryEvent[]): AggregatedStats;

package/dist/loop-engineering/aggregate.js

@@ -0,0 +1,132 @@
+function percentile(sortedValues, p) {
+    if (sortedValues.length === 0)
+        return 0;
+    const idx = Math.ceil((p / 100) * sortedValues.length) - 1;
+    return sortedValues[Math.max(0, idx)];
+}
+function topMessages(messages, limit = 5) {
+    const counts = new Map();
+    for (const msg of messages) {
+        if (!msg)
+            continue;
+        counts.set(msg, (counts.get(msg) || 0) + 1);
+    }
+    return Array.from(counts.entries())
+        .map(([message, count]) => ({ message, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, limit);
+}
+export function aggregateByTool(events) {
+    const groups = new Map();
+    for (const e of events) {
+        const key = e.tool_name || "unknown";
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(e);
+    }
+    const results = [];
+    for (const [tool_name, group] of groups) {
+        const total = group.length;
+        const success = group.filter((e) => e.status === "success").length;
+        const failed = group.filter((e) => e.status === "failed").length;
+        const pending = group.filter((e) => e.status === "pending_input").length;
+        const semanticHits = group.filter((e) => e.semantic_hit).length;
+        const durations = group.map((e) => e.duration_ms).sort((a, b) => a - b);
+        const errorDist = {};
+        const errorMsgs = [];
+        for (const e of group) {
+            if (e.error_code) {
+                errorDist[e.error_code] = (errorDist[e.error_code] || 0) + 1;
+            }
+            if (e.error_message)
+                errorMsgs.push(e.error_message);
+        }
+        results.push({
+            tool_name,
+            total_calls: total,
+            success_count: success,
+            failed_count: failed,
+            pending_input_count: pending,
+            success_rate: total > 0 ? success / total : 0,
+            avg_duration_ms: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+            p50_duration_ms: percentile(durations, 50),
+            p95_duration_ms: percentile(durations, 95),
+            semantic_hit_rate: total > 0 ? semanticHits / total : 0,
+            error_distribution: errorDist,
+            top_error_messages: topMessages(errorMsgs),
+        });
+    }
+    return results.sort((a, b) => b.total_calls - a.total_calls);
+}
+export function aggregateByOperation(events) {
+    const groups = new Map();
+    for (const e of events) {
+        const key = e.operation_type || "unknown";
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(e);
+    }
+    const results = [];
+    for (const [operation_type, group] of groups) {
+        const total = group.length;
+        const success = group.filter((e) => e.status === "success").length;
+        const semanticHits = group.filter((e) => e.semantic_hit).length;
+        const errorDist = {};
+        for (const e of group) {
+            if (e.error_code) {
+                errorDist[e.error_code] = (errorDist[e.error_code] || 0) + 1;
+            }
+        }
+        results.push({
+            operation_type,
+            total_calls: total,
+            success_rate: total > 0 ? success / total : 0,
+            semantic_hit_rate: total > 0 ? semanticHits / total : 0,
+            error_distribution: errorDist,
+        });
+    }
+    return results.sort((a, b) => b.total_calls - a.total_calls);
+}
+export function aggregate(events) {
+    const total = events.length;
+    const success = events.filter((e) => e.status === "success").length;
+    const semanticHits = events.filter((e) => e.semantic_hit).length;
+    const unknownErrors = events.filter((e) => e.error_code === "unknown").length;
+    const durations = events.map((e) => e.duration_ms);
+    const errorDist = {};
+    const intentDist = {};
+    for (const e of events) {
+        if (e.error_code) {
+            errorDist[e.error_code] = (errorDist[e.error_code] || 0) + 1;
+        }
+        if (e.intent) {
+            intentDist[e.intent] = (intentDist[e.intent] || 0) + 1;
+        }
+    }
+    const timestamps = events
+        .map((e) => e.timestamp)
+        .filter(Boolean)
+        .sort();
+    return {
+        aggregation_date: new Date().toISOString(),
+        total_events: total,
+        date_range: {
+            earliest: timestamps[0] || "",
+            latest: timestamps[timestamps.length - 1] || "",
+        },
+        per_tool: aggregateByTool(events),
+        per_operation: aggregateByOperation(events),
+        overall: {
+            total_calls: total,
+            success_count: success,
+            failed_count: events.filter((e) => e.status === "failed").length,
+            success_rate: total > 0 ? success / total : 0,
+            semantic_hit_rate: total > 0 ? semanticHits / total : 0,
+            unknown_error_count: unknownErrors,
+            unknown_error_rate: total > 0 ? unknownErrors / total : 0,
+            avg_duration_ms: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+        },
+        error_code_distribution: errorDist,
+        intent_distribution: intentDist,
+    };
+}

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

@@ -0,0 +1,22 @@
+import type { AggregatedStats } from "./aggregate.js";
+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;
+    type: DiagnosisType;
+    severity: DiagnosisSeverity;
+    title: string;
+    description: string;
+    evidence: Record<string, unknown>;
+    target: string;
+    proposed_improvement_type: "rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation" | "industry_update_application";
+}
+export interface DiagnosisReport {
+    report_id: string;
+    diagnosis_date: string;
+    total_diagnoses: number;
+    diagnoses: Diagnosis[];
+    summary: string;
+}
+export declare function diagnoseIndustryHealth(industries?: string[]): Diagnosis[];
+export declare function diagnose(stats: AggregatedStats): DiagnosisReport;