@wowok/agent-mcp 2.3.6 → 2.3.8

package/dist/index.js

@@ -5,7 +5,8 @@ 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 { MachineNode2File_InputSchema, MachineNode2File_OutputWrappedSchema, Guard2File_InputSchema, Guard2File_OutputWrappedSchema, strictParse, CallOutputSchema, handleCallResult, createServerConfig, createCapabilitiesConfig, createToolMeta, transformSubmission, getEnvConfig, OnchainEventsInputSchema, OnchainEventsResultSchema, ProtocolInfoQuerySchema, ProtocolInfoResultSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, MessengerOperationInputSchema, BridgeOperationsSchema, BridgeCallOutputSchema, OnchainOperationsSchema, WipOperationsSchema, OnchainTableDataSchema, OnchainTableDataResultSchema, WatchQueryOperationsSchema, } from "./schema/index.js";
+import { handleBridgeOperations } from "./schema/call/bridge-handler.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, GetLocalNamesByAddresses, 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/wowok";
 import { areSchemasAvailable, getSchemaIndex, processSchemaQuery, } from "./schema-query/index.js";
 const SERVER_DESCRIPTION = `WoWok MCP Server - Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.
@@ -148,310 +149,6 @@ function transformRewardData(data) {
     }
     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;
@@ -529,90 +226,6 @@ async function handleOnchainTableData(args) {
         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.object({
-            query_type: z.literal("local_names"),
-            addresses: z.array(z.string()).describe("Array of addresses to look up local names for"),
-        }).describe("Query local names (account name and local mark name) for a list of addresses. Returns array of: { account?: string, local_mark?: string, address: string }"),
-    ]),
-    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"),
-            type: z.union([z.string(), z.literal("CoinWrapper"), z.null()]).optional().describe("Type filter for querying received objects. " +
-                "- If undefined or null: query all types (equivalent to the old all_type=true). " +
-                "- If 'CoinWrapper': query CoinWrapper type for the object's token (equivalent to the old all_type=false). " +
-                "- If string: query specific StructType (e.g., '0x2::payment::CoinWrapper<0x2::wow::WOW>')."),
-            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 type filter. Returns: ReceivedBalance | ReceivedNormal[]"),
-    ]),
-]));
 async function handleOnchainOperations(args) {
     try {
         if (typeof args === 'object' && args !== null && args.description && !args.operation_type) {
@@ -1456,19 +1069,20 @@ async function main() {
             "Always check the schema before calling an unfamiliar tool.\n\n" +
             "Actions:\n" +
             "  'list' - Show all available schemas (tools + on-chain operations). Start here to discover what exists.\n" +
-            "  'get' - Fetch the full JSON Schema by name (e.g. 'onchain_operations'). Use with the 'name' param.\n" +
+            "  'get' - Fetch the full input JSON Schema by name (e.g. 'onchain_operations'). Use with the 'name' param.\n" +
+            "  'get_output' - Fetch the output JSON Schema of a tool by name (e.g. 'onchain_operations'). Use with the 'name' param. Use this to understand a tool's return value structure.\n" +
             "  'search' - Find schemas by keyword, matching name/title/description. Use with the 'query' param.\n" +
             "  'list_operations' - Show only on-chain operation schemas (prefixed 'onchain_operations_'). Narrower than 'list'.",
         inputSchema: z.object({
-            action: z.enum(["list", "get", "search", "list_operations"])
-                .describe("Action to perform: 'list' to see all available schemas, 'get' to retrieve a specific schema, 'search' to find schemas by keyword, 'list_operations' to list all on-chain operations"),
-            name: z.string().optional().describe("Schema name for 'get' action (e.g., 'onchain_operations', 'account_operation', 'onchain_operations_permission')"),
+            action: z.enum(["list", "get", "get_output", "search", "list_operations"])
+                .describe("Action to perform: 'list' to see all available schemas, 'get' to retrieve a specific input schema, 'get_output' to retrieve a tool's output schema, 'search' to find schemas by keyword, 'list_operations' to list all on-chain operations"),
+            name: z.string().optional().describe("Schema/tool name for 'get'/'get_output' action (e.g., 'onchain_operations', 'account_operation', 'onchain_operations_permission')"),
             query: z.string().optional().describe("Search query for 'search' action"),
         }),
         outputSchema: z.object({
             success: z.boolean().describe("Whether the request was successful"),
             action: z.string().describe("The action that was performed"),
-            data: z.any().describe("Response data - JSON Schema object for 'get', array of schema info for 'list'/'search'/'list_operations'"),
+            data: z.any().describe("Response data - JSON Schema object for 'get'/'get_output', array of schema info for 'list'/'search'/'list_operations'"),
             message: z.string().describe("Human-readable message describing the result"),
             suggestions: z.array(z.string()).optional().describe("Suggested next steps or alternatives"),
         }),
@@ -1523,6 +1137,14 @@ async function main() {
                         textContent += "\n```\n";
                     }
                     break;
+                case "get_output":
+                    if (data) {
+                        textContent += "\n\n## Output JSON Schema\n\n";
+                        textContent += "```json\n";
+                        textContent += JSON.stringify(data, null, 2);
+                        textContent += "\n```\n";
+                    }
+                    break;
                 case "search":
                     if (Array.isArray(data) && data.length > 0) {
                         textContent += `\n\nFound ${data.length} schemas matching '${args.query}':\n`;
@@ -1557,6 +1179,30 @@ async function main() {
             structuredContent: response,
         };
     });
+    server.registerTool("bridge_operation", {
+        title: "🌉 Bridge - Cross-Chain Operations",
+        description: "🌉 Simplified cross-chain bridge between WOW and EVM (Ethereum mainnet). Only WOW mainnet provides cross-chain functionality.\n\n" +
+            "Key concepts (transparent to user):\n" +
+            "  • Global single activeEvmAccount - auto-generated on first use, holds cross-chain assets.\n" +
+            "  • WOW→EVM: assets auto-claim to activeEvmAccount; optional withdrawTo transfers to a final EVM address.\n" +
+            "  • EVM→WOW: deposit from activeEvmAccount (balance checked first), assets arrive at the WOW account.\n\n" +
+            "Operations (operation_type):\n" +
+            "  • cross_chain_wow_to_evm - WOW→EVM cross-chain (asset to activeEvmAccount or withdrawTo). [Requires WOW mainnet env]\n" +
+            "  • cross_chain_evm_to_wow - EVM→WOW cross-chain (from activeEvmAccount to WOW account). [Requires WOW mainnet env]\n" +
+            "  • withdraw - Withdraw from activeEvmAccount to another EVM address (non-cross-chain). [No env needed]\n" +
+            "  • query_active_evm_account - Query activeEvmAccount address + balances (per chain or all). [No env needed]\n" +
+            "  • query_supported_evm_chains - List supported EVM chains (enum/description/chainId/RPC health). [No env needed]\n" +
+            "  • query_supported_tokens - List supported Bridge tokens per chain (WOW/EVM contract addresses, decimals, description). [No env needed]\n" +
+            "  • query_transfer_list - Query transfer history list with optional filters (status/direction/token/limit). [No env needed]\n" +
+            "  • query_transfer_status - Query single transfer detail by transferId. [No env needed]\n" +
+            "  • manage_evm_rpc - Manage EVM RPC endpoints (list/add/remove/set/ping) to handle 429 rate limits. [No env needed]\n\n" +
+            "Token support follows SDK config (ETH/WETH/WBTC/USDC/USDT). WOW account names are supported (resolved via LocalMark).\n" +
+            "NOTE: Use schema_query (name='bridge_operation') to retrieve the exact JSON Schema with all field definitions before calling.",
+        inputSchema: BridgeOperationsSchema,
+        outputSchema: BridgeCallOutputSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+        _meta: createToolMeta("operation", ["bridge", "cross-chain", "evm", "ethereum", "wow", "transfer", "rpc"]),
+    }, handleBridgeOperations);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     process.on("SIGINT", async () => {

package/dist/schema/call/bridge-handler.d.ts

@@ -0,0 +1,5 @@
+import type { CallOutput } from "./base.js";
+export declare function handleBridgeOperations(args: any): Promise<{
+    content: any[];
+    structuredContent: CallOutput;
+}>;