@wowok/agent-mcp 2.3.18 → 2.4.3

package/dist/tools/shared.js

@@ -0,0 +1,130 @@
+import { confirmGate } from "../safety/confirm-gate.js";
+import { renderPreview } from "../safety/preview.js";
+import { validateOperation, hasBlockingViolations, getWarningViolations, } from "../knowledge/index.js";
+import { getHarness } from "../harness/index.js";
+import { isEnabled as isRuntimeEnabled } from "../config/index.js";
+import { classifyError, buildDataSemantic, } from "../schema/call/semantic.js";
+import { strictParse } from "../schema/index.js";
+export function withHarness(base, operation, intent) {
+    if (!isRuntimeEnabled("harness"))
+        return base;
+    try {
+        const harness = getHarness();
+        const expected = harness.expect(operation, intent, base.operation_type, base.data);
+        return {
+            ...base,
+            harness,
+            expected,
+            operation_id: `${base.operation_type}_${Date.now()}`,
+        };
+    }
+    catch {
+        return base;
+    }
+}
+export function wrapLocalHandler(config) {
+    const { schema, operationFn, parseLabel, buildContext } = config;
+    return async (args) => {
+        let validated;
+        try {
+            validated = strictParse(schema, args, parseLabel);
+            const result = await operationFn(validated);
+            const ctx = buildContext(validated);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+                structuredContent: {
+                    result: {
+                        status: "success",
+                        data: result,
+                    },
+                    semantic: buildDataSemantic(result, ctx),
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const ctx = validated ? buildContext(validated) : undefined;
+            const classified = classifyError(errorMessage);
+            const errorResult = {
+                status: "error",
+                error: errorMessage,
+            };
+            if (classified.error_code !== undefined)
+                errorResult.error_code = classified.error_code;
+            if (classified.retryable !== undefined)
+                errorResult.retryable = classified.retryable;
+            if (classified.recovery_hint !== undefined)
+                errorResult.recovery_hint = classified.recovery_hint;
+            return {
+                content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                structuredContent: {
+                    result: errorResult,
+                    semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
+                },
+            };
+        }
+    };
+}
+export function buildPendingConfirmation(operation_type, data, env) {
+    const gate = confirmGate(operation_type, data, env, env?.user_intent_phrases);
+    if (gate.pass)
+        return { content: [], structuredContent: null };
+    const preview = gate.preview;
+    const rendered = renderPreview(preview);
+    const output = {
+        message: rendered,
+        result: {
+            type: "pending_confirmation",
+            preview,
+            rule_id: gate.rule_id,
+        },
+        semantic: {
+            intent: `${operation_type}_awaiting_confirmation`,
+            status: "pending_input",
+            summary: `Operation blocked by ConfirmGate (${gate.level}). Review the preview and re-call with env.confirmed=true to proceed.`,
+            next_actions: [
+                {
+                    action: "confirm: re-call the SAME operation with env.confirmed=true",
+                    reason: `ConfirmGate rule '${gate.rule_id}' matched. The operation was NOT executed.`,
+                    tool: "onchain_operations",
+                    priority: "required",
+                },
+            ],
+            warnings: preview.warnings ?? [],
+        },
+    };
+    return {
+        content: [{ type: "text", text: rendered }],
+        structuredContent: output,
+    };
+}
+export function buildConstraintError(operation_type, violations) {
+    const errors = violations.filter((v) => v.severity === "error");
+    const errorList = errors.map((v) => `  • [${v.field}] ${v.message}`).join("\n");
+    const message = `Pre-call constraint violations for '${operation_type}':\n${errorList}\n\nFix the listed field(s) and retry.`;
+    const output = {
+        message,
+        result: {
+            type: "error",
+            error: message,
+            error_code: "invalid_parameter",
+            retryable: false,
+            recovery_hint: "Review the constraint violations above and correct the corresponding fields.",
+        },
+    };
+    return {
+        content: [{ type: "text", text: message }],
+        structuredContent: output,
+    };
+}
+export function buildClassifiedErrorResult(base, error, classified) {
+    const result = { ...base, error };
+    if (classified.error_code !== undefined)
+        result.error_code = classified.error_code;
+    if (classified.retryable !== undefined)
+        result.retryable = classified.retryable;
+    if (classified.recovery_hint !== undefined)
+        result.recovery_hint = classified.recovery_hint;
+    return result;
+}
+export { validateOperation, hasBlockingViolations, getWarningViolations, };

package/dist/tools/types.d.ts

@@ -0,0 +1,35 @@
+import type { z } from "zod";
+import type { classifyError } from "../schema/call/semantic.js";
+import type { SemanticContext } from "../schema/call/semantic.js";
+export interface ToolConfig {
+    title: string;
+    description: string;
+    inputSchema: z.ZodTypeAny;
+    outputSchema?: z.ZodTypeAny;
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    _meta?: any;
+}
+export type ErrorShapeBuilder = (error: string, classified: ReturnType<typeof classifyError>, ctx: SemanticContext) => Record<string, any>;
+export interface ToolDispatchResult {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: any;
+}
+export interface ToolEntry {
+    name: string;
+    handler: (args: any) => Promise<ToolDispatchResult>;
+    config: ToolConfig;
+    errorShapeBuilder?: ErrorShapeBuilder;
+    timeoutMs?: number;
+    applyRules?: (args: any) => ToolDispatchResult | null;
+}
+export interface DispatchOptions {
+    skipRules?: boolean;
+}

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/wrap.d.ts

@@ -0,0 +1,6 @@
+import type { ErrorShapeBuilder } from "./types.js";
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs?: number, operationName?: string): Promise<T>;
+export declare function wrapHandlerWithErrorShape(handler: (args: any) => Promise<any>, timeoutMs: number, toolName: string, errorShapeBuilder?: ErrorShapeBuilder): (args: any) => Promise<any>;
+export declare const statusErrorShape: ErrorShapeBuilder;
+export declare const operationErrorShape: ErrorShapeBuilder;
+export declare const strictStatusErrorShape: ErrorShapeBuilder;

package/dist/tools/wrap.js

@@ -0,0 +1,55 @@
+import { classifyError, buildDataSemantic, } from "../schema/call/semantic.js";
+import { buildClassifiedErrorResult } from "./shared.js";
+export function withTimeout(promise, timeoutMs = 30000, operationName = "operation") {
+    let timer;
+    return Promise.race([
+        promise.finally(() => {
+            if (timer)
+                clearTimeout(timer);
+        }),
+        new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                let hint = "";
+                if (operationName.includes("messenger")) {
+                    hint = " This is a messenger network operation. Possible causes: " +
+                        "(1) messenger server (https://messenger.wowok.net) unreachable, " +
+                        "(2) no messenger-enabled account configured (use account_operation to set messenger name), " +
+                        "(3) network connectivity issue. " +
+                        "Ensure you have a messenger-enabled account and the server is reachable.";
+                }
+                reject(new Error(`Operation '${operationName}' timed out after ${timeoutMs}ms.${hint}`));
+            }, timeoutMs);
+        }),
+    ]);
+}
+export function wrapHandlerWithErrorShape(handler, timeoutMs, toolName, errorShapeBuilder) {
+    return async (args) => {
+        try {
+            return await withTimeout(handler(args), timeoutMs, toolName);
+        }
+        catch (error) {
+            if (errorShapeBuilder) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const classified = classifyError(errorMessage);
+                const ctx = { operation_type: toolName, data: args };
+                const structuredContent = errorShapeBuilder(errorMessage, classified, ctx);
+                return {
+                    content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    structuredContent,
+                };
+            }
+            throw error;
+        }
+    };
+}
+export const statusErrorShape = (error, classified, ctx) => ({
+    result: buildClassifiedErrorResult({ status: "error" }, error, classified),
+    semantic: buildDataSemantic(undefined, ctx, true, error),
+});
+export const operationErrorShape = (error, classified, ctx) => ({
+    result: buildClassifiedErrorResult({ operation: "error" }, error, classified),
+    semantic: buildDataSemantic(undefined, ctx, true, error),
+});
+export const strictStatusErrorShape = (error, _classified, _ctx) => ({
+    result: { status: "error", error },
+});

package/package.json

@@ -1,11 +1,25 @@
 {
   "name": "@wowok/agent-mcp",
-  "version": "2.3.18",
+  "version": "2.4.3",
   "description": "Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "node",
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./rules": {
+      "types": "./dist/rules.d.ts",
+      "import": "./dist/rules.js"
+    },
+    "./tools": {
+      "types": "./dist/tools/index.d.ts",
+      "import": "./dist/tools/index.js"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/wowok-ai/agent.git"
@@ -36,16 +50,16 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@wowok/wowok": "2.3.18",
+    "@wowok/wowok": "2.4.3",
     "lodash": "^4.18.1",
-    "zod": "^3.25.76"
+    "zod": "^3.25.76",
+    "zod-to-json-schema": "^3.25.2"
   },
   "devDependencies": {
     "@types/node": "^22.19.19",
     "tsx": "^4.21.0",
     "typescript": "^5.8.2",
-    "vitest": "^2.1.0",
-    "zod-to-json-schema": "^3.25.2"
+    "vitest": "^2.1.0"
   },
   "scripts": {
     "clean": "rm -rf dist",