@wowok/agent-mcp 2.3.18 → 2.4.3

package/dist/schemas/onchain_table_data.output.json

@@ -1589,6 +1589,7 @@
                                   "number",
                                   "string"
                                 ],
+                                "default": 0,
                                 "description": "Threshold to trigger node advancement. If total Forward weight is greater than or equal to threshold, node advancement is triggered."
                               },
                               "forwards": {
@@ -1652,10 +1653,7 @@
                                                 {
                                                   "type": "array",
                                                   "items": {
-                                                    "type": [
-                                                      "number",
-                                                      "string"
-                                                    ]
+                                                    "$ref": "#/definitions/onchain_table_data/properties/result/anyOf/8/properties/result/anyOf/0/properties/value/items/properties/threshold"
                                                   }
                                                 },
                                                 {
@@ -1690,7 +1688,6 @@
                             },
                             "required": [
                               "prev_node",
-                              "threshold",
                               "forwards"
                             ],
                             "additionalProperties": false,
@@ -1881,18 +1878,15 @@
                                 "description": "Total operation weight"
                               },
                               "threshold": {
-                                "type": [
-                                  "number",
-                                  "string"
-                                ],
+                                "$ref": "#/definitions/onchain_table_data/properties/result/anyOf/8/properties/result/anyOf/0/properties/value/items/properties/threshold",
+                                "default": 0,
                                 "description": "Operation threshold. When total operation weight exceeds threshold, session is considered completed and Progress moves from current node to next node."
                               }
                             },
                             "required": [
                               "next_node",
                               "forwards",
-                              "weights",
-                              "threshold"
+                              "weights"
                             ],
                             "additionalProperties": false,
                             "description": "Progress session"
@@ -2359,7 +2353,7 @@
                 }
               },
               "additionalProperties": false,
-              "description": "Experience layer feedback from past operations (Phase 2 议题 2)"
+              "description": "Experience layer feedback from past operations (Phase 2 Topic 2)"
             },
             "service_status": {
               "type": "object",
@@ -2409,7 +2403,7 @@
                   "items": {
                     "type": "string"
                   },
-                  "description": "Actionable recommendations for the buyer. Example: ['要求商家配置仲裁','通过 Messenger 协商退款条款']"
+                  "description": "Actionable recommendations for the buyer. Example: ['Require merchant to configure arbitration','Negotiate refund terms via Messenger']"
                 },
                 "reminders": {
                   "type": "array",
@@ -2444,7 +2438,7 @@
                       },
                       "message": {
                         "type": "string",
-                        "description": "Human-readable reminder message. Example: '🔴 综合风险分 25/100，强烈建议不购买'"
+                        "description": "Human-readable reminder message. Example: 'Composite risk score 25/100, strongly discourage purchase'"
                       },
                       "action": {
                         "type": "string",
@@ -2460,7 +2454,7 @@
                     "additionalProperties": false,
                     "description": "A buyer-side reminder triggered at a specific order lifecycle stage (Phase 3 C-3)."
                   },
-                  "description": "Stage-specific reminders (deduped, sorted by priority, capped to 3 high-risk). Example: [{priority:'required', message:'🔴 模糊 Guard 必须人工审查'}]"
+                  "description": "Stage-specific reminders (deduped, sorted by priority, capped to 3 high-risk). Example: [{priority:'required', message:'Ambiguous Guard must be human-reviewed'}]"
                 },
                 "preference_match": {
                   "type": "object",
@@ -2476,14 +2470,14 @@
                       "items": {
                         "type": "string"
                       },
-                      "description": "Aspects that match user preferences. Example: ['价格低于均价 10%','有仲裁']"
+                      "description": "Aspects that match user preferences. Example: ['Price 10% below average','Has arbitration']"
                     },
                     "mismatches": {
                       "type": "array",
                       "items": {
                         "type": "string"
                       },
-                      "description": "Aspects that mismatch user preferences. Example: ['交付周期超出期望']"
+                      "description": "Aspects that mismatch user preferences. Example: ['Delivery cycle exceeds expectation']"
                     }
                   },
                   "required": [
@@ -2507,11 +2501,11 @@
               "properties": {
                 "industry_signal": {
                   "type": "string",
-                  "description": "Industry evolution signal summary. Example: '行业健康度 82/100（healthy）；累积 25 个行业信号'"
+                  "description": "Industry evolution signal summary. Example: 'Industry health 82/100 (healthy); 25 cumulative industry signals'"
                 },
                 "evolution_advice": {
                   "type": "string",
-                  "description": "Evolution advice for the current operation. Example: '建议强制配置仲裁 + 赔偿金 + 交付 Guard'"
+                  "description": "Evolution advice for the current operation. Example: 'Recommend mandatory arbitration + compensation fund + delivery Guard'"
                 },
                 "confidence": {
                   "type": "number",
@@ -2548,7 +2542,7 @@
                   "items": {
                     "type": "string"
                   },
-                  "description": "Phase 4 P4-6.C: Role-targeted advice strings (user/merchant/arbitrator). Example: ['强化忠诚度飞轮','优化首单转化']"
+                  "description": "Phase 4 P4-6.C: Role-targeted advice strings (user/merchant/arbitrator). Example: ['Strengthen loyalty flywheel','Optimize first-order conversion']"
                 },
                 "role": {
                   "type": "string",
@@ -2630,21 +2624,21 @@
                 },
                 "scene_description": {
                   "type": "string",
-                  "description": "Human-readable scene description. Example: '工作流节点推进验证（Forward.guard）'"
+                  "description": "Human-readable scene description. Example: 'Workflow node forward validation (Forward.guard)'"
                 },
                 "scene_constraints": {
                   "type": "array",
                   "items": {
                     "type": "string"
                   },
-                  "description": "Special constraints for the matched scene. Example: ['Machine 发布后 Forward.guard 不可修改']"
+                  "description": "Special constraints for the matched scene. Example: ['Forward.guard cannot be modified after Machine is published']"
                 },
                 "suggested_patterns": {
                   "type": "array",
                   "items": {
                     "type": "string"
                   },
-                  "description": "Suggested Guard patterns based on user intent. Example: ['时间锁','进度状态检查']"
+                  "description": "Suggested Guard patterns based on user intent. Example: ['time lock','progress status check']"
                 },
                 "available_queries": {
                   "type": "array",
@@ -2657,7 +2651,7 @@
                       },
                       "name": {
                         "type": "string",
-                        "description": "Query instruction name. Example: 'progress.current_node_name'"
+                        "description": "Query instruction name. Example: 'progress.current'"
                       },
                       "objectType": {
                         "type": "string",
@@ -2688,14 +2682,14 @@
                   "items": {
                     "type": "string"
                   },
-                  "description": "Risk warnings for the current Guard design. Example: ['Guard 创建后不可修改','时间锁测试用 1000ms']"
+                  "description": "Risk warnings for the current Guard design. Example: ['Guard cannot be modified after creation','Time lock test uses 1000ms']"
                 },
                 "pending_questions": {
                   "type": "array",
                   "items": {
                     "type": "string"
                   },
-                  "description": "Questions for the user to complete the puzzle. Example: ['Guard 将绑定到哪个 Host Object？']"
+                  "description": "Questions for the user to complete the puzzle. Example: ['Which Host Object will the Guard bind to?']"
                 },
                 "confirmation_text": {
                   "type": "string",

package/dist/schemas/wip_file.output.json

@@ -50,7 +50,30 @@
                   "type": "boolean"
                 },
                 "signatures": {
-                  "type": "array"
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "publicKey": {
+                        "type": "string",
+                        "description": "Signature public key"
+                      },
+                      "address": {
+                        "type": "string",
+                        "description": "Address derived from public key"
+                      },
+                      "valid": {
+                        "type": "boolean",
+                        "description": "Whether signature is valid"
+                      }
+                    },
+                    "required": [
+                      "publicKey",
+                      "valid"
+                    ],
+                    "additionalProperties": false,
+                    "description": "Single signature verification result"
+                  }
                 }
               },
               "required": [

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

@@ -0,0 +1 @@
+export { handleBridgeOperations } from "../../schema/call/bridge-handler.js";

package/dist/tools/handlers/bridge.js

@@ -0,0 +1 @@
+export { handleBridgeOperations } from "../../schema/call/bridge-handler.js";

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

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

package/dist/tools/handlers/config.js

@@ -0,0 +1,71 @@
+import { listServices, getServiceInfo, toggle as toggleService, setEnabled as setServiceEnabled, reset as resetService, } from "../../config/index.js";
+export async function handleConfigOperation(args) {
+    const action = args.action;
+    let result;
+    switch (action) {
+        case "list":
+            result = { services: listServices() };
+            break;
+        case "toggle": {
+            const service = args.service;
+            if (!service)
+                throw new Error("'service' param is required for toggle");
+            const existing = getServiceInfo(service);
+            if (!existing) {
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
+            }
+            const newState = toggleService(service);
+            result = { service, enabled: newState, reminder: existing.reminder };
+            break;
+        }
+        case "enable": {
+            const service = args.service;
+            if (!service)
+                throw new Error("'service' param is required for enable");
+            const existing = getServiceInfo(service);
+            if (!existing)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
+            setServiceEnabled(service, true);
+            result = { service, enabled: true, reminder: existing.reminder };
+            break;
+        }
+        case "disable": {
+            const service = args.service;
+            if (!service)
+                throw new Error("'service' param is required for disable");
+            const existing = getServiceInfo(service);
+            if (!existing)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
+            setServiceEnabled(service, false);
+            result = { service, enabled: false, reminder: existing.reminder };
+            break;
+        }
+        case "reset": {
+            const service = args.service;
+            if (!service)
+                throw new Error("'service' param is required for reset");
+            const existing = getServiceInfo(service);
+            if (!existing)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
+            resetService(service);
+            result = { service, enabled: getServiceInfo(service)?.enabled, reminder: existing.reminder, reset: true };
+            break;
+        }
+        case "info": {
+            const service = args.service;
+            if (!service)
+                throw new Error("'service' param is required for info");
+            const info = getServiceInfo(service);
+            if (!info)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
+            result = info;
+            break;
+        }
+        default:
+            throw new Error(`Unknown config_operation action: ${action}`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}

package/dist/tools/handlers/file-export.d.ts

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

package/dist/tools/handlers/file-export.js

@@ -0,0 +1,90 @@
+import { resolve } from "path";
+import { strictParse, getEnvConfig, Guard2File_InputSchema, MachineNode2File_InputSchema, } from "../../schema/index.js";
+import { guard2file, machineNode2file, } from "@wowok/wowok";
+export async function handleGuard2File(args) {
+    const validated = strictParse(Guard2File_InputSchema, args, "guard2file input");
+    const env = getEnvConfig(validated.env);
+    try {
+        await guard2file(validated.guard, validated.file_path, validated.format || "json", env.network);
+        const result = {
+            result: {
+                status: "success",
+                data: {
+                    file_path: resolve(validated.file_path),
+                    format: validated.format || "json",
+                    guard_object: validated.guard,
+                },
+            },
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        const result = {
+            result: {
+                status: "error",
+                error: error.message,
+            },
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: result,
+        };
+    }
+}
+export async function handleMachineNode2File(args) {
+    const validated = strictParse(MachineNode2File_InputSchema, args, "machineNode2file input");
+    const env = getEnvConfig(validated.env);
+    try {
+        await machineNode2file(validated.machine, validated.file_path, validated.format || "json", env.network);
+        let node_count = undefined;
+        try {
+            const filePath = resolve(validated.file_path);
+            const fileContent = await import('fs/promises').then(fs => fs.readFile(filePath, 'utf-8'));
+            if ((validated.format || "json") === "json") {
+                const parsed = JSON.parse(fileContent);
+                if (Array.isArray(parsed)) {
+                    node_count = parsed.length;
+                }
+            }
+            else {
+                const nodeMatches = fileContent.match(/^##\s+Node:/gm);
+                node_count = nodeMatches ? nodeMatches.length : 0;
+            }
+        }
+        catch {
+            node_count = undefined;
+        }
+        const result = {
+            result: {
+                status: "success",
+                data: {
+                    file_path: resolve(validated.file_path),
+                    format: validated.format || "json",
+                    machine_object: validated.machine,
+                },
+            },
+        };
+        if (node_count !== undefined) {
+            result.result.data.node_count = node_count;
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        const result = {
+            result: {
+                status: "error",
+                error: error.message,
+            },
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: result,
+        };
+    }
+}

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

@@ -0,0 +1,30 @@
+export declare const handleAccountOperation: (args: any) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        result: any;
+        semantic: any;
+    };
+}>;
+export declare const handleMarkOperation: (args: any) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        result: any;
+        semantic: any;
+    };
+}>;
+export declare const handleInfoOperation: (args: any) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        result: any;
+        semantic: any;
+    };
+}>;

package/dist/tools/handlers/local.js

@@ -0,0 +1,27 @@
+import { wrapLocalHandler } from "../shared.js";
+import { AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, } from "../../schema/index.js";
+import { account_operation, local_mark_operation, local_info_operation, } from "@wowok/wowok";
+export const handleAccountOperation = wrapLocalHandler({
+    schema: AccountOperationSchema,
+    operationFn: account_operation,
+    parseLabel: "account_operation input",
+    buildContext: (validated) => ({
+        operation_type: "account_" + validated.operation_type,
+        data: validated,
+    }),
+});
+export const handleMarkOperation = wrapLocalHandler({
+    schema: LocalMarkOperationSchema,
+    operationFn: local_mark_operation,
+    parseLabel: "local_mark_operation input",
+    buildContext: (validated) => ({
+        operation_type: "mark_" + validated.operation_type,
+        data: validated,
+    }),
+});
+export const handleInfoOperation = wrapLocalHandler({
+    schema: LocalInfoOperationSchema,
+    operationFn: local_info_operation,
+    parseLabel: "local_info_operation input",
+    buildContext: (validated) => ({ operation_type: "local_info", data: validated }),
+});

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

@@ -0,0 +1,16 @@
+import type { ToolDispatchResult } from "../types.js";
+export declare function normalizeAccountOrMark(input: string | {
+    name_or_address?: string;
+    local_mark_first?: boolean;
+}): {
+    name_or_address?: string;
+    local_mark_first?: boolean;
+};
+export declare function normalizeManyAccountOrMark(input: string[] | {
+    entities: any[];
+    check_all_founded?: boolean;
+}): {
+    entities: any[];
+    check_all_founded?: boolean;
+};
+export declare function handleMessengerOperation(args: any): Promise<ToolDispatchResult>;

package/dist/tools/handlers/messenger.js

@@ -0,0 +1,187 @@
+import { strictParse, MessengerOperationInputSchema, } from "../../schema/index.js";
+import { watch_conversations, send_message, send_file, watch_messages, extract_zip_messages, pull_messages, generate_wts, verify_wts, sign_wts, wts2html, proof_message, mark_messages_as_viewed, mark_conversation_as_viewed, blacklist, friendslist, guardlist, settings, } from "@wowok/wowok";
+import { classifyError, buildDataSemantic, } from "../../schema/call/semantic.js";
+export function normalizeAccountOrMark(input) {
+    if (typeof input === 'string') {
+        return { name_or_address: input, local_mark_first: true };
+    }
+    return input;
+}
+export function normalizeManyAccountOrMark(input) {
+    if (Array.isArray(input)) {
+        return {
+            entities: input.map(item => typeof item === 'string' ? { name_or_address: item, local_mark_first: true } : item),
+            check_all_founded: true,
+        };
+    }
+    return input;
+}
+export async function handleMessengerOperation(args) {
+    let validated;
+    try {
+        validated = strictParse(MessengerOperationInputSchema, args, "messenger_operation input");
+        let result;
+        switch (validated.operation) {
+            case "watch_conversations": {
+                const conversations = await watch_conversations(validated.filter);
+                result = { operation: "watch_conversations", result: conversations };
+                break;
+            }
+            case "send_message": {
+                const sendResult = await send_message(validated.from, normalizeAccountOrMark(validated.to), validated.content, validated.options);
+                const filteredResult = {
+                    ...sendResult,
+                    merkleData: sendResult.merkleData ? {
+                        leafIndex: sendResult.merkleData.leafIndex,
+                        prevRoot: sendResult.merkleData.prevRoot,
+                        newRoot: sendResult.merkleData.newRoot,
+                        serverSignature: sendResult.merkleData.serverSignature,
+                        serverTimestamp: sendResult.merkleData.serverTimestamp,
+                        serverPublicKey: sendResult.merkleData.serverPublicKey,
+                    } : undefined,
+                };
+                result = { operation: "send_message", result: filteredResult };
+                break;
+            }
+            case "send_file": {
+                const sendResult = await send_file(validated.from, normalizeAccountOrMark(validated.to), validated.filePath, validated.options);
+                const filteredResult = {
+                    ...sendResult,
+                    merkleData: sendResult.merkleData ? {
+                        leafIndex: sendResult.merkleData.leafIndex,
+                        prevRoot: sendResult.merkleData.prevRoot,
+                        newRoot: sendResult.merkleData.newRoot,
+                        serverSignature: sendResult.merkleData.serverSignature,
+                        serverTimestamp: sendResult.merkleData.serverTimestamp,
+                        serverPublicKey: sendResult.merkleData.serverPublicKey,
+                    } : undefined,
+                };
+                result = { operation: "send_file", result: filteredResult };
+                break;
+            }
+            case "watch_messages": {
+                const filter = validated.filter ? {
+                    ...validated.filter,
+                    peerAddress: validated.filter.peerAddress ? normalizeAccountOrMark(validated.filter.peerAddress) : undefined,
+                } : undefined;
+                const messages = await watch_messages(filter);
+                result = { operation: "watch_messages", result: messages };
+                break;
+            }
+            case "extract_zip_messages": {
+                const extractedPaths = await extract_zip_messages(validated.account, validated.messages, validated.outputDir);
+                result = { operation: "extract_zip_messages", result: extractedPaths };
+                break;
+            }
+            case "generate_wts": {
+                const params = validated.params ? {
+                    ...validated.params,
+                    peerAccount: normalizeAccountOrMark(validated.params.peerAccount),
+                } : undefined;
+                const wtsResult = await generate_wts(params);
+                result = { operation: "generate_wts", result: wtsResult };
+                break;
+            }
+            case "verify_wts": {
+                const verifyResult = await verify_wts(validated.wtsFilePath);
+                result = { operation: "verify_wts", result: verifyResult };
+                break;
+            }
+            case "sign_wts": {
+                const signedPath = await sign_wts(validated.wtsFilePath, validated.account, validated.outputPath);
+                result = { operation: "sign_wts", result: signedPath };
+                break;
+            }
+            case "wts2html": {
+                const htmlResult = await wts2html(validated.wtsPath, validated.options);
+                result = { operation: "wts2html", result: htmlResult };
+                break;
+            }
+            case "proof_message": {
+                const proofResult = await proof_message(validated.account, validated.messageId, validated.network);
+                result = { operation: "proof_message", result: proofResult };
+                break;
+            }
+            case "blacklist": {
+                const blacklistParams = {
+                    account: validated.account,
+                    op: validated.blacklist.op,
+                };
+                if ('users' in validated.blacklist) {
+                    blacklistParams.users = normalizeManyAccountOrMark(validated.blacklist.users);
+                }
+                const blacklistResult = await blacklist(blacklistParams);
+                result = { operation: "blacklist", op: validated.blacklist.op, result: blacklistResult.result };
+                break;
+            }
+            case "friendslist": {
+                const friendslistParams = {
+                    account: validated.account,
+                    op: validated.friendslist.op,
+                };
+                if ('users' in validated.friendslist) {
+                    friendslistParams.users = normalizeManyAccountOrMark(validated.friendslist.users);
+                }
+                const friendslistResult = await friendslist(friendslistParams);
+                result = { operation: "friendslist", op: validated.friendslist.op, result: friendslistResult.result };
+                break;
+            }
+            case "guardlist": {
+                const guardlistResult = await guardlist({
+                    account: validated.account,
+                    ...validated.guardlist,
+                });
+                result = { operation: "guardlist", op: validated.guardlist.op, result: guardlistResult.result };
+                break;
+            }
+            case "settings": {
+                const settingsResult = await settings({
+                    account: validated.account,
+                    ...validated.settings,
+                });
+                result = { operation: "settings", op: validated.settings.op, result: settingsResult.result };
+                break;
+            }
+            case "mark_messages_as_viewed": {
+                const markedCount = await mark_messages_as_viewed(validated.messageIds, validated.account);
+                result = { operation: "mark_messages_as_viewed", result: markedCount };
+                break;
+            }
+            case "mark_conversation_as_viewed": {
+                const markedCount = await mark_conversation_as_viewed(normalizeAccountOrMark(validated.peerAddress), validated.account);
+                result = { operation: "mark_conversation_as_viewed", result: markedCount };
+                break;
+            }
+            case "pull_messages": {
+                const messages = await pull_messages(validated.account, validated.limit);
+                result = { operation: "pull_messages", result: messages };
+                break;
+            }
+            default:
+                throw new Error(`Unknown messenger operation: ${validated.operation}`);
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: { result },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const ctx = validated ? { operation_type: "messenger_" + validated.operation, data: validated } : undefined;
+        const classified = classifyError(errorMessage);
+        const errorResult = { operation: "error", error: errorMessage };
+        if (classified.error_code !== undefined)
+            errorResult.error_code = classified.error_code;
+        if (classified.retryable !== undefined)
+            errorResult.retryable = classified.retryable;
+        if (classified.recovery_hint !== undefined)
+            errorResult.recovery_hint = classified.recovery_hint;
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            structuredContent: {
+                result: errorResult,
+                semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
+            },
+        };
+    }
+}

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

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