@wowok/agent-mcp 2.3.18 → 2.4.3

package/dist/tools/handlers/trust.js

@@ -0,0 +1,194 @@
+import { strictParse, TrustScoreInputSchema, } from "../../schema/index.js";
+import { query_objects, } from "@wowok/wowok";
+import { computeServiceTrustScore, } from "../../knowledge/index.js";
+import { assembleInfoPuzzle, assessRisk, } from "../../customer/index.js";
+function extractTrustMetrics(serviceObj) {
+    const data = serviceObj?.data ?? serviceObj ?? {};
+    const sales = Array.isArray(data.sales) ? data.sales : [];
+    const activeSales = sales.filter((s) => s && !s.suspension);
+    void activeSales;
+    const compensationFund = data.compensation_fund;
+    const compBalance = (() => {
+        if (compensationFund === null || compensationFund === undefined)
+            return undefined;
+        if (typeof compensationFund === "bigint")
+            return compensationFund;
+        if (typeof compensationFund === "number")
+            return BigInt(compensationFund);
+        if (typeof compensationFund === "string") {
+            try {
+                return BigInt(compensationFund);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        if (typeof compensationFund === "object") {
+            const bal = compensationFund.balance;
+            if (bal === null || bal === undefined)
+                return undefined;
+            try {
+                return BigInt(bal);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    })();
+    return {
+        arbitrationCases: Array.isArray(data.arbitrations) ? data.arbitrations.length : undefined,
+        compensationFundBalance: compBalance,
+        hasMachineBound: typeof data.machine === "string" && data.machine.length > 0,
+        hasBuyGuard: typeof data.buy_guard === "string" && data.buy_guard.length > 0,
+    };
+}
+function buildPuzzleRawData(serviceObj, orderAmount, trustScore, serviceOwner) {
+    const data = serviceObj?.data ?? serviceObj ?? {};
+    const sales = Array.isArray(data.sales) ? data.sales : [];
+    const order_allocators = data.order_allocators
+        ? Array.isArray(data.order_allocators.allocators)
+            ? data.order_allocators
+            : { allocators: data.order_allocators }
+        : undefined;
+    const serviceRaw = {
+        name: data.name ?? serviceObj?.id,
+        bPublished: data.bPublished,
+        bPaused: data.bPaused,
+        price: sales[0]?.price != null ? String(sales[0].price) : "0",
+        priceRaw: sales[0]?.price != null ? BigInt(sales[0].price) : 0n,
+        token_type: sales[0]?.price_type ?? (compensation_fund_token(data) ?? "0x2::wow::WOW"),
+        sales,
+        machine: data.machine ?? undefined,
+        buy_guard: data.buy_guard ?? undefined,
+        customer_required: data.customer_required,
+        arbitrations: data.arbitrations,
+        compensation_fund: data.compensation_fund
+            ? { balance: extractBalance(data.compensation_fund) }
+            : undefined,
+        compensation_lock_duration: typeof data.setting_lock_duration === "number"
+            ? data.setting_lock_duration
+            : undefined,
+        um: data.um ?? undefined,
+        order_allocators: order_allocators ? [order_allocators] : undefined,
+    };
+    return {
+        service: serviceRaw,
+        order_amount: orderAmount,
+        trust_score: trustScore,
+        service_owner: serviceOwner,
+    };
+}
+function compensation_fund_token(data) {
+    if (data?.compensation_fund && typeof data.compensation_fund === "object") {
+        return data.compensation_fund.token_type;
+    }
+    return undefined;
+}
+function extractBalance(b) {
+    if (b === null || b === undefined)
+        return 0n;
+    if (typeof b === "bigint")
+        return b;
+    if (typeof b === "number")
+        return BigInt(b);
+    if (typeof b === "string") {
+        try {
+            return BigInt(b);
+        }
+        catch {
+            return 0n;
+        }
+    }
+    if (typeof b === "object") {
+        const bal = b.balance;
+        if (bal === null || bal === undefined)
+            return 0n;
+        try {
+            return BigInt(bal);
+        }
+        catch {
+            return 0n;
+        }
+    }
+    return 0n;
+}
+export async function handleTrustScore(args) {
+    const validated = strictParse(TrustScoreInputSchema, args, "trust_score input");
+    const depth = (validated.depth ?? "evaluate");
+    const queryResult = await query_objects({
+        objects: [validated.service],
+        no_cache: validated.no_cache,
+        network: validated.network,
+    });
+    const objects = queryResult?.objects;
+    if (!objects || !Array.isArray(objects) || objects.length === 0) {
+        throw new Error(`Service object not found for '${validated.service}'. ` +
+            `Verify the ID/name and network, or use query_toolkit with query_type='onchain_objects' to debug.`);
+    }
+    const serviceObj = objects[0];
+    const objType = serviceObj?.data?.object_type ?? serviceObj?.object_type ?? serviceObj?.type;
+    if (objType && typeof objType === "string" && !objType.includes("Service")) {
+        throw new Error(`Object '${validated.service}' is not a Service (type: ${objType}). ` +
+            `trust_score only evaluates Service objects.`);
+    }
+    const metrics = extractTrustMetrics(serviceObj);
+    const trustScore = computeServiceTrustScore(metrics);
+    const sales = Array.isArray(serviceObj?.data?.sales) ? serviceObj.data.sales : [];
+    const activeSale = sales.find((s) => s && !s.suspension) ?? sales[0];
+    const salePriceRaw = activeSale?.price != null ? BigInt(activeSale.price) : 0n;
+    const orderAmount = validated.order_amount != null
+        ? BigInt(validated.order_amount)
+        : salePriceRaw;
+    let riskScore = undefined;
+    let infoPuzzle = undefined;
+    if (depth === "evaluate" || depth === "preorder") {
+        const puzzleRaw = buildPuzzleRawData(serviceObj, orderAmount, { score: trustScore.score, level: trustScore.level }, undefined);
+        infoPuzzle = assembleInfoPuzzle(validated.service, puzzleRaw, depth);
+        riskScore = assessRisk(infoPuzzle);
+    }
+    const result = {
+        service_id: validated.service,
+        service_name: serviceObj?.data?.name ?? serviceObj?.name ?? validated.service,
+        service_basics: {
+            bPublished: serviceObj?.data?.bPublished ?? false,
+            bPaused: serviceObj?.data?.bPaused ?? false,
+            sales_count: sales.filter((s) => s && !s.suspension).length,
+            has_machine: !!serviceObj?.data?.machine,
+            has_buy_guard: !!serviceObj?.data?.buy_guard,
+            has_um_contact: !!serviceObj?.data?.um,
+            arbitrations_count: Array.isArray(serviceObj?.data?.arbitrations)
+                ? serviceObj.data.arbitrations.length
+                : 0,
+        },
+        trust_score: {
+            score: trustScore.score,
+            level: trustScore.level,
+            summary: trustScore.summary,
+            warnings: trustScore.warnings,
+            breakdown: trustScore.breakdown,
+        },
+        order_amount: orderAmount.toString(),
+        depth,
+        ...(riskScore ? {
+            risk_score: {
+                total: riskScore.total,
+                level: riskScore.level,
+                red_flags: riskScore.red_flags,
+                advice: riskScore.advice,
+                dimensions: riskScore.dimensions,
+            },
+        } : {}),
+        ...(infoPuzzle ? {
+            info_puzzle: {
+                completeness: infoPuzzle.completeness,
+                gaps: infoPuzzle.gaps,
+                assembled_at: infoPuzzle.assembled_at,
+            },
+        } : {}),
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}

package/dist/tools/handlers/wip.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDispatchResult } from "../types.js";
+export declare function handleWipOperations(args: any): Promise<ToolDispatchResult>;

package/dist/tools/handlers/wip.js

@@ -0,0 +1,44 @@
+import { strictParse, WipOperationsSchema, } from "../../schema/index.js";
+import { generate_wip, verify_wip, sign_wip, wip2html, } from "@wowok/wowok";
+export async function handleWipOperations(args) {
+    const validated = strictParse(WipOperationsSchema, args, "wip_file input");
+    let structuredContent;
+    switch (validated.type) {
+        case "generate": {
+            const result = await generate_wip(validated.options, validated.outputPath);
+            structuredContent = { result: { type: "generate", filePath: result } };
+            break;
+        }
+        case "verify": {
+            const result = await verify_wip(validated.wipFilePath, validated.hash_equal, validated.requireSignature);
+            structuredContent = { result: { type: "verify", ...result } };
+            break;
+        }
+        case "sign": {
+            const result = await sign_wip(validated.wipFilePath, validated.account, validated.outputPath);
+            structuredContent = { result: { type: "sign", filePath: result } };
+            break;
+        }
+        case "wip2html": {
+            const result = await wip2html(validated.wipPath, validated.options);
+            let output = { type: "wip2html" };
+            if (typeof result === "string") {
+                output.html = result;
+            }
+            else if (Array.isArray(result)) {
+                output.files = result;
+            }
+            else {
+                output.html = String(result);
+            }
+            structuredContent = { result: output };
+            break;
+        }
+        default:
+            throw new Error("Unknown WIP operation type");
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+        structuredContent,
+    };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,13 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ToolEntry, ToolDispatchResult, DispatchOptions } from "./types.js";
+export declare const TOOL_REGISTRY: ToolEntry[];
+export declare const TOOL_REGISTRY_MAP: Map<string, ToolEntry>;
+export declare function dispatchToolCall(name: string, args: any, options?: DispatchOptions): Promise<ToolDispatchResult>;
+export interface ToolListEntry {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export declare function listTools(): ToolListEntry[];
+export declare function registerAllTools(server: McpServer): void;