@wowok/agent-mcp 2.4.1 → 2.4.3

package/dist/tools/handlers/query.js

@@ -0,0 +1,256 @@
+import { strictParse, WatchQueryOperationsSchema, OnchainTableDataSchema, OnchainEventsInputSchema, ProtocolInfoQuerySchema, } from "../../schema/index.js";
+import { query_local_mark_list, query_account_list, query_local_info_list, query_local_token_list, query_account, GetLocalNamesByAddresses, query_personal, query_objects, query_table, query_tableItem, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_received, queryProtocolInfo, query_events, generateNodeComments, } from "@wowok/wowok";
+import { buildDataSemantic, } from "../../schema/call/semantic.js";
+import { normalizeAccountOrMark } from "./messenger.js";
+export async function handleWatchQueryOperations(args) {
+    const validated = strictParse(WatchQueryOperationsSchema, args, "watch_and_query input");
+    let result;
+    switch (validated.query_type) {
+        case "local_mark_list": {
+            const queryResult = await query_local_mark_list(validated.filter || {});
+            result = { query_type: "local_mark_list", result: queryResult };
+            break;
+        }
+        case "account_list": {
+            const queryResult = await query_account_list(validated.filter);
+            result = { query_type: "account_list", result: queryResult };
+            break;
+        }
+        case "local_info_list": {
+            const queryResult = await query_local_info_list(validated.filter);
+            result = { query_type: "local_info_list", result: queryResult };
+            break;
+        }
+        case "token_list": {
+            const queryResult = await query_local_token_list(validated.filter || {});
+            result = { query_type: "token_list", result: queryResult };
+            break;
+        }
+        case "account_balance": {
+            const queryResult = await query_account({
+                name_or_address: validated.name_or_address,
+                token_type: validated.token_type,
+                balance: validated.balance,
+                coin: validated.coin,
+                network: validated.network,
+            });
+            result = { query_type: "account_balance", result: queryResult };
+            break;
+        }
+        case "local_names": {
+            const queryResult = await GetLocalNamesByAddresses(validated.addresses);
+            result = { query_type: "local_names", result: queryResult };
+            break;
+        }
+        case "onchain_personal_profile": {
+            const queryResult = await query_personal({
+                account: validated.account,
+                no_cache: validated.no_cache,
+                network: validated.network,
+            });
+            result = { query_type: "onchain_personal_profile", result: queryResult };
+            break;
+        }
+        case "onchain_objects": {
+            const queryResult = await query_objects({
+                objects: validated.objects,
+                no_cache: validated.no_cache,
+                network: validated.network,
+            });
+            if (queryResult && queryResult.objects && Array.isArray(queryResult.objects)) {
+                queryResult.objects = queryResult.objects.map((obj) => {
+                    if (obj && obj.data && obj.data.type === "Guard" && obj.data.root) {
+                        try {
+                            const nodeComments = generateNodeComments(obj.data.root);
+                            return {
+                                ...obj,
+                                _guard_node_comments: nodeComments,
+                            };
+                        }
+                        catch (e) {
+                            return obj;
+                        }
+                    }
+                    return obj;
+                });
+            }
+            result = { query_type: "onchain_objects", result: queryResult };
+            break;
+        }
+        case "onchain_received": {
+            const queryResult = await query_received({
+                name_or_address: normalizeAccountOrMark(validated.name_or_address),
+                type: validated.type,
+                cursor: validated.cursor,
+                limit: validated.limit,
+                no_cache: validated.no_cache,
+                network: validated.network,
+            });
+            result = { query_type: "onchain_received", result: queryResult };
+            break;
+        }
+        default:
+            throw new Error(`Unknown query type. Valid query_types are: "local_mark_list", "account_list", "local_info_list", "token_list", "account_balance", "local_names", "onchain_personal_profile", "onchain_objects", "onchain_received". For table queries, use the "onchain_table_data" tool.`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: {
+            result,
+            semantic: buildDataSemantic(result, {
+                operation_type: "query_toolkit",
+                data: validated,
+            }),
+        },
+    };
+}
+export async function handleOnchainTableData(args) {
+    const validated = strictParse(OnchainTableDataSchema, args, "onchain_table_data input");
+    let result;
+    switch (validated.query_type) {
+        case "onchain_table": {
+            const queryResult = await query_table({
+                parent: validated.parent,
+                cursor: validated.cursor,
+                limit: validated.limit,
+                no_cache: validated.no_cache,
+                network: validated.network,
+            });
+            result = { query_type: "onchain_table", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_repository_data": {
+            const queryResult = await queryTableItem_RepositoryData({
+                parent: validated.parent, name: validated.name, entity: validated.entity,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_repository_data", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_permission_perm": {
+            const queryResult = await queryTableItem_PermissionPerm({
+                parent: validated.parent, address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_permission_perm", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_reward_record": {
+            const queryResult = await queryTableItem_RewardRecord({
+                parent: validated.parent, address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_reward_record", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_demand_presenter": {
+            const queryResult = await queryTableItem_DemandPresenter({
+                parent: validated.parent, address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_demand_presenter", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_treasury_history": {
+            const queryResult = await queryTableItem_TreasuryHistory({
+                parent: validated.parent, address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_treasury_history", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_machine_node": {
+            const queryResult = await queryTableItem_MachineNode({
+                parent: validated.parent, key: validated.key,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_machine_node", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_progress_history": {
+            const queryResult = await queryTableItem_ProgressHistory({
+                parent: validated.parent, u64: validated.u64,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_progress_history", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_address_mark": {
+            const queryResult = await queryTableItem_AddressMark({
+                parent: validated.parent, address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_address_mark", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_entity_registrar": {
+            const queryResult = await queryTableItem_EntityRegistrar({
+                address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_entity_registrar", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_entity_linker": {
+            const queryResult = await queryTableItem_EntityLinker({
+                address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_entity_linker", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_generic": {
+            const queryResult = await query_tableItem({
+                parent: validated.parent,
+                key: { type: validated.key_type, value: validated.key_value },
+                no_cache: validated.no_cache,
+                network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_generic", result: queryResult };
+            break;
+        }
+        default:
+            throw new Error(`Unknown table query type. Valid query_types are: "onchain_table", "onchain_table_item_repository_data", "onchain_table_item_permission_perm", "onchain_table_item_reward_record", "onchain_table_item_demand_presenter", "onchain_table_item_treasury_history", "onchain_table_item_machine_node", "onchain_table_item_progress_history", "onchain_table_item_address_mark", "onchain_table_item_entity_registrar", "onchain_table_item_entity_linker", "onchain_table_item_generic"`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: {
+            result,
+            semantic: buildDataSemantic(result, {
+                operation_type: "onchain_table_data",
+                data: validated,
+            }),
+        },
+    };
+}
+export async function handleOnchainEvents(args) {
+    const validated = strictParse(OnchainEventsInputSchema, args, "onchain_events input");
+    const queryResult = await query_events({
+        type: validated.type,
+        cursor: validated.cursor ? {
+            eventSeq: String(validated.cursor.eventSeq),
+            txDigest: validated.cursor.txDigest,
+        } : null,
+        limit: validated.limit ?? null,
+        order: validated.order ?? null,
+        no_cache: validated.no_cache,
+        network: validated.network,
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
+        structuredContent: {
+            result: queryResult,
+            semantic: buildDataSemantic(queryResult, {
+                operation_type: "onchain_events",
+                data: validated,
+            }),
+        },
+    };
+}
+export async function handleWowokInfo(args) {
+    const validated = strictParse(ProtocolInfoQuerySchema, args, "wowok_buildin_info input");
+    const queryResult = await queryProtocolInfo(validated);
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
+        structuredContent: { result: queryResult },
+    };
+}

package/dist/tools/handlers/schema-query.d.ts

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

package/dist/tools/handlers/schema-query.js

@@ -0,0 +1,92 @@
+import { processSchemaQuery, } from "../../schema-query/index.js";
+export async function handleSchemaQuery(args) {
+    const request = {
+        action: args.action,
+        name: args.name,
+        query: args.query,
+    };
+    const response = processSchemaQuery(request);
+    let textContent = response.message;
+    const data = response.data;
+    if (response.success && data) {
+        switch (args.action) {
+            case "list":
+                if (Array.isArray(data) && data.length > 0) {
+                    textContent += "\n\nAll available schemas:\n";
+                    for (const item of data) {
+                        textContent += `\n  • ${item.name}`;
+                        if (item.title) {
+                            textContent += ` - ${item.title}`;
+                        }
+                        if (item.description) {
+                            textContent += `\n    ${item.description.slice(0, 100)}...`;
+                        }
+                        textContent += "\n";
+                    }
+                }
+                break;
+            case "list_operations":
+                if (Array.isArray(data) && data.length > 0) {
+                    textContent += "\n\nOn-chain operation schemas:\n";
+                    for (const item of data) {
+                        textContent += `\n  • ${item.name}`;
+                        if (item.title) {
+                            textContent += ` - ${item.title}`;
+                        }
+                        if (item.description) {
+                            textContent += `\n    ${item.description.slice(0, 100)}...`;
+                        }
+                        textContent += "\n";
+                    }
+                }
+                break;
+            case "get":
+                if (data) {
+                    textContent += "\n\n## JSON Schema\n\n";
+                    textContent += "```json\n";
+                    textContent += JSON.stringify(data, null, 2);
+                    textContent += "\n```\n";
+                }
+                break;
+            case "get_output":
+                if (data) {
+                    textContent += "\n\n## Output JSON Schema\n\n";
+                    textContent += "```json\n";
+                    textContent += JSON.stringify(data, null, 2);
+                    textContent += "\n```\n";
+                }
+                break;
+            case "search":
+                if (Array.isArray(data) && data.length > 0) {
+                    textContent += `\n\nFound ${data.length} schemas matching '${args.query}':\n`;
+                    for (const item of data) {
+                        textContent += `\n  • ${item.name}`;
+                        if (item.title) {
+                            textContent += ` - ${item.title}`;
+                        }
+                        if (item.description) {
+                            textContent += `\n    ${item.description.slice(0, 100)}...`;
+                        }
+                        textContent += "\n";
+                    }
+                }
+                else {
+                    textContent += "\n\nNo schemas found. Try 'list' to browse all available schemas, or use a broader search term.";
+                }
+                break;
+        }
+    }
+    if (response.suggestions && response.suggestions.length > 0) {
+        textContent += "\n\n💡 Suggestions:\n";
+        for (const suggestion of response.suggestions) {
+            textContent += `  • ${suggestion}\n`;
+        }
+    }
+    return {
+        content: [{
+                type: "text",
+                text: textContent,
+            }],
+        structuredContent: response,
+    };
+}

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

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

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;