@wowok/agent-mcp 2.3.12 → 2.3.14

package/dist/harness/types.d.ts

@@ -0,0 +1,137 @@
+export type ObjectType = "Permission" | "Service" | "Machine" | "Guard" | "Allocation" | "Progress" | "Repository" | "Treasury" | "Reward" | "Demand" | "Order" | "Arbitration" | "Contact" | "Personal" | "Payment";
+export type ObjectStatus = "not_created" | "created_unpublished" | "published" | "failed";
+export interface ODGNode {
+    id: string;
+    type: ObjectType;
+    status: ObjectStatus;
+    reversible: boolean;
+    dependencies: string[];
+    user_decisions?: string[];
+    risk_flags?: string[];
+    estimated_time?: string;
+    address?: string;
+}
+export interface ODGPhase {
+    name: string;
+    objects: string[];
+    description?: string;
+}
+export interface ODG {
+    task_id: string;
+    scenario: string;
+    objects: ODGNode[];
+    phases: ODGPhase[];
+}
+export interface ExpectedObject {
+    role: string;
+    expect_fields?: Record<string, unknown>;
+}
+export interface ExpectedFundFlow {
+    role: string;
+    amount?: string;
+    coinType?: string;
+    from?: string | null;
+    to?: string | null;
+}
+export interface ExpectedEvent {
+    type: string;
+    expect_count?: string;
+}
+export interface ExpectedResult {
+    operation: string;
+    intent: string;
+    pre_conditions: Array<{
+        check: string;
+        error: string;
+    }>;
+    expected: {
+        result_type: "transaction" | "submission" | "error" | "data" | "null";
+        semantic_created?: ExpectedObject[];
+        semantic_modified?: ExpectedObject[];
+        semantic_released?: ExpectedFundFlow[];
+        events?: ExpectedEvent[];
+        state_transition?: {
+            from: string;
+            to: string;
+        };
+    };
+    post_verification?: Array<{
+        tool: string;
+        params: Record<string, unknown>;
+        assert: string;
+    }>;
+}
+export type VerifyStatus = "pass" | "warn" | "fail";
+export interface VerifyMismatch {
+    dimension: "created" | "modified" | "released" | "state" | "event";
+    expected: string;
+    actual: string;
+    severity: VerifyStatus;
+    detail: string;
+}
+export interface VerifyReport {
+    status: VerifyStatus;
+    mismatches: VerifyMismatch[];
+    summary: string;
+    timestamp: string;
+}
+export type RecoveryStrategy = "retry" | "claim_faucet" | "fill_submission" | "recreate" | "switch_account" | "query_and_retry" | "adjust_params" | "escalate_human" | "stop";
+export interface RecoveryAction {
+    strategy: RecoveryStrategy;
+    should_retry: boolean;
+    adjusted_params?: Record<string, unknown>;
+    user_prompt?: string;
+    max_attempts: number;
+    current_attempt: number;
+    detail: string;
+}
+export type PhaseStatus = "in_progress" | "completed" | "failed";
+export interface Checkpoint {
+    checkpoint_id: string;
+    task_id: string;
+    timestamp: string;
+    phase: string;
+    phase_status: PhaseStatus;
+    odg_snapshot: Record<string, {
+        status: ObjectStatus;
+        address?: string;
+        reversible: boolean;
+        tested?: boolean;
+    }>;
+    user_decisions: Record<string, unknown>;
+    operation_log: Array<{
+        op_id: string;
+        tool: string;
+        params?: Record<string, unknown>;
+        result_digest?: string;
+        status: VerifyStatus;
+    }>;
+    next_phase: string;
+    semantic_summary: {
+        total_ops: number;
+        success_ops: number;
+        failed_ops: number;
+        recoveries: number;
+    };
+}
+export interface ScenarioTemplate {
+    name: string;
+    keywords: string[];
+    objects: Array<Omit<ODGNode, "id" | "status" | "address">>;
+    phases: Array<{
+        name: string;
+        object_types: ObjectType[];
+    }>;
+    default_permissions: {
+        provider?: number;
+        customer?: "namedOperator";
+        arbiter?: number;
+    };
+    description: string;
+}
+export interface HarnessContext {
+    odg?: ODG;
+    current_phase?: string;
+    checkpoint?: Checkpoint;
+    user_decisions?: Record<string, unknown>;
+}

package/dist/harness/types.js

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

package/dist/harness/verify.d.ts

@@ -0,0 +1,42 @@
+import type { ExpectedResult, VerifyReport } from "./types.js";
+export interface VerifyInput {
+    expected: ExpectedResult;
+    actual: {
+        result_type?: string;
+        semantic?: {
+            intent?: string;
+            status?: string;
+            summary?: string;
+            created?: Array<{
+                id: string;
+                role: string;
+                immutable?: boolean;
+            }>;
+            modified?: Array<{
+                id: string;
+                role: string;
+            }>;
+            released?: Array<{
+                amount: string;
+                coinType: string;
+                role: string;
+                from?: string | null;
+                to?: string | null;
+            }>;
+            events?: Array<{
+                event_type: string;
+                business_meaning: string;
+                category: string;
+            }>;
+            next_actions?: Array<{
+                action: string;
+                priority: string;
+            }>;
+            warnings?: string[];
+        };
+        error_code?: string;
+        error?: string;
+    };
+}
+export declare function verify(input: VerifyInput): VerifyReport;
+export declare function generateExpected(operation: string, intent: string, operationType: string, data?: Record<string, unknown>): ExpectedResult;

package/dist/harness/verify.js

@@ -0,0 +1,237 @@
+function verifyCreated(expected, actual) {
+    const mismatches = [];
+    const expectedCreated = expected.expected.semantic_created ?? [];
+    const actualCreated = actual.semantic?.created ?? [];
+    for (const exp of expectedCreated) {
+        const found = actualCreated.find((a) => a.role === exp.role);
+        if (!found) {
+            mismatches.push({
+                dimension: "created",
+                expected: `role=${exp.role}`,
+                actual: "not found",
+                severity: "fail",
+                detail: `Expected to create object with role '${exp.role}', but none was created`,
+            });
+        }
+    }
+    for (const act of actualCreated) {
+        const expected_role = expectedCreated.find((e) => e.role === act.role);
+        if (!expected_role) {
+            mismatches.push({
+                dimension: "created",
+                expected: `no object with role=${act.role}`,
+                actual: `role=${act.role}`,
+                severity: "warn",
+                detail: `Unexpected object created with role '${act.role}' — may indicate rule table gap`,
+            });
+        }
+    }
+    return mismatches;
+}
+function verifyModified(expected, actual) {
+    const mismatches = [];
+    const expectedModified = expected.expected.semantic_modified ?? [];
+    const actualModified = actual.semantic?.modified ?? [];
+    for (const exp of expectedModified) {
+        const found = actualModified.find((a) => a.role === exp.role);
+        if (!found) {
+            mismatches.push({
+                dimension: "modified",
+                expected: `role=${exp.role} fields=${JSON.stringify(exp.expect_fields ?? {})}`,
+                actual: "not modified",
+                severity: "fail",
+                detail: `Expected to modify object with role '${exp.role}', but it was not modified`,
+            });
+        }
+    }
+    return mismatches;
+}
+function verifyReleased(expected, actual) {
+    const mismatches = [];
+    const expectedReleased = expected.expected.semantic_released ?? [];
+    const actualReleased = actual.semantic?.released ?? [];
+    for (const exp of expectedReleased) {
+        const found = actualReleased.find((a) => a.role === exp.role);
+        if (!found) {
+            mismatches.push({
+                dimension: "released",
+                expected: `role=${exp.role} amount=${exp.amount ?? "?"} from=${exp.from ?? "?"} to=${exp.to ?? "?"}`,
+                actual: "no fund movement",
+                severity: "fail",
+                detail: `Expected fund movement with role '${exp.role}', but none occurred — fund flow risk`,
+            });
+        }
+        else {
+            if (exp.amount && exp.amount !== found.amount) {
+                mismatches.push({
+                    dimension: "released",
+                    expected: `amount=${exp.amount}`,
+                    actual: `amount=${found.amount}`,
+                    severity: "fail",
+                    detail: `Fund amount mismatch for role '${exp.role}' — fund flow risk`,
+                });
+            }
+            if (exp.from && found.from && exp.from !== found.from) {
+                mismatches.push({
+                    dimension: "released",
+                    expected: `from=${exp.from}`,
+                    actual: `from=${found.from}`,
+                    severity: "fail",
+                    detail: `Fund source mismatch for role '${exp.role}' — fund flow direction risk`,
+                });
+            }
+            if (exp.to && found.to && exp.to !== found.to) {
+                mismatches.push({
+                    dimension: "released",
+                    expected: `to=${exp.to}`,
+                    actual: `to=${found.to}`,
+                    severity: "fail",
+                    detail: `Fund destination mismatch for role '${exp.role}' — fund flow direction risk`,
+                });
+            }
+        }
+    }
+    return mismatches;
+}
+function verifyEvents(expected, actual) {
+    const mismatches = [];
+    const expectedEvents = expected.expected.events ?? [];
+    const actualEvents = actual.semantic?.events ?? [];
+    for (const exp of expectedEvents) {
+        const found = actualEvents.find((a) => a.event_type.includes(exp.type) || a.business_meaning.toLowerCase().includes(exp.type.toLowerCase()));
+        if (!found) {
+            mismatches.push({
+                dimension: "event",
+                expected: `event_type contains '${exp.type}'`,
+                actual: "event not found",
+                severity: "warn",
+                detail: `Expected event '${exp.type}' was not found — may indicate semantic layer gap or operation didn't trigger it`,
+            });
+        }
+    }
+    return mismatches;
+}
+function verifyStateTransition(expected, actual) {
+    const mismatches = [];
+    const transition = expected.expected.state_transition;
+    if (!transition)
+        return mismatches;
+    if (actual.semantic?.status === "success") {
+        return mismatches;
+    }
+    if (actual.semantic?.status === "failed") {
+        mismatches.push({
+            dimension: "state",
+            expected: `${transition.from} → ${transition.to}`,
+            actual: "operation failed",
+            severity: "fail",
+            detail: `Expected state transition '${transition.from} → ${transition.to}' failed — operation did not succeed`,
+        });
+    }
+    return mismatches;
+}
+export function verify(input) {
+    const mismatches = [
+        ...verifyCreated(input.expected, input.actual),
+        ...verifyModified(input.expected, input.actual),
+        ...verifyReleased(input.expected, input.actual),
+        ...verifyEvents(input.expected, input.actual),
+        ...verifyStateTransition(input.expected, input.actual),
+    ];
+    const hasFail = mismatches.some((m) => m.severity === "fail");
+    const hasWarn = mismatches.some((m) => m.severity === "warn");
+    const status = hasFail ? "fail" : hasWarn ? "warn" : "pass";
+    const failCount = mismatches.filter((m) => m.severity === "fail").length;
+    const warnCount = mismatches.filter((m) => m.severity === "warn").length;
+    let summary;
+    if (status === "pass") {
+        summary = "All verifications passed — expected results match actual results";
+    }
+    else if (status === "warn") {
+        summary = `${warnCount} warning(s) — operation succeeded with minor discrepancies`;
+    }
+    else {
+        summary = `${failCount} failure(s), ${warnCount} warning(s) — expected results do not match actual results`;
+    }
+    return {
+        status,
+        mismatches,
+        summary,
+        timestamp: new Date().toISOString(),
+    };
+}
+export function generateExpected(operation, intent, operationType, data) {
+    const expected = {
+        result_type: "transaction",
+    };
+    switch (operationType) {
+        case "service":
+            if (data?.publish === true || data?.bPublished === true) {
+                expected.semantic_modified = [{ role: "Service", expect_fields: { bPublished: true } }];
+                expected.state_transition = { from: "unpublished", to: "published" };
+            }
+            else {
+                expected.semantic_created = [{ role: "Service" }];
+            }
+            break;
+        case "machine":
+            expected.semantic_created = [{ role: "Machine" }];
+            break;
+        case "guard":
+            expected.semantic_created = [{ role: "Guard" }];
+            expected.events = [{ type: "GuardCreated", expect_count: ">=1" }];
+            break;
+        case "permission":
+            expected.semantic_created = [{ role: "Permission" }];
+            break;
+        case "order":
+            if (data?.arb !== undefined) {
+                expected.state_transition = { from: "ordered", to: "arbitration" };
+            }
+            else {
+                expected.semantic_created = [{ role: "Order" }];
+                expected.semantic_released = [{ role: "payment" }];
+                expected.events = [{ type: "OrderPaid", expect_count: ">=1" }];
+            }
+            break;
+        case "payment":
+            expected.semantic_released = [{ role: "payment" }];
+            break;
+        case "treasury":
+            if (data?.deposit !== undefined) {
+                expected.semantic_released = [{ role: "deposit" }];
+            }
+            else {
+                expected.semantic_released = [{ role: "release" }];
+            }
+            break;
+        case "reward":
+            if (data?.claim !== undefined || data?.withdraw !== undefined) {
+                expected.semantic_released = [{ role: "reward" }];
+            }
+            else {
+                expected.semantic_created = [{ role: "Reward" }];
+            }
+            break;
+        case "allocation":
+            expected.semantic_released = [{ role: "release" }];
+            expected.events = [{ type: "Allocation", expect_count: ">=1" }];
+            break;
+        case "demand":
+            if (data?.submit !== undefined) {
+                expected.semantic_modified = [{ role: "Demand" }];
+            }
+            else {
+                expected.semantic_created = [{ role: "Demand" }];
+            }
+            break;
+        default:
+            break;
+    }
+    return {
+        operation,
+        intent,
+        pre_conditions: [],
+        expected,
+    };
+}