@wowok/agent-mcp 2.2.8

package/dist/index.js

@@ -0,0 +1,1479 @@
+#!/usr/bin/env node
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+import { CallService_DataSchema, CallMachine_DataSchema, MachineNode2File_InputSchema, MachineNode2File_OutputWrappedSchema, CallProgress_DataSchema, CallPermission_DataSchema, CallGuard_DataSchema, Guard2File_InputSchema, Guard2File_OutputWrappedSchema, CallArbitration_DataSchema, CallRepository_DataSchema, CallContact_DataSchema, CallTreasury_DataSchema, CallReward_DataSchema, CallAllocation_DataSchema, CallPersonal_DataSchema, CallPayment_DataSchema, CallDemand_DataSchema, CallOrder_DataSchema, CallEnvSchema, SubmissionCallSchema, strictParse, CallOutputSchema, handleCallResult, createServerConfig, createCapabilitiesConfig, createToolMeta, transformSubmission, getEnvConfig, WipGenerationOptionsSchema, WipToHtmlOptionsSchema, TokenDataFilterSchema, LocalInfoFilterSchema, LocalMarkFilterSchema, AccountFilterSchema, TokenTypeSchema, OnchainEventsInputSchema, OnchainEventsResultSchema, ProtocolInfoQuerySchema, ProtocolInfoResultSchema, TableAnswerSchema, TableItem_RepositoryDataSchema, TableItem_PermissionPermSchema, TableItem_EntityRegistrarSchema, TableItem_EntityLinkerSchema, TableItem_RewardRecordSchema, TableItem_DemandPresenterSchema, TableItem_TreasuryHistorySchema, TableItem_MachineNodeSchema, TableItem_ProgressHistorySchema, TableItem_AddressMarkSchema, NameOrAddressSchema, ObjectBaseSchema, AccountOrMark_AddressSchema, AccountOrMark_AddressAISchema, EntrypointSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, MessengerOperationInputSchema, } from "./schema/index.js";
+import { CallService, CallMachine, CallProgress, CallPermission, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, guard2file, parseGuardFile, formatGuardParseErrors, machineNode2file, generateNodeComments, generate_wip, verify_wip, sign_wip, wip2html, account_operation, local_mark_operation, local_info_operation, watch_conversations, send_message, send_file, watch_messages, extract_zip_messages, generate_wts, verify_wts, sign_wts, wts2html, proof_message, mark_messages_as_viewed, mark_conversation_as_viewed, query_local_mark_list, query_account_list, query_local_info_list, query_local_token_list, query_account, query_personal, query_objects, query_table, query_tableItem, queryProtocolInfo, query_received, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_events, blacklist, friendslist, guardlist, settings, AmountType, } from "wowok";
+const SERVER_DESCRIPTION = `WoWok MCP Server - Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.
+
+## Token System Overview
+
+### Default Platform Token: WOW
+- Token Type: 0x2::wow::WOW
+- Precision: 1_000_000_000 (9 decimal places)
+- This is the default token for all operations unless specified otherwise
+
+### Multi-Token Support
+The platform supports ANY token (e.g., USDT, USDC, custom tokens). To use non-WOW tokens:
+1. Use query_toolkit with query_type='token_list' to query available tokens and their precision info
+2. Use the token's full type string (e.g., '0x2::usdt::USDT') in token_type parameter
+3. Each token has its own precision - always verify before operations
+
+### Token Precision Handling
+Different tokens have different precisions. ALWAYS query to verify:
+- WOW (default): 1_000_000_000 (9 decimals)
+- Other tokens: Use query_toolkit with query_type='token_list' to get actual precision
+- Never assume a token's decimal places - always query first
+
+## CRITICAL: Token Amount Handling
+
+### Amount Input Rules
+1. WITH currency unit (e.g., '2WOW', '10.5WOW', '100USDT'):
+   - Auto-converted using token's precision: 2WOW -> 2_000_000_000
+   - Use for: All on-chain token operations
+   - MUST match the token_type parameter
+
+2. WITHOUT currency unit (e.g., '2', '100'):
+   - Used as-is: 2 -> 2
+   - Use for: Regular numeric parameters (counts, indices, etc.)
+
+### Multi-Token Operation Examples
+- Create USDT-priced Service: token_type='0x2::usdt::USDT', amount='100USDT'
+- Allocate USDC rewards: token_type='0x2::usdc::USDC', amount='500USDC'
+- WOW remains default: omit token_type or use '0x2::wow::WOW'
+
+### Security Warning
+Token amounts are HIGHLY SENSITIVE. Always:
+- Confirm user's intent before executing transfers
+- Verify token type and amount format (with/without unit)
+- Query token precision if unsure
+- Double-check large amount transactions
+- Never assume decimal places - use explicit token unit
+
+## Tool Selection Guide
+
+| User Intent | Correct Tool | Wrong Tool (Avoid) |
+|------------|--------------|-------------------|
+| Create service listing | onchain_operations (service) | query_toolkit |
+| Send coins to address | onchain_operations (payment) | account_operation |
+| Check my balance | query_toolkit (account_balance) | onchain_operations |
+| Manage local wallet | account_operation | onchain_operations |
+| Export Guard for edit | guard2file | query_toolkit |
+| Send/Watch encrypted message | messenger_operation | onchain_operations |
+| Create workflow template | onchain_operations (machine) | wip_file |
+| Store my phone number | local_info_operation | onchain_operations |
+| Buy service (create order) | onchain_operations (order) | onchain_operations (service) |
+| Manage my orders | onchain_operations (order) | query_toolkit |
+| Apply for arbitration | onchain_operations (order) | onchain_operations (arbitration) |
+| Create reward pool for marketing | onchain_operations (reward) | onchain_operations (treasury) |
+| Claim rewards from pool | onchain_operations (reward) | query_toolkit |
+| Create fund allocation plan | onchain_operations (allocation) | onchain_operations (treasury) |
+| Execute fund distribution | onchain_operations (allocation) | onchain_operations (payment) |
+| Post service demand with reward | onchain_operations (demand) | onchain_operations (service) |
+| Submit solution for demand | onchain_operations (demand) | onchain_operations (order) |
+| Create team treasury | onchain_operations (treasury) | onchain_operations (allocation) |
+| Deposit/Withdraw from treasury | onchain_operations (treasury) | onchain_operations (payment) |
+| Create access control rules | onchain_operations (permission) | onchain_operations (guard) |
+| Create validation rules (Guard) | onchain_operations (guard) | onchain_operations (permission) |
+| Export Guard for editing | guard2file | query_toolkit |
+| Export Machine nodes for editing | machineNode2file | query_toolkit |
+| Query token list and precision | query_toolkit (token_list) | wowok_buildin_info |
+| Watch on-chain events | onchain_events | query_toolkit |
+| Generate WIP promise file | wip_file (generate) | messenger_operation |
+| Sign WIP file | wip_file (sign) | account_operation (signData) |
+| Verify WIP file integrity | wip_file (verify) | query_toolkit |
+| Send encrypted file via messenger | messenger_operation (send_file) | wip_file |
+| Generate witness timestamp (WTS) | messenger_operation (generate_wts) | wip_file |
+| Query protocol constants | wowok_buildin_info | query_toolkit |
+| Get documentation URL | documents_and_learn | wowok_buildin_info |
+
+## Local vs On-chain Operations
+
+### LOCAL ONLY (Never touch blockchain):
+- account_operation
+- local_mark_operation
+- local_info_operation
+
+### ON-CHAIN (Blockchain transactions):
+- onchain_operations
+- messenger_operation (some operations)
+- wip_file (sign operation)
+
+### QUERY (Read-only):
+- query_toolkit
+- onchain_events
+- wowok_buildin_info
+- documents_and_learn
+- guard2file
+- machineNode2file
+`;
+const server = new McpServer(createServerConfig(packageJson, SERVER_DESCRIPTION), createCapabilitiesConfig());
+function convertAmountType(type) {
+    if (typeof type === "number")
+        return type;
+    const upperType = type.toUpperCase();
+    if (upperType === "GUARDU64IDENTIFIER" || upperType === "GUARD_U64_IDENTIFIER") {
+        return AmountType.GuardU64Identifier;
+    }
+    if (upperType === "FIXED") {
+        return AmountType.Fixed;
+    }
+    return AmountType.Fixed;
+}
+function transformRewardData(data) {
+    if (!data)
+        return data;
+    const transformed = { ...data };
+    if (transformed.guard_add && Array.isArray(transformed.guard_add)) {
+        transformed.guard_add = transformed.guard_add.map((guard) => {
+            if (guard.amount && typeof guard.amount.type === "string") {
+                return {
+                    ...guard,
+                    amount: {
+                        ...guard.amount,
+                        type: convertAmountType(guard.amount.type)
+                    }
+                };
+            }
+            return guard;
+        });
+    }
+    return transformed;
+}
+const OnchainOperationsSchema = z.preprocess((input) => {
+    if (typeof input === 'object' && input !== null) {
+        const obj = { ...input };
+        if (typeof obj.description === 'string' && !obj.operation_type) {
+            try {
+                const parsed = JSON.parse(obj.description);
+                if (parsed && typeof parsed === 'object' && parsed.operation_type) {
+                    return parsed;
+                }
+            }
+            catch { }
+        }
+        if (typeof obj.data === 'string') {
+            try {
+                obj.data = JSON.parse(obj.data);
+            }
+            catch { }
+        }
+        if (typeof obj.env === 'string') {
+            try {
+                obj.env = JSON.parse(obj.env);
+            }
+            catch { }
+        }
+        if (typeof obj.submission === 'string') {
+            try {
+                obj.submission = JSON.parse(obj.submission);
+            }
+            catch { }
+        }
+        if (typeof obj.info === 'string') {
+            try {
+                obj.info = JSON.parse(obj.info);
+            }
+            catch { }
+        }
+        return obj;
+    }
+    return input;
+}, z.discriminatedUnion("operation_type", [
+    z.object({
+        operation_type: z.literal("service"),
+        data: CallService_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("🏪 Service Object: Create and manage product/service listings with transparent promises, bind workflow templates to order processing, set pricing, issue discount coupons to customers, and establish quality standards, etc.."),
+    z.object({
+        operation_type: z.literal("machine"),
+        data: CallMachine_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("⚙️ Machine Object: Design and deploy automated workflow templates (Machines) that define how services are delivered, etc.."),
+    z.object({
+        operation_type: z.literal("progress"),
+        data: CallProgress_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("📊 Progress Object: Track and manage active workflows in real-time."),
+    z.object({
+        operation_type: z.literal("repository"),
+        data: CallRepository_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("📦 Repository Object: Read/write database with consensus field + address as key, strongly-typed data as value."),
+    z.object({
+        operation_type: z.literal("arbitration"),
+        data: CallArbitration_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("⚖️ Arbitration Object: Access a transparent on-chain arbitration system for resolving order conflicts."),
+    z.object({
+        operation_type: z.literal("contact"),
+        data: CallContact_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("💬 Contact Object: Manage on-chain instant messaging contact profiles."),
+    z.object({
+        operation_type: z.literal("treasury"),
+        data: CallTreasury_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("💰 Treasury Object: Create and manage treasury for team funds with deposit/withdrawal rules, etc.."),
+    z.object({
+        operation_type: z.literal("reward"),
+        data: CallReward_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("🎁 Reward Object: Create reward pools and set claim conditions by Guard verification."),
+    z.object({
+        operation_type: z.literal("allocation"),
+        data: CallAllocation_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("📤 Allocation Object: Create distribution plans to auto-distribute funds to multiple recipients."),
+    z.object({
+        operation_type: z.literal("permission"),
+        data: CallPermission_DataSchema,
+        env: CallEnvSchema.optional(),
+    }).describe("🔐 Permission Object: Define who can perform which operations on WoWok objects. Important Note: If needed, you should first query 'guard instructions' through the 'wowok_buildin_info' tool."),
+    z.object({
+        operation_type: z.literal("guard"),
+        data: CallGuard_DataSchema,
+        env: CallEnvSchema.optional(),
+    }).describe("🛡️ Guard Object: Create immutable programmable validation rules that return boolean results. Set 'namedNew' to name the new Guard. Use root.type='node' for direct node tree or root.type='file' to load from file. Use 'wowok_buildin_info' tool with query='guard instructions' for all available operations. NOTE for EntityLinker/EntityRegistrar queries: Add system addresses to the Guard table - ENTITY_LINKER_ADDRESS (0xaaa) for EntityLinker, ENTITY_REGISTRAR_ADDRESS (0xaab) for EntityRegistrar."),
+    z.object({
+        operation_type: z.literal("personal"),
+        data: CallPersonal_DataSchema,
+        env: CallEnvSchema.optional(),
+    }).describe("🆔 Public Identity Profile: Establish and manage your on-chain public identity. ⚠️ CRITICAL: Everything here is PERMANENTLY PUBLIC on the blockchain!"),
+    z.object({
+        operation_type: z.literal("payment"),
+        data: CallPayment_DataSchema,
+        env: CallEnvSchema.optional(),
+    }).describe("💰 Payment Object: Send instant, irreversible coin transfers to any wallet address."),
+    z.object({
+        operation_type: z.literal("demand"),
+        data: CallDemand_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("🎯 Demand Object: Post service requests with reward pools on-chain."),
+    z.object({
+        operation_type: z.literal("order"),
+        data: CallOrder_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("📦 Order Object: Manage the order lifecycle, Including operating order arbitration (Arb Object associated with the order), advancing progress (Progress Object associated with the order), extracting order refunds/payments, setting agents, etc."),
+    z.object({
+        operation_type: z.literal("gen_passport"),
+        guard: z.union([z.string(), z.array(z.string())]).describe("Guard object ID(s) to verify and generate passport from. Can be a single guard (string) or multiple guards (array of strings). Supports guard names or addresses."),
+        info: SubmissionCallSchema.optional().describe("Optional submission data. If not provided, will attempt to get existing submissions from the guard."),
+        env: CallEnvSchema.optional(),
+    }).describe("🛂 Generate Verified Passport Object: Create immutable verified credentials after Guard validation passes. Supports verifying multiple guards at once."),
+]));
+const WipOperationsSchema = z.preprocess((input) => {
+    if (typeof input === 'object' && input !== null) {
+        const obj = { ...input };
+        if (typeof obj.description === 'string' && !obj.type) {
+            try {
+                const parsed = JSON.parse(obj.description);
+                if (parsed && typeof parsed === 'object' && parsed.type) {
+                    return parsed;
+                }
+            }
+            catch { }
+        }
+        if (typeof obj.options === 'string') {
+            try {
+                obj.options = JSON.parse(obj.options);
+            }
+            catch { }
+        }
+        return obj;
+    }
+    return input;
+}, z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("generate"),
+        options: WipGenerationOptionsSchema.describe("WIP generation options"),
+        outputPath: z.string().describe("Output file path (.wip file). If file exists, it will be overwritten"),
+    }).describe("Generate WIP file from markdown text and optional images"),
+    z.object({
+        type: z.literal("verify"),
+        wipFilePath: z.string().describe("WIP file path to verify. Supports: 1) Local file path (e.g., '/path/to/file.wip', 'C:\\Users\\name\\doc.wip'), 2) Network URL (e.g., 'https://example.com/doc.wip', 'http://site.com/file.wip'), 3) Data URL (e.g., 'data:application/json;base64,eyJ3aXAiOi...')"),
+        hash_equal: z.string().optional().describe("Optional expected hash value. If provided, the function will first verify if the file's hash matches this value. If not matched, returns hash mismatch error."),
+        requireSignature: z.boolean().optional().describe("Optional flag to require digital signature. If true, verification will fail if WIP file has no signature"),
+    }).describe("Verify WIP file integrity and signatures"),
+    z.object({
+        type: z.literal("sign"),
+        wipFilePath: z.string().describe("WIP file path to sign. Supports: 1) Local file path (e.g., '/path/to/file.wip'), 2) Network URL (e.g., 'https://example.com/doc.wip'). The file will be loaded, validated, and signed"),
+        account: z.string().optional().describe("Signing account (account name or address). If not specified, uses default account"),
+        outputPath: z.string().optional().describe("Output file path. If not specified, adds 'signed_' prefix to original file name (e.g., 'doc.wip' becomes 'signed_doc.wip')"),
+    }).describe("Sign WIP file with account"),
+    z.object({
+        type: z.literal("wip2html"),
+        wipPath: z.string().describe("WIP file path or directory path. Supports: 1) Single WIP file (e.g., '/path/to/file.wip'), 2) Directory containing .wip files (e.g., '/path/to/wips/'), 3) Network URL (e.g., 'https://example.com/doc.wip'). When directory is provided, all .wip files in the directory will be converted to HTML"),
+        options: WipToHtmlOptionsSchema.optional().describe("Conversion options"),
+    }).describe("Convert WIP file to HTML format"),
+]));
+const OnchainTableDataSchema = z.preprocess((input) => {
+    if (typeof input === 'object' && input !== null && !Array.isArray(input)) {
+        const obj = { ...input };
+        if (typeof obj.description === 'string' && !obj.query_type) {
+            try {
+                const parsed = JSON.parse(obj.description);
+                if (parsed && typeof parsed === 'object' && parsed.query_type) {
+                    return parsed;
+                }
+            }
+            catch { }
+        }
+        if (obj.cursor === '')
+            obj.cursor = null;
+        if (obj.limit === '')
+            obj.limit = null;
+        return obj;
+    }
+    return input;
+}, z.union([
+    z.discriminatedUnion("query_type", [
+        z.object({
+            query_type: z.literal("onchain_table"),
+            parent: NameOrAddressSchema.describe("Parent object ID whose dynamic fields table to query"),
+            cursor: z.union([z.string(), z.null()]).optional().describe("Pagination cursor from previous page's nextCursor"),
+            limit: z.union([z.number(), z.null()]).optional().describe("Max items per page"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Paginated query of an on-chain object's dynamic fields table — returns items with keys, types, and object IDs. Use to explore all entries (e.g., all orders in a Service, all records in a Repository). Returns: TableAnswer | undefined (items[], nextCursor, hasNextPage)"),
+        z.object({
+            query_type: z.literal("onchain_table_item_repository_data"),
+            parent: NameOrAddressSchema.describe("Parent Repository object ID"),
+            name: z.string().describe("Name/key of the record to retrieve from the repository"),
+            entity: z.union([AccountOrMark_AddressSchema, z.number()]).describe("Entity ID or address that owns/identifies the record"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query a specific record from a Repository's on-chain key-value database by name and entity. Use to read stored data records. Returns: TableItem_RepositoryData | undefined"),
+        z.object({
+            query_type: z.literal("onchain_table_item_permission_perm"),
+            parent: NameOrAddressSchema.describe("Parent Permission object ID"),
+            address: z.union([AccountOrMark_AddressSchema, z.string()]).describe("User address or Guard ID whose permissions to check"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query a permission entry from a Permission object's perm table — checks what operations a user/guard is allowed to perform. Use to verify access rights. Returns: TableItem_PermissionPerm | undefined"),
+        z.object({
+            query_type: z.literal("onchain_table_item_entity_registrar"),
+            address: z.union([AccountOrMark_AddressSchema, z.string()]).describe("User address to look up in the global EntityRegistrar"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query an entity's registration record from the global EntityRegistrar — verifies if an address is registered on the blockchain. Use to check registration status and details. Returns: TableItem_EntityRegistrar | undefined"),
+        z.object({
+            query_type: z.literal("onchain_table_item_entity_linker"),
+            address: z.union([AccountOrMark_AddressSchema, z.string()]).describe("Entity address whose community votes/endorsements to query"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query community votes/endorsements for an entity from the global EntityLinker — shows how others have voted on this entity. Use to check reputation and community trust. Returns: TableItem_EntityLinker | undefined"),
+        z.object({
+            query_type: z.literal("onchain_table_item_reward_record"),
+            parent: NameOrAddressSchema.describe("Parent Reward object ID"),
+            address: AccountOrMark_AddressSchema.describe("User address that claimed the reward"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query a reward claim record from a Reward object's table — checks if a user has claimed a specific incentive. Use to verify reward distribution status. Returns: TableItem_RewardRecord | undefined"),
+    ]),
+    z.discriminatedUnion("query_type", [
+        z.object({
+            query_type: z.literal("onchain_table_item_demand_presenter"),
+            parent: NameOrAddressSchema.describe("Parent Demand object ID"),
+            address: AccountOrMark_AddressSchema.describe("Presenter address that submitted the demand"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query a demand submission from a Demand object's table — Demands are service requests submitted by users. Use to check a specific demand's details. Returns: TableItem_DemandPresenter | undefined"),
+        z.object({
+            query_type: z.literal("onchain_table_item_treasury_history"),
+            parent: NameOrAddressSchema.describe("Parent Treasury object ID"),
+            address: AccountOrMark_AddressSchema.describe("Payment ID whose treasury record to look up"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query a payment record from a Treasury's history table by payment ID — Treasury manages funds and payment tracking. Use to look up payment details and status. Returns: TableItem_TreasuryHistory | undefined"),
+        z.object({
+            query_type: z.literal("onchain_table_item_machine_node"),
+            parent: NameOrAddressSchema.describe("Parent Machine object ID"),
+            key: z.string().describe("Node name (string key) to query in the Machine's workflow definition"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query a workflow node definition from a Machine object's table by node name — Machines define workflow templates. Use to inspect a specific node's configuration and logic. Returns: TableItem_MachineNode | undefined"),
+        z.object({
+            query_type: z.literal("onchain_table_item_progress_history"),
+            parent: NameOrAddressSchema.describe("Parent Progress object ID"),
+            u64: z.union([z.number(), z.string()]).describe("Sequence number (u64) of the progress step to query"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query a progress step record from a Progress object's table by sequence number — Progress tracks order/workflow execution. Use to check the status of a specific execution step. Returns: TableItem_ProgressHistory | undefined"),
+        z.object({
+            query_type: z.literal("onchain_table_item_address_mark"),
+            parent: NameOrAddressSchema.describe("Parent AddressMark object ID"),
+            address: AccountOrMark_AddressSchema.describe("Address whose PUBLIC on-chain name/tags to look up"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query a PUBLIC on-chain name/tag mark for an address — unlike local marks, these are published on-chain. Use to look up public labels attached to any address. Returns: TableItem_AddressMark | undefined"),
+        z.object({
+            query_type: z.literal("onchain_table_item_generic"),
+            parent: NameOrAddressSchema.describe("Parent object ID whose dynamic field to query"),
+            key_type: z.string().describe("Type of the key (e.g., 'address', 'u64', 'string', '0x2::object::ID')"),
+            key_value: z.any().describe("Value of the key. Must match the key_type format"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query a generic table item from ANY object's dynamic fields — supports arbitrary key types and values for non-WoWok objects. Use for custom objects and general-purpose table lookups. Returns: ObjectBase | undefined"),
+    ]),
+]));
+const OnchainTableDataResultSchema = z.object({
+    result: z.union([
+        z.object({ query_type: z.literal("onchain_table"), result: z.union([TableAnswerSchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_repository_data"), result: z.union([TableItem_RepositoryDataSchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_permission_perm"), result: z.union([TableItem_PermissionPermSchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_entity_registrar"), result: z.union([TableItem_EntityRegistrarSchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_entity_linker"), result: z.union([TableItem_EntityLinkerSchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_reward_record"), result: z.union([TableItem_RewardRecordSchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_demand_presenter"), result: z.union([TableItem_DemandPresenterSchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_treasury_history"), result: z.union([TableItem_TreasuryHistorySchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_machine_node"), result: z.union([TableItem_MachineNodeSchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_progress_history"), result: z.union([TableItem_ProgressHistorySchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_address_mark"), result: z.union([TableItem_AddressMarkSchema, z.undefined()]) }),
+        z.object({ query_type: z.literal("onchain_table_item_generic"), result: z.union([ObjectBaseSchema, z.undefined()]) }),
+    ])
+});
+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 },
+    };
+}
+const WatchQueryOperationsSchema = z.preprocess((input) => {
+    if (typeof input === 'object' && input !== null) {
+        const obj = { ...input };
+        if (typeof obj.description === 'string' && !obj.query_type) {
+            try {
+                const parsed = JSON.parse(obj.description);
+                if (parsed && typeof parsed === 'object' && parsed.query_type) {
+                    return parsed;
+                }
+            }
+            catch { }
+        }
+        for (const key of ['filter', 'objects', 'env', 'token_type']) {
+            if (typeof obj[key] === 'string') {
+                try {
+                    obj[key] = JSON.parse(obj[key]);
+                }
+                catch { }
+            }
+        }
+        return obj;
+    }
+    return input;
+}, z.union([
+    z.discriminatedUnion("query_type", [
+        z.object({
+            query_type: z.literal("local_mark_list"),
+            filter: LocalMarkFilterSchema.optional().describe("Local mark filter"),
+        }).describe("Query your LOCAL address book — maps human-readable names to blockchain addresses with optional tags. Use to resolve names→addresses or find addresses by tag. Returns: MarkData[] (name, address, tags, timestamps)"),
+        z.object({
+            query_type: z.literal("account_list"),
+            filter: AccountFilterSchema.optional().describe("Account filter"),
+        }).describe("Query your LOCAL accounts — view all accounts stored on this device (addresses, public keys, messenger status, suspension state). Use to discover available accounts before operations. Returns: AccountData[] (name, address, pubkey, suspended, messenger, timestamps)"),
+        z.object({
+            query_type: z.literal("local_info_list"),
+            filter: LocalInfoFilterSchema.optional().describe("Local info filter"),
+        }).describe("Query your LOCAL private info — sensitive data like delivery addresses, phone numbers, contacts stored ONLY on this device. Use to retrieve saved contact/delivery details. Returns: InfoData[] (name, default value, contents, timestamps)"),
+        z.object({
+            query_type: z.literal("token_list"),
+            filter: TokenDataFilterSchema.optional(),
+        }).describe("Query cached token metadata — symbol, decimals, icon URL, description for tokens previously fetched from chain. Use to look up token info without an on-chain query. Returns: TokenTypeInfo[] (type, alias, name, symbol, decimals, iconUrl)"),
+        z.object({
+            query_type: z.literal("account_balance"),
+            name_or_address: NameOrAddressSchema.optional().describe("Account name or address. Use empty string '' for the default account. Defaults to '' if omitted."),
+            balance: z.boolean().optional().describe("Set to true to query total balance amount for the token type"),
+            coin: z.object({
+                cursor: z.union([z.string(), z.null()]).optional().describe("Pagination cursor for listing coin objects"),
+                limit: z.union([z.number(), z.null()]).optional().describe("Max coin objects per page"),
+            }).optional().describe("Set to query paginated coin objects instead of balance. Use cursor/limit for pagination."),
+            token_type: TokenTypeSchema.optional().describe("Token type to query; defaults to 0x2::wow::WOW (platform token)"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query an account's coin balance OR paginated coin objects. Use balance=true for total amount, or coin={cursor,limit} to list individual coin objects. Returns: { address, balance? | coin? }"),
+    ]),
+    z.discriminatedUnion("query_type", [
+        z.object({
+            query_type: z.literal("onchain_personal_profile"),
+            account: NameOrAddressSchema.optional().describe("Account name or ID to query. Use empty string '' for the default account."),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query any user's PUBLIC on-chain profile — social links, reputation (likes/dislikes), personal info records, voting history, referrer. Use to look up a user's public identity and reputation. Returns: ObjectPersonal | undefined"),
+        z.object({
+            query_type: z.literal("onchain_objects"),
+            objects: z.array(NameOrAddressSchema).describe("List of object IDs (names or addresses) to query in batch"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Batch query on-chain WOWOK objects by ID or name — supports Service, Machine, Order, Treasury, Reward, Arb, Personal, Contact, and more. Use to inspect one or more objects in a single call. Returns: { objects: ObjectBase[] }"),
+        z.object({
+            query_type: z.literal("onchain_received"),
+            name_or_address: AccountOrMark_AddressAISchema.describe("Name or address of the object that received payments/items - can be a string (name/address) or full object"),
+            all_type: z.boolean().optional().describe("Set to true to query all token types received; defaults to the object's Token type '0x2::payment::CoinWrapper<TOKEN>' (Coins wrapper sent via Payment object). If the object has no Token type, the call will fail."),
+            cursor: z.union([z.string(), z.null()]).optional().describe("Pagination cursor from previous page"),
+            limit: z.union([z.number(), z.null()]).optional().describe("Max records per page"),
+            no_cache: z.boolean().optional().describe("Set to true to bypass cache and fetch fresh on-chain data"),
+            network: EntrypointSchema.optional(),
+        }).describe("Query objects (Payments, Tokens, NFTs) received by a specific object. Use to track incoming payments or items sent to an on-chain object. Supports pagination and all_type filter. Returns: ReceivedBalance | ReceivedNormal[]"),
+    ]),
+]));
+async function handleOnchainOperations(args) {
+    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: ... }' }");
+            }
+        }
+        const validated = strictParse(OnchainOperationsSchema, args, "onchain_operations input");
+        const env = getEnvConfig(validated.env);
+        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);
+                return handleCallResult(result);
+            }
+            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);
+            }
+            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);
+            }
+            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);
+            }
+            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);
+            }
+            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);
+            }
+            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);
+            }
+            case "reward": {
+                const transformedData = transformRewardData(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);
+            }
+            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);
+            }
+            case "permission": {
+                const callPermission = new CallPermission(validated.data);
+                const result = await callPermission.call(env);
+                return handleCallResult(result);
+            }
+            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);
+            }
+            case "personal": {
+                const transformPersonalData = (data) => {
+                    const result = { ...data };
+                    if (data.mark) {
+                        const transformAddress = (addr) => {
+                            if (typeof addr === 'string') {
+                                return { name_or_address: addr, local_mark_first: true };
+                            }
+                            return addr;
+                        };
+                        if (data.mark.op === 'add' && data.mark.data) {
+                            result.mark = {
+                                ...data.mark,
+                                data: data.mark.data.map((item) => ({
+                                    ...item,
+                                    address: transformAddress(item.address)
+                                }))
+                            };
+                        }
+                        else if (data.mark.op === 'remove' && data.mark.data) {
+                            result.mark = {
+                                ...data.mark,
+                                data: data.mark.data.map((item) => ({
+                                    ...item,
+                                    address: transformAddress(item.address)
+                                }))
+                            };
+                        }
+                        else if (data.mark.op === 'clear' && data.mark.address) {
+                            const addr = data.mark.address;
+                            if (Array.isArray(addr) && addr.every((a) => typeof a === 'string')) {
+                                result.mark = {
+                                    ...data.mark,
+                                    address: {
+                                        entities: addr.map((a) => ({ name_or_address: a, local_mark_first: true }))
+                                    }
+                                };
+                            }
+                        }
+                        else if (data.mark.op === 'transfer' && data.mark.to) {
+                            result.mark = {
+                                ...data.mark,
+                                to: transformAddress(data.mark.to)
+                            };
+                        }
+                    }
+                    return result;
+                };
+                const transformedData = transformPersonalData(validated.data);
+                const callPersonal = new CallPersonal(transformedData);
+                const result = await callPersonal.call(env);
+                return handleCallResult(result);
+            }
+            case "payment": {
+                const callPayment = new CallPayment(validated.data);
+                const result = await callPayment.call(env);
+                return handleCallResult(result);
+            }
+            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);
+            }
+            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);
+            }
+            case "gen_passport": {
+                const result = await gen_passport(env, validated.guard, validated.info);
+                return handleCallResult(result);
+            }
+        }
+        throw new Error(`Unknown on-chain operation type: ${validated.operation_type}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            structuredContent: {
+                message: `Error: ${errorMessage}`,
+                result: {
+                    type: "error",
+                    error: errorMessage,
+                },
+            },
+        };
+    }
+}
+async function handleAccountOperation(args) {
+    try {
+        const validated = strictParse(AccountOperationSchema, args, "account_operation input");
+        const result = await account_operation(validated);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: {
+                result: {
+                    status: "success",
+                    data: result,
+                },
+            },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            structuredContent: {
+                result: {
+                    status: "error",
+                    error: errorMessage,
+                },
+            },
+        };
+    }
+}
+async function handleMarkOperation(args) {
+    try {
+        const validated = strictParse(LocalMarkOperationSchema, args, "local_mark_operation input");
+        const result = await local_mark_operation(validated);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: {
+                result: {
+                    status: "success",
+                    data: result,
+                },
+            },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            structuredContent: {
+                result: {
+                    status: "error",
+                    error: errorMessage,
+                },
+            },
+        };
+    }
+}
+async function handleInfoOperation(args) {
+    try {
+        const validated = strictParse(LocalInfoOperationSchema, args, "local_info_operation input");
+        const result = await local_info_operation(validated);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: {
+                result: {
+                    status: "success",
+                    data: result,
+                },
+            },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            structuredContent: {
+                result: {
+                    status: "error",
+                    error: errorMessage,
+                },
+            },
+        };
+    }
+}
+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,
+    };
+}
+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 "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),
+                all_type: validated.all_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", "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 },
+    };
+}
+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 },
+    };
+}
+async function handleOnchainEvents(args) {
+    const validated = strictParse(OnchainEventsInputSchema, args, "onchain_events input");
+    const queryResult = await query_events({
+        type: validated.type,
+        cursor: validated.cursor ?? 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 },
+    };
+}
+function normalizeAccountOrMark(input) {
+    if (typeof input === 'string') {
+        return { name_or_address: input, local_mark_first: true };
+    }
+    return input;
+}
+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;
+}
+async function handleMessengerOperation(args) {
+    const 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;
+        }
+        default:
+            throw new Error(`Unknown messenger operation: ${validated.operation}`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        structuredContent: { result },
+    };
+}
+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,
+        };
+    }
+}
+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);
+        const result = {
+            result: {
+                status: "success",
+                data: {
+                    file_path: resolve(validated.file_path),
+                    format: validated.format || "json",
+                    machine_object: validated.machine,
+                    node_count: 0,
+                },
+            },
+        };
+        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 { OnchainOperationsSchema, WipOperationsSchema, WatchQueryOperationsSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, ProtocolInfoQuerySchema, CallOutputSchema, MessengerOperationInputSchema, MessengerOperationOutputSchema };
+async function main() {
+    server.registerTool("onchain_operations", {
+        title: "⛓️ On-chain Operations",
+        description: "On-chain operations for WoWok object: service (marketplace listings), machine (workflow templates), progress (order tracking), repository (on-chain database), arbitration (dispute resolution), contact (IM management), treasury (team funds), reward (incentive pools), allocation (auto-distribution), permission (access control), guard (programmable trust rules), personal (public profile), payment (direct coin transfers), demand (service requests), order (order management), gen_passport (verified credentials).",
+        inputSchema: OnchainOperationsSchema,
+        outputSchema: CallOutputSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+        _meta: createToolMeta("operation", ["service", "machine", "progress", "repository", "arbitration", "contact", "treasury", "reward", "allocation", "permission", "guard", "personal", "payment", "demand", "order", "gen_passport", "on-chain", "blockchain"]),
+    }, handleOnchainOperations);
+    server.registerTool("account_operation", {
+        title: "🔒 LOCAL ONLY: Account - Wallet Management",
+        description: "🔒 100% LOCAL, NEVER ON-CHAIN 🔒 Manage WoWok accounts locally on device: generate, suspend, resume, faucet-test, operate assets, sign data, etc.",
+        inputSchema: AccountOperationSchema,
+        outputSchema: AccountOperationOutputWrappedSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        _meta: createToolMeta("operation", ["account", "local", "private", "wallet", "off-chain"]),
+    }, handleAccountOperation);
+    server.registerTool("local_mark_operation", {
+        title: "🔒 LOCAL ONLY: LocalMark - Address Book Management",
+        description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage ID names and tags stored ONLY on your local device for easy identification of user address or object IDs by name.",
+        inputSchema: LocalMarkOperationSchema,
+        outputSchema: LocalMarkOperationOutputWrappedSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        _meta: createToolMeta("operation", ["mark", "local", "private", "address-book", "off-chain"]),
+    }, handleMarkOperation);
+    server.registerTool("local_info_operation", {
+        title: "🔒 LOCAL ONLY: LocalInfo - Private Data Management",
+        description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage sensitive personal information stored ONLY on your device: delivery addresses, phone numbers, contacts.",
+        inputSchema: LocalInfoOperationSchema,
+        outputSchema: LocalInfoOperationOutputWrappedSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        _meta: createToolMeta("operation", ["info", "local", "private", "data-management", "off-chain"]),
+    }, handleInfoOperation);
+    server.registerTool("wip_file", {
+        title: "🤝 Witness Information Promise File Operations",
+        description: "generate (create WIP files from markdown and images), verify (integrity check), sign (add signatures), or wip2html (convert to HTML).",
+        inputSchema: WipOperationsSchema,
+        outputSchema: z.object({
+            result: WipOperationOutputSchema,
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        _meta: createToolMeta("operation", ["wip", "promise", "file-generation", "verification", "signature", "local"]),
+    }, handleWipOperations);
+    server.registerTool("messenger_operation", {
+        title: "💬 Messenger Operations",
+        description: "WoWok encrypted messenger operations: watch conversations (with unread filtering, preview messages), send message, send file, watch messages (with viewed status filtering), extract zip messages, generate WTS, verify WTS, sign WTS, WTS to HTML, proof message on-chain, manage blacklist, friendslist, guardlist, settings, mark messages as viewed, and mark conversation as viewed.",
+        inputSchema: MessengerOperationInputSchema,
+        outputSchema: MessengerOperationOutputSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+        _meta: createToolMeta("operation", ["messenger", "message", "file", "wts", "blacklist", "friendslist", "guardlist", "settings", "proof", "communication"]),
+    }, handleMessengerOperation);
+    server.registerTool("guard2file", {
+        title: "📄 Guard to File - Export Guard Definition",
+        description: "Export a Guard object's definition from the blockchain to a local JSON or Markdown file for editing and creating new Guard objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.",
+        inputSchema: Guard2File_InputSchema,
+        outputSchema: Guard2File_OutputWrappedSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("generate file", ["guard", "export", "file", "json", "markdown", "on-chain"]),
+    }, handleGuard2File);
+    server.registerTool("machineNode2file", {
+        title: "⚙️ Machine Node to File - Export Machine Node Definition",
+        description: "Export a Machine object's node definition from the blockchain to a local JSON or Markdown file for editing and creating new Machine objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.",
+        inputSchema: MachineNode2File_InputSchema,
+        outputSchema: MachineNode2File_OutputWrappedSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("generate file", ["machine", "export", "file", "json", "markdown", "on-chain", "workflow"]),
+    }, handleMachineNode2File);
+    server.registerTool("query_toolkit", {
+        title: "🔍 Data Query Toolkit",
+        description: "WOWOK data query toolkit — 8 query types covering local device data and on-chain blockchain data:\n\n"
+            + "LOCAL (device-only, never on-chain):\n"
+            + "1. local_mark_list — Query your LOCAL address book: maps human-readable names to blockchain addresses with optional tags. Use to resolve names→addresses or find addresses by tag.\n"
+            + "2. account_list — Query your LOCAL accounts: view all accounts stored on this device (addresses, public keys, messenger status, suspension state). Use to discover available accounts before operations.\n"
+            + "3. local_info_list — Query your LOCAL private info: sensitive data like delivery addresses, phone numbers, contacts stored ONLY on this device.\n"
+            + "4. token_list — Query cached token metadata: symbol, decimals, icon URL, description for tokens previously fetched from chain. Use to look up token precision/decimals before performing token operations. Returns: TokenTypeInfo[] (type, alias, name, symbol, decimals, iconUrl).\n"
+            + "5. account_balance — Query an account's coin balance OR paginated coin objects. Use balance=true for total amount, or coin={cursor,limit} to list individual coin objects. Supports multi-token via token_type parameter.\n\n"
+            + "ONCHAIN (blockchain):\n"
+            + "6. onchain_personal_profile — Query any user's PUBLIC on-chain profile: social links, reputation (likes/dislikes), personal info records, voting history, referrer.\n"
+            + "7. onchain_objects — Batch query on-chain WOWOK objects by ID or name: supports Service, Machine, Order, Treasury, Reward, Arb, Personal, Contact, and more.\n"
+            + "8. onchain_received — Query objects (Payments, Tokens, NFTs) received by a specific object. Supports pagination and all_type filter.\n\n"
+            + "For dynamic table data queries (pagination, table items), use the 'onchain_table_data' tool.",
+        inputSchema: WatchQueryOperationsSchema,
+        outputSchema: z.object({
+            result: z.any().describe("Query result — type depends on query_type. Local queries return arrays (MarkData[], AccountData[], InfoData[], TokenTypeInfo[]). account_balance returns { address, balance? | coin? }. Onchain queries return typed objects or undefined. onchain_received returns ReceivedBalance | ReceivedNormal[].")
+        }),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("query", ["watch", "query", "on-chain", "local", "events", "objects", "tokens", "balance", "profile"]),
+    }, handleWatchQueryOperations);
+    server.registerTool("onchain_table_data", {
+        title: "📊 Watch WoWok On-chain Table Data Query",
+        description: "Query dynamic table data of on-chain objects — supports paginated table queries and specific table item lookups. Each table item belongs to a parent object type and has a specific meaning:\n\n"
+            + "1. onchain_table — Paginated query of ANY object's dynamic fields table (Parent: any object). Returns all entries with keys, types, and object IDs. Use to explore all sub-items of an object.\n"
+            + "2. onchain_table_item_repository_data — Query a record from a Repository's on-chain key-value database (Parent: Repository). Key: name + entity (address or number). Returns the stored data record with typed value.\n"
+            + "3. onchain_table_item_permission_perm — Query a permission entry from a Permission object's access control table (Parent: Permission). Key: user address or Guard ID. Returns the permission list (perm[]) granted to that user/guard.\n"
+            + "4. onchain_table_item_entity_registrar — Query an entity's registration record from the GLOBAL EntityRegistrar (Parent: system EntityRegistrar). Key: user address. Returns registration info: description, referrer, records, mark_object.\n"
+            + "5. onchain_table_item_entity_linker — Query community votes/endorsements for an entity from the GLOBAL EntityLinker (Parent: system EntityLinker). Key: entity address. Returns vote records (likes/dislikes) showing community trust.\n"
+            + "6. onchain_table_item_reward_record — Query a reward claim record from a Reward object's distribution table (Parent: Reward). Key: recipient address. Returns claim history: guard used, total claimed, per-claim details.\n"
+            + "7. onchain_table_item_demand_presenter — Query a demand submission from a Demand object's presenter table (Parent: Demand). Key: presenter address. Returns submission details: recommendation, service, feedback, acceptance score.\n"
+            + "8. onchain_table_item_treasury_history — Query a payment record from a Treasury's history table (Parent: Treasury). Key: payment ID (address). Returns payment details: operation type, signer, amount, external guard.\n"
+            + "9. onchain_table_item_machine_node — Query a workflow node definition from a Machine object's node table (Parent: Machine). Key: node name (string). Returns node configuration: pairs, forwards, guards, thresholds.\n"
+            + "10. onchain_table_item_progress_history — Query a progress step record from a Progress object's history table (Parent: Progress). Key: sequence number (u64). Returns step details: node, next_node, session state, time.\n"
+            + "11. onchain_table_item_address_mark — Query a PUBLIC on-chain name/tag mark from an AddressMark object's table (Parent: AddressMark). Key: address. Returns public labels: entity, name, tags[]. Unlike local marks, these are published on-chain.\n"
+            + "12. onchain_table_item_generic — Query a generic table item from ANY object's dynamic fields (Parent: any object). Supports arbitrary key types (address, u64, string, object ID, etc.). Use for custom objects and general-purpose table lookups. Returns: ObjectBase | undefined.",
+        inputSchema: OnchainTableDataSchema,
+        outputSchema: OnchainTableDataResultSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("table query", ["on-chain", "table", "dynamic fields", "pagination", "repository", "permission", "reward", "demand", "treasury", "machine", "progress"]),
+    }, handleOnchainTableData);
+    server.registerTool("onchain_events", {
+        title: "📅 Watch WoWok On-chain Events",
+        description: "Watch on-chain WoWok events by type. Supports arbitration events, new order events, progress events, demand presentation events, demand feedback events, and new entity registration events. Use pagination cursor for fetching large result sets.",
+        inputSchema: OnchainEventsInputSchema,
+        outputSchema: OnchainEventsResultSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("watch wowook events", ["events", "on-chain", "arbitration", "order", "progress", "demand", "entity"]),
+    }, handleOnchainEvents);
+    server.registerTool("wowok_buildin_info", {
+        title: "ℹ️ WoWok Build-in Information",
+        description: "Query WoWok protocol information: 'constants', 'built-in permissions', 'guard instructions', 'current network', or 'value types'.",
+        inputSchema: ProtocolInfoQuerySchema,
+        outputSchema: ProtocolInfoResultSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("WoWok info", ["build-in", "constants", "permissions", "guard", "network", "value-types"]),
+    }, handleWowokInfo);
+    server.registerTool("documents_and_learn", {
+        title: "📚 Documents and Learn",
+        description: "Access WoWok documentation and learning resources. Provides official documentation URL for users and AI to get more information about WoWok protocol, components, and usage.",
+        inputSchema: z.object({
+            topic: z.string().optional().describe("Optional topic to search for in documentation (e.g., 'guard', 'service', 'messenger', 'stage-01-introduction')"),
+        }),
+        outputSchema: z.object({
+            documentation_url: z.string().describe("Official WoWok documentation URL on GitHub"),
+            topic: z.string().optional().describe("Requested topic if specified"),
+            original_topic: z.string().optional().describe("Original topic input by user (before normalization)"),
+            message: z.string().describe("Welcome message with documentation information. Always included in response."),
+        }),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("documentation", ["docs", "learn", "tutorial", "guide", "help", "reference"]),
+    }, async (args) => {
+        const GITHUB_BASE_URL = "https://github.com/wowok-ai/docs/blob/main/docs";
+        if (!args.topic) {
+            const url = GITHUB_BASE_URL;
+            const message = `Welcome to WoWok Documentation! Access comprehensive guides, tutorials, and API references at: ${url}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: message,
+                    },
+                ],
+                structuredContent: {
+                    documentation_url: url,
+                    message: message,
+                },
+            };
+        }
+        const normalizedTopic = args.topic.toLowerCase().trim();
+        const url = `${GITHUB_BASE_URL}/${normalizedTopic}.md`;
+        const message = `Documentation for "${normalizedTopic}"\nGitHub URL: ${url}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: message,
+                },
+            ],
+            structuredContent: {
+                documentation_url: url,
+                topic: normalizedTopic,
+                original_topic: args.topic,
+                message: message,
+            },
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.on("SIGINT", async () => {
+        await server.close();
+        process.exit(0);
+    });
+}
+main().catch(console.error);