@wowok/agent-mcp 2.3.18 → 2.4.3

package/dist/tools/handlers/onchain.js

@@ -0,0 +1,246 @@
+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 { OnchainOperationsSchema, strictParse, getEnvConfig, handleCallResult, checkClientSchemaCompatibility, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, transformSubmission, } from "../../schema/index.js";
+import { isProjectServiceEnabled, normalize as projectNormalize, } from "../../project/index.js";
+import { withHarness } from "../shared.js";
+export async function handleOnchainOperations(args) {
+    let validated;
+    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 (hasWrappedParams) {
+                throw new Error("Invalid parameter structure. Parameters should NOT be wrapped in 'description' field.\n" +
+                    "Correct format: { operation_type: '...', data: {...} }\n" +
+                    "Incorrect format: { description: '{ operation_type: ... }' }");
+            }
+        }
+        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 schemaCheck = clientSchemaVersion
+            ? checkClientSchemaCompatibility(clientSchemaVersion, { mode: schemaStrictMode ? "strict" : "warn" })
+            : undefined;
+        const buildCtx = (data) => ({
+            operation_type: validated.operation_type,
+            data,
+            pre_warnings: [...constraintWarnings, ...projectWarnings].length
+                ? [...constraintWarnings, ...projectWarnings]
+                : undefined,
+            schema_check: schemaCheck,
+        });
+        const projectEnvPrefix = env?.project;
+        if (isProjectServiceEnabled()) {
+            const pn = projectNormalize({
+                operation_type: validated.operation_type,
+                data: validated.data,
+                projectPrefix: projectEnvPrefix,
+            });
+            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;
+        }
+        switch (validated.operation_type) {
+            case "service": {
+                const callService = new CallService(validated.data);
+                const result = validated.submission
+                    ? await callService.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callService.call(env);
+                const data = validated.data;
+                const intent = data?.publish ? "publish service" : data?.bPublished !== undefined ? "modify service" : "create service";
+                return handleCallResult(result, withHarness(buildCtx(data), "service", intent));
+            }
+            case "machine": {
+                if (validated.data.node && typeof validated.data.node === 'object' && 'json_or_markdown_file' in validated.data.node) {
+                    const filePathStr = validated.data.node.json_or_markdown_file;
+                    let fileContent;
+                    try {
+                        const filePath = resolve(filePathStr);
+                        fileContent = readFileSync(filePath, 'utf-8');
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to read file '${filePathStr}': ${e.message}`);
+                    }
+                    const parseResult = parseMachineNodesFromText(fileContent);
+                    if (!parseResult.success) {
+                        const errorMessages = formatMachineNodeErrors(parseResult.errors);
+                        throw new Error(`Machine node validation failed for file '${filePathStr}':\n\n${errorMessages}`);
+                    }
+                    if (!parseResult.data) {
+                        throw new Error(`No nodes found in file '${filePathStr}'`);
+                    }
+                    validated.data.node = {
+                        op: "set",
+                        nodes: parseResult.data,
+                        bReplace: true
+                    };
+                }
+                const callMachine = new CallMachine(validated.data);
+                const result = validated.submission
+                    ? await callMachine.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callMachine.call(env);
+                return handleCallResult(result, buildCtx(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, buildCtx(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, buildCtx(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, buildCtx(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, buildCtx(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, buildCtx(validated.data));
+            }
+            case "reward": {
+                const transformedData = transformRewardInput(validated.data);
+                const callReward = new CallReward(transformedData);
+                const result = validated.submission
+                    ? await callReward.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callReward.call(env);
+                return handleCallResult(result, buildCtx(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, buildCtx(validated.data));
+            }
+            case "permission": {
+                const callPermission = new CallPermission(validated.data);
+                const result = await callPermission.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "guard": {
+                const validatedData = validated.data;
+                if (validatedData.root?.type === "file") {
+                    const filePath = resolve(validatedData.root.file_path);
+                    let fileContent;
+                    try {
+                        fileContent = readFileSync(filePath, 'utf-8');
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to read Guard definition file '${validatedData.root.file_path}': ${e.message}`);
+                    }
+                    const parseResult = parseGuardFile(fileContent, validatedData.root.format);
+                    if (!parseResult.success) {
+                        const errorMessages = formatGuardParseErrors(parseResult.errors);
+                        throw new Error(`Guard validation failed for file '${validatedData.root.file_path}':\n\n${errorMessages}`);
+                    }
+                    const fileData = parseResult.data;
+                    validatedData.root = { type: "node", node: fileData.root };
+                    if (fileData.table !== undefined && validatedData.table === undefined) {
+                        validatedData.table = fileData.table;
+                    }
+                    if (fileData.description !== undefined && validatedData.description === undefined) {
+                        validatedData.description = fileData.description;
+                    }
+                    if (fileData.rely !== undefined && validatedData.rely === undefined) {
+                        validatedData.rely = fileData.rely;
+                    }
+                    if (fileData.namedNew !== undefined && validatedData.namedNew === undefined) {
+                        validatedData.namedNew = fileData.namedNew;
+                    }
+                }
+                if (validatedData.root && typeof validatedData.root === 'object') {
+                    const rootObj = validatedData.root;
+                    if (rootObj.type === 'node' && rootObj.node) {
+                        validatedData.root = rootObj.node;
+                    }
+                }
+                if (!validatedData.table || validatedData.table.length === 0) {
+                    throw new Error("Guard 'table' field is required and cannot be empty");
+                }
+                if (!validatedData.root) {
+                    throw new Error("Guard 'root' field is required");
+                }
+                const callGuard = new CallGuard(validatedData);
+                const result = await callGuard.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "personal": {
+                const transformedData = transformPersonalInput(validated.data);
+                const callPersonal = new CallPersonal(transformedData);
+                const result = await callPersonal.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "payment": {
+                const callPayment = new CallPayment(validated.data);
+                const result = await callPayment.call(env);
+                return handleCallResult(result, buildCtx(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, buildCtx(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, buildCtx(validated.data));
+            }
+            case "gen_passport": {
+                const result = await gen_passport(env, validated.guard, validated.info);
+                return handleCallResult(result, buildCtx(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, buildCtx(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, buildCtx(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 handleCallResult({ error: errorMessage }, validated ? {
+            operation_type: validated.operation_type,
+            data: validated.data,
+        } : undefined);
+    }
+}

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

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

package/dist/tools/handlers/project.js

@@ -0,0 +1,53 @@
+import { queryProjects, queryProjectObjects, queryShareableObjects, queryDependencies, queryReferencedBy, queryPrePublishCheck, queryCrossProjectReferences, queryGraphStats, saveGraph, loadGraph, } from "../../project/index.js";
+export async function handleProjectOperation(args) {
+    const action = args.action;
+    const project = args.project;
+    const object = args.object;
+    let result;
+    switch (action) {
+        case "list_projects":
+            result = await queryProjects();
+            break;
+        case "list_objects":
+            if (!project)
+                throw new Error("'project' param is required for list_objects");
+            result = await queryProjectObjects(project);
+            break;
+        case "shareable":
+            result = await queryShareableObjects();
+            break;
+        case "dependencies":
+            if (!object)
+                throw new Error("'object' param is required for dependencies");
+            result = queryDependencies(object);
+            break;
+        case "referenced_by":
+            if (!object)
+                throw new Error("'object' param is required for referenced_by");
+            result = queryReferencedBy(object);
+            break;
+        case "pre_publish_check":
+            if (!object)
+                throw new Error("'object' param is required for pre_publish_check");
+            result = { warnings: queryPrePublishCheck(object) };
+            break;
+        case "cross_project_refs":
+            result = queryCrossProjectReferences();
+            break;
+        case "graph_stats":
+            result = queryGraphStats();
+            break;
+        case "save_graph":
+            result = { saved: true, path: saveGraph() };
+            break;
+        case "load_graph":
+            result = { loaded: loadGraph() };
+            break;
+        default:
+            throw new Error(`Unknown project_operation action: ${action}`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { ToolDispatchResult } from "../types.js";
+export declare function handleWatchQueryOperations(args: any): Promise<ToolDispatchResult>;
+export declare function handleOnchainTableData(args: any): Promise<ToolDispatchResult>;
+export declare function handleOnchainEvents(args: any): Promise<ToolDispatchResult>;
+export declare function handleWowokInfo(args: any): Promise<ToolDispatchResult>;

package/dist/tools/handlers/query.js

@@ -0,0 +1,256 @@
+import { strictParse, WatchQueryOperationsSchema, OnchainTableDataSchema, OnchainEventsInputSchema, ProtocolInfoQuerySchema, } from "../../schema/index.js";
+import { 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, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_received, queryProtocolInfo, query_events, generateNodeComments, } from "@wowok/wowok";
+import { buildDataSemantic, } from "../../schema/call/semantic.js";
+import { normalizeAccountOrMark } from "./messenger.js";
+export async function handleWatchQueryOperations(args) {
+    const validated = strictParse(WatchQueryOperationsSchema, args, "watch_and_query input");
+    let result;
+    switch (validated.query_type) {
+        case "local_mark_list": {
+            const queryResult = await query_local_mark_list(validated.filter || {});
+            result = { query_type: "local_mark_list", result: queryResult };
+            break;
+        }
+        case "account_list": {
+            const queryResult = await query_account_list(validated.filter);
+            result = { query_type: "account_list", result: queryResult };
+            break;
+        }
+        case "local_info_list": {
+            const queryResult = await query_local_info_list(validated.filter);
+            result = { query_type: "local_info_list", result: queryResult };
+            break;
+        }
+        case "token_list": {
+            const queryResult = await query_local_token_list(validated.filter || {});
+            result = { query_type: "token_list", result: queryResult };
+            break;
+        }
+        case "account_balance": {
+            const queryResult = await query_account({
+                name_or_address: validated.name_or_address,
+                token_type: validated.token_type,
+                balance: validated.balance,
+                coin: validated.coin,
+                network: validated.network,
+            });
+            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 };
+            break;
+        }
+        case "onchain_objects": {
+            const queryResult = await query_objects({
+                objects: validated.objects,
+                no_cache: validated.no_cache,
+                network: validated.network,
+            });
+            if (queryResult && queryResult.objects && Array.isArray(queryResult.objects)) {
+                queryResult.objects = queryResult.objects.map((obj) => {
+                    if (obj && obj.data && obj.data.type === "Guard" && obj.data.root) {
+                        try {
+                            const nodeComments = generateNodeComments(obj.data.root);
+                            return {
+                                ...obj,
+                                _guard_node_comments: nodeComments,
+                            };
+                        }
+                        catch (e) {
+                            return obj;
+                        }
+                    }
+                    return obj;
+                });
+            }
+            result = { query_type: "onchain_objects", result: queryResult };
+            break;
+        }
+        case "onchain_received": {
+            const queryResult = await query_received({
+                name_or_address: normalizeAccountOrMark(validated.name_or_address),
+                type: validated.type,
+                cursor: validated.cursor,
+                limit: validated.limit,
+                no_cache: validated.no_cache,
+                network: validated.network,
+            });
+            result = { query_type: "onchain_received", result: queryResult };
+            break;
+        }
+        default:
+            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 }) }],
+        structuredContent: {
+            result,
+            semantic: buildDataSemantic(result, {
+                operation_type: "query_toolkit",
+                data: validated,
+            }),
+        },
+    };
+}
+export async function handleOnchainTableData(args) {
+    const validated = strictParse(OnchainTableDataSchema, args, "onchain_table_data input");
+    let result;
+    switch (validated.query_type) {
+        case "onchain_table": {
+            const queryResult = await query_table({
+                parent: validated.parent,
+                cursor: validated.cursor,
+                limit: validated.limit,
+                no_cache: validated.no_cache,
+                network: validated.network,
+            });
+            result = { query_type: "onchain_table", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_repository_data": {
+            const queryResult = await queryTableItem_RepositoryData({
+                parent: validated.parent, name: validated.name, entity: validated.entity,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_repository_data", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_permission_perm": {
+            const queryResult = await queryTableItem_PermissionPerm({
+                parent: validated.parent, address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_permission_perm", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_reward_record": {
+            const queryResult = await queryTableItem_RewardRecord({
+                parent: validated.parent, address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_reward_record", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_demand_presenter": {
+            const queryResult = await queryTableItem_DemandPresenter({
+                parent: validated.parent, address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_demand_presenter", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_treasury_history": {
+            const queryResult = await queryTableItem_TreasuryHistory({
+                parent: validated.parent, address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_treasury_history", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_machine_node": {
+            const queryResult = await queryTableItem_MachineNode({
+                parent: validated.parent, key: validated.key,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_machine_node", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_progress_history": {
+            const queryResult = await queryTableItem_ProgressHistory({
+                parent: validated.parent, u64: validated.u64,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_progress_history", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_address_mark": {
+            const queryResult = await queryTableItem_AddressMark({
+                parent: validated.parent, address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_address_mark", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_entity_registrar": {
+            const queryResult = await queryTableItem_EntityRegistrar({
+                address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_entity_registrar", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_entity_linker": {
+            const queryResult = await queryTableItem_EntityLinker({
+                address: validated.address,
+                no_cache: validated.no_cache, network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_entity_linker", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_generic": {
+            const queryResult = await query_tableItem({
+                parent: validated.parent,
+                key: { type: validated.key_type, value: validated.key_value },
+                no_cache: validated.no_cache,
+                network: validated.network,
+            });
+            result = { query_type: "onchain_table_item_generic", result: queryResult };
+            break;
+        }
+        default:
+            throw new Error(`Unknown table query type. Valid query_types are: "onchain_table", "onchain_table_item_repository_data", "onchain_table_item_permission_perm", "onchain_table_item_reward_record", "onchain_table_item_demand_presenter", "onchain_table_item_treasury_history", "onchain_table_item_machine_node", "onchain_table_item_progress_history", "onchain_table_item_address_mark", "onchain_table_item_entity_registrar", "onchain_table_item_entity_linker", "onchain_table_item_generic"`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: {
+            result,
+            semantic: buildDataSemantic(result, {
+                operation_type: "onchain_table_data",
+                data: validated,
+            }),
+        },
+    };
+}
+export async function handleOnchainEvents(args) {
+    const validated = strictParse(OnchainEventsInputSchema, args, "onchain_events input");
+    const queryResult = await query_events({
+        type: validated.type,
+        cursor: validated.cursor ? {
+            eventSeq: String(validated.cursor.eventSeq),
+            txDigest: validated.cursor.txDigest,
+        } : null,
+        limit: validated.limit ?? null,
+        order: validated.order ?? null,
+        no_cache: validated.no_cache,
+        network: validated.network,
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
+        structuredContent: {
+            result: queryResult,
+            semantic: buildDataSemantic(queryResult, {
+                operation_type: "onchain_events",
+                data: validated,
+            }),
+        },
+    };
+}
+export async function handleWowokInfo(args) {
+    const validated = strictParse(ProtocolInfoQuerySchema, args, "wowok_buildin_info input");
+    const queryResult = await queryProtocolInfo(validated);
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
+        structuredContent: { result: queryResult },
+    };
+}

package/dist/tools/handlers/schema-query.d.ts

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

package/dist/tools/handlers/schema-query.js

@@ -0,0 +1,92 @@
+import { processSchemaQuery, } from "../../schema-query/index.js";
+export async function handleSchemaQuery(args) {
+    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":
+                if (Array.isArray(data) && data.length > 0) {
+                    textContent += "\n\nAll available 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 "list_operations":
+                if (Array.isArray(data) && data.length > 0) {
+                    textContent += "\n\nOn-chain operation 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 "get_output":
+                if (data) {
+                    textContent += "\n\n## Output 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}`;
+                        }
+                        if (item.description) {
+                            textContent += `\n    ${item.description.slice(0, 100)}...`;
+                        }
+                        textContent += "\n";
+                    }
+                }
+                else {
+                    textContent += "\n\nNo schemas found. Try 'list' to browse all available schemas, or use a broader search term.";
+                }
+                break;
+        }
+    }
+    if (response.suggestions && response.suggestions.length > 0) {
+        textContent += "\n\n💡 Suggestions:\n";
+        for (const suggestion of response.suggestions) {
+            textContent += `  • ${suggestion}\n`;
+        }
+    }
+    return {
+        content: [{
+                type: "text",
+                text: textContent,
+            }],
+        structuredContent: response,
+    };
+}

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

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