@wowok/agent-mcp 2.4.1 → 2.4.3

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>;

package/dist/tools/handlers/onchain.js

@@ -0,0 +1,246 @@
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import { CallService, CallMachine, CallProgress, CallPermission, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, parseGuardFile, formatGuardParseErrors, transformRewardInput, transformPersonalInput, } from "@wowok/wowok";
+import { OnchainOperationsSchema, strictParse, getEnvConfig, handleCallResult, checkClientSchemaCompatibility, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, transformSubmission, } from "../../schema/index.js";
+import { isProjectServiceEnabled, normalize as projectNormalize, } from "../../project/index.js";
+import { withHarness } from "../shared.js";
+export async function handleOnchainOperations(args) {
+    let validated;
+    let constraintWarnings = [];
+    let projectWarnings = [];
+    try {
+        if (typeof args === 'object' && args !== null && args.description && !args.operation_type) {
+            const hasWrappedParams = typeof args.description === 'string' &&
+                (args.description.includes('operation_type') || args.description.includes('data'));
+            if (hasWrappedParams) {
+                throw new Error("Invalid parameter structure. Parameters should NOT be wrapped in 'description' field.\n" +
+                    "Correct format: { operation_type: '...', data: {...} }\n" +
+                    "Incorrect format: { description: '{ operation_type: ... }' }");
+            }
+        }
+        validated = strictParse(OnchainOperationsSchema, args, "onchain_operations input");
+        const env = getEnvConfig(validated.env);
+        const clientSchemaVersion = env?.client_schema_version;
+        const schemaStrictMode = env?.schema_strict_mode;
+        const schemaCheck = clientSchemaVersion
+            ? checkClientSchemaCompatibility(clientSchemaVersion, { mode: schemaStrictMode ? "strict" : "warn" })
+            : undefined;
+        const buildCtx = (data) => ({
+            operation_type: validated.operation_type,
+            data,
+            pre_warnings: [...constraintWarnings, ...projectWarnings].length
+                ? [...constraintWarnings, ...projectWarnings]
+                : undefined,
+            schema_check: schemaCheck,
+        });
+        const projectEnvPrefix = env?.project;
+        if (isProjectServiceEnabled()) {
+            const pn = projectNormalize({
+                operation_type: validated.operation_type,
+                data: validated.data,
+                projectPrefix: projectEnvPrefix,
+            });
+            validated.data = pn.data;
+            projectWarnings = pn.warnings ?? [];
+        }
+        if (env && typeof env === "object") {
+            delete env.confirmed;
+            delete env.user_intent_phrases;
+            delete env.project;
+            delete env.client_schema_version;
+            delete env.schema_strict_mode;
+        }
+        switch (validated.operation_type) {
+            case "service": {
+                const callService = new CallService(validated.data);
+                const result = validated.submission
+                    ? await callService.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callService.call(env);
+                const data = validated.data;
+                const intent = data?.publish ? "publish service" : data?.bPublished !== undefined ? "modify service" : "create service";
+                return handleCallResult(result, withHarness(buildCtx(data), "service", intent));
+            }
+            case "machine": {
+                if (validated.data.node && typeof validated.data.node === 'object' && 'json_or_markdown_file' in validated.data.node) {
+                    const filePathStr = validated.data.node.json_or_markdown_file;
+                    let fileContent;
+                    try {
+                        const filePath = resolve(filePathStr);
+                        fileContent = readFileSync(filePath, 'utf-8');
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to read file '${filePathStr}': ${e.message}`);
+                    }
+                    const parseResult = parseMachineNodesFromText(fileContent);
+                    if (!parseResult.success) {
+                        const errorMessages = formatMachineNodeErrors(parseResult.errors);
+                        throw new Error(`Machine node validation failed for file '${filePathStr}':\n\n${errorMessages}`);
+                    }
+                    if (!parseResult.data) {
+                        throw new Error(`No nodes found in file '${filePathStr}'`);
+                    }
+                    validated.data.node = {
+                        op: "set",
+                        nodes: parseResult.data,
+                        bReplace: true
+                    };
+                }
+                const callMachine = new CallMachine(validated.data);
+                const result = validated.submission
+                    ? await callMachine.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callMachine.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "progress": {
+                const callProgress = new CallProgress(validated.data);
+                const result = validated.submission
+                    ? await callProgress.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callProgress.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "repository": {
+                const callRepository = new CallRepository(validated.data);
+                const result = validated.submission
+                    ? await callRepository.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callRepository.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "arbitration": {
+                const callArbitration = new CallArbitration(validated.data);
+                const result = validated.submission
+                    ? await callArbitration.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callArbitration.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "contact": {
+                const callContact = new CallContact(validated.data);
+                const result = validated.submission
+                    ? await callContact.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callContact.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "treasury": {
+                const callTreasury = new CallTreasury(validated.data);
+                const result = validated.submission
+                    ? await callTreasury.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callTreasury.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "reward": {
+                const transformedData = transformRewardInput(validated.data);
+                const callReward = new CallReward(transformedData);
+                const result = validated.submission
+                    ? await callReward.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callReward.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "allocation": {
+                const callAllocation = new CallAllocation(validated.data);
+                const result = validated.submission
+                    ? await callAllocation.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callAllocation.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "permission": {
+                const callPermission = new CallPermission(validated.data);
+                const result = await callPermission.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "guard": {
+                const validatedData = validated.data;
+                if (validatedData.root?.type === "file") {
+                    const filePath = resolve(validatedData.root.file_path);
+                    let fileContent;
+                    try {
+                        fileContent = readFileSync(filePath, 'utf-8');
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to read Guard definition file '${validatedData.root.file_path}': ${e.message}`);
+                    }
+                    const parseResult = parseGuardFile(fileContent, validatedData.root.format);
+                    if (!parseResult.success) {
+                        const errorMessages = formatGuardParseErrors(parseResult.errors);
+                        throw new Error(`Guard validation failed for file '${validatedData.root.file_path}':\n\n${errorMessages}`);
+                    }
+                    const fileData = parseResult.data;
+                    validatedData.root = { type: "node", node: fileData.root };
+                    if (fileData.table !== undefined && validatedData.table === undefined) {
+                        validatedData.table = fileData.table;
+                    }
+                    if (fileData.description !== undefined && validatedData.description === undefined) {
+                        validatedData.description = fileData.description;
+                    }
+                    if (fileData.rely !== undefined && validatedData.rely === undefined) {
+                        validatedData.rely = fileData.rely;
+                    }
+                    if (fileData.namedNew !== undefined && validatedData.namedNew === undefined) {
+                        validatedData.namedNew = fileData.namedNew;
+                    }
+                }
+                if (validatedData.root && typeof validatedData.root === 'object') {
+                    const rootObj = validatedData.root;
+                    if (rootObj.type === 'node' && rootObj.node) {
+                        validatedData.root = rootObj.node;
+                    }
+                }
+                if (!validatedData.table || validatedData.table.length === 0) {
+                    throw new Error("Guard 'table' field is required and cannot be empty");
+                }
+                if (!validatedData.root) {
+                    throw new Error("Guard 'root' field is required");
+                }
+                const callGuard = new CallGuard(validatedData);
+                const result = await callGuard.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "personal": {
+                const transformedData = transformPersonalInput(validated.data);
+                const callPersonal = new CallPersonal(transformedData);
+                const result = await callPersonal.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "payment": {
+                const callPayment = new CallPayment(validated.data);
+                const result = await callPayment.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "demand": {
+                const callDemand = new CallDemand(validated.data);
+                const result = validated.submission
+                    ? await callDemand.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callDemand.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "order": {
+                const callOrder = new CallOrder(validated.data);
+                const result = validated.submission
+                    ? await callOrder.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callOrder.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "gen_passport": {
+                const result = await gen_passport(env, validated.guard, validated.info);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "proof": {
+                const callProof = new CallProof(validated.data);
+                const result = validated.submission
+                    ? await callProof.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callProof.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "gen_proof": {
+                const result = await gen_proof(env, validated.proof, validated.server_pubkey, validated.server_signature, validated.proof_type, validated.description, validated.item_count, validated.about_address);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+        }
+        throw new Error(`Unknown on-chain operation type: ${validated.operation_type}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return handleCallResult({ error: errorMessage }, validated ? {
+            operation_type: validated.operation_type,
+            data: validated.data,
+        } : undefined);
+    }
+}

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

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

package/dist/tools/handlers/project.js

@@ -0,0 +1,53 @@
+import { queryProjects, queryProjectObjects, queryShareableObjects, queryDependencies, queryReferencedBy, queryPrePublishCheck, queryCrossProjectReferences, queryGraphStats, saveGraph, loadGraph, } from "../../project/index.js";
+export async function handleProjectOperation(args) {
+    const action = args.action;
+    const project = args.project;
+    const object = args.object;
+    let result;
+    switch (action) {
+        case "list_projects":
+            result = await queryProjects();
+            break;
+        case "list_objects":
+            if (!project)
+                throw new Error("'project' param is required for list_objects");
+            result = await queryProjectObjects(project);
+            break;
+        case "shareable":
+            result = await queryShareableObjects();
+            break;
+        case "dependencies":
+            if (!object)
+                throw new Error("'object' param is required for dependencies");
+            result = queryDependencies(object);
+            break;
+        case "referenced_by":
+            if (!object)
+                throw new Error("'object' param is required for referenced_by");
+            result = queryReferencedBy(object);
+            break;
+        case "pre_publish_check":
+            if (!object)
+                throw new Error("'object' param is required for pre_publish_check");
+            result = { warnings: queryPrePublishCheck(object) };
+            break;
+        case "cross_project_refs":
+            result = queryCrossProjectReferences();
+            break;
+        case "graph_stats":
+            result = queryGraphStats();
+            break;
+        case "save_graph":
+            result = { saved: true, path: saveGraph() };
+            break;
+        case "load_graph":
+            result = { loaded: loadGraph() };
+            break;
+        default:
+            throw new Error(`Unknown project_operation action: ${action}`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}

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

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