@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/tools/types.d.ts

@@ -12,23 +12,23 @@ export interface ToolConfig {
         idempotentHint?: boolean;
         openWorldHint?: boolean;
     };
-    _meta?: any;
+    _meta?: Record<string, unknown>;
 }
-export type ErrorShapeBuilder = (error: string, classified: ReturnType<typeof classifyError>, ctx: SemanticContext) => Record<string, any>;
+export type ErrorShapeBuilder = (error: string, classified: ReturnType<typeof classifyError>, ctx: SemanticContext) => Record<string, unknown>;
 export interface ToolDispatchResult {
     content: {
         type: "text";
         text: string;
     }[];
-    structuredContent: any;
+    structuredContent: Record<string, unknown> | undefined;
 }
 export interface ToolEntry {
     name: string;
-    handler: (args: any) => Promise<ToolDispatchResult>;
+    handler: (args: unknown) => Promise<ToolDispatchResult>;
     config: ToolConfig;
     errorShapeBuilder?: ErrorShapeBuilder;
     timeoutMs?: number;
-    applyRules?: (args: any) => ToolDispatchResult | null;
+    applyRules?: (args: unknown) => ToolDispatchResult | null;
 }
 export interface DispatchOptions {
     skipRules?: boolean;

package/dist/tools/wrap.d.ts

@@ -1,6 +1,14 @@
-import type { ErrorShapeBuilder } from "./types.js";
+import type { ErrorShapeBuilder, ToolDispatchResult } 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 function wrapHandlerWithErrorShape(handler: (args: unknown) => Promise<ToolDispatchResult>, timeoutMs: number, toolName: string, errorShapeBuilder?: ErrorShapeBuilder): (args: unknown) => Promise<ToolDispatchResult>;
 export declare const statusErrorShape: ErrorShapeBuilder;
 export declare const operationErrorShape: ErrorShapeBuilder;
 export declare const strictStatusErrorShape: ErrorShapeBuilder;
+export type HarnessHookPhase = "pre_call" | "post_call" | "pre_publish" | "pre_sign";
+export interface HarnessHookContext {
+    toolName: string;
+    args: unknown;
+    result?: ToolDispatchResult;
+    error?: unknown;
+}
+export declare function dispatchWithHarness(handler: (args: unknown) => Promise<ToolDispatchResult>, toolName: string): (args: unknown) => Promise<ToolDispatchResult>;

package/dist/tools/wrap.js

@@ -1,5 +1,9 @@
 import { classifyError, buildDataSemantic, } from "../schema/call/semantic.js";
 import { buildClassifiedErrorResult } from "./shared.js";
+import { shouldRunLightHooks, shouldRunHeavyHooks, recordOperationFailure, } from "../harness/auto-escalation.js";
+import { getHarness } from "../harness/index.js";
+import { recordOperationOutcome } from "../experience/index.js";
+import { recordIndustrySignal } from "../knowledge/flywheel-loop.js";
 export function withTimeout(promise, timeoutMs = 30000, operationName = "operation") {
     let timer;
     return Promise.race([
@@ -53,3 +57,211 @@ export const operationErrorShape = (error, classified, ctx) => ({
 export const strictStatusErrorShape = (error, _classified, _ctx) => ({
     result: { status: "error", error },
 });
+export function dispatchWithHarness(handler, toolName) {
+    return async (args) => {
+        const harnessWarnings = [];
+        const harness = getHarness();
+        const runLight = shouldRunLightHooks();
+        const runHeavy = shouldRunHeavyHooks();
+        const isPublishOp = runHeavy && isPublishOperation(toolName, args);
+        const isSignOp = runHeavy && isSignOperation(toolName, args);
+        let expectedResult;
+        if (runLight) {
+            try {
+                const operationType = extractOperationType(toolName, args);
+                const intent = extractIntent(toolName, args);
+                if (operationType && intent) {
+                    expectedResult = harness.expect(toolName, intent, operationType, extractData(args));
+                }
+            }
+            catch (e) {
+                harnessWarnings.push(`pre_call hook failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        if (isPublishOp) {
+            try {
+                harnessWarnings.push("pre_publish: full-tier check engaged");
+            }
+            catch (e) {
+                harnessWarnings.push(`pre_publish hook failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        if (isSignOp) {
+            try {
+                harnessWarnings.push("pre_sign: full-tier check engaged");
+            }
+            catch (e) {
+                harnessWarnings.push(`pre_sign hook failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        let result;
+        try {
+            result = await handler(args);
+        }
+        catch (e) {
+            const errorCode = e instanceof Error ? e.message : String(e);
+            const escalation = recordOperationFailure(toolName, errorCode);
+            if (escalation) {
+                harnessWarnings.push(`Harness escalated to full tier: ${escalation.reason}`);
+            }
+            throw e;
+        }
+        if (runLight && expectedResult) {
+            try {
+                if (result?.structuredContent) {
+                    const verifyInput = buildVerifyInput(expectedResult, result);
+                    const report = harness.verify(verifyInput);
+                    if (report.status === "fail") {
+                        harnessWarnings.push(`Harness verify FAIL: ${report.summary}`);
+                    }
+                    else if (report.status === "warn") {
+                        harnessWarnings.push(`Harness verify WARN: ${report.summary}`);
+                    }
+                }
+            }
+            catch (e) {
+                harnessWarnings.push(`post_call hook failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        if (isWriteClassTool(toolName)) {
+            try {
+                const operationType = extractOperationType(toolName, args) ?? toolName;
+                const intent = extractIntent(toolName, args) ?? toolName;
+                const data = extractData(args) ?? args;
+                const outcome = classifyOutcome(result);
+                const errorCode = extractErrorCode(result);
+                const industry = extractIndustry(args) ?? "general";
+                recordOperationOutcome(operationType, data, intent, outcome, errorCode);
+                recordIndustrySignal(industry, { type: operationType }, {
+                    success: outcome === "success",
+                    error_code: errorCode,
+                });
+            }
+            catch (e) {
+                harnessWarnings.push(`signal collection failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        if (harnessWarnings.length > 0 && result?.structuredContent) {
+            const sc = result.structuredContent;
+            const semantic = sc.semantic;
+            if (semantic) {
+                const existing = Array.isArray(semantic.harness_warnings) ? semantic.harness_warnings : [];
+                semantic.harness_warnings = [...existing, ...harnessWarnings];
+            }
+            else {
+                sc.harness_warnings = harnessWarnings;
+            }
+        }
+        return result;
+    };
+}
+function isPublishOperation(toolName, args) {
+    if (toolName !== "onchain_operations")
+        return false;
+    const opType = extractOperationType(toolName, args);
+    return opType === "service" || opType === "machine";
+}
+function isSignOperation(toolName, args) {
+    if (toolName === "wip_file") {
+        const data = args?.operation_type;
+        return data === "sign";
+    }
+    return toolName === "onchain_operations";
+}
+function extractOperationType(toolName, args) {
+    if (!args || typeof args !== "object")
+        return undefined;
+    const obj = args;
+    if (toolName === "onchain_operations") {
+        return typeof obj.operation_type === "string" ? obj.operation_type : undefined;
+    }
+    if (toolName === "project_operation") {
+        return typeof obj.action === "string" ? obj.action : undefined;
+    }
+    return typeof obj.operation_type === "string" ? obj.operation_type : undefined;
+}
+function extractIntent(toolName, args) {
+    if (!args || typeof args !== "object")
+        return undefined;
+    const obj = args;
+    if (toolName === "project_operation" && typeof obj.action === "string") {
+        return `project:${obj.action}`;
+    }
+    const opType = obj.operation_type;
+    if (typeof opType === "string")
+        return `${toolName}:${opType}`;
+    return toolName;
+}
+function extractData(args) {
+    if (!args || typeof args !== "object")
+        return undefined;
+    const obj = args;
+    const data = obj.data;
+    return data && typeof data === "object" ? data : undefined;
+}
+function buildVerifyInput(expected, result) {
+    const sc = (result.structuredContent ?? {});
+    const semantic = sc.semantic;
+    return {
+        expected,
+        actual: {
+            result_type: typeof sc.result_type === "string" ? sc.result_type : undefined,
+            semantic,
+            error_code: typeof sc.error_code === "string" ? sc.error_code : undefined,
+            error: typeof sc.error === "string" ? sc.error : undefined,
+        },
+    };
+}
+const WRITE_CLASS_TOOLS = new Set([
+    "onchain_operations",
+    "project_operation",
+    "wip_file",
+    "messenger_operation",
+    "bridge_operation",
+]);
+function isWriteClassTool(toolName) {
+    return WRITE_CLASS_TOOLS.has(toolName);
+}
+function classifyOutcome(result) {
+    if (!result?.structuredContent)
+        return "failed";
+    const sc = result.structuredContent;
+    const status = typeof sc.status === "string" ? sc.status
+        : typeof sc.result_type === "string" ? sc.result_type
+            : "";
+    if (status === "error" || status === "failed")
+        return "failed";
+    if (status === "partial")
+        return "partial";
+    return "success";
+}
+function extractErrorCode(result) {
+    if (!result?.structuredContent)
+        return undefined;
+    const sc = result.structuredContent;
+    if (typeof sc.error_code === "string")
+        return sc.error_code;
+    const err = sc.error;
+    if (typeof err === "string")
+        return err;
+    if (err && typeof err === "object") {
+        const code = err.code;
+        if (typeof code === "string")
+            return code;
+    }
+    return undefined;
+}
+function extractIndustry(args) {
+    if (!args || typeof args !== "object")
+        return undefined;
+    const obj = args;
+    if (typeof obj.industry === "string")
+        return obj.industry;
+    const data = obj.data;
+    if (data && typeof data === "object") {
+        const d = data;
+        if (typeof d.industry === "string")
+            return d.industry;
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wowok/agent-mcp",
-  "version": "2.4.3",
+  "version": "2.5.0",
   "description": "Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,7 +50,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@wowok/wowok": "2.4.3",
+    "@wowok/wowok": "2.5.0",
     "lodash": "^4.18.1",
     "zod": "^3.25.76",
     "zod-to-json-schema": "^3.25.2"
@@ -66,7 +66,7 @@
     "build": "tsc && pnpm generate:schemas",
     "watch": "tsc --watch",
     "start": "tsx src/index.ts",
-    "generate:schemas": "tsx scripts/generate-json-schemas.ts",
+    "generate:schemas": "node --max-old-space-size=4096 --import tsx/esm scripts/generate-json-schemas.ts",
     "test": "vitest run",
     "test:watch": "vitest"
   }