@wowok/agent-mcp 2.3.16 → 2.3.18

package/dist/schema/operations.js

@@ -1,6 +1,5 @@
 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, CallProof_DataSchema, CallGenProof_InputSchema, CallEnvSchema, SubmissionCallSchema, } from './call/index.js';
-const SemanticSummarySchema = z.any();
+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, CallProof_DataSchema, CallGenProof_InputSchema, CallEnvSchema, SubmissionCallSchema, SemanticSummarySchema, } 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';
@@ -49,102 +48,102 @@ export const OnchainOperationsSchema = z.preprocess((input) => {
         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.."),
+    }).strict().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.."),
+    }).strict().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."),
+    }).strict().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."),
+    }).strict().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."),
+    }).strict().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."),
+    }).strict().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.."),
+    }).strict().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."),
+    }).strict().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."),
+    }).strict().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."),
+    }).strict().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."),
+    }).strict().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!"),
+    }).strict().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."),
+    }).strict().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."),
+    }).strict().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."),
+    }).strict().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."),
+    }).strict().describe("🛂 Generate Verified Passport Object: Create immutable verified credentials after Guard validation passes. Supports verifying multiple guards at once."),
     z.object({
         operation_type: z.literal("proof"),
         data: CallProof_DataSchema,
         env: CallEnvSchema.optional(),
         submission: SubmissionCallSchema.optional(),
-    }).describe("📜 Proof Object: Create immutable on-chain proof objects with server signatures. Used for timestamped message proofs, Merkle tree root proofs, etc. Set 'namedNew' in data to name the new Proof."),
+    }).strict().describe("📜 Proof Object: Create immutable on-chain proof objects with server signatures. Used for timestamped message proofs, Merkle tree root proofs, etc. Set 'namedNew' in data to name the new Proof."),
     CallGenProof_InputSchema.extend({
         operation_type: z.literal("gen_proof"),
-    }).describe("Generate a new Proof object on-chain (convenience function without namedNew wrapper)"),
+    }).strict().describe("Generate a new Proof object on-chain (convenience function without namedNew wrapper)"),
 ]));
 export const WipOperationsSchema = z.preprocess((input) => {
     if (typeof input === 'object' && input !== null) {
@@ -172,24 +171,24 @@ export const WipOperationsSchema = z.preprocess((input) => {
         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"),
+    }).strict().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"),
+    }).strict().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"),
+    }).strict().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"),
+    }).strict().describe("Convert WIP file to HTML format"),
 ]));
 export const OnchainTableDataSchema = z.preprocess((input) => {
     if (typeof input === 'object' && input !== null && !Array.isArray(input)) {
@@ -219,7 +218,7 @@ export const OnchainTableDataSchema = z.preprocess((input) => {
             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)"),
+        }).strict().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"),
@@ -227,33 +226,33 @@ export const OnchainTableDataSchema = z.preprocess((input) => {
             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"),
+        }).strict().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"),
+        }).strict().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"),
+        }).strict().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"),
+        }).strict().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"),
+        }).strict().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({
@@ -262,35 +261,35 @@ export const OnchainTableDataSchema = z.preprocess((input) => {
             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"),
+        }).strict().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"),
+        }).strict().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"),
+        }).strict().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"),
+        }).strict().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"),
+        }).strict().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"),
@@ -298,7 +297,7 @@ export const OnchainTableDataSchema = z.preprocess((input) => {
             key_value: z.any().describe("Value of the key. Must match the key_type format (e.g., string for '0x1::string::String', address for '0x1::address::Address', number for '0x1::u64::U64')"),
             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"),
+        }).strict().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) => {
@@ -324,66 +323,62 @@ export const WatchQueryOperationsSchema = z.preprocess((input) => {
         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, messenger status, suspension state). Use filter.includePubkey=true to also include public keys (~900 bytes each, omitted by default). 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[]"),
-    ]),
+}, z.discriminatedUnion("query_type", [
+    z.object({
+        query_type: z.literal("local_mark_list"),
+        filter: LocalMarkFilterSchema.optional().describe("Local mark filter"),
+    }).strict().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"),
+    }).strict().describe("Query your LOCAL accounts — view all accounts stored on this device (addresses, messenger status, suspension state). Use filter.includePubkey=true to also include public keys (~900 bytes each, omitted by default). Returns: AccountData[] (name, address, pubkey?, suspended, messenger, timestamps)"),
+    z.object({
+        query_type: z.literal("local_info_list"),
+        filter: LocalInfoFilterSchema.optional().describe("Local info filter"),
+    }).strict().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(),
+    }).strict().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"),
+        }).strict().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(),
+    }).strict().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"),
+    }).strict().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.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(),
+    }).strict().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(),
+    }).strict().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(),
+    }).strict().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([

package/dist/schema/project/index.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const ProjectOperationInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["list_projects", "list_objects", "shareable", "dependencies", "referenced_by", "pre_publish_check", "cross_project_refs", "graph_stats", "save_graph", "load_graph"]>;
+    project: z.ZodOptional<z.ZodString>;
+    object: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    action: "dependencies" | "list_projects" | "list_objects" | "shareable" | "referenced_by" | "pre_publish_check" | "cross_project_refs" | "graph_stats" | "save_graph" | "load_graph";
+    object?: string | undefined;
+    project?: string | undefined;
+}, {
+    action: "dependencies" | "list_projects" | "list_objects" | "shareable" | "referenced_by" | "pre_publish_check" | "cross_project_refs" | "graph_stats" | "save_graph" | "load_graph";
+    object?: string | undefined;
+    project?: string | undefined;
+}>;
+export declare const ProjectOperationOutputSchema: z.ZodObject<{
+    result: z.ZodAny;
+}, "strict", z.ZodTypeAny, {
+    result?: any;
+}, {
+    result?: any;
+}>;

package/dist/schema/project/index.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export const ProjectOperationInputSchema = z
+    .object({
+    action: z
+        .enum([
+        "list_projects",
+        "list_objects",
+        "shareable",
+        "dependencies",
+        "referenced_by",
+        "pre_publish_check",
+        "cross_project_refs",
+        "graph_stats",
+        "save_graph",
+        "load_graph",
+    ])
+        .describe("Query/action to perform"),
+    project: z
+        .string()
+        .optional()
+        .describe("Project prefix (for list_objects)"),
+    object: z
+        .string()
+        .optional()
+        .describe("Object name or address (for dependencies / referenced_by / pre_publish_check)"),
+})
+    .strict();
+export const ProjectOperationOutputSchema = z
+    .object({
+    result: z.any().describe("Query result — shape depends on action"),
+})
+    .strict();