wowok_agent/dist/schema/call/handler.js

Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.

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 || {};
}