@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/schemas/schema_query.output.json

@@ -17,7 +17,43 @@
           "description": "The action that was performed"
         },
         "data": {
-          "description": "Response data - JSON Schema object for 'get'/'get_output', array of schema info for 'list'/'search'/'list_operations'"
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "name": {
+                    "type": "string",
+                    "description": "Schema/tool identifier (e.g. 'onchain_operations')."
+                  },
+                  "title": {
+                    "type": "string",
+                    "description": "Human-readable title, if known."
+                  },
+                  "description": {
+                    "type": "string",
+                    "description": "Short description, if known."
+                  }
+                },
+                "required": [
+                  "name"
+                ],
+                "additionalProperties": false
+              },
+              "description": "List of schema summaries (list/search/list_operations)."
+            },
+            {
+              "type": "object",
+              "additionalProperties": {},
+              "description": "JSON Schema object (get/get_output)."
+            },
+            {
+              "type": "null",
+              "description": "No data — lookup failed or returned nothing."
+            }
+          ],
+          "description": "Response data — array of schema summaries for list-like actions, JSON Schema object for get/get_output, null on failure."
         },
         "message": {
           "type": "string",
@@ -34,6 +70,7 @@
       "required": [
         "success",
         "action",
+        "data",
         "message"
       ],
       "additionalProperties": false

package/dist/telemetry/index.d.ts

@@ -15,5 +15,5 @@ export declare function isTelemetryEnabled(): boolean;
 export declare function captureTelemetry(toolName: string, structuredContent: CallOutput | undefined, durationMs: number, operationTypeHint?: string): Promise<void>;
 export declare function captureTelemetryError(toolName: string, error: any, durationMs: number, operationTypeHint?: string): Promise<void>;
 export declare function withTelemetry<TArgs, TOutput extends {
-    structuredContent?: CallOutput;
+    structuredContent?: unknown;
 }>(toolName: string, handler: (args: TArgs) => Promise<TOutput>): (args: TArgs) => Promise<TOutput>;

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: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/config.js

@@ -0,0 +1,74 @@
+import { listServices, getServiceInfo, toggle as toggleService, setEnabled as setServiceEnabled, reset as resetService, } from "../../config/index.js";
+import { strictParse } from "../../schema/index.js";
+import { ConfigOperationInputSchema } from "../../schema/config/index.js";
+export async function handleConfigOperation(args) {
+    const validated = strictParse(ConfigOperationInputSchema, args, "config_operation input");
+    const { action, service: serviceRaw } = validated;
+    let result;
+    switch (action) {
+        case "list":
+            result = { action: "list", services: listServices() };
+            break;
+        case "toggle": {
+            if (!serviceRaw)
+                throw new Error("'service' param is required for toggle");
+            const service = serviceRaw;
+            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 = { action: "toggle", service, enabled: newState, reminder: existing.reminder };
+            break;
+        }
+        case "enable": {
+            if (!serviceRaw)
+                throw new Error("'service' param is required for enable");
+            const service = serviceRaw;
+            const existing = getServiceInfo(service);
+            if (!existing)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
+            setServiceEnabled(service, true);
+            result = { action: "enable", service, enabled: true, reminder: existing.reminder };
+            break;
+        }
+        case "disable": {
+            if (!serviceRaw)
+                throw new Error("'service' param is required for disable");
+            const service = serviceRaw;
+            const existing = getServiceInfo(service);
+            if (!existing)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
+            setServiceEnabled(service, false);
+            result = { action: "disable", service, enabled: false, reminder: existing.reminder };
+            break;
+        }
+        case "reset": {
+            if (!serviceRaw)
+                throw new Error("'service' param is required for reset");
+            const service = serviceRaw;
+            const existing = getServiceInfo(service);
+            if (!existing)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
+            resetService(service);
+            result = { action: "reset", service, enabled: getServiceInfo(service)?.enabled, reminder: existing.reminder, reset: true };
+            break;
+        }
+        case "info": {
+            if (!serviceRaw)
+                throw new Error("'service' param is required for info");
+            const service = serviceRaw;
+            const info = getServiceInfo(service);
+            if (!info)
+                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
+            result = { action: "info", ...info };
+            break;
+        }
+        default:
+            throw new Error(`Unknown config_operation action: ${String(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: unknown): Promise<ToolDispatchResult>;
+export declare function handleMachineNode2File(args: unknown): 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,3 @@
+export declare const handleAccountOperation: (args: unknown) => Promise<import("../types.js").ToolDispatchResult>;
+export declare const handleMarkOperation: (args: unknown) => Promise<import("../types.js").ToolDispatchResult>;
+export declare const handleInfoOperation: (args: unknown) => Promise<import("../types.js").ToolDispatchResult>;

package/dist/tools/handlers/local.js

@@ -0,0 +1,38 @@
+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";
+function deriveOpType(prefix, validated) {
+    for (const key of Object.keys(validated)) {
+        if (validated[key] !== undefined) {
+            return `${prefix}_${String(key)}`;
+        }
+    }
+    return `${prefix}_unknown`;
+}
+export const handleAccountOperation = wrapLocalHandler({
+    schema: AccountOperationSchema,
+    operationFn: account_operation,
+    parseLabel: "account_operation input",
+    buildContext: (validated) => ({
+        operation_type: deriveOpType("account", validated),
+        data: validated,
+    }),
+});
+export const handleMarkOperation = wrapLocalHandler({
+    schema: LocalMarkOperationSchema,
+    operationFn: local_mark_operation,
+    parseLabel: "local_mark_operation input",
+    buildContext: (validated) => ({
+        operation_type: deriveOpType("mark", validated),
+        data: validated,
+    }),
+});
+export const handleInfoOperation = wrapLocalHandler({
+    schema: LocalInfoOperationSchema,
+    operationFn: local_info_operation,
+    parseLabel: "local_info_operation input",
+    buildContext: (validated) => ({
+        operation_type: deriveOpType("local_info", validated),
+        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: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/messenger.js

@@ -0,0 +1,188 @@
+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");
+        const opLiteral = validated.operation;
+        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: ${opLiteral}`);
+        }
+        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: unknown): Promise<ToolDispatchResult>;