@wowok/agent-mcp 2.2.8

package/dist/schema/call/guard.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { CallEnvSchema, NamedObjectSchema, SubmissionCallSchema } from './base.js';
+import { GuardNodeSchema } from '../query/index.js';
+import { DescriptionSchema, GuardTableItemBaseSchema, NameOrAddressSchema } from '../common/index.js';
+export const CallGuard_RootSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("node"),
+        node: GuardNodeSchema.describe("Guard computational tree root node. MUST return a Bool value (pass/fail)."),
+    }).strict(),
+    z.object({
+        type: z.literal("file"),
+        file_path: z.string().describe("Path to JSON or Markdown file containing Guard definition. File can define: namedNew, description, table, root, rely."),
+        format: z.enum(["json", "markdown"]).optional().default("json")
+            .describe("File format: 'json' or 'markdown'. Default is 'json'."),
+    }).strict(),
+]).describe("Guard root definition. Either provide a direct node tree or reference a file to load. When using file type, fields defined in the schema (namedNew, description, table, rely) will OVERRIDE the corresponding fields in the file.");
+export const CallGuard_DataSchema = z.object({
+    namedNew: NamedObjectSchema.optional().describe("Name and optional tags for the new Guard object. Set 'onChain: true' to create a public on-chain identity. When using root.type='file', this field OVERRIDES namedNew in the file."),
+    description: DescriptionSchema.optional().describe("Guard description. When using root.type='file', this field OVERRIDES description in the file."),
+    table: z.array(GuardTableItemBaseSchema).optional().describe("Data table of the Guard object. When using root.type='file', this field OVERRIDES table in the file."),
+    root: CallGuard_RootSchema.describe("Root definition: either a direct node tree (type='node') or a file reference (type='file'). When type='file', the file can define all Guard fields (namedNew, description, table, root, rely), and schema fields override file content."),
+    rely: z.object({
+        guards: z.array(NameOrAddressSchema).describe("List of dependent Guard object IDs or names."),
+        logic_or: z.boolean().optional().describe("Whether to use logical OR operator."),
+    }).optional().describe("All Guard objects that the new Guard object depends on. If logic_or is true, the execution result of the new Guard object is the logical OR of the execution results of all dependent Guard objects; otherwise, it is logical AND. When using root.type='file', this field OVERRIDES rely in the file."),
+}).strict().describe("On-chain Guard creation. IMPORTANT: All defined data (include all submitted data) must be defined in the 'table' field. USAGE: Set 'namedNew' field with {name, tags?, onChain?} to name the new Guard. The Guard is immutable once created. Define the validation logic in 'root' field. When root.type='file', the file can contain all Guard fields, and any fields defined in the schema will OVERRIDE the file content.");
+export const CallGuard_InputSchema = z.object({
+    data: CallGuard_DataSchema.describe("Guard data definition."),
+    env: CallEnvSchema.optional(),
+}).strict().describe("On-chain Guard creation input wrapper. Contains the Guard data definition and optional environment settings.");
+export const CallGenPassport_InputSchema = z.object({
+    guard: z.union([NameOrAddressSchema, z.array(NameOrAddressSchema)]).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(),
+}).strict().describe("Generate a new Passport object after Guard verification succeeds. The Passport is an immutable on-chain object that can be used for offline friend verification, transaction condition verification, etc. Supports verifying multiple guards at once.");
+export const Guard2File_InputSchema = z.object({
+    guard: NameOrAddressSchema.describe("Guard object ID or name to export"),
+    file_path: z.string().describe("Output file path (absolute or relative)"),
+    format: z.enum(["json", "markdown"]).optional().describe("Output format: 'json' (default) or 'markdown'"),
+    env: CallEnvSchema.optional(),
+}).strict().describe("Query a Guard object from the blockchain and export its definition to a JSON or Markdown file. The exported file can be edited and used to create new Guard objects.");
+export const Guard2File_OutputSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("success"),
+        data: z.object({
+            file_path: z.string().describe("Absolute path of the exported file"),
+            format: z.enum(["json", "markdown"]).describe("Export format"),
+            guard_object: z.string().describe("Guard object ID"),
+        }).strict().describe("Success result data"),
+    }).strict(),
+    z.object({
+        status: z.literal("error"),
+        error: z.string().describe("Error message"),
+    }).strict(),
+]).describe("Guard2File operation output schema with discriminator");
+export const Guard2File_OutputWrappedSchema = z.object({
+    result: Guard2File_OutputSchema,
+}).strict().describe("Guard2File operation output wrapped schema");

package/dist/schema/call/handler.d.ts

@@ -0,0 +1,38 @@
+import type { CallEnv } from "wowok";
+import type { CallOutput } from "./base.js";
+export declare function handleCallResult(result: any): {
+    content: any[];
+    structuredContent: CallOutput;
+};
+export declare function createServerConfig(packageJson: any, description?: string): {
+    name: any;
+    version: any;
+    description: any;
+};
+export declare function createCapabilitiesConfig(): {
+    capabilities: {
+        prompts: {};
+        resources: {};
+        tools: {
+            listChanged: boolean;
+        };
+        logging: {};
+    };
+};
+export declare function createToolMeta(category: string, tags: string[]): {
+    author: string;
+    createdAt: string;
+    lastUpdated: string;
+    category: string;
+    tags: string[];
+    requiresAuth: boolean;
+};
+export declare function createToolAnnotations(readOnlyHint?: boolean, destructiveHint?: boolean): {
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+    idempotentHint: boolean;
+    openWorldHint: boolean;
+};
+export declare function transformSubmission(submission: any): Promise<any>;
+export declare function validateInput<T>(data: any, schema: any): T;
+export declare function getEnvConfig(env?: any): CallEnv;

package/dist/schema/call/handler.js

@@ -0,0 +1,171 @@
+import { ResponseData, LocalMark, enrichMoveError } from "wowok";
+export function handleCallResult(result) {
+    if (result && "error" in result) {
+        const enrichedError = enrichMoveError(result.error);
+        const output = {
+            message: `Error: ${enrichedError}`,
+            result: { type: "error", error: enrichedError },
+        };
+        return {
+            content: [{ type: "text", text: output.message }],
+            structuredContent: output,
+        };
+    }
+    if (result && "digest" in result) {
+        const r = ResponseData(result);
+        const txStatus = result?.effects?.status?.status;
+        const txError = result?.effects?.status?.error;
+        const isSuccess = txStatus === "success";
+        if (!isSuccess) {
+            const enrichedError = enrichMoveError(txError || txStatus || "unknown error");
+            const output = {
+                message: `Transaction failed: ${enrichedError}`,
+                result: { type: "error", error: enrichedError },
+            };
+            return {
+                content: [
+                    { type: "text", text: output.message },
+                    { type: "text", text: JSON.stringify(r) },
+                ],
+                structuredContent: output,
+            };
+        }
+        const output = {
+            message: "Transaction completed successfully",
+            result: { type: "transaction", ...result },
+        };
+        return {
+            content: [
+                { type: "text", text: output.message },
+                { type: "text", text: JSON.stringify(r) },
+            ],
+            structuredContent: output,
+        };
+    }
+    if (result && "guard" in result && "submission" in result) {
+        const output = {
+            message: "Submission required for Guard verification",
+            result: { type: "submission", ...result },
+        };
+        return {
+            content: [
+                { type: "text", text: output.message },
+                { type: "text", text: JSON.stringify(result) },
+            ],
+            structuredContent: output,
+        };
+    }
+    if (Array.isArray(result)) {
+        const output = {
+            message: "Operation completed",
+            result: { type: "data", data: result },
+        };
+        return {
+            content: [
+                { type: "text", text: output.message },
+                { type: "text", text: JSON.stringify(result) },
+            ],
+            structuredContent: output,
+        };
+    }
+    if (result === undefined || result === null) {
+        const output = {
+            message: "Operation completed",
+            result: { type: "null" },
+        };
+        return {
+            content: [{ type: "text", text: output.message }],
+            structuredContent: output,
+        };
+    }
+    const output = {
+        message: "Operation completed",
+        result: { type: "transaction", ...result },
+    };
+    return {
+        content: [{ type: "text", text: output.message }],
+        structuredContent: output,
+    };
+}
+export function createServerConfig(packageJson, description) {
+    return {
+        name: packageJson.name,
+        version: packageJson.version,
+        description: description || packageJson.description,
+    };
+}
+export function createCapabilitiesConfig() {
+    return {
+        capabilities: {
+            prompts: {},
+            resources: {},
+            tools: { listChanged: true },
+            logging: {},
+        },
+    };
+}
+export function createToolMeta(category, tags) {
+    return {
+        author: "WOWOK Team",
+        createdAt: "2026-02-01",
+        lastUpdated: "2026-02-01",
+        category,
+        tags,
+        requiresAuth: false,
+    };
+}
+export function createToolAnnotations(readOnlyHint = false, destructiveHint = false) {
+    return {
+        readOnlyHint,
+        destructiveHint,
+        idempotentHint: true,
+        openWorldHint: false,
+    };
+}
+export async function transformSubmission(submission) {
+    if (!submission)
+        return undefined;
+    const guardNames = (submission.guard || []).map((g) => g.object).filter(Boolean);
+    const submissionGuardNames = (submission.submission || []).map((s) => s.guard).filter(Boolean);
+    const allNames = [...new Set([...guardNames, ...submissionGuardNames])];
+    const resolvedAddresses = allNames.length > 0
+        ? await LocalMark.Instance().get_many_address(allNames)
+        : [];
+    const nameToAddress = new Map();
+    allNames.forEach((name, index) => {
+        const addr = resolvedAddresses[index];
+        if (addr) {
+            nameToAddress.set(name, addr);
+        }
+    });
+    const getAddress = (name) => {
+        if (nameToAddress.has(name)) {
+            return nameToAddress.get(name);
+        }
+        for (const [n, addr] of nameToAddress.entries()) {
+            if (n === name)
+                return addr;
+        }
+        if (name.startsWith("0x") && name.length === 66) {
+            return name;
+        }
+        throw new Error(`Guard name or address not found: ${name}`);
+    };
+    return {
+        type: "submission",
+        guard: (submission.guard || []).map((g) => ({
+            object: getAddress(g.object),
+            impack: g.impack || false,
+        })),
+        submission: (submission.submission || []).map((s) => ({
+            guard: getAddress(s.guard),
+            submission: s.submission || [],
+        })),
+    };
+}
+export function validateInput(data, schema) {
+    return schema.parse(data);
+}
+export function getEnvConfig(env) {
+    return env || {};
+}

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

@@ -0,0 +1,18 @@
+export * from './base.js';
+export * from './handler.js';
+export * from './contact.js';
+export * from './demand.js';
+export * from './guard.js';
+export * from './machine.js';
+export * from './arbitration.js';
+export * from './allocation.js';
+export * from './order.js';
+export * from './payment.js';
+export * from './permission.js';
+export * from './personal.js';
+export * from './proof.js';
+export * from './progress.js';
+export * from './repository.js';
+export * from './reward.js';
+export * from './service.js';
+export * from './treasury.js';

package/dist/schema/call/index.js

@@ -0,0 +1,18 @@
+export * from './base.js';
+export * from './handler.js';
+export * from './contact.js';
+export * from './demand.js';
+export * from './guard.js';
+export * from './machine.js';
+export * from './arbitration.js';
+export * from './allocation.js';
+export * from './order.js';
+export * from './payment.js';
+export * from './permission.js';
+export * from './personal.js';
+export * from './proof.js';
+export * from './progress.js';
+export * from './repository.js';
+export * from './reward.js';
+export * from './service.js';
+export * from './treasury.js';