@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/schemas/schema_query.output.json

@@ -17,7 +17,43 @@
           "description": "The action that was performed"
         },
         "data": {
-          "description": "Response data - JSON Schema object for 'get'/'get_output', array of schema info for 'list'/'search'/'list_operations'"
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "name": {
+                    "type": "string",
+                    "description": "Schema/tool identifier (e.g. 'onchain_operations')."
+                  },
+                  "title": {
+                    "type": "string",
+                    "description": "Human-readable title, if known."
+                  },
+                  "description": {
+                    "type": "string",
+                    "description": "Short description, if known."
+                  }
+                },
+                "required": [
+                  "name"
+                ],
+                "additionalProperties": false
+              },
+              "description": "List of schema summaries (list/search/list_operations)."
+            },
+            {
+              "type": "object",
+              "additionalProperties": {},
+              "description": "JSON Schema object (get/get_output)."
+            },
+            {
+              "type": "null",
+              "description": "No data — lookup failed or returned nothing."
+            }
+          ],
+          "description": "Response data — array of schema summaries for list-like actions, JSON Schema object for get/get_output, null on failure."
         },
         "message": {
           "type": "string",
@@ -34,6 +70,7 @@
       "required": [
         "success",
         "action",
+        "data",
         "message"
       ],
       "additionalProperties": false

package/dist/telemetry/index.d.ts

@@ -15,5 +15,5 @@ export declare function isTelemetryEnabled(): boolean;
 export declare function captureTelemetry(toolName: string, structuredContent: CallOutput | undefined, durationMs: number, operationTypeHint?: string): Promise<void>;
 export declare function captureTelemetryError(toolName: string, error: any, durationMs: number, operationTypeHint?: string): Promise<void>;
 export declare function withTelemetry<TArgs, TOutput extends {
-    structuredContent?: CallOutput;
+    structuredContent?: unknown;
 }>(toolName: string, handler: (args: TArgs) => Promise<TOutput>): (args: TArgs) => Promise<TOutput>;

package/dist/tools/handlers/config.d.ts

@@ -1,2 +1,2 @@
 import type { ToolDispatchResult } from "../types.js";
-export declare function handleConfigOperation(args: any): Promise<ToolDispatchResult>;
+export declare function handleConfigOperation(args: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/config.js

@@ -1,68 +1,71 @@
 import { listServices, getServiceInfo, toggle as toggleService, setEnabled as setServiceEnabled, reset as resetService, } from "../../config/index.js";
+import { strictParse } from "../../schema/index.js";
+import { ConfigOperationInputSchema } from "../../schema/config/index.js";
 export async function handleConfigOperation(args) {
-    const action = args.action;
+    const validated = strictParse(ConfigOperationInputSchema, args, "config_operation input");
+    const { action, service: serviceRaw } = validated;
     let result;
     switch (action) {
         case "list":
-            result = { services: listServices() };
+            result = { action: "list", services: listServices() };
             break;
         case "toggle": {
-            const service = args.service;
-            if (!service)
+            if (!serviceRaw)
                 throw new Error("'service' param is required for toggle");
+            const service = serviceRaw;
             const existing = getServiceInfo(service);
             if (!existing) {
                 throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
             }
             const newState = toggleService(service);
-            result = { service, enabled: newState, reminder: existing.reminder };
+            result = { action: "toggle", service, enabled: newState, reminder: existing.reminder };
             break;
         }
         case "enable": {
-            const service = args.service;
-            if (!service)
+            if (!serviceRaw)
                 throw new Error("'service' param is required for enable");
+            const service = serviceRaw;
             const existing = getServiceInfo(service);
             if (!existing)
                 throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
             setServiceEnabled(service, true);
-            result = { service, enabled: true, reminder: existing.reminder };
+            result = { action: "enable", service, enabled: true, reminder: existing.reminder };
             break;
         }
         case "disable": {
-            const service = args.service;
-            if (!service)
+            if (!serviceRaw)
                 throw new Error("'service' param is required for disable");
+            const service = serviceRaw;
             const existing = getServiceInfo(service);
             if (!existing)
                 throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
             setServiceEnabled(service, false);
-            result = { service, enabled: false, reminder: existing.reminder };
+            result = { action: "disable", service, enabled: false, reminder: existing.reminder };
             break;
         }
         case "reset": {
-            const service = args.service;
-            if (!service)
+            if (!serviceRaw)
                 throw new Error("'service' param is required for reset");
+            const service = serviceRaw;
             const existing = getServiceInfo(service);
             if (!existing)
                 throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
             resetService(service);
-            result = { service, enabled: getServiceInfo(service)?.enabled, reminder: existing.reminder, reset: true };
+            result = { action: "reset", service, enabled: getServiceInfo(service)?.enabled, reminder: existing.reminder, reset: true };
             break;
         }
         case "info": {
-            const service = args.service;
-            if (!service)
+            if (!serviceRaw)
                 throw new Error("'service' param is required for info");
+            const service = serviceRaw;
             const info = getServiceInfo(service);
             if (!info)
                 throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
-            result = info;
+            result = { action: "info", ...info };
             break;
         }
         default:
-            throw new Error(`Unknown config_operation action: ${action}`);
+            throw new Error(`Unknown config_operation action: ${String(action)}`);
     }
     return {
         content: [{ type: "text", text: JSON.stringify({ result }) }],

package/dist/tools/handlers/file-export.d.ts

@@ -1,3 +1,3 @@
 import type { ToolDispatchResult } from "../types.js";
-export declare function handleGuard2File(args: any): Promise<ToolDispatchResult>;
-export declare function handleMachineNode2File(args: any): Promise<ToolDispatchResult>;
+export declare function handleGuard2File(args: unknown): Promise<ToolDispatchResult>;
+export declare function handleMachineNode2File(args: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/local.d.ts

@@ -1,30 +1,3 @@
-export declare const handleAccountOperation: (args: any) => Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-    structuredContent: {
-        result: any;
-        semantic: any;
-    };
-}>;
-export declare const handleMarkOperation: (args: any) => Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-    structuredContent: {
-        result: any;
-        semantic: any;
-    };
-}>;
-export declare const handleInfoOperation: (args: any) => Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-    structuredContent: {
-        result: any;
-        semantic: any;
-    };
-}>;
+export declare const handleAccountOperation: (args: unknown) => Promise<import("../types.js").ToolDispatchResult>;
+export declare const handleMarkOperation: (args: unknown) => Promise<import("../types.js").ToolDispatchResult>;
+export declare const handleInfoOperation: (args: unknown) => Promise<import("../types.js").ToolDispatchResult>;

package/dist/tools/handlers/local.js

@@ -1,12 +1,20 @@
 import { wrapLocalHandler } from "../shared.js";
 import { AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, } from "../../schema/index.js";
 import { account_operation, local_mark_operation, local_info_operation, } from "@wowok/wowok";
+function deriveOpType(prefix, validated) {
+    for (const key of Object.keys(validated)) {
+        if (validated[key] !== undefined) {
+            return `${prefix}_${String(key)}`;
+        }
+    }
+    return `${prefix}_unknown`;
+}
 export const handleAccountOperation = wrapLocalHandler({
     schema: AccountOperationSchema,
     operationFn: account_operation,
     parseLabel: "account_operation input",
     buildContext: (validated) => ({
-        operation_type: "account_" + validated.operation_type,
+        operation_type: deriveOpType("account", validated),
         data: validated,
     }),
 });
@@ -15,7 +23,7 @@ export const handleMarkOperation = wrapLocalHandler({
     operationFn: local_mark_operation,
     parseLabel: "local_mark_operation input",
     buildContext: (validated) => ({
-        operation_type: "mark_" + validated.operation_type,
+        operation_type: deriveOpType("mark", validated),
         data: validated,
     }),
 });
@@ -23,5 +31,8 @@ export const handleInfoOperation = wrapLocalHandler({
     schema: LocalInfoOperationSchema,
     operationFn: local_info_operation,
     parseLabel: "local_info_operation input",
-    buildContext: (validated) => ({ operation_type: "local_info", data: validated }),
+    buildContext: (validated) => ({
+        operation_type: deriveOpType("local_info", validated),
+        data: validated,
+    }),
 });

package/dist/tools/handlers/messenger.d.ts

@@ -13,4 +13,4 @@ export declare function normalizeManyAccountOrMark(input: string[] | {
     entities: any[];
     check_all_founded?: boolean;
 };
-export declare function handleMessengerOperation(args: any): Promise<ToolDispatchResult>;
+export declare function handleMessengerOperation(args: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/messenger.js

@@ -20,6 +20,7 @@ export async function handleMessengerOperation(args) {
     let validated;
     try {
         validated = strictParse(MessengerOperationInputSchema, args, "messenger_operation input");
+        const opLiteral = validated.operation;
         let result;
         switch (validated.operation) {
             case "watch_conversations": {
@@ -158,7 +159,7 @@ export async function handleMessengerOperation(args) {
                 break;
             }
             default:
-                throw new Error(`Unknown messenger operation: ${validated.operation}`);
+                throw new Error(`Unknown messenger operation: ${opLiteral}`);
         }
         return {
             content: [{ type: "text", text: JSON.stringify(result) }],

package/dist/tools/handlers/onchain.d.ts

@@ -1,2 +1,2 @@
 import type { ToolDispatchResult } from "../types.js";
-export declare function handleOnchainOperations(args: any): Promise<ToolDispatchResult>;
+export declare function handleOnchainOperations(args: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/onchain.js

@@ -1,7 +1,8 @@
 import { readFileSync } from "fs";
 import { resolve } from "path";
-import { CallService, CallMachine, CallProgress, CallPermission, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, parseGuardFile, formatGuardParseErrors, transformRewardInput, transformPersonalInput, } from "@wowok/wowok";
+import { CallService, CallMachine, CallProgress, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, parseGuardFile, formatGuardParseErrors, transformRewardInput, transformPersonalInput, } from "@wowok/wowok";
 import { OnchainOperationsSchema, strictParse, getEnvConfig, handleCallResult, checkClientSchemaCompatibility, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, transformSubmission, } from "../../schema/index.js";
+import { handlePermissionOperations } from "../../schema/call/permission-handler.js";
 import { isProjectServiceEnabled, normalize as projectNormalize, } from "../../project/index.js";
 import { withHarness } from "../shared.js";
 export async function handleOnchainOperations(args) {
@@ -9,9 +10,11 @@ export async function handleOnchainOperations(args) {
     let constraintWarnings = [];
     let projectWarnings = [];
     try {
-        if (typeof args === 'object' && args !== null && args.description && !args.operation_type) {
-            const hasWrappedParams = typeof args.description === 'string' &&
-                (args.description.includes('operation_type') || args.description.includes('data'));
+        if (typeof args === 'object' && args !== null
+            && 'description' in args && !('operation_type' in args)) {
+            const desc = args.description;
+            const hasWrappedParams = typeof desc === 'string' &&
+                (desc.includes('operation_type') || desc.includes('data'));
             if (hasWrappedParams) {
                 throw new Error("Invalid parameter structure. Parameters should NOT be wrapped in 'description' field.\n" +
                     "Correct format: { operation_type: '...', data: {...} }\n" +
@@ -20,8 +23,8 @@ export async function handleOnchainOperations(args) {
         }
         validated = strictParse(OnchainOperationsSchema, args, "onchain_operations input");
         const env = getEnvConfig(validated.env);
-        const clientSchemaVersion = env?.client_schema_version;
-        const schemaStrictMode = env?.schema_strict_mode;
+        const clientSchemaVersion = env.client_schema_version;
+        const schemaStrictMode = env.schema_strict_mode;
         const schemaCheck = clientSchemaVersion
             ? checkClientSchemaCompatibility(clientSchemaVersion, { mode: schemaStrictMode ? "strict" : "warn" })
             : undefined;
@@ -33,8 +36,8 @@ export async function handleOnchainOperations(args) {
                 : undefined,
             schema_check: schemaCheck,
         });
-        const projectEnvPrefix = env?.project;
-        if (isProjectServiceEnabled()) {
+        const projectEnvPrefix = env.project;
+        if (isProjectServiceEnabled() && 'data' in validated && validated.data) {
             const pn = projectNormalize({
                 operation_type: validated.operation_type,
                 data: validated.data,
@@ -43,13 +46,11 @@ export async function handleOnchainOperations(args) {
             validated.data = pn.data;
             projectWarnings = pn.warnings ?? [];
         }
-        if (env && typeof env === "object") {
-            delete env.confirmed;
-            delete env.user_intent_phrases;
-            delete env.project;
-            delete env.client_schema_version;
-            delete env.schema_strict_mode;
-        }
+        delete env.confirmed;
+        delete env.user_intent_phrases;
+        delete env.project;
+        delete env.client_schema_version;
+        delete env.schema_strict_mode;
         switch (validated.operation_type) {
             case "service": {
                 const callService = new CallService(validated.data);
@@ -142,9 +143,7 @@ export async function handleOnchainOperations(args) {
                 return handleCallResult(result, buildCtx(validated.data));
             }
             case "permission": {
-                const callPermission = new CallPermission(validated.data);
-                const result = await callPermission.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                return handlePermissionOperations(validated.data, env, buildCtx);
             }
             case "guard": {
                 const validatedData = validated.data;
@@ -234,13 +233,16 @@ export async function handleOnchainOperations(args) {
                 return handleCallResult(result, buildCtx(validated.data));
             }
         }
-        throw new Error(`Unknown on-chain operation type: ${validated.operation_type}`);
+        const exhaustiveOp = validated;
+        throw new Error(`Unknown on-chain operation type: ${String(exhaustiveOp.operation_type)}`);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        return handleCallResult({ error: errorMessage }, validated ? {
-            operation_type: validated.operation_type,
-            data: validated.data,
+        const opType = validated?.operation_type;
+        const ctxData = validated && 'data' in validated ? validated.data : undefined;
+        return handleCallResult({ error: errorMessage }, opType ? {
+            operation_type: opType,
+            data: ctxData,
         } : undefined);
     }
 }

package/dist/tools/handlers/project.d.ts

@@ -1,2 +1,2 @@
 import type { ToolDispatchResult } from "../types.js";
-export declare function handleProjectOperation(args: any): Promise<ToolDispatchResult>;
+export declare function handleProjectOperation(args: unknown): Promise<ToolDispatchResult>;