@wowok/agent-mcp 2.7.1 → 2.7.3

package/dist/knowledge/arbitration-trust.js

@@ -1,117 +0,0 @@
-const WEIGHTS = {
-    acceptanceRate: 35,
-    timeliness: 20,
-    volume: 15,
-    responseSpeed: 10,
-    compensation: 10,
-    identity: 10,
-};
-export function computeTrustScore(metrics) {
-    const components = [];
-    const acceptanceRate = metrics.totalCases > 0
-        ? metrics.acceptedVerdicts / metrics.totalCases
-        : 0;
-    const acceptancePoints = Math.round(acceptanceRate * WEIGHTS.acceptanceRate);
-    components.push({
-        name: "verdict_acceptance",
-        maxPoints: WEIGHTS.acceptanceRate,
-        earnedPoints: acceptancePoints,
-        reason: `${metrics.acceptedVerdicts}/${metrics.totalCases} verdicts accepted without dispute`,
-    });
-    const timelyRate = metrics.totalCases > 0
-        ? metrics.timelyResolutions / metrics.totalCases
-        : 0;
-    const timelyPoints = Math.round(timelyRate * WEIGHTS.timeliness);
-    components.push({
-        name: "timeliness",
-        maxPoints: WEIGHTS.timeliness,
-        earnedPoints: timelyPoints,
-        reason: `${metrics.timelyResolutions}/${metrics.totalCases} cases resolved in time`,
-    });
-    const volumePoints = Math.min(WEIGHTS.volume, Math.round((metrics.totalCases / 20) * WEIGHTS.volume));
-    components.push({
-        name: "case_volume",
-        maxPoints: WEIGHTS.volume,
-        earnedPoints: volumePoints,
-        reason: `${metrics.totalCases} total cases handled`,
-    });
-    let responsePoints = 0;
-    if (metrics.avgResponseHours <= 1)
-        responsePoints = 10;
-    else if (metrics.avgResponseHours <= 6)
-        responsePoints = 7;
-    else if (metrics.avgResponseHours <= 24)
-        responsePoints = 5;
-    else if (metrics.avgResponseHours <= 72)
-        responsePoints = 3;
-    components.push({
-        name: "response_speed",
-        maxPoints: WEIGHTS.responseSpeed,
-        earnedPoints: responsePoints,
-        reason: `Average response: ${metrics.avgResponseHours}h`,
-    });
-    const compPoints = (metrics.compensationLocked !== undefined && metrics.compensationLocked > 0n)
-        ? WEIGHTS.compensation
-        : 0;
-    components.push({
-        name: "compensation_fund",
-        maxPoints: WEIGHTS.compensation,
-        earnedPoints: compPoints,
-        reason: metrics.compensationLocked
-            ? `Compensation fund: ${metrics.compensationLocked} smallest unit`
-            : "No compensation fund locked",
-    });
-    const identityPoints = metrics.hasVerifiedIdentity ? WEIGHTS.identity : 0;
-    components.push({
-        name: "verified_identity",
-        maxPoints: WEIGHTS.identity,
-        earnedPoints: identityPoints,
-        reason: metrics.hasVerifiedIdentity
-            ? "Has verified on-chain Personal identity"
-            : "No verified on-chain identity",
-    });
-    const score = components.reduce((sum, c) => sum + c.earnedPoints, 0);
-    const level = scoreLevel(score);
-    const warnings = buildWarnings(score, metrics, components);
-    return { score, components, level, warnings };
-}
-function scoreLevel(score) {
-    if (score < 25)
-        return "high_risk";
-    if (score < 50)
-        return "caution";
-    if (score < 75)
-        return "moderate";
-    return "trusted";
-}
-function buildWarnings(score, metrics, components) {
-    const warnings = [];
-    if (score < 50) {
-        warnings.push(`Arbitrator trust score is low (${score}/100, ${scoreLevel(score)}). ` +
-            `Customers should choose this arbitrator with caution. The user retains data usage authority; the system does not block usage.`);
-    }
-    if (metrics.disputedVerdicts > 0 && metrics.totalCases > 0) {
-        const disputeRate = metrics.disputedVerdicts / metrics.totalCases;
-        if (disputeRate > 0.3) {
-            warnings.push(`High dispute rate (${(disputeRate * 100).toFixed(1)}%): ` +
-                `${metrics.disputedVerdicts}/${metrics.totalCases} cases had disputes.`);
-        }
-    }
-    if (!metrics.hasVerifiedIdentity) {
-        warnings.push("Arbitrator has not verified on-chain identity (no Personal object); recommend verifying authenticity.");
-    }
-    if (metrics.avgResponseHours > 72) {
-        warnings.push(`Arbitrator average response time is long (${metrics.avgResponseHours}h), which may affect dispute resolution efficiency.`);
-    }
-    return warnings;
-}
-export function quickRiskAssessment(score) {
-    const level = scoreLevel(score);
-    switch (level) {
-        case "high_risk": return "High risk: recommend changing arbitrator or adding compensation fund protection";
-        case "caution": return "Caution: trust score is low, recommend careful evaluation";
-        case "moderate": return "Moderate trust: acceptable, recommend continued observation";
-        case "trusted": return "High trust: arbitrator performs well";
-    }
-}
-export const ARBITRATION_TRUST_VERSION = 1;

package/dist/schema/call/bridge-handler.d.ts

@@ -1,8 +0,0 @@
-import type { CallOutput } from "./base.js";
-export declare function handleBridgeOperations(args: unknown): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-    structuredContent: CallOutput;
-}>;

package/dist/schema/call/bridge-handler.js

@@ -1,265 +0,0 @@
-import { BridgeClient, LocalMark, } from "@wowok/wowok";
-import { classifyError, buildSemantic, buildDataSemantic } from "./semantic.js";
-let _bridgeClient = null;
-let _bridgeClientEnv = null;
-function getBridgeClient(env) {
-    const envObj = env || {};
-    const curAccount = envObj?.account;
-    if (_bridgeClient === null || _bridgeClientEnv === null || curAccount !== _bridgeClientEnv?.account) {
-        _bridgeClient = new BridgeClient({ wowEnv: envObj });
-        _bridgeClientEnv = envObj;
-    }
-    return _bridgeClient;
-}
-function getBridgeClientForQuery() {
-    if (_bridgeClient !== null)
-        return _bridgeClient;
-    _bridgeClient = new BridgeClient({});
-    _bridgeClientEnv = {};
-    return _bridgeClient;
-}
-function validateMainnet(env) {
-    const network = env?.network;
-    if (network && network !== "mainnet") {
-        throw new Error(`Bridge only supports WOW mainnet (current network: '${network}'). Only mainnet provides cross-chain functionality.`);
-    }
-}
-async function resolveWowAddress(addrOrName, env) {
-    if (!addrOrName) {
-        const acc = env?.account;
-        return acc;
-    }
-    if (/^0x[0-9a-fA-F]{64}$/.test(addrOrName))
-        return addrOrName;
-    try {
-        const addr = await LocalMark.Instance().get_address(addrOrName);
-        if (addr)
-            return addr;
-        return addrOrName;
-    }
-    catch {
-        return addrOrName;
-    }
-}
-function safeJson(obj) {
-    return JSON.stringify(obj, (_k, v) => typeof v === "bigint" ? v.toString() : v, 2);
-}
-function convertBigInts(obj) {
-    if (typeof obj === "bigint")
-        return obj.toString();
-    if (Array.isArray(obj))
-        return obj.map(convertBigInts);
-    if (obj && typeof obj === "object") {
-        const out = {};
-        for (const k of Object.keys(obj))
-            out[k] = convertBigInts(obj[k]);
-        return out;
-    }
-    return obj;
-}
-function ok(message, result, context) {
-    const safeResult = convertBigInts(result);
-    const semantic = buildSemantic(safeResult, context);
-    const output = { message, result: { type: "data", data: safeResult }, semantic };
-    return {
-        content: [
-            { type: "text", text: message },
-            { type: "text", text: safeJson(safeResult) },
-        ],
-        structuredContent: output,
-    };
-}
-function err(message, context) {
-    const classified = classifyError(message);
-    const semantic = buildDataSemantic(undefined, context, true, message);
-    const output = {
-        message,
-        result: {
-            type: "error",
-            error: message,
-            error_code: classified.error_code,
-            retryable: classified.retryable,
-            recovery_hint: classified.recovery_hint,
-        },
-        semantic,
-    };
-    return {
-        content: [{ type: "text", text: message }],
-        structuredContent: output,
-    };
-}
-export async function handleBridgeOperations(args) {
-    if (!args || typeof args !== "object") {
-        return err("Invalid args: expected an object with operation_type");
-    }
-    let validated;
-    try {
-        const { strictParse } = await import("./base.js");
-        validated = strictParse((await import("./bridge.js")).BridgeOperationsSchema, args, "bridge_operations input");
-    }
-    catch (e) {
-        return err(`Parameter validation failed: ${e?.message ?? String(e)}`);
-    }
-    const env = validated.env;
-    const ctx = {
-        operation_type: "bridge_" + validated.operation_type,
-        data: validated.data,
-    };
-    try {
-        switch (validated.operation_type) {
-            case "cross_chain_wow_to_evm": {
-                validateMainnet(env);
-                const data = validated.data;
-                const client = getBridgeClient(env);
-                const result = await client.bridgeWowToEvmSimple({
-                    token: data.token,
-                    amount: BigInt(data.amount),
-                    withdrawTo: data.withdrawTo,
-                    waitForFinalization: false,
-                    idempotencyKey: data.idempotencyKey,
-                    idempotentByParams: data.idempotentByParams,
-                });
-                const idemMsg = result.idempotentHit ? " [IDEMPOTENT HIT — no new deposit]" : "";
-                return ok(`WOW→EVM cross-chain step 1 (deposit) submitted. transferId=${result.transferId}, activeEvmAccount=${result.activeEvmAccount}.${idemMsg} ` +
-                    `Next: poll query_transfer_status until bridge signs (~1-5 min), then call claim_wow_to_evm to complete.`, result, ctx);
-            }
-            case "cross_chain_evm_to_wow": {
-                validateMainnet(env);
-                const data = validated.data;
-                const recipientWowAddress = await resolveWowAddress(data.recipientWowAddress, env);
-                const client = getBridgeClient(env);
-                const result = await client.bridgeEvmToWowSimple({
-                    token: data.token,
-                    amount: BigInt(data.amount),
-                    recipientWowAddress,
-                    waitForFinalization: false,
-                    idempotencyKey: data.idempotencyKey,
-                    idempotentByParams: data.idempotentByParams,
-                });
-                const idemMsg = result.idempotentHit ? " [IDEMPOTENT HIT — no new deposit]" : "";
-                return ok(`EVM→WOW cross-chain submitted. transferId=${result.transferId}, activeEvmAccount=${result.activeEvmAccount}.${idemMsg} ` +
-                    `Bridge will auto-claim on WOW (~10-20 min). Poll query_transfer_status to monitor progress.`, result, ctx);
-            }
-            case "claim_wow_to_evm": {
-                validateMainnet(env);
-                const data = validated.data;
-                const client = getBridgeClient(env);
-                const result = await client.claimWowToEvm(data.transferId);
-                return ok(`WOW→EVM claim (step 2) completed. transferId=${result.transferId}, claimTxHash=${result.claimTxHash}`, result, ctx);
-            }
-            case "resume_transfer": {
-                validateMainnet(env);
-                const data = validated.data;
-                const client = getBridgeClient(env);
-                const result = await client.resumeTransfer(data.transferId);
-                return ok(`Transfer ${data.transferId} resumed. Current step: ${result.step}, status: ${result.status}.`, result, ctx);
-            }
-            case "withdraw": {
-                const data = validated.data;
-                const client = getBridgeClientForQuery();
-                let tokenAddress = data.tokenAddress;
-                if (!tokenAddress && data.token && data.token !== "ETH") {
-                    const cfg = client.config;
-                    const chain = cfg?.evmChains?.find((c) => c.name === (data.network ?? "mainnet"));
-                    const tokenMeta = chain?.tokens?.find((t) => t.symbol === data.token);
-                    tokenAddress = tokenMeta?.evmAddress;
-                    if (!tokenAddress) {
-                        return err(`Cannot resolve ERC20 token address for symbol '${data.token}' on chain '${data.network ?? "mainnet"}'. Please pass tokenAddress explicitly.`, ctx);
-                    }
-                }
-                const result = await client.withdrawFromActiveEvmAccount({
-                    to: data.to,
-                    amount: BigInt(data.amount),
-                    tokenAddress,
-                    token: data.token ? data.token : undefined,
-                    network: data.network,
-                });
-                return ok(`Withdrawal submitted. transferId=${result.transferId}, txHash=${result.txHash}`, result, ctx);
-            }
-            case "query_active_evm_account": {
-                const data = validated.data ?? {};
-                const client = getBridgeClientForQuery();
-                const result = await client.queryActiveEvmAccount({
-                    network: data.network,
-                    tokens: data.tokens,
-                });
-                return ok(`activeEvmAccount: ${result.address} (${result.chains.length} chain(s))`, result, ctx);
-            }
-            case "query_supported_evm_chains": {
-                const client = getBridgeClientForQuery();
-                const result = await client.querySupportedEvmChains();
-                return ok(`${result.length} EVM chain(s) supported: ${result.map(c => `${c.name}(chainId=${c.chainId})`).join(", ")}`, result, ctx);
-            }
-            case "query_supported_tokens": {
-                const data = validated.data ?? {};
-                const client = getBridgeClientForQuery();
-                const result = await client.querySupportedTokens({
-                    network: data.network,
-                });
-                const totalTokens = result.reduce((sum, c) => sum + c.tokens.length, 0);
-                return ok(`${result.length} chain(s), ${totalTokens} token entries: ${result.map((c) => `${c.chainName}(${c.tokens.length} tokens)`).join(", ")}`, result, ctx);
-            }
-            case "query_transfer_list": {
-                const data = validated.data ?? {};
-                const client = getBridgeClientForQuery();
-                let result = await client.queryTransferList({
-                    onlyActive: data.onlyActive,
-                });
-                if (data.status) {
-                    result = result.filter((r) => r.status === data.status);
-                }
-                if (data.direction) {
-                    result = result.filter((r) => r.direction === data.direction);
-                }
-                if (data.token) {
-                    result = result.filter((r) => r.token === data.token);
-                }
-                if (data.limit && data.limit > 0) {
-                    result = result.slice(0, data.limit);
-                }
-                const active = result.filter(r => r.status !== "success" && r.status !== "failed").length;
-                return ok(`${result.length} transfer record(s) (${active} in progress)${data.status || data.direction || data.token ? " (filtered)" : ""}`, result, ctx);
-            }
-            case "query_transfer_status": {
-                const data = validated.data;
-                const client = getBridgeClientForQuery();
-                const refresh = data.refresh !== false;
-                if (refresh) {
-                    try {
-                        await Promise.race([
-                            client.refreshTransferStatus(data.transferId),
-                            new Promise((_, reject) => setTimeout(() => reject(new Error("refresh timeout")), 15_000)),
-                        ]);
-                    }
-                    catch {
-                    }
-                }
-                const result = await client.queryTransferStatus(data.transferId);
-                if (!result) {
-                    return err(`transferId '${data.transferId}' not found. ` +
-                        `Use query_transfer_list to see all valid transferIds. ` +
-                        `Note: transfer history is persisted in cache.db and restored on MCP restart, ` +
-                        `so this transferId may never have been created in this environment.`, ctx);
-                }
-                return ok(`Transfer ${data.transferId}: ${result.direction} / ${result.step} / ${result.status}`, result, ctx);
-            }
-            case "manage_evm_rpc": {
-                const data = validated.data;
-                const client = getBridgeClientForQuery();
-                const result = await client.manageEvmRpc({
-                    op: data.op,
-                    network: data.network,
-                    rpcUrls: data.rpcUrls,
-                });
-                return ok(`RPC '${data.op}' operation ${result.success ? "succeeded" : "failed"}`, result, ctx);
-            }
-            default: {
-                return err(`Unsupported operation_type: ${validated.operation_type}`, ctx);
-            }
-        }
-    }
-    catch (e) {
-        const msg = e?.message ?? String(e);
-        return err(`Bridge operation failed: ${msg}`, ctx);
-    }
-}

package/dist/schema/sync-layer4.d.ts

@@ -1,21 +0,0 @@
-export declare const LAYER3_DIR: string;
-export declare const LAYER4_DIR: string;
-export declare const ALL_TOOLS: readonly string[];
-export interface SyncResult {
-    ok: number;
-    failed: number;
-    errors: Array<{
-        tool: string;
-        error: string;
-    }>;
-    layer3Dir: string;
-    layer4Dir: string;
-    total: number;
-}
-export interface SyncOptions {
-    silent?: boolean;
-    layer3Dir?: string;
-    layer4Dir?: string;
-}
-export declare function syncDeployedToolDescriptors(options?: SyncOptions): SyncResult;
-export declare function shouldAutoSyncAtStartup(): boolean;