@wowok/agent-mcp 2.2.11 → 2.2.14

package/dist/index.d.ts

@@ -15642,6 +15642,15 @@ declare const WatchQueryOperationsSchema: z.ZodEffects<z.ZodUnion<[z.ZodDiscrimi
         cursor?: string | null | undefined;
         limit?: number | null | undefined;
     } | undefined;
+}>, z.ZodObject<{
+    query_type: z.ZodLiteral<"local_names">;
+    addresses: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    query_type: "local_names";
+    addresses: string[];
+}, {
+    query_type: "local_names";
+    addresses: string[];
 }>]>, z.ZodDiscriminatedUnion<"query_type", [z.ZodObject<{
     query_type: z.ZodLiteral<"onchain_personal_profile">;
     account: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
@@ -15775,6 +15784,9 @@ declare const WatchQueryOperationsSchema: z.ZodEffects<z.ZodUnion<[z.ZodDiscrimi
         cursor?: string | null | undefined;
         limit?: number | null | undefined;
     } | undefined;
+} | {
+    query_type: "local_names";
+    addresses: string[];
 } | {
     query_type: "onchain_personal_profile";
     no_cache?: boolean | undefined;

package/dist/index.js

@@ -6,7 +6,8 @@ import { readFileSync } from "fs";
 import { resolve } from "path";
 const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 import { CallService_DataSchema, CallMachine_DataSchema, MachineNode2File_InputSchema, MachineNode2File_OutputWrappedSchema, CallProgress_DataSchema, CallPermission_DataSchema, CallGuard_DataSchema, Guard2File_InputSchema, Guard2File_OutputWrappedSchema, CallArbitration_DataSchema, CallRepository_DataSchema, CallContact_DataSchema, CallTreasury_DataSchema, CallReward_DataSchema, CallAllocation_DataSchema, CallPersonal_DataSchema, CallPayment_DataSchema, CallDemand_DataSchema, CallOrder_DataSchema, CallEnvSchema, SubmissionCallSchema, strictParse, CallOutputSchema, handleCallResult, createServerConfig, createCapabilitiesConfig, createToolMeta, transformSubmission, getEnvConfig, WipGenerationOptionsSchema, WipToHtmlOptionsSchema, TokenDataFilterSchema, LocalInfoFilterSchema, LocalMarkFilterSchema, AccountFilterSchema, TokenTypeSchema, OnchainEventsInputSchema, OnchainEventsResultSchema, ProtocolInfoQuerySchema, ProtocolInfoResultSchema, TableAnswerSchema, TableItem_RepositoryDataSchema, TableItem_PermissionPermSchema, TableItem_EntityRegistrarSchema, TableItem_EntityLinkerSchema, TableItem_RewardRecordSchema, TableItem_DemandPresenterSchema, TableItem_TreasuryHistorySchema, TableItem_MachineNodeSchema, TableItem_ProgressHistorySchema, TableItem_AddressMarkSchema, NameOrAddressSchema, ObjectBaseSchema, AccountOrMark_AddressSchema, AccountOrMark_AddressAISchema, EntrypointSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, MessengerOperationInputSchema, } from "./schema/index.js";
-import { CallService, CallMachine, CallProgress, CallPermission, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, guard2file, parseGuardFile, formatGuardParseErrors, machineNode2file, generateNodeComments, generate_wip, verify_wip, sign_wip, wip2html, account_operation, local_mark_operation, local_info_operation, watch_conversations, send_message, send_file, watch_messages, extract_zip_messages, generate_wts, verify_wts, sign_wts, wts2html, proof_message, mark_messages_as_viewed, mark_conversation_as_viewed, query_local_mark_list, query_account_list, query_local_info_list, query_local_token_list, query_account, query_personal, query_objects, query_table, query_tableItem, queryProtocolInfo, query_received, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_events, blacklist, friendslist, guardlist, settings, AmountType, } from "@wowok/wowok";
+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.
 
 ## Token System Overview
@@ -576,6 +577,10 @@ const WatchQueryOperationsSchema = z.preprocess((input) => {
             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({
@@ -1000,6 +1005,11 @@ async function handleWatchQueryOperations(args) {
             result = { query_type: "account_balance", result: queryResult };
             break;
         }
+        case "local_names": {
+            const queryResult = await GetLocalNamesByAddresses(validated.addresses);
+            result = { query_type: "local_names", result: queryResult };
+            break;
+        }
         case "onchain_personal_profile": {
             const queryResult = await query_personal({ account: validated.account, no_cache: validated.no_cache, network: validated.network });
             result = { query_type: "onchain_personal_profile", result: queryResult };
@@ -1040,7 +1050,7 @@ async function handleWatchQueryOperations(args) {
             break;
         }
         default:
-            throw new Error(`Unknown query type. Valid query_types are: "local_mark_list", "account_list", "local_info_list", "token_list", "account_balance", "onchain_personal_profile", "onchain_objects", "onchain_received". For table queries, use the "onchain_table_data" tool.`);
+            throw new Error(`Unknown query type. Valid query_types are: "local_mark_list", "account_list", "local_info_list", "token_list", "account_balance", "local_names", "onchain_personal_profile", "onchain_objects", "onchain_received". For table queries, use the "onchain_table_data" tool.`);
     }
     return {
         content: [{ type: "text", text: JSON.stringify({ result }) }],
@@ -1296,6 +1306,15 @@ async function handleMachineNode2File(args) {
 }
 export { OnchainOperationsSchema, WipOperationsSchema, WatchQueryOperationsSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, ProtocolInfoQuerySchema, CallOutputSchema, MessengerOperationInputSchema, MessengerOperationOutputSchema };
 async function main() {
+    if (areSchemasAvailable()) {
+        const index = getSchemaIndex();
+        if (index) {
+            console.error(`Schema system ready: ${index.tools?.length || 0} tools, ${index.operations?.length || 0} operations`);
+        }
+    }
+    else {
+        console.error("Schema files not available. Run 'npm run generate:schemas' to generate them.");
+    }
     server.registerTool("onchain_operations", {
         title: "⛓️ On-chain Operations",
         description: "On-chain operations for WoWok object: service (marketplace listings), machine (workflow templates), progress (order tracking), repository (on-chain database), arbitration (dispute resolution), contact (IM management), treasury (team funds), reward (incentive pools), allocation (auto-distribution), permission (access control), guard (programmable trust rules), personal (public profile), payment (direct coin transfers), demand (service requests), order (order management), gen_passport (verified credentials).",
@@ -1364,17 +1383,18 @@ async function main() {
     }, handleMachineNode2File);
     server.registerTool("query_toolkit", {
         title: "🔍 Data Query Toolkit",
-        description: "WOWOK data query toolkit — 8 query types covering local device data and on-chain blockchain data:\n\n"
+        description: "WOWOK data query toolkit — 9 query types covering local device data and on-chain blockchain data:\n\n"
             + "LOCAL (device-only, never on-chain):\n"
             + "1. local_mark_list — Query your LOCAL address book: maps human-readable names to blockchain addresses with optional tags. Use to resolve names→addresses or find addresses by tag.\n"
             + "2. account_list — Query your LOCAL accounts: view all accounts stored on this device (addresses, public keys, messenger status, suspension state). Use to discover available accounts before operations.\n"
             + "3. local_info_list — Query your LOCAL private info: sensitive data like delivery addresses, phone numbers, contacts stored ONLY on this device.\n"
             + "4. token_list — Query cached token metadata: symbol, decimals, icon URL, description for tokens previously fetched from chain. Use to look up token precision/decimals before performing token operations. Returns: TokenTypeInfo[] (type, alias, name, symbol, decimals, iconUrl).\n"
-            + "5. account_balance — Query an account's coin balance OR paginated coin objects. Use balance=true for total amount, or coin={cursor,limit} to list individual coin objects. Supports multi-token via token_type parameter.\n\n"
+            + "5. account_balance — Query an account's coin balance OR paginated coin objects. Use balance=true for total amount, or coin={cursor,limit} to list individual coin objects. Supports multi-token via token_type parameter.\n"
+            + "6. local_names — Query local names by a list of addresses. For each address, returns the resolved account name (if exists) and local mark name (if exists). Returns: { account?, local_mark?, address }[].\n\n"
             + "ONCHAIN (blockchain):\n"
-            + "6. onchain_personal_profile — Query any user's PUBLIC on-chain profile: social links, reputation (likes/dislikes), personal info records, voting history, referrer.\n"
-            + "7. onchain_objects — Batch query on-chain WOWOK objects by ID or name: supports Service, Machine, Order, Treasury, Reward, Arb, Personal, Contact, and more.\n"
-            + "8. onchain_received — Query objects (Payments, Tokens, NFTs) received by a specific object. Supports pagination and all_type filter.\n\n"
+            + "7. onchain_personal_profile — Query any user's PUBLIC on-chain profile: social links, reputation (likes/dislikes), personal info records, voting history, referrer.\n"
+            + "8. onchain_objects — Batch query on-chain WOWOK objects by ID or name: supports Service, Machine, Order, Treasury, Reward, Arb, Personal, Contact, and more.\n"
+            + "9. onchain_received — Query objects (Payments, Tokens, NFTs) received by a specific object. Supports pagination and all_type filter.\n\n"
             + "For dynamic table data queries (pagination, table items), use the 'onchain_table_data' tool.",
         inputSchema: WatchQueryOperationsSchema,
         outputSchema: z.object({
@@ -1419,54 +1439,85 @@ async function main() {
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         _meta: createToolMeta("WoWok info", ["build-in", "constants", "permissions", "guard", "network", "value-types"]),
     }, handleWowokInfo);
-    server.registerTool("documents_and_learn", {
-        title: "📚 Documents and Learn",
-        description: "Access WoWok documentation and learning resources. Provides official documentation URL for users and AI to get more information about WoWok protocol, components, and usage.",
+    server.registerTool("schema_query", {
+        title: "📋 Schema Query",
+        description: "Query JSON schemas for all WoWok MCP tools and operations. Use this tool to understand the exact structure required for calling other tools. Returns complete JSON Schema definitions with all properties, types, and descriptions. This is the authoritative source for tool schemas.",
         inputSchema: z.object({
-            topic: z.string().optional().describe("Optional topic to search for in documentation (e.g., 'guard', 'service', 'messenger', 'stage-01-introduction')"),
+            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')"),
+            query: z.string().optional().describe("Search query for 'search' action"),
         }),
         outputSchema: z.object({
-            documentation_url: z.string().describe("Official WoWok documentation URL on GitHub"),
-            topic: z.string().optional().describe("Requested topic if specified"),
-            original_topic: z.string().optional().describe("Original topic input by user (before normalization)"),
-            message: z.string().describe("Welcome message with documentation information. Always included in response."),
+            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'"),
+            message: z.string().describe("Human-readable message describing the result"),
+            suggestions: z.array(z.string()).optional().describe("Suggested next steps or alternatives"),
         }),
-        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-        _meta: createToolMeta("documentation", ["docs", "learn", "tutorial", "guide", "help", "reference"]),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        _meta: createToolMeta("schema", ["schema", "json-schema", "types", "structure", "validation", "reference"]),
     }, async (args) => {
-        const GITHUB_BASE_URL = "https://github.com/wowok-ai/docs/blob/main/docs";
-        if (!args.topic) {
-            const url = GITHUB_BASE_URL;
-            const message = `Welcome to WoWok Documentation! Access comprehensive guides, tutorials, and API references at: ${url}`;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: message,
-                    },
-                ],
-                structuredContent: {
-                    documentation_url: url,
-                    message: message,
-                },
-            };
+        const request = {
+            action: args.action,
+            name: args.name,
+            query: args.query,
+        };
+        const response = processSchemaQuery(request);
+        let textContent = response.message;
+        const data = response.data;
+        if (response.success && data) {
+            switch (args.action) {
+                case "list":
+                case "list_operations":
+                    if (Array.isArray(data) && data.length > 0) {
+                        textContent += "\n\nAvailable schemas:\n";
+                        for (const item of data) {
+                            textContent += `\n  • ${item.name}`;
+                            if (item.title) {
+                                textContent += ` - ${item.title}`;
+                            }
+                            if (item.description) {
+                                textContent += `\n    ${item.description.slice(0, 100)}...`;
+                            }
+                            textContent += "\n";
+                        }
+                    }
+                    break;
+                case "get":
+                    if (data) {
+                        textContent += "\n\n## 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`;
+                        for (const item of data) {
+                            textContent += `\n  • ${item.name}`;
+                            if (item.title) {
+                                textContent += ` - ${item.title}`;
+                            }
+                            textContent += "\n";
+                        }
+                    }
+                    break;
+            }
+        }
+        if (response.suggestions && response.suggestions.length > 0) {
+            textContent += "\n\n💡 Suggestions:\n";
+            for (const suggestion of response.suggestions) {
+                textContent += `  • ${suggestion}\n`;
+            }
         }
-        const normalizedTopic = args.topic.toLowerCase().trim();
-        const url = `${GITHUB_BASE_URL}/${normalizedTopic}.md`;
-        const message = `Documentation for "${normalizedTopic}"\nGitHub URL: ${url}`;
         return {
-            content: [
-                {
+            content: [{
                     type: "text",
-                    text: message,
-                },
-            ],
-            structuredContent: {
-                documentation_url: url,
-                topic: normalizedTopic,
-                original_topic: args.topic,
-                message: message,
-            },
+                    text: textContent,
+                }],
+            structuredContent: response,
         };
     });
     const transport = new StdioServerTransport();

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

@@ -0,0 +1,29 @@
+export interface SchemaInfo {
+    name: string;
+    title: string;
+    description?: string;
+    path: string;
+}
+export interface SchemaQueryRequest {
+    action: "list" | "get" | "search" | "list_operations";
+    name?: string;
+    query?: string;
+}
+export interface SchemaQueryResponse {
+    [key: string]: unknown;
+    success: boolean;
+    action: string;
+    data: any;
+    message: string;
+    suggestions?: string[];
+}
+export declare function areSchemasAvailable(): boolean;
+export declare function getSchemaIndex(): {
+    tools: SchemaInfo[];
+    operations: SchemaInfo[];
+} | null;
+export declare function listSchemas(): SchemaInfo[];
+export declare function getSchema(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

@@ -0,0 +1,149 @@
+import { readFileSync, existsSync } from "fs";
+import { resolve, join } from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const SCHEMAS_DIR = resolve(__dirname, "../../dist/schemas");
+export function areSchemasAvailable() {
+    return existsSync(SCHEMAS_DIR) && existsSync(join(SCHEMAS_DIR, "index.json"));
+}
+export function getSchemaIndex() {
+    try {
+        const indexPath = join(SCHEMAS_DIR, "index.json");
+        if (!existsSync(indexPath))
+            return null;
+        const content = readFileSync(indexPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function listSchemas() {
+    const index = getSchemaIndex();
+    if (!index)
+        return [];
+    return [
+        ...(index.tools || []),
+        ...(index.operations || []),
+    ];
+}
+export function getSchema(name) {
+    try {
+        let schemaPath = join(SCHEMAS_DIR, `${name}.schema.json`);
+        if (!existsSync(schemaPath)) {
+            schemaPath = join(SCHEMAS_DIR, `${name}.json`);
+        }
+        if (!existsSync(schemaPath)) {
+            return null;
+        }
+        const content = readFileSync(schemaPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function searchSchemas(query) {
+    const allSchemas = listSchemas();
+    const lowerQuery = query.toLowerCase();
+    return allSchemas.filter(schema => {
+        const nameMatch = schema.name.toLowerCase().includes(lowerQuery);
+        const titleMatch = schema.title?.toLowerCase().includes(lowerQuery);
+        const descMatch = schema.description?.toLowerCase().includes(lowerQuery);
+        return nameMatch || titleMatch || descMatch;
+    });
+}
+export function listOperations() {
+    const index = getSchemaIndex();
+    if (!index)
+        return [];
+    return (index.operations || []).filter(op => op.name.startsWith("onchain_operations_"));
+}
+export function processSchemaQuery(request) {
+    const { action, name, query } = request;
+    if (!areSchemasAvailable()) {
+        return {
+            success: false,
+            action,
+            data: null,
+            message: "Schema files are not available. Please run 'npm run generate:schemas' first.",
+            suggestions: ["Run 'npm run generate:schemas' to generate schema files", "Ensure the dist/schemas directory exists"],
+        };
+    }
+    switch (action) {
+        case "list": {
+            const schemas = listSchemas();
+            return {
+                success: true,
+                action,
+                data: schemas,
+                message: `Found ${schemas.length} available schemas`,
+            };
+        }
+        case "get": {
+            if (!name) {
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: "Schema name is required for 'get' action",
+                    suggestions: ["Provide a schema name", "Use 'list' action to see available schemas"],
+                };
+            }
+            const schema = getSchema(name);
+            if (!schema) {
+                const suggestions = searchSchemas(name).slice(0, 5);
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: `Schema '${name}' not found`,
+                    suggestions: suggestions.length > 0
+                        ? suggestions.map(s => `Did you mean: ${s.name}?`)
+                        : ["Use 'list' action to see available schemas"],
+                };
+            }
+            return {
+                success: true,
+                action,
+                data: schema,
+                message: `Retrieved schema: ${name}`,
+            };
+        }
+        case "search": {
+            if (!query) {
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: "Search query is required for 'search' action",
+                };
+            }
+            const results = searchSchemas(query);
+            return {
+                success: true,
+                action,
+                data: results,
+                message: `Found ${results.length} schemas matching '${query}'`,
+            };
+        }
+        case "list_operations": {
+            const operations = listOperations();
+            return {
+                success: true,
+                action,
+                data: operations,
+                message: `Found ${operations.length} on-chain operations`,
+            };
+        }
+        default:
+            return {
+                success: false,
+                action,
+                data: null,
+                message: `Unknown action: ${action}`,
+                suggestions: ["Use 'list', 'get', 'search', or 'list_operations'"],
+            };
+    }
+}