@wowok/agent-mcp 2.7.1 → 2.7.3

package/dist/schema-query/index.js

@@ -1,810 +0,0 @@
-import { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync } from "fs";
-import { resolve, join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { TOOLS_REFERENCE, getToolReference, searchToolReference, getToolSequence, } from "../knowledge/tools-reference.js";
-import { GUARD_DESIGN_PATTERNS, getGuardDesignPattern, GUARD_DESIGN_PATTERNS_VERSION, } from "../knowledge/guard-design-patterns.js";
-import { OBJECT_REUSE_RULES, CREATE_VS_MODIFY_PATTERN, IMMUTABILITY_RULES, OPERATION_TYPE_CLASSIFICATION, OPERATION_CLASS_META, NAMING_CONVENTIONS, SAFETY_RULES_VERSION, } from "../knowledge/safety-rules.js";
-import { listTemplates as listRegistryTemplates, getTemplateDetail, instantiateTemplate, getTemplateCounts, TEMPLATE_OBJECT_TYPES, } from "../knowledge/template-registry.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = fileURLToPath(new URL(".", import.meta.url));
-const SCHEMAS_DIR = resolve(__dirname, "../../dist/schemas");
-const GUARD_TEMPLATES_PATH_SCRIPTS = resolve(__dirname, "../../scripts/guard-templates.json");
-const GUARD_TEMPLATES_PATH_DIST = resolve(__dirname, "../../dist/schemas/guard-templates.json");
-const GUARD_TEMPLATES_PATH = existsSync(GUARD_TEMPLATES_PATH_SCRIPTS)
-    ? GUARD_TEMPLATES_PATH_SCRIPTS
-    : GUARD_TEMPLATES_PATH_DIST;
-const EXAMPLES_DIR_SCRIPTS = resolve(__dirname, "../../scripts/examples");
-const EXAMPLES_DIR_DIST = resolve(__dirname, "../examples");
-export const EXAMPLES_DIR = existsSync(EXAMPLES_DIR_SCRIPTS)
-    ? EXAMPLES_DIR_SCRIPTS
-    : EXAMPLES_DIR_DIST;
-const WORKSPACE_TMP_DIR = resolve(process.cwd(), ".trae", "tmp");
-export function areSchemasAvailable() {
-    return existsSync(SCHEMAS_DIR) && existsSync(join(SCHEMAS_DIR, "index.json"));
-}
-export function getSchemaIndex() {
-    try {
-        const indexPath = join(SCHEMAS_DIR, "index.json");
-        if (!existsSync(indexPath))
-            return null;
-        const content = readFileSync(indexPath, "utf-8");
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-}
-export function listSchemas() {
-    const index = getSchemaIndex();
-    if (!index)
-        return [];
-    return [
-        ...(index.tools || []),
-        ...(index.operations || []),
-    ];
-}
-export function getSchema(name) {
-    try {
-        let schemaPath = join(SCHEMAS_DIR, `${name}.schema.json`);
-        if (!existsSync(schemaPath)) {
-            schemaPath = join(SCHEMAS_DIR, `${name}.json`);
-        }
-        if (!existsSync(schemaPath)) {
-            return null;
-        }
-        const content = readFileSync(schemaPath, "utf-8");
-        const schema = JSON.parse(content);
-        return resolveSchemaRefs(schema);
-    }
-    catch {
-        return null;
-    }
-}
-export function getOutputSchema(name) {
-    try {
-        const schemaPath = join(SCHEMAS_DIR, `${name}.output.json`);
-        if (!existsSync(schemaPath)) {
-            return null;
-        }
-        const content = readFileSync(schemaPath, "utf-8");
-        const schema = JSON.parse(content);
-        return resolveSchemaRefs(schema);
-    }
-    catch {
-        return null;
-    }
-}
-export function getGuardTemplates(templateName) {
-    try {
-        if (!existsSync(GUARD_TEMPLATES_PATH)) {
-            return null;
-        }
-        const content = readFileSync(GUARD_TEMPLATES_PATH, "utf-8");
-        const catalog = JSON.parse(content);
-        if (!templateName) {
-            return {
-                version: catalog.version,
-                description: catalog.description,
-                templates: (catalog.templates || []).map((t) => ({
-                    name: t.name,
-                    title: t.title,
-                    description: t.description,
-                    use_case: t.use_case,
-                })),
-                query_reference: catalog.query_reference,
-                node_return_types: catalog.node_return_types,
-            };
-        }
-        const template = (catalog.templates || []).find((t) => t.name === templateName);
-        if (!template) {
-            return null;
-        }
-        return template;
-    }
-    catch {
-        return null;
-    }
-}
-export function searchExamples(query) {
-    if (!existsSync(EXAMPLES_DIR)) {
-        return [];
-    }
-    let files;
-    try {
-        files = readdirSync(EXAMPLES_DIR);
-    }
-    catch {
-        return [];
-    }
-    const lowerQuery = query.toLowerCase().trim();
-    if (!lowerQuery) {
-        return [];
-    }
-    const results = [];
-    for (const file of files) {
-        if (!file.endsWith(".json"))
-            continue;
-        const filePath = join(EXAMPLES_DIR, file);
-        try {
-            const content = readFileSync(filePath, "utf-8");
-            const example = JSON.parse(content);
-            const title = String(example.title ?? "");
-            const description = String(example.description ?? "");
-            const tags = Array.isArray(example.tags) ? example.tags.map((t) => String(t)) : [];
-            const operationType = String(example.operation_type ?? "");
-            const industry = String(example.industry ?? "");
-            const matchedFields = [];
-            if (title.toLowerCase().includes(lowerQuery)) {
-                matchedFields.push("title");
-            }
-            if (description.toLowerCase().includes(lowerQuery)) {
-                matchedFields.push("description");
-            }
-            if (tags.some((t) => t.toLowerCase() === lowerQuery)) {
-                matchedFields.push("tags");
-            }
-            if (operationType && operationType.toLowerCase() === lowerQuery) {
-                matchedFields.push("operation_type");
-            }
-            if (industry && industry.toLowerCase() === lowerQuery) {
-                matchedFields.push("industry");
-            }
-            if (matchedFields.length > 0) {
-                results.push({
-                    file,
-                    title,
-                    description,
-                    tags,
-                    industry,
-                    operation_type: operationType,
-                    verified: example.verified === true,
-                    score: matchedFields.length,
-                    matched_fields: matchedFields,
-                });
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    results.sort((a, b) => {
-        if (b.score !== a.score)
-            return b.score - a.score;
-        return a.file.localeCompare(b.file);
-    });
-    return results;
-}
-export function getSchemaField(name, fieldPath) {
-    const schema = getSchema(name);
-    if (!schema)
-        return null;
-    const parts = fieldPath.split(".").filter(Boolean);
-    let current = schema;
-    for (const part of parts) {
-        if (!current || typeof current !== "object")
-            return null;
-        if (current.properties && part in current.properties) {
-            current = current.properties[part];
-            continue;
-        }
-        if (current.items && typeof current.items === "object") {
-            if (/^\d+$/.test(part)) {
-                current = current.items;
-                continue;
-            }
-            if (current.items.properties && part in current.items.properties) {
-                current = current.items.properties[part];
-                continue;
-            }
-        }
-        if (Array.isArray(current.oneOf) || Array.isArray(current.anyOf)) {
-            const variants = current.oneOf ?? current.anyOf;
-            for (const v of variants) {
-                if (v && typeof v === "object" && v.properties && part in v.properties) {
-                    current = v.properties[part];
-                    break;
-                }
-            }
-            continue;
-        }
-        if (part in current) {
-            current = current[part];
-            continue;
-        }
-        return null;
-    }
-    return current;
-}
-function resolveSchemaRefs(schema, visited = new Set()) {
-    if (!schema || typeof schema !== "object") {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map(item => resolveSchemaRefs(item, visited));
-    }
-    const result = {};
-    for (const [key, value] of Object.entries(schema)) {
-        if (key === "$ref" && typeof value === "string") {
-            if (value.startsWith("#")) {
-                result[key] = value;
-            }
-            else {
-                const refSchema = loadRefSchema(value, visited);
-                if (refSchema) {
-                    Object.assign(result, resolveSchemaRefs(refSchema, visited));
-                }
-            }
-        }
-        else if (typeof value === "object") {
-            result[key] = resolveSchemaRefs(value, visited);
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function loadRefSchema(ref, visited) {
-    if (ref.startsWith("#")) {
-        return null;
-    }
-    if (visited.has(ref)) {
-        return { description: `Circular reference to ${ref}` };
-    }
-    visited.add(ref);
-    try {
-        const refPath = join(SCHEMAS_DIR, ref);
-        if (!existsSync(refPath)) {
-            return null;
-        }
-        const content = readFileSync(refPath, "utf-8");
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-}
-export function searchSchemas(query) {
-    const allSchemas = listSchemas();
-    const lowerQuery = query.toLowerCase();
-    return allSchemas.filter(schema => {
-        const nameMatch = schema.name.toLowerCase().includes(lowerQuery);
-        const titleMatch = schema.title?.toLowerCase().includes(lowerQuery);
-        const descMatch = schema.description?.toLowerCase().includes(lowerQuery);
-        return nameMatch || titleMatch || descMatch;
-    });
-}
-export function listOperations() {
-    const index = getSchemaIndex();
-    if (!index)
-        return [];
-    return (index.operations || []).filter(op => op.name.startsWith("onchain_operations_"));
-}
-function writeResponseToFile(data, preferredPath) {
-    try {
-        let targetPath;
-        if (preferredPath) {
-            targetPath = resolve(process.cwd(), preferredPath);
-        }
-        else {
-            if (!existsSync(WORKSPACE_TMP_DIR)) {
-                mkdirSync(WORKSPACE_TMP_DIR, { recursive: true });
-            }
-            const timestamp = Date.now();
-            targetPath = join(WORKSPACE_TMP_DIR, `schema-${timestamp}.json`);
-        }
-        const parentDir = dirname(targetPath);
-        if (!existsSync(parentDir)) {
-            mkdirSync(parentDir, { recursive: true });
-        }
-        const jsonStr = typeof data === "string" ? data : JSON.stringify(data, null, 2);
-        writeFileSync(targetPath, jsonStr, "utf-8");
-        return targetPath;
-    }
-    catch (e) {
-        return null;
-    }
-}
-export function processSchemaQuery(request) {
-    const { action, name, query, field_path, template, output_file, object_type, params } = request;
-    if (action === "get_guard_templates") {
-        const templates = getGuardTemplates(template);
-        if (!templates) {
-            return {
-                success: false,
-                action,
-                data: null,
-                message: template
-                    ? `Guard template '${template}' not found. Omit 'template' to list all available templates.`
-                    : "Guard templates file not found. Ensure scripts/guard-templates.json exists.",
-                suggestions: [
-                    "Omit 'template' to list all available templates.",
-                    "Available template names: signer_verification, progress_node_check, order_owner_verification, service_belonging_check, reward_not_claimed, combined_reward_guard",
-                ],
-            };
-        }
-        if (output_file) {
-            const filePath = writeResponseToFile(templates, output_file);
-            if (filePath) {
-                return {
-                    success: true,
-                    action,
-                    data: null,
-                    message: `Guard template${template ? ` '${template}'` : "s"} written to file: ${filePath}`,
-                    output_file_path: filePath,
-                    suggestions: [`Use Read tool to open ${filePath}`],
-                };
-            }
-        }
-        return {
-            success: true,
-            action,
-            data: templates,
-            message: template
-                ? `Retrieved Guard template: ${template}`
-                : `Retrieved ${Array.isArray(templates.templates) ? templates.templates.length : 0} Guard templates`,
-        };
-    }
-    if (action === "get_templates") {
-        if (!template) {
-            const metas = listRegistryTemplates(object_type);
-            const counts = getTemplateCounts();
-            const data = {
-                total: metas.length,
-                filter: object_type ?? null,
-                counts_by_object_type: counts,
-                templates: metas,
-            };
-            if (output_file) {
-                const filePath = writeResponseToFile(data, output_file);
-                if (filePath) {
-                    return {
-                        success: true,
-                        action,
-                        data: null,
-                        message: `${metas.length} templates written to file: ${filePath}`,
-                        output_file_path: filePath,
-                        suggestions: [`Use Read tool to open ${filePath}`],
-                    };
-                }
-            }
-            return {
-                success: true,
-                action,
-                data,
-                message: `${metas.length} template(s)${object_type ? ` for object_type='${object_type}'` : ""} ` +
-                    `(total registry: ${Object.values(counts).reduce((a, b) => a + b, 0)} across ${TEMPLATE_OBJECT_TYPES.length} object types). ` +
-                    `Provide 'template' (id) for full detail; add 'params' (JSON string) to instantiate.`,
-            };
-        }
-        if (!params) {
-            const detail = getTemplateDetail(template);
-            if (!detail) {
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: `Template '${template}' not found in the unified registry.`,
-                    suggestions: [
-                        "Omit 'template' to list all template metadata (id + object_type + parameters).",
-                        `Filter by object_type: ${TEMPLATE_OBJECT_TYPES.join(", ")}`,
-                    ],
-                };
-            }
-            if (output_file) {
-                const filePath = writeResponseToFile(detail, output_file);
-                if (filePath) {
-                    return {
-                        success: true,
-                        action,
-                        data: null,
-                        message: `Template '${template}' detail written to file: ${filePath}`,
-                        output_file_path: filePath,
-                        suggestions: [`Use Read tool to open ${filePath}`],
-                    };
-                }
-            }
-            return {
-                success: true,
-                action,
-                data: detail,
-                message: `Template '${template}' (${detail.object_type}, ${detail.instantiable ? "instantiable" : "guidance-only"}). ` +
-                    `To instantiate, call again with 'params' = JSON object of the declared parameters.`,
-            };
-        }
-        let parsedParams;
-        try {
-            const parsed = JSON.parse(params);
-            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: `'params' must be a JSON object (e.g. '{"key":"value"}'), got ${Array.isArray(parsed) ? "array" : typeof parsed}.`,
-                };
-            }
-            parsedParams = parsed;
-        }
-        catch (e) {
-            return {
-                success: false,
-                action,
-                data: null,
-                message: `Failed to parse 'params' as JSON: ${e instanceof Error ? e.message : String(e)}`,
-                suggestions: ["Example: params='{\"whitelist\":[\"0xabc...\"]}'"],
-            };
-        }
-        const result = instantiateTemplate(template, parsedParams);
-        if (!result.ok) {
-            return {
-                success: false,
-                action,
-                data: result.guidance !== undefined ? { guidance: result.guidance } : null,
-                message: `Instantiation failed for '${template}': ${result.error}`,
-                suggestions: result.missing_params
-                    ? [`Missing required params: ${result.missing_params.join(", ")}`, "Call with 'template' only (no 'params') to see full parameter declarations."]
-                    : ["Call with 'template' only (no 'params') to see full parameter declarations."],
-            };
-        }
-        const data = {
-            object_type: result.object_type,
-            template_id: result.template_id,
-            body: result.body,
-            ...(result.notes ? { notes: result.notes } : {}),
-        };
-        if (output_file) {
-            const filePath = writeResponseToFile(data, output_file);
-            if (filePath) {
-                return {
-                    success: true,
-                    action,
-                    data: null,
-                    message: `Instantiated template '${template}' written to file: ${filePath}`,
-                    output_file_path: filePath,
-                    suggestions: [`Use Read tool to open ${filePath}`],
-                };
-            }
-        }
-        return {
-            success: true,
-            action,
-            data,
-            message: `Instantiated '${template}' (${result.object_type}). ` +
-                `Review the body against the onchain_operations schema before submitting.`,
-        };
-    }
-    if (action === "search_examples") {
-        if (!query) {
-            return {
-                success: false,
-                action,
-                data: null,
-                message: "Search query is required for 'search_examples' action",
-                suggestions: [
-                    "Provide a 'query' string (e.g. 'rental', 'guard', 'service', 'machine')",
-                    "Searchable fields: title, description, tags, operation_type, industry",
-                ],
-            };
-        }
-        const results = searchExamples(query);
-        return {
-            success: true,
-            action,
-            data: results,
-            message: `Found ${results.length} example(s) matching '${query}'`,
-            suggestions: results.length === 0
-                ? [
-                    "Try broader terms like 'service', 'machine', 'guard', 'permission'",
-                    "Try an industry name: 'rental', 'retail', 'general'",
-                    "Use 'get' action with a schema name to see the full JSON Schema",
-                ]
-                : undefined,
-        };
-    }
-    if (action === "get_tool_reference") {
-        if (name) {
-            const entry = getToolReference(name);
-            if (!entry) {
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: `Tool '${name}' not found in the tool reference.`,
-                    suggestions: [
-                        "Omit 'name' to list all tools.",
-                        `Available tools: ${TOOLS_REFERENCE.map((t) => t.name).join(", ")}`,
-                    ],
-                };
-            }
-            const sequence = getToolSequence(name);
-            return {
-                success: true,
-                action,
-                data: { tool: entry, call_sequence: sequence ?? null },
-                message: `Retrieved tool reference: ${name}`,
-            };
-        }
-        if (query) {
-            const matches = searchToolReference(query);
-            return {
-                success: true,
-                action,
-                data: { tools: matches, count: matches.length },
-                message: `Found ${matches.length} tool(s) matching '${query}'`,
-                suggestions: matches.length === 0
-                    ? ["Try a broader keyword (e.g. 'onchain', 'guard', 'schema'), or omit 'query' to list all tools."]
-                    : undefined,
-            };
-        }
-        const catalog = TOOLS_REFERENCE.map((t) => ({
-            name: t.name,
-            summary: t.summary,
-            actions: t.actions ?? [],
-            notes: t.notes ?? [],
-        }));
-        return {
-            success: true,
-            action,
-            data: { tools: catalog, count: catalog.length },
-            message: `Retrieved reference for ${catalog.length} MCP tools. Pass name='<tool>' for full detail (params, prerequisites, follow-ups).`,
-        };
-    }
-    if (action === "get_guard_design_patterns") {
-        if (name) {
-            const pattern = getGuardDesignPattern(name);
-            if (!pattern) {
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: `Guard design pattern '${name}' not found.`,
-                    suggestions: [
-                        "Omit 'name' to list the full catalog.",
-                        `Available pattern ids: ${GUARD_DESIGN_PATTERNS.map((p) => p.id).join(", ")}`,
-                    ],
-                };
-            }
-            return {
-                success: true,
-                action,
-                data: { pattern },
-                message: `Retrieved Guard design pattern: ${name}`,
-            };
-        }
-        if (query) {
-            const byHost = GUARD_DESIGN_PATTERNS.filter((p) => p.host === query);
-            const matches = byHost.length > 0
-                ? byHost
-                : GUARD_DESIGN_PATTERNS.filter((p) => p.business_requirement.toLowerCase().includes(query.toLowerCase()) ||
-                    p.logic_summary.toLowerCase().includes(query.toLowerCase()));
-            return {
-                success: true,
-                action,
-                data: { patterns: matches, count: matches.length, filtered_by: byHost.length > 0 ? "host" : "keyword" },
-                message: `Found ${matches.length} Guard design pattern(s) matching '${query}'`,
-                suggestions: matches.length === 0
-                    ? ["Filter by host: service_buy_guard, service_allocator_guard, machine_forward, progress_submission, reward_claim, repository_write, arbitration_usage, arbitration_voting, gen_passport"]
-                    : undefined,
-            };
-        }
-        const catalog = GUARD_DESIGN_PATTERNS.map((p) => ({
-            id: p.id,
-            business_requirement: p.business_requirement,
-            host: p.host,
-            data_source: p.data_source,
-            verifier_level: p.verifier_level,
-            logic_summary: p.logic_summary,
-            key_queries: p.key_queries,
-            notes: p.notes ?? [],
-        }));
-        return {
-            success: true,
-            action,
-            data: { patterns: catalog, count: catalog.length, version: GUARD_DESIGN_PATTERNS_VERSION },
-            message: `Retrieved ${catalog.length} Guard design patterns. Pass name='<pattern_id>' for full detail (witness types, mitigated risks, industries).`,
-        };
-    }
-    if (action === "get_safety_rules") {
-        return {
-            success: true,
-            action,
-            data: {
-                version: SAFETY_RULES_VERSION,
-                object_reuse_rules: OBJECT_REUSE_RULES,
-                create_vs_modify_pattern: CREATE_VS_MODIFY_PATTERN,
-                immutability_rules: IMMUTABILITY_RULES,
-                operation_type_classification: OPERATION_TYPE_CLASSIFICATION,
-                operation_class_meta: OPERATION_CLASS_META,
-                naming_conventions: NAMING_CONVENTIONS,
-            },
-            message: "Retrieved safety rule tables (reuse / immutability / operation classification / naming). " +
-                "Key points: prefer REUSING existing objects (string reference = reuse, object shape = create); " +
-                "Machine publish locks nodes/pairs/forwards, Service publish locks machine/order_allocators/arbitrations (sales stays mutable); " +
-                "Guard is CREATE-only immutable; on-chain writes require explicit user confirmation.",
-        };
-    }
-    if (!areSchemasAvailable()) {
-        return {
-            success: false,
-            action,
-            data: null,
-            message: "Schema files are not available. Please run 'npm run generate:schemas' first.",
-            suggestions: ["Run 'npm run generate:schemas' to generate schema files", "Ensure the dist/schemas directory exists"],
-        };
-    }
-    switch (action) {
-        case "list": {
-            const schemas = listSchemas();
-            return {
-                success: true,
-                action,
-                data: schemas,
-                message: `Found ${schemas.length} available schemas`,
-            };
-        }
-        case "get": {
-            if (!name) {
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: "Schema name is required for 'get' action",
-                    suggestions: ["Provide a schema name", "Use 'list' action to see available schemas"],
-                };
-            }
-            const schema = getSchema(name);
-            if (!schema) {
-                const suggestions = searchSchemas(name).slice(0, 5);
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: `Schema '${name}' not found`,
-                    suggestions: suggestions.length > 0
-                        ? suggestions.map(s => `Did you mean: ${s.name}?`)
-                        : ["Use 'list' action to see available schemas"],
-                };
-            }
-            if (output_file) {
-                const filePath = writeResponseToFile(schema, output_file);
-                if (filePath) {
-                    return {
-                        success: true,
-                        action,
-                        data: null,
-                        message: `Schema '${name}' written to file: ${filePath}`,
-                        output_file_path: filePath,
-                        suggestions: [`Use Read tool to open ${filePath}`],
-                    };
-                }
-            }
-            return {
-                success: true,
-                action,
-                data: schema,
-                message: `Retrieved schema: ${name}`,
-            };
-        }
-        case "get_field": {
-            if (!name || !field_path) {
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: "Both 'name' and 'field_path' are required for 'get_field' action",
-                    suggestions: [
-                        "Example: {action: 'get_field', name: 'onchain_operations_machine', field_path: 'data.node'}",
-                        "Use 'get' action to retrieve the full schema",
-                    ],
-                };
-            }
-            const fieldSchema = getSchemaField(name, field_path);
-            if (!fieldSchema) {
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: `Field path '${field_path}' not found in schema '${name}'`,
-                    suggestions: [
-                        "Check the field path (dot-separated, e.g. 'data.node')",
-                        "Use 'get' action to see the full schema structure",
-                    ],
-                };
-            }
-            return {
-                success: true,
-                action,
-                data: fieldSchema,
-                message: `Retrieved field '${field_path}' from schema '${name}'`,
-            };
-        }
-        case "search": {
-            if (!query) {
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: "Search query is required for 'search' action",
-                };
-            }
-            const results = searchSchemas(query);
-            return {
-                success: true,
-                action,
-                data: results,
-                message: `Found ${results.length} schemas matching '${query}'`,
-            };
-        }
-        case "list_operations": {
-            const operations = listOperations();
-            return {
-                success: true,
-                action,
-                data: operations,
-                message: `Found ${operations.length} on-chain operations`,
-            };
-        }
-        case "get_output": {
-            if (!name) {
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: "Tool name is required for 'get_output' action",
-                    suggestions: ["Provide a tool name", "Use 'list' action to see available tools and their outputPath"],
-                };
-            }
-            const schema = getOutputSchema(name);
-            if (!schema) {
-                const allSchemas = listSchemas();
-                const toolExists = allSchemas.find(s => s.name === name);
-                if (toolExists) {
-                    return {
-                        success: false,
-                        action,
-                        data: null,
-                        message: `Tool '${name}' exists but has no output schema file. The tool may not declare an outputSchema, or the schema file was not generated.`,
-                        suggestions: [`Use 'get' action with name='${name}' to retrieve its input schema`],
-                    };
-                }
-                const suggestions = searchSchemas(name).slice(0, 5);
-                return {
-                    success: false,
-                    action,
-                    data: null,
-                    message: `Tool '${name}' not found`,
-                    suggestions: suggestions.length > 0
-                        ? suggestions.map(s => `Did you mean: ${s.name}?`)
-                        : ["Use 'list' action to see available tools"],
-                };
-            }
-            if (output_file) {
-                const filePath = writeResponseToFile(schema, output_file);
-                if (filePath) {
-                    return {
-                        success: true,
-                        action,
-                        data: null,
-                        message: `Output schema '${name}' written to file: ${filePath}`,
-                        output_file_path: filePath,
-                        suggestions: [`Use Read tool to open ${filePath}`],
-                    };
-                }
-            }
-            return {
-                success: true,
-                action,
-                data: schema,
-                message: `Retrieved output schema: ${name}`,
-            };
-        }
-        default:
-            return {
-                success: false,
-                action,
-                data: null,
-                message: `Unknown action: ${action}`,
-                suggestions: ["Use 'list', 'get', 'get_field', 'get_output', 'search', 'list_operations', 'get_guard_templates', or 'search_examples'"],
-            };
-    }
-}