@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/tools/handlers/project.js

@@ -1,50 +1,290 @@
 import { queryProjects, queryProjectObjects, queryShareableObjects, queryDependencies, queryReferencedBy, queryPrePublishCheck, queryCrossProjectReferences, queryGraphStats, saveGraph, loadGraph, } from "../../project/index.js";
+import { analyzeBusinessIntent } from "../../project/business-puzzle.js";
+import { aggregateProjectRisks } from "../../project/risk-aggregator.js";
+import { generateDeploymentDoc, validateDeploymentDoc, } from "../../project/deployment-doc.js";
+import { traceSubsteps } from "../../project/substep-trace.js";
+import { strictParse } from "../../schema/index.js";
+import { ProjectOperationInputSchema } from "../../schema/project/index.js";
+import { injectEvolutionContext } from "../../knowledge/flywheel-loop.js";
+import { getExperienceFeedback } from "../../experience/index.js";
+function requireProject(v) {
+    if (!v.project) {
+        throw new Error("'project' (prefix) is required for this action");
+    }
+    if (!v.version) {
+        throw new Error("'version' is required for this action (e.g. 'v1')");
+    }
+    return { prefix: v.project, version: v.version };
+}
+function requireUserIntent(v) {
+    if (!v.user_intent) {
+        throw new Error("'user_intent' is required for analyze_intent");
+    }
+    return v.user_intent;
+}
+function requirePuzzles(v) {
+    if (!v.puzzles || Object.keys(v.puzzles).length === 0) {
+        throw new Error("'puzzles' is required for this action (obtain from analyze_intent)");
+    }
+    return v.puzzles;
+}
+function requireDeploymentInputs(v) {
+    if (!v.business_intent) {
+        throw new Error("'business_intent' is required for generate_deployment_doc");
+    }
+    if (!v.objects || v.objects.length === 0) {
+        throw new Error("'objects' is required for generate_deployment_doc");
+    }
+    if (!v.edges) {
+        throw new Error("'edges' is required for generate_deployment_doc");
+    }
+    if (!v.steps) {
+        throw new Error("'steps' is required for generate_deployment_doc");
+    }
+    return {
+        business_intent: v.business_intent,
+        objects: v.objects,
+        edges: v.edges,
+        steps: v.steps,
+    };
+}
+function requireSubsteps(v) {
+    if (!v.network) {
+        throw new Error("'network' is required for trace_substeps");
+    }
+    if (v.network !== "testnet" && v.network !== "mainnet") {
+        throw new Error("'network' must be 'testnet' or 'mainnet'");
+    }
+    if (!v.substeps || v.substeps.length === 0) {
+        throw new Error("'substeps' is required for trace_substeps");
+    }
+    return {
+        network: v.network,
+        substeps: v.substeps,
+    };
+}
+async function handleAnalyzeIntent(validated) {
+    const { prefix, version } = requireProject(validated);
+    const userIntent = requireUserIntent(validated);
+    const result = analyzeBusinessIntent({
+        user_intent: userIntent,
+        project_name: `${prefix}_${version}`,
+        industry: validated.industry,
+        target_objects: validated.target_objects,
+    });
+    const industry = validated.industry ?? "general";
+    let evolutionContext;
+    let experienceFeedback;
+    try {
+        evolutionContext = injectEvolutionContext(undefined, industry);
+    }
+    catch {
+        evolutionContext = undefined;
+    }
+    try {
+        experienceFeedback = getExperienceFeedback("analyze_intent", { user_intent: userIntent, industry, target_objects: validated.target_objects }, `project:analyze_intent`);
+    }
+    catch {
+        experienceFeedback = undefined;
+    }
+    return {
+        action: "analyze_intent",
+        intent_parsed: result.intent_parsed,
+        puzzles: result.puzzles,
+        overall_completeness: result.overall_completeness,
+        next_step: result.next_step,
+        warnings: result.warnings,
+        evolution_context: evolutionContext,
+        experience_feedback: experienceFeedback,
+    };
+}
+async function handleAggregateRisks(validated) {
+    const { prefix, version } = requireProject(validated);
+    const puzzles = requirePuzzles(validated);
+    const result = aggregateProjectRisks({
+        project_prefix: prefix,
+        version: version,
+        industry: validated.industry,
+        puzzles,
+        severity_threshold: validated.severity_threshold,
+        user_confirmed_high_risks: validated.user_confirmed_high_risks,
+    });
+    const hasCritical = result.severity_summary.CRITICAL > 0;
+    const unconfirmedHigh = result.findings.filter((r) => r.severity === "HIGH").length;
+    return {
+        action: "aggregate_risks",
+        namespace: result.namespace,
+        findings: result.findings,
+        severity_summary: result.severity_summary,
+        status: result.status,
+        pending_confirmations: result.pending_confirmations,
+        calibrated_at: result.calibrated_at,
+        warnings: result.warnings,
+        can_proceed: !hasCritical,
+        user_action_required: hasCritical
+            ? `Fix ${result.severity_summary.CRITICAL} CRITICAL risk(s) before proceeding`
+            : unconfirmedHigh > 0
+                ? `Review ${unconfirmedHigh} HIGH risk(s). You may proceed at your own risk.`
+                : "All risks reviewed. You may proceed.",
+    };
+}
+async function handleGenerateDeploymentDoc(validated) {
+    const { prefix, version } = requireProject(validated);
+    const required = requireDeploymentInputs(validated);
+    const docInput = {
+        project_prefix: prefix,
+        version: version,
+        business_intent: required.business_intent,
+        industry: validated.industry ?? "general",
+        author: validated.author,
+        objects: required.objects,
+        edges: required.edges,
+        steps: required.steps,
+        scenarios: validated.scenarios,
+        risk_status: validated.risk_status,
+        risk_critical_count: validated.risk_critical_count,
+        risk_high_count: validated.risk_high_count,
+    };
+    const markdown = generateDeploymentDoc(docInput);
+    const generatedAt = new Date().toISOString();
+    const shouldRunScanner = validated.run_scanner !== false;
+    let validationResult;
+    if (shouldRunScanner) {
+        const validation = validateDeploymentDoc(docInput);
+        validationResult = {
+            valid: validation.valid,
+            checks: validation.checks,
+            errors: validation.errors,
+        };
+    }
+    const errorCount = validationResult
+        ? validationResult.checks.filter((c) => c.status === "FAIL").length
+        : 0;
+    const warningCount = validationResult
+        ? validationResult.checks.filter((c) => c.status === "WARN").length
+        : 0;
+    return {
+        action: "generate_deployment_doc",
+        markdown,
+        meta: {
+            project_prefix: prefix,
+            version: version,
+            generated_at: generatedAt,
+            object_count: required.objects.length,
+            step_count: required.steps.length,
+        },
+        validation: validationResult,
+        can_proceed: errorCount === 0,
+        user_action_required: errorCount > 0
+            ? `Fix ${errorCount} D-error(s) before deploying`
+            : warningCount > 0
+                ? `${warningCount} D-warning(s) found. You may proceed at your own risk.`
+                : "Deployment document ready. You may proceed to stage 5.",
+    };
+}
+async function handleTraceSubsteps(validated) {
+    const { prefix, version } = requireProject(validated);
+    const { network, substeps } = requireSubsteps(validated);
+    const result = traceSubsteps({
+        project_prefix: prefix,
+        version: version,
+        network: network,
+        substeps,
+    });
+    const hasFailedSubstep = substeps.some((s) => s.status === "FAILED");
+    const canProceed = result.coherent && !hasFailedSubstep;
+    const issueParts = [];
+    if (result.dangling_inputs.length > 0) {
+        issueParts.push(`${result.dangling_inputs.length} dangling inputs`);
+    }
+    if (result.circular_refs.length > 0) {
+        issueParts.push(`${result.circular_refs.length} circular refs`);
+    }
+    if (result.missing_outputs.length > 0) {
+        issueParts.push(`${result.missing_outputs.length} missing outputs`);
+    }
+    if (result.cross_step_breaks.length > 0) {
+        issueParts.push(`${result.cross_step_breaks.length} cross-step breaks`);
+    }
+    if (hasFailedSubstep) {
+        const failedCount = substeps.filter((s) => s.status === "FAILED").length;
+        issueParts.push(`${failedCount} failed substep(s)`);
+    }
+    return {
+        action: "trace_substeps",
+        namespace: result.namespace,
+        network: result.network,
+        coherent: result.coherent,
+        dangling_inputs: result.dangling_inputs,
+        circular_refs: result.circular_refs,
+        missing_outputs: result.missing_outputs,
+        cross_step_breaks: result.cross_step_breaks,
+        step_details: result.step_details,
+        topological_order: result.topological_order,
+        d10_check: result.d10_check,
+        can_proceed: canProceed,
+        user_action_required: issueParts.length > 0
+            ? `Fix: ${issueParts.join(", ")}`
+            : "All substeps passed. Deployment complete.",
+    };
+}
 export async function handleProjectOperation(args) {
-    const action = args.action;
-    const project = args.project;
-    const object = args.object;
+    const validated = strictParse(ProjectOperationInputSchema, args, "project_operation input");
+    const { action } = validated;
     let result;
     switch (action) {
         case "list_projects":
-            result = await queryProjects();
+            result = { action: "list_projects", items: await queryProjects() };
             break;
         case "list_objects":
-            if (!project)
+            if (!validated.project)
                 throw new Error("'project' param is required for list_objects");
-            result = await queryProjectObjects(project);
+            result = { action: "list_objects", items: await queryProjectObjects(validated.project) };
             break;
         case "shareable":
-            result = await queryShareableObjects();
+            result = { action: "shareable", items: await queryShareableObjects() };
             break;
         case "dependencies":
-            if (!object)
+            if (!validated.object)
                 throw new Error("'object' param is required for dependencies");
-            result = queryDependencies(object);
+            result = { action: "dependencies", items: queryDependencies(validated.object) };
             break;
         case "referenced_by":
-            if (!object)
+            if (!validated.object)
                 throw new Error("'object' param is required for referenced_by");
-            result = queryReferencedBy(object);
+            result = { action: "referenced_by", items: queryReferencedBy(validated.object) };
             break;
         case "pre_publish_check":
-            if (!object)
+            if (!validated.object)
                 throw new Error("'object' param is required for pre_publish_check");
-            result = { warnings: queryPrePublishCheck(object) };
+            result = { action: "pre_publish_check", warnings: queryPrePublishCheck(validated.object) };
             break;
         case "cross_project_refs":
-            result = queryCrossProjectReferences();
+            result = { action: "cross_project_refs", items: queryCrossProjectReferences() };
             break;
         case "graph_stats":
-            result = queryGraphStats();
+            result = { action: "graph_stats", stats: queryGraphStats() };
             break;
         case "save_graph":
-            result = { saved: true, path: saveGraph() };
+            result = { action: "save_graph", saved: true, path: saveGraph() };
             break;
         case "load_graph":
-            result = { loaded: loadGraph() };
+            result = { action: "load_graph", loaded: loadGraph() };
+            break;
+        case "analyze_intent":
+            result = await handleAnalyzeIntent(validated);
+            break;
+        case "aggregate_risks":
+            result = await handleAggregateRisks(validated);
+            break;
+        case "generate_deployment_doc":
+            result = await handleGenerateDeploymentDoc(validated);
+            break;
+        case "trace_substeps":
+            result = await handleTraceSubsteps(validated);
             break;
         default:
-            throw new Error(`Unknown project_operation action: ${action}`);
+            throw new Error(`Unknown project_operation action: ${String(action)}`);
     }
     return {
         content: [{ type: "text", text: JSON.stringify({ result }) }],

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

@@ -1,5 +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>;
+export declare function handleWatchQueryOperations(args: unknown): Promise<ToolDispatchResult>;
+export declare function handleOnchainTableData(args: unknown): Promise<ToolDispatchResult>;
+export declare function handleOnchainEvents(args: unknown): Promise<ToolDispatchResult>;
+export declare function handleWowokInfo(args: unknown): Promise<ToolDispatchResult>;

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

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

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

@@ -1,20 +1,23 @@
 import { processSchemaQuery, } from "../../schema-query/index.js";
+import { strictParse } from "../../schema/index.js";
+import { SchemaQueryInputSchema } from "../../schema/schema-query/index.js";
 export async function handleSchemaQuery(args) {
+    const validated = strictParse(SchemaQueryInputSchema, args, "schema_query input");
     const request = {
-        action: args.action,
-        name: args.name,
-        query: args.query,
+        action: validated.action,
+        name: validated.name,
+        query: validated.query,
     };
     const response = processSchemaQuery(request);
     let textContent = response.message;
     const data = response.data;
     if (response.success && data) {
-        switch (args.action) {
+        switch (request.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}`;
+                        textContent += `\n  • ${item.name ?? ""}`;
                         if (item.title) {
                             textContent += ` - ${item.title}`;
                         }
@@ -29,7 +32,7 @@ export async function handleSchemaQuery(args) {
                 if (Array.isArray(data) && data.length > 0) {
                     textContent += "\n\nOn-chain operation schemas:\n";
                     for (const item of data) {
-                        textContent += `\n  • ${item.name}`;
+                        textContent += `\n  • ${item.name ?? ""}`;
                         if (item.title) {
                             textContent += ` - ${item.title}`;
                         }
@@ -41,26 +44,22 @@ export async function handleSchemaQuery(args) {
                 }
                 break;
             case "get":
-                if (data) {
-                    textContent += "\n\n## JSON Schema\n\n";
-                    textContent += "```json\n";
-                    textContent += JSON.stringify(data, null, 2);
-                    textContent += "\n```\n";
-                }
+                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";
-                }
+                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`;
+                    textContent += `\n\nFound ${data.length} schemas matching '${request.query ?? ""}':\n`;
                     for (const item of data) {
-                        textContent += `\n  • ${item.name}`;
+                        textContent += `\n  • ${item.name ?? ""}`;
                         if (item.title) {
                             textContent += ` - ${item.title}`;
                         }
@@ -74,6 +73,8 @@ export async function handleSchemaQuery(args) {
                     textContent += "\n\nNo schemas found. Try 'list' to browse all available schemas, or use a broader search term.";
                 }
                 break;
+            default:
+                throw new Error(`Unknown schema_query action: ${String(request.action)}`);
         }
     }
     if (response.suggestions && response.suggestions.length > 0) {

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

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

package/dist/tools/handlers/trust.js

@@ -140,8 +140,8 @@ export async function handleTrustScore(args) {
     const orderAmount = validated.order_amount != null
         ? BigInt(validated.order_amount)
         : salePriceRaw;
-    let riskScore = undefined;
-    let infoPuzzle = undefined;
+    let riskScore;
+    let infoPuzzle;
     if (depth === "evaluate" || depth === "preorder") {
         const puzzleRaw = buildPuzzleRawData(serviceObj, orderAmount, { score: trustScore.score, level: trustScore.level }, undefined);
         infoPuzzle = assembleInfoPuzzle(validated.service, puzzleRaw, depth);

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

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

package/dist/tools/handlers/wip.js

@@ -21,7 +21,7 @@ export async function handleWipOperations(args) {
         }
         case "wip2html": {
             const result = await wip2html(validated.wipPath, validated.options);
-            let output = { type: "wip2html" };
+            const output = { type: "wip2html" };
             if (typeof result === "string") {
                 output.html = result;
             }

package/dist/tools/index.d.ts

@@ -2,7 +2,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { ToolEntry, ToolDispatchResult, DispatchOptions } from "./types.js";
 export declare const TOOL_REGISTRY: ToolEntry[];
 export declare const TOOL_REGISTRY_MAP: Map<string, ToolEntry>;
-export declare function dispatchToolCall(name: string, args: any, options?: DispatchOptions): Promise<ToolDispatchResult>;
+export declare function dispatchToolCall(name: string, args: unknown, options?: DispatchOptions): Promise<ToolDispatchResult>;
 export interface ToolListEntry {
     name: string;
     title: string;

package/dist/tools/index.js

@@ -3,6 +3,7 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
+import { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const SCHEMA_DIR_CANDIDATES = [
@@ -10,7 +11,7 @@ const SCHEMA_DIR_CANDIDATES = [
     join(__dirname, "..", "..", "dist", "schemas"),
 ];
 const preGeneratedSchemaCache = new Map();
-import { wrapHandlerWithErrorShape, statusErrorShape, operationErrorShape, strictStatusErrorShape, } from "./wrap.js";
+import { wrapHandlerWithErrorShape, statusErrorShape, operationErrorShape, strictStatusErrorShape, dispatchWithHarness, } from "./wrap.js";
 import { withTelemetry } from "../telemetry/index.js";
 import { handleOnchainOperations } from "./handlers/onchain.js";
 import { handleAccountOperation, handleMarkOperation, handleInfoOperation } from "./handlers/local.js";
@@ -24,7 +25,7 @@ import { handleProjectOperation } from "./handlers/project.js";
 import { handleConfigOperation } from "./handlers/config.js";
 import { handleTrustScore } from "./handlers/trust.js";
 import { applyOnchainRules } from "./rules-hook.js";
-import { createToolMeta, OnchainOperationsSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, WipOperationsSchema, MessengerOperationInputSchema, Guard2File_InputSchema, MachineNode2File_InputSchema, WatchQueryOperationsSchema, OnchainTableDataSchema, OnchainEventsInputSchema, ProtocolInfoQuerySchema, SchemaQueryInputSchema, BridgeOperationsSchema, ProjectOperationInputSchema, ConfigOperationInputSchema, TrustScoreInputSchema, CallOutputSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, Guard2File_OutputWrappedSchema, MachineNode2File_OutputWrappedSchema, OnchainTableDataResultSchema, OnchainEventsResultSchema, ProtocolInfoResultSchema, SchemaQueryOutputSchema, BridgeCallOutputSchema, ProjectOperationOutputSchema, ConfigOperationOutputSchema, TrustScoreOutputSchema, } from "../schema/index.js";
+import { createToolMeta, OnchainOperationsSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, WipOperationsSchema, MessengerOperationInputSchema, Guard2File_InputSchema, MachineNode2File_InputSchema, WatchQueryOperationsSchema, WatchQueryOperationsResultSchema, OnchainTableDataSchema, OnchainEventsInputSchema, ProtocolInfoQuerySchema, SchemaQueryInputSchema, BridgeOperationsSchema, ProjectOperationInputSchema, ConfigOperationInputSchema, TrustScoreInputSchema, CallOutputSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, Guard2File_OutputWrappedSchema, MachineNode2File_OutputWrappedSchema, OnchainTableDataResultSchema, OnchainEventsResultSchema, ProtocolInfoResultSchema, SchemaQueryOutputSchema, BridgeCallOutputSchema, ProjectOperationOutputSchema, ConfigOperationOutputSchema, TrustScoreOutputSchema, } from "../schema/index.js";
 export const TOOL_REGISTRY = [
     {
         name: "onchain_operations",
@@ -152,10 +153,7 @@ export const TOOL_REGISTRY = [
                 + "For dynamic table data queries (pagination, table items), use the 'onchain_table_data' tool.\n\n"
                 + "💡 Schema hint: Use schema_query with action='get' and name='query_toolkit' to retrieve the exact parameter schema with all query types and field definitions.",
             inputSchema: WatchQueryOperationsSchema,
-            outputSchema: z.object({
-                result: z.unknown().describe("Query result — type depends on query_type. Local queries return arrays (MarkData[], AccountData[], InfoData[], TokenTypeInfo[]). account_balance returns { address, balance? | coin? }. Onchain queries return typed objects or undefined. onchain_received returns ReceivedBalance | ReceivedNormal[]."),
-                semantic: z.unknown().optional().describe("Business semantic summary for the query operation"),
-            }),
+            outputSchema: WatchQueryOperationsResultSchema,
             annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
             _meta: createToolMeta("query", ["watch", "query", "on-chain", "local", "events", "objects", "tokens", "balance", "profile"]),
         },
@@ -360,8 +358,9 @@ export async function dispatchToolCall(name, args, options) {
         if (ruleResult)
             return ruleResult;
     }
+    const harnessWrapped = dispatchWithHarness(entry.handler, name);
     const timeoutMs = entry.timeoutMs ?? 60000;
-    const wrapped = wrapHandlerWithErrorShape(entry.handler, timeoutMs, name, entry.errorShapeBuilder);
+    const wrapped = wrapHandlerWithErrorShape(harnessWrapped, timeoutMs, name, entry.errorShapeBuilder);
     return wrapped(args);
 }
 function zodToJsonSchemaSafe(schema, name) {
@@ -390,7 +389,7 @@ function resolveSchemaRefs(schema) {
         const parts = path.slice(2).split("/");
         let target = schema;
         for (const part of parts) {
-            if (target == null || typeof target !== "object" || Array.isArray(target)) {
+            if (target == null || typeof target !== "object") {
                 return null;
             }
             target = target[part];
@@ -455,6 +454,25 @@ function loadPreGeneratedSchema(toolName) {
     }
     return null;
 }
+const preGeneratedOutputSchemaCache = new Map();
+function loadPreGeneratedOutputSchema(toolName) {
+    const cached = preGeneratedOutputSchemaCache.get(toolName);
+    if (cached)
+        return cached;
+    for (const dir of SCHEMA_DIR_CANDIDATES) {
+        try {
+            const schemaPath = join(dir, `${toolName}.output.json`);
+            const raw = readFileSync(schemaPath, "utf-8");
+            const schema = JSON.parse(raw);
+            const resolved = resolveSchemaRefs(schema);
+            preGeneratedOutputSchemaCache.set(toolName, resolved);
+            return resolved;
+        }
+        catch {
+        }
+    }
+    return null;
+}
 export function listTools() {
     return TOOL_REGISTRY.map(entry => {
         const preGenerated = loadPreGeneratedSchema(entry.name);
@@ -476,4 +494,33 @@ export function registerAllTools(server) {
         const wrapped = wrapHandlerWithErrorShape(handlerWithRules, timeoutMs, entry.name, entry.errorShapeBuilder);
         server.registerTool(entry.name, entry.config, withTelemetry(entry.name, wrapped));
     }
+    overrideToolsListHandler(server);
+}
+function overrideToolsListHandler(server) {
+    server.server.setRequestHandler(ListToolsRequestSchema, () => ({
+        tools: TOOL_REGISTRY.map(entry => {
+            const rawSchema = loadPreGeneratedSchema(entry.name) ??
+                zodToJsonSchemaSafe(entry.config.inputSchema, entry.name);
+            const inputSchema = ensureObjectType(rawSchema);
+            const toolDef = {
+                name: entry.name,
+                title: entry.config.title,
+                description: entry.config.description,
+                inputSchema,
+                annotations: entry.config.annotations,
+                _meta: entry.config._meta,
+            };
+            if (entry.config.outputSchema) {
+                const outputSchema = loadPreGeneratedOutputSchema(entry.name) ??
+                    zodToJsonSchemaSafe(entry.config.outputSchema, `${entry.name}_output`);
+                toolDef.outputSchema = outputSchema;
+            }
+            return toolDef;
+        }),
+    }));
+}
+function ensureObjectType(schema) {
+    if (schema.type === "object")
+        return schema;
+    return { ...schema, type: "object" };
 }

package/dist/tools/rules-hook.d.ts

@@ -1,2 +1,2 @@
 import type { ToolDispatchResult } from "./types.js";
-export declare function applyOnchainRules(args: any): ToolDispatchResult | null;
+export declare function applyOnchainRules(args: unknown): ToolDispatchResult | null;

package/dist/tools/rules-hook.js

@@ -10,11 +10,12 @@ export function applyOnchainRules(args) {
         return null;
     }
     const env = getEnvConfig(validated.env);
-    const gateResult = buildPendingConfirmation(validated.operation_type, validated.data, env);
+    const data = 'data' in validated ? validated.data : undefined;
+    const gateResult = buildPendingConfirmation(validated.operation_type, data, env);
     if (gateResult.structuredContent) {
         return gateResult;
     }
-    const constraintViolations = validateOperation(validated.operation_type, validated.data);
+    const constraintViolations = validateOperation(validated.operation_type, data);
     if (hasBlockingViolations(constraintViolations)) {
         return buildConstraintError(validated.operation_type, constraintViolations);
     }

package/dist/tools/shared.d.ts

@@ -1,29 +1,20 @@
 import { validateOperation, hasBlockingViolations, getWarningViolations, type ConstraintViolation } from "../knowledge/index.js";
 import { classifyError, type SemanticContext } from "../schema/call/semantic.js";
+import type { ToolDispatchResult } from "./types.js";
 export declare function withHarness(base: SemanticContext, operation: string, intent: string): SemanticContext;
-export interface LocalHandlerConfig {
-    schema: import("zod").ZodTypeAny;
-    operationFn: (input: any) => Promise<any>;
+import type { z } from "zod";
+import type { CallEnv } from "../schema/call/base.js";
+export interface LocalHandlerConfig<S extends z.ZodTypeAny> {
+    schema: S;
+    operationFn: (input: z.infer<S>) => Promise<unknown>;
     parseLabel: string;
-    buildContext: (validated: any) => SemanticContext;
+    buildContext: (validated: z.infer<S>) => SemanticContext;
 }
-export declare function wrapLocalHandler(config: LocalHandlerConfig): (args: any) => Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-    structuredContent: {
-        result: any;
-        semantic: any;
-    };
-}>;
-export declare function buildPendingConfirmation(operation_type: string, data: any, env: any): {
-    content: any[];
-    structuredContent: any;
+export declare function wrapLocalHandler<S extends z.ZodTypeAny>(config: LocalHandlerConfig<S>): (args: unknown) => Promise<ToolDispatchResult>;
+export declare function buildPendingConfirmation(operation_type: string, data: unknown, env: CallEnv | undefined): ToolDispatchResult | {
+    content: never[];
+    structuredContent: null;
 };
-export declare function buildConstraintError(operation_type: string, violations: ConstraintViolation[]): {
-    content: any[];
-    structuredContent: any;
-};
-export declare function buildClassifiedErrorResult(base: Record<string, any>, error: string, classified: ReturnType<typeof classifyError>): Record<string, any>;
+export declare function buildConstraintError(operation_type: string, violations: ConstraintViolation[]): ToolDispatchResult;
+export declare function buildClassifiedErrorResult(base: Record<string, unknown>, error: string, classified: ReturnType<typeof classifyError>): Record<string, unknown>;
 export { validateOperation, hasBlockingViolations, getWarningViolations, type ConstraintViolation, };