@wowok/agent-mcp 2.3.12 → 2.3.14

package/dist/index.js

@@ -7,7 +7,27 @@ import { resolve } from "path";
 const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 import { MachineNode2File_InputSchema, MachineNode2File_OutputWrappedSchema, Guard2File_InputSchema, Guard2File_OutputWrappedSchema, strictParse, CallOutputSchema, handleCallResult, createServerConfig, createCapabilitiesConfig, createToolMeta, transformSubmission, getEnvConfig, OnchainEventsInputSchema, OnchainEventsResultSchema, ProtocolInfoQuerySchema, ProtocolInfoResultSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, MessengerOperationInputSchema, BridgeOperationsSchema, BridgeCallOutputSchema, OnchainOperationsSchema, WipOperationsSchema, OnchainTableDataSchema, OnchainTableDataResultSchema, WatchQueryOperationsSchema, } from "./schema/index.js";
 import { handleBridgeOperations } from "./schema/call/bridge-handler.js";
-import { CallService, CallMachine, CallProgress, CallPermission, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, guard2file, parseGuardFile, formatGuardParseErrors, machineNode2file, generateNodeComments, generate_wip, verify_wip, sign_wip, wip2html, account_operation, local_mark_operation, local_info_operation, watch_conversations, send_message, send_file, watch_messages, extract_zip_messages, generate_wts, verify_wts, sign_wts, wts2html, proof_message, mark_messages_as_viewed, mark_conversation_as_viewed, query_local_mark_list, query_account_list, query_local_info_list, query_local_token_list, query_account, GetLocalNamesByAddresses, query_personal, query_objects, query_table, query_tableItem, queryProtocolInfo, query_received, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_events, blacklist, friendslist, guardlist, settings, AmountType, } from "@wowok/wowok";
+import { buildDataSemantic, classifyError } from "./schema/call/semantic.js";
+import { getHarness } from "./harness/index.js";
+const HARNESS_ENABLED = process.env.WOWOK_HARNESS_ENABLED === "1" || process.env.WOWOK_HARNESS_ENABLED === "true";
+function withHarness(base, operation, intent) {
+    if (!HARNESS_ENABLED)
+        return base;
+    try {
+        const harness = getHarness();
+        const expected = harness.expect(operation, intent, base.operation_type, base.data);
+        return {
+            ...base,
+            harness,
+            expected,
+            operation_id: `${base.operation_type}_${Date.now()}`,
+        };
+    }
+    catch {
+        return base;
+    }
+}
+import { CallService, CallMachine, CallProgress, CallPermission, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, 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, pull_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.
 
@@ -117,6 +137,13 @@ Token amounts are HIGHLY SENSITIVE. Always:
 - machineNode2file
 `;
 const server = new McpServer(createServerConfig(packageJson, SERVER_DESCRIPTION), createCapabilitiesConfig());
+import { withTelemetry, setTelemetryEnabled } from "./telemetry/index.js";
+if (process.env.WOWOK_TELEMETRY === "false" || process.env.WOWOK_TELEMETRY === "0") {
+    setTelemetryEnabled(false);
+}
+function reg(name, config, handler) {
+    server.registerTool(name, config, withTelemetry(name, handler));
+}
 function convertAmountType(type) {
     if (typeof type === "number")
         return type;
@@ -223,10 +250,17 @@ async function handleOnchainTableData(args) {
     }
     return {
         content: [{ type: "text", text: JSON.stringify({ result }) }],
-        structuredContent: { result },
+        structuredContent: {
+            result,
+            semantic: buildDataSemantic(result, {
+                operation_type: "onchain_table_data",
+                data: validated,
+            }),
+        },
     };
 }
 async function handleOnchainOperations(args) {
+    let validated;
     try {
         if (typeof args === 'object' && args !== null && args.description && !args.operation_type) {
             const hasWrappedParams = typeof args.description === 'string' &&
@@ -237,7 +271,7 @@ async function handleOnchainOperations(args) {
                     "Incorrect format: { description: '{ operation_type: ... }' }");
             }
         }
-        const validated = strictParse(OnchainOperationsSchema, args, "onchain_operations input");
+        validated = strictParse(OnchainOperationsSchema, args, "onchain_operations input");
         const env = getEnvConfig(validated.env);
         switch (validated.operation_type) {
             case "service": {
@@ -245,7 +279,9 @@ async function handleOnchainOperations(args) {
                 const result = validated.submission
                     ? await callService.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callService.call(env);
-                return handleCallResult(result);
+                const data = validated.data;
+                const intent = data?.publish ? "publish service" : data?.bPublished !== undefined ? "modify service" : "create service";
+                return handleCallResult(result, withHarness({ operation_type: validated.operation_type, data }, "service", intent));
             }
             case "machine": {
                 if (validated.data.node && typeof validated.data.node === 'object' && 'json_or_markdown_file' in validated.data.node) {
@@ -276,42 +312,42 @@ async function handleOnchainOperations(args) {
                 const result = validated.submission
                     ? await callMachine.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callMachine.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "progress": {
                 const callProgress = new CallProgress(validated.data);
                 const result = validated.submission
                     ? await callProgress.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callProgress.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "repository": {
                 const callRepository = new CallRepository(validated.data);
                 const result = validated.submission
                     ? await callRepository.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callRepository.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "arbitration": {
                 const callArbitration = new CallArbitration(validated.data);
                 const result = validated.submission
                     ? await callArbitration.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callArbitration.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "contact": {
                 const callContact = new CallContact(validated.data);
                 const result = validated.submission
                     ? await callContact.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callContact.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "treasury": {
                 const callTreasury = new CallTreasury(validated.data);
                 const result = validated.submission
                     ? await callTreasury.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callTreasury.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "reward": {
                 const transformedData = transformRewardData(validated.data);
@@ -319,19 +355,19 @@ async function handleOnchainOperations(args) {
                 const result = validated.submission
                     ? await callReward.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callReward.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "allocation": {
                 const callAllocation = new CallAllocation(validated.data);
                 const result = validated.submission
                     ? await callAllocation.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callAllocation.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "permission": {
                 const callPermission = new CallPermission(validated.data);
                 const result = await callPermission.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "guard": {
                 const validatedData = validated.data;
@@ -378,7 +414,7 @@ async function handleOnchainOperations(args) {
                 }
                 const callGuard = new CallGuard(validatedData);
                 const result = await callGuard.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "personal": {
                 const transformPersonalData = (data) => {
@@ -431,52 +467,56 @@ async function handleOnchainOperations(args) {
                 const transformedData = transformPersonalData(validated.data);
                 const callPersonal = new CallPersonal(transformedData);
                 const result = await callPersonal.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "payment": {
                 const callPayment = new CallPayment(validated.data);
                 const result = await callPayment.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "demand": {
                 const callDemand = new CallDemand(validated.data);
                 const result = validated.submission
                     ? await callDemand.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callDemand.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "order": {
                 const callOrder = new CallOrder(validated.data);
                 const result = validated.submission
                     ? await callOrder.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callOrder.call(env);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
             case "gen_passport": {
                 const result = await gen_passport(env, validated.guard, validated.info);
-                return handleCallResult(result);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+            }
+            case "proof": {
+                const callProof = new CallProof(validated.data);
+                const result = validated.submission
+                    ? await callProof.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callProof.call(env);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+            }
+            case "gen_proof": {
+                const result = await gen_proof(env, validated.proof, validated.server_pubkey, validated.server_signature, validated.proof_type, validated.description, validated.item_count, validated.about_address);
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
             }
         }
         throw new Error(`Unknown on-chain operation type: ${validated.operation_type}`);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: "text", text: `Error: ${errorMessage}` }],
-            structuredContent: {
-                message: `Error: ${errorMessage}`,
-                result: {
-                    type: "error",
-                    error: errorMessage,
-                },
-            },
-        };
+        return handleCallResult({ error: errorMessage }, validated ? { operation_type: validated.operation_type, data: validated.data } : undefined);
     }
 }
 async function handleAccountOperation(args) {
+    let validated;
     try {
-        const validated = strictParse(AccountOperationSchema, args, "account_operation input");
+        validated = strictParse(AccountOperationSchema, args, "account_operation input");
         const result = await account_operation(validated);
+        const ctx = { operation_type: "account_" + validated.operation_type, data: validated };
         return {
             content: [{ type: "text", text: JSON.stringify(result) }],
             structuredContent: {
@@ -484,26 +524,35 @@ async function handleAccountOperation(args) {
                     status: "success",
                     data: result,
                 },
+                semantic: buildDataSemantic(result, ctx),
             },
         };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
+        const ctx = validated ? { operation_type: "account_" + validated.operation_type, data: validated } : undefined;
+        const classified = classifyError(errorMessage);
         return {
             content: [{ type: "text", text: `Error: ${errorMessage}` }],
             structuredContent: {
                 result: {
                     status: "error",
                     error: errorMessage,
+                    error_code: classified.error_code,
+                    retryable: classified.retryable,
+                    recovery_hint: classified.recovery_hint,
                 },
+                semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
             },
         };
     }
 }
 async function handleMarkOperation(args) {
+    let validated;
     try {
-        const validated = strictParse(LocalMarkOperationSchema, args, "local_mark_operation input");
+        validated = strictParse(LocalMarkOperationSchema, args, "local_mark_operation input");
         const result = await local_mark_operation(validated);
+        const ctx = { operation_type: "mark_" + validated.operation_type, data: validated };
         return {
             content: [{ type: "text", text: JSON.stringify(result) }],
             structuredContent: {
@@ -511,26 +560,35 @@ async function handleMarkOperation(args) {
                     status: "success",
                     data: result,
                 },
+                semantic: buildDataSemantic(result, ctx),
             },
         };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
+        const ctx = validated ? { operation_type: "mark_" + validated.operation_type, data: validated } : undefined;
+        const classified = classifyError(errorMessage);
         return {
             content: [{ type: "text", text: `Error: ${errorMessage}` }],
             structuredContent: {
                 result: {
                     status: "error",
                     error: errorMessage,
+                    error_code: classified.error_code,
+                    retryable: classified.retryable,
+                    recovery_hint: classified.recovery_hint,
                 },
+                semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
             },
         };
     }
 }
 async function handleInfoOperation(args) {
+    let validated;
     try {
-        const validated = strictParse(LocalInfoOperationSchema, args, "local_info_operation input");
+        validated = strictParse(LocalInfoOperationSchema, args, "local_info_operation input");
         const result = await local_info_operation(validated);
+        const ctx = { operation_type: "local_info", data: validated };
         return {
             content: [{ type: "text", text: JSON.stringify(result) }],
             structuredContent: {
@@ -538,18 +596,25 @@ async function handleInfoOperation(args) {
                     status: "success",
                     data: result,
                 },
+                semantic: buildDataSemantic(result, ctx),
             },
         };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
+        const ctx = validated ? { operation_type: "local_info", data: validated } : undefined;
+        const classified = classifyError(errorMessage);
         return {
             content: [{ type: "text", text: `Error: ${errorMessage}` }],
             structuredContent: {
                 result: {
                     status: "error",
                     error: errorMessage,
+                    error_code: classified.error_code,
+                    retryable: classified.retryable,
+                    recovery_hint: classified.recovery_hint,
                 },
+                semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
             },
         };
     }
@@ -674,7 +739,13 @@ async function handleWatchQueryOperations(args) {
     }
     return {
         content: [{ type: "text", text: JSON.stringify({ result }) }],
-        structuredContent: { result },
+        structuredContent: {
+            result,
+            semantic: buildDataSemantic(result, {
+                operation_type: "query_toolkit",
+                data: validated,
+            }),
+        },
     };
 }
 async function handleWowokInfo(args) {
@@ -700,7 +771,13 @@ async function handleOnchainEvents(args) {
     });
     return {
         content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
-        structuredContent: { result: queryResult },
+        structuredContent: {
+            result: queryResult,
+            semantic: buildDataSemantic(queryResult, {
+                operation_type: "onchain_events",
+                data: validated,
+            }),
+        },
     };
 }
 function normalizeAccountOrMark(input) {
@@ -852,6 +929,11 @@ async function handleMessengerOperation(args) {
             result = { operation: "mark_conversation_as_viewed", result: markedCount };
             break;
         }
+        case "pull_messages": {
+            const messages = await pull_messages(validated.account, validated.limit);
+            result = { operation: "pull_messages", result: messages };
+            break;
+        }
         default:
             throw new Error(`Unknown messenger operation: ${validated.operation}`);
     }
@@ -938,15 +1020,15 @@ async function main() {
     else {
         console.error("Schema files not available. Run 'npm run generate:schemas' to generate them.");
     }
-    server.registerTool("onchain_operations", {
+    reg("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).",
+        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), proof (on-chain proof objects), gen_proof (generate proof shortcut).",
         inputSchema: OnchainOperationsSchema,
         outputSchema: CallOutputSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
-        _meta: createToolMeta("operation", ["service", "machine", "progress", "repository", "arbitration", "contact", "treasury", "reward", "allocation", "permission", "guard", "personal", "payment", "demand", "order", "gen_passport", "on-chain", "blockchain"]),
+        _meta: createToolMeta("operation", ["service", "machine", "progress", "repository", "arbitration", "contact", "treasury", "reward", "allocation", "permission", "guard", "personal", "payment", "demand", "order", "gen_passport", "proof", "gen_proof", "on-chain", "blockchain"]),
     }, handleOnchainOperations);
-    server.registerTool("account_operation", {
+    reg("account_operation", {
         title: "🔒 LOCAL ONLY: Account - Wallet Management",
         description: "🔒 100% LOCAL, NEVER ON-CHAIN 🔒 Manage WoWok accounts locally on device: generate, suspend, resume, faucet-test, operate assets, sign data, etc.",
         inputSchema: AccountOperationSchema,
@@ -954,7 +1036,7 @@ async function main() {
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
         _meta: createToolMeta("operation", ["account", "local", "private", "wallet", "off-chain"]),
     }, handleAccountOperation);
-    server.registerTool("local_mark_operation", {
+    reg("local_mark_operation", {
         title: "🔒 LOCAL ONLY: LocalMark - Address Book Management",
         description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage ID names and tags stored ONLY on your local device for easy identification of user address or object IDs by name.",
         inputSchema: LocalMarkOperationSchema,
@@ -962,7 +1044,7 @@ async function main() {
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
         _meta: createToolMeta("operation", ["mark", "local", "private", "address-book", "off-chain"]),
     }, handleMarkOperation);
-    server.registerTool("local_info_operation", {
+    reg("local_info_operation", {
         title: "🔒 LOCAL ONLY: LocalInfo - Private Data Management",
         description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage sensitive personal information stored ONLY on your device: delivery addresses, phone numbers, contacts.",
         inputSchema: LocalInfoOperationSchema,
@@ -970,7 +1052,7 @@ async function main() {
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
         _meta: createToolMeta("operation", ["info", "local", "private", "data-management", "off-chain"]),
     }, handleInfoOperation);
-    server.registerTool("wip_file", {
+    reg("wip_file", {
         title: "🤝 Witness Immutable Promise File Operations",
         description: "generate (create WIP files from markdown and images), verify (integrity check), sign (add signatures), or wip2html (convert to HTML).",
         inputSchema: WipOperationsSchema,
@@ -980,15 +1062,15 @@ async function main() {
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
         _meta: createToolMeta("operation", ["wip", "promise", "file-generation", "verification", "signature", "local"]),
     }, handleWipOperations);
-    server.registerTool("messenger_operation", {
+    reg("messenger_operation", {
         title: "💬 Messenger Operations",
-        description: "WoWok encrypted messenger operations: watch conversations (with unread filtering, preview messages), send message, send file, watch messages (with viewed status filtering), extract zip messages, generate WTS, verify WTS, sign WTS, WTS to HTML, proof message on-chain, manage blacklist, friendslist, guardlist, settings, mark messages as viewed, and mark conversation as viewed.",
+        description: "WoWok encrypted messenger operations: watch conversations (with unread filtering, preview messages), send message, send file, watch messages (with viewed status filtering), extract zip messages, generate WTS, verify WTS, sign WTS, WTS to HTML, proof message on-chain, manage blacklist, friendslist, guardlist, settings, mark messages as viewed, mark conversation as viewed, and pull messages from server.",
         inputSchema: MessengerOperationInputSchema,
         outputSchema: MessengerOperationOutputSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
         _meta: createToolMeta("operation", ["messenger", "message", "file", "wts", "blacklist", "friendslist", "guardlist", "settings", "proof", "communication"]),
     }, handleMessengerOperation);
-    server.registerTool("guard2file", {
+    reg("guard2file", {
         title: "📄 Guard to File - Export Guard Definition",
         description: "Export a Guard object's definition from the blockchain to a local JSON or Markdown file for editing and creating new Guard objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.",
         inputSchema: Guard2File_InputSchema,
@@ -996,7 +1078,7 @@ async function main() {
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         _meta: createToolMeta("generate file", ["guard", "export", "file", "json", "markdown", "on-chain"]),
     }, handleGuard2File);
-    server.registerTool("machineNode2file", {
+    reg("machineNode2file", {
         title: "⚙️ Machine Node to File - Export Machine Node Definition",
         description: "Export a Machine object's node definition from the blockchain to a local JSON or Markdown file for editing and creating new Machine objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.",
         inputSchema: MachineNode2File_InputSchema,
@@ -1004,12 +1086,12 @@ async function main() {
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         _meta: createToolMeta("generate file", ["machine", "export", "file", "json", "markdown", "on-chain", "workflow"]),
     }, handleMachineNode2File);
-    server.registerTool("query_toolkit", {
+    reg("query_toolkit", {
         title: "🔍 Data Query Toolkit",
         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"
+            + "2. account_list — Query your LOCAL accounts (addresses, messenger status, suspension state). Use filter.includePubkey=true to also include public keys. 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"
@@ -1026,7 +1108,7 @@ async function main() {
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         _meta: createToolMeta("query", ["watch", "query", "on-chain", "local", "events", "objects", "tokens", "balance", "profile"]),
     }, handleWatchQueryOperations);
-    server.registerTool("onchain_table_data", {
+    reg("onchain_table_data", {
         title: "📊 Watch WoWok On-chain Table Data Query",
         description: "Query dynamic table data of on-chain objects — supports paginated table queries and specific table item lookups. Each table item belongs to a parent object type and has a specific meaning:\n\n"
             + "1. onchain_table — Paginated query of ANY object's dynamic fields table (Parent: any object). Returns all entries with keys, types, and object IDs. Use to explore all sub-items of an object.\n"
@@ -1046,7 +1128,7 @@ async function main() {
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         _meta: createToolMeta("table query", ["on-chain", "table", "dynamic fields", "pagination", "repository", "permission", "reward", "demand", "treasury", "machine", "progress"]),
     }, handleOnchainTableData);
-    server.registerTool("onchain_events", {
+    reg("onchain_events", {
         title: "📅 Watch WoWok On-chain Events",
         description: "Watch on-chain WoWok events by type. Supports arbitration events, new order events, progress events, demand presentation events, demand feedback events, and new entity registration events. Use pagination cursor for fetching large result sets.",
         inputSchema: OnchainEventsInputSchema,
@@ -1054,7 +1136,7 @@ async function main() {
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         _meta: createToolMeta("watch wowook events", ["events", "on-chain", "arbitration", "order", "progress", "demand", "entity"]),
     }, handleOnchainEvents);
-    server.registerTool("wowok_buildin_info", {
+    reg("wowok_buildin_info", {
         title: "ℹ️ WoWok Build-in Information",
         description: "Query WoWok protocol information: 'constants', 'built-in permissions', 'guard instructions', 'current network', 'value types', or 'mainnet bridge tokens'. For 'mainnet bridge tokens': returns cross-chain bridge tokens (ETH, WETH, WBTC, USDC, USDT) with each token's symbol, WOW-side type tag (wowTypeTag), EVM address, decimals, and description. The wowTypeTag (format {address}::{module}::{struct}) can be used directly as the `type_parameter` of Service / Treasury / Reward / Allocation objects to set their payment token — e.g. use USDT's wowTypeTag to create a Service that accepts USDT payments.",
         inputSchema: ProtocolInfoQuerySchema,
@@ -1062,7 +1144,7 @@ async function main() {
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         _meta: createToolMeta("WoWok info", ["build-in", "constants", "permissions", "guard", "network", "value-types", "bridge-tokens"]),
     }, handleWowokInfo);
-    server.registerTool("schema_query", {
+    reg("schema_query", {
         title: "📋 Schema Query",
         description: "Look up JSON Schemas for WoWok MCP tools and on-chain operations. " +
             "This is the authoritative reference for exact parameter structures, types, and required fields. " +
@@ -1179,7 +1261,7 @@ async function main() {
             structuredContent: response,
         };
     });
-    server.registerTool("bridge_operation", {
+    reg("bridge_operation", {
         title: "🌉 Bridge - Cross-Chain Operations",
         description: "🌉 Simplified cross-chain bridge between WOW and EVM (Ethereum mainnet). Only WOW mainnet provides cross-chain functionality.\n\n" +
             "Key concepts (transparent to user):\n" +

package/dist/loop-engineering/aggregate.d.ts

@@ -0,0 +1,50 @@
+import type { TelemetryEvent } from "../telemetry/index.js";
+export interface ToolStats {
+    tool_name: string;
+    total_calls: number;
+    success_count: number;
+    failed_count: number;
+    pending_input_count: number;
+    success_rate: number;
+    avg_duration_ms: number;
+    p50_duration_ms: number;
+    p95_duration_ms: number;
+    semantic_hit_rate: number;
+    error_distribution: Record<string, number>;
+    top_error_messages: Array<{
+        message: string;
+        count: number;
+    }>;
+}
+export interface OperationStats {
+    operation_type: string;
+    total_calls: number;
+    success_rate: number;
+    semantic_hit_rate: number;
+    error_distribution: Record<string, number>;
+}
+export interface AggregatedStats {
+    aggregation_date: string;
+    total_events: number;
+    date_range: {
+        earliest: string;
+        latest: string;
+    };
+    per_tool: ToolStats[];
+    per_operation: OperationStats[];
+    overall: {
+        total_calls: number;
+        success_count: number;
+        failed_count: number;
+        success_rate: number;
+        semantic_hit_rate: number;
+        unknown_error_count: number;
+        unknown_error_rate: number;
+        avg_duration_ms: number;
+    };
+    error_code_distribution: Record<string, number>;
+    intent_distribution: Record<string, number>;
+}
+export declare function aggregateByTool(events: TelemetryEvent[]): ToolStats[];
+export declare function aggregateByOperation(events: TelemetryEvent[]): OperationStats[];
+export declare function aggregate(events: TelemetryEvent[]): AggregatedStats;