@wowok/agent-mcp 2.3.6 → 2.3.8

package/dist/schema/operations.js

@@ -0,0 +1,393 @@
+import { z } from 'zod';
+import { CallService_DataSchema, CallMachine_DataSchema, CallProgress_DataSchema, CallRepository_DataSchema, CallArbitration_DataSchema, CallContact_DataSchema, CallTreasury_DataSchema, CallReward_DataSchema, CallAllocation_DataSchema, CallPermission_DataSchema, CallGuard_DataSchema, CallPersonal_DataSchema, CallPayment_DataSchema, CallDemand_DataSchema, CallOrder_DataSchema, CallEnvSchema, SubmissionCallSchema, } from './call/index.js';
+import { WipGenerationOptionsSchema, WipToHtmlOptionsSchema, LocalMarkFilterSchema, AccountFilterSchema, LocalInfoFilterSchema, TokenDataFilterSchema, } from './local/index.js';
+import { NameOrAddressSchema, AccountOrMark_AddressSchema, AccountOrMark_AddressAISchema, EntrypointSchema, TokenTypeSchema, ObjectBaseSchema, } from './common/index.js';
+import { TableAnswerSchema, TableItem_RepositoryDataSchema, TableItem_PermissionPermSchema, TableItem_EntityRegistrarSchema, TableItem_EntityLinkerSchema, TableItem_RewardRecordSchema, TableItem_DemandPresenterSchema, TableItem_TreasuryHistorySchema, TableItem_MachineNodeSchema, TableItem_ProgressHistorySchema, TableItem_AddressMarkSchema, } from './query/index.js';
+export 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."),
+]));
+export 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"),
+]));
+export 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"),
+    ]),
+]));
+export 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[]"),
+    ]),
+]));
+export 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()]) }),
+    ])
+});

package/dist/schema-query/index.d.ts

@@ -3,9 +3,10 @@ export interface SchemaInfo {
     title: string;
     description?: string;
     path: string;
+    outputPath?: string;
 }
 export interface SchemaQueryRequest {
-    action: "list" | "get" | "search" | "list_operations";
+    action: "list" | "get" | "search" | "list_operations" | "get_output";
     name?: string;
     query?: string;
 }
@@ -24,6 +25,7 @@ export declare function getSchemaIndex(): {
 } | null;
 export declare function listSchemas(): SchemaInfo[];
 export declare function getSchema(name: string): any | null;
+export declare function getOutputSchema(name: string): any | null;
 export declare function searchSchemas(query: string): SchemaInfo[];
 export declare function listOperations(): SchemaInfo[];
 export declare function processSchemaQuery(request: SchemaQueryRequest): SchemaQueryResponse;

package/dist/schema-query/index.js

@@ -45,6 +45,20 @@ export function getSchema(name) {
         return null;
     }
 }
+export function getOutputSchema(name) {
+    try {
+        const schemaPath = join(SCHEMAS_DIR, `${name}.output.json`);
+        if (!existsSync(schemaPath)) {
+            return null;
+        }
+        const content = readFileSync(schemaPath, "utf-8");
+        const schema = JSON.parse(content);
+        return resolveSchemaRefs(schema);
+    }
+    catch {
+        return null;
+    }
+}
 function resolveSchemaRefs(schema, visited = new Set()) {
     if (!schema || typeof schema !== "object") {
         return schema;
@@ -55,9 +69,14 @@ function resolveSchemaRefs(schema, visited = new Set()) {
     const result = {};
     for (const [key, value] of Object.entries(schema)) {
         if (key === "$ref" && typeof value === "string") {
-            const refSchema = loadRefSchema(value, visited);
-            if (refSchema) {
-                Object.assign(result, resolveSchemaRefs(refSchema, visited));
+            if (value.startsWith("#")) {
+                result[key] = value;
+            }
+            else {
+                const refSchema = loadRefSchema(value, visited);
+                if (refSchema) {
+                    Object.assign(result, resolveSchemaRefs(refSchema, visited));
+                }
             }
         }
         else if (typeof value === "object") {
@@ -182,6 +201,47 @@ export function processSchemaQuery(request) {
                 message: `Found ${operations.length} on-chain operations`,
             };
         }
+        case "get_output": {
+            if (!name) {
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: "Tool name is required for 'get_output' action",
+                    suggestions: ["Provide a tool name", "Use 'list' action to see available tools and their outputPath"],
+                };
+            }
+            const schema = getOutputSchema(name);
+            if (!schema) {
+                const allSchemas = listSchemas();
+                const toolExists = allSchemas.find(s => s.name === name);
+                if (toolExists) {
+                    return {
+                        success: false,
+                        action,
+                        data: null,
+                        message: `Tool '${name}' exists but has no output schema file. The tool may not declare an outputSchema, or the schema file was not generated.`,
+                        suggestions: [`Use 'get' action with name='${name}' to retrieve its input schema`],
+                    };
+                }
+                const suggestions = searchSchemas(name).slice(0, 5);
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: `Tool '${name}' not found`,
+                    suggestions: suggestions.length > 0
+                        ? suggestions.map(s => `Did you mean: ${s.name}?`)
+                        : ["Use 'list' action to see available tools"],
+                };
+            }
+            return {
+                success: true,
+                action,
+                data: schema,
+                message: `Retrieved output schema: ${name}`,
+            };
+        }
         default:
             return {
                 success: false,