@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/schema/trust/index.d.ts

@@ -0,0 +1,407 @@
+import { z } from "zod";
+export declare const TrustScoreInputSchema: z.ZodObject<{
+    service: z.ZodEffects<z.ZodString, string, string>;
+    order_amount: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    depth: z.ZodOptional<z.ZodEnum<["browse", "evaluate", "preorder"]>>;
+    network: z.ZodOptional<z.ZodString>;
+    no_cache: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    service: string;
+    no_cache?: boolean | undefined;
+    network?: string | undefined;
+    order_amount?: string | number | undefined;
+    depth?: "browse" | "evaluate" | "preorder" | undefined;
+}, {
+    service: string;
+    no_cache?: boolean | undefined;
+    network?: string | undefined;
+    order_amount?: string | number | undefined;
+    depth?: "browse" | "evaluate" | "preorder" | undefined;
+}>;
+export declare const TrustScoreOutputSchema: z.ZodObject<{
+    result: z.ZodObject<{
+        service_id: z.ZodString;
+        service_name: z.ZodString;
+        service_basics: z.ZodObject<{
+            bPublished: z.ZodBoolean;
+            bPaused: z.ZodBoolean;
+            sales_count: z.ZodNumber;
+            has_machine: z.ZodBoolean;
+            has_buy_guard: z.ZodBoolean;
+            has_um_contact: z.ZodBoolean;
+            arbitrations_count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            bPublished: boolean;
+            bPaused: boolean;
+            sales_count: number;
+            has_machine: boolean;
+            has_buy_guard: boolean;
+            has_um_contact: boolean;
+            arbitrations_count: number;
+        }, {
+            bPublished: boolean;
+            bPaused: boolean;
+            sales_count: number;
+            has_machine: boolean;
+            has_buy_guard: boolean;
+            has_um_contact: boolean;
+            arbitrations_count: number;
+        }>;
+        trust_score: z.ZodObject<{
+            score: z.ZodNumber;
+            level: z.ZodEnum<["high_risk", "caution", "moderate", "trusted"]>;
+            summary: z.ZodString;
+            warnings: z.ZodArray<z.ZodString, "many">;
+            breakdown: z.ZodArray<z.ZodObject<{
+                score: z.ZodNumber;
+                maxScore: z.ZodNumber;
+                description: z.ZodString;
+                humanReadable: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                description: string;
+                score: number;
+                maxScore: number;
+                humanReadable: string;
+            }, {
+                description: string;
+                score: number;
+                maxScore: number;
+                humanReadable: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            summary: string;
+            warnings: string[];
+            level: "high_risk" | "caution" | "moderate" | "trusted";
+            breakdown: {
+                description: string;
+                score: number;
+                maxScore: number;
+                humanReadable: string;
+            }[];
+        }, {
+            score: number;
+            summary: string;
+            warnings: string[];
+            level: "high_risk" | "caution" | "moderate" | "trusted";
+            breakdown: {
+                description: string;
+                score: number;
+                maxScore: number;
+                humanReadable: string;
+            }[];
+        }>;
+        order_amount: z.ZodString;
+        depth: z.ZodEnum<["browse", "evaluate", "preorder"]>;
+        risk_score: z.ZodOptional<z.ZodObject<{
+            total: z.ZodNumber;
+            level: z.ZodEnum<["low", "medium_low", "medium_high", "high"]>;
+            red_flags: z.ZodArray<z.ZodString, "many">;
+            advice: z.ZodArray<z.ZodString, "many">;
+            dimensions: z.ZodArray<z.ZodObject<{
+                name: z.ZodEnum<["workflow", "fund", "trust", "behavior"]>;
+                score: z.ZodNumber;
+                max_score: z.ZodNumber;
+                checks: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    dimension: z.ZodEnum<["workflow", "fund", "trust", "behavior"]>;
+                    description: z.ZodString;
+                    weight: z.ZodNumber;
+                    passed: z.ZodBoolean;
+                    advice: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    description: string;
+                    id: string;
+                    dimension: "fund" | "workflow" | "trust" | "behavior";
+                    weight: number;
+                    passed: boolean;
+                    advice?: string | undefined;
+                }, {
+                    description: string;
+                    id: string;
+                    dimension: "fund" | "workflow" | "trust" | "behavior";
+                    weight: number;
+                    passed: boolean;
+                    advice?: string | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                name: "fund" | "workflow" | "trust" | "behavior";
+                score: number;
+                max_score: number;
+                checks: {
+                    description: string;
+                    id: string;
+                    dimension: "fund" | "workflow" | "trust" | "behavior";
+                    weight: number;
+                    passed: boolean;
+                    advice?: string | undefined;
+                }[];
+            }, {
+                name: "fund" | "workflow" | "trust" | "behavior";
+                score: number;
+                max_score: number;
+                checks: {
+                    description: string;
+                    id: string;
+                    dimension: "fund" | "workflow" | "trust" | "behavior";
+                    weight: number;
+                    passed: boolean;
+                    advice?: string | undefined;
+                }[];
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            advice: string[];
+            level: "low" | "medium_low" | "medium_high" | "high";
+            total: number;
+            red_flags: string[];
+            dimensions: {
+                name: "fund" | "workflow" | "trust" | "behavior";
+                score: number;
+                max_score: number;
+                checks: {
+                    description: string;
+                    id: string;
+                    dimension: "fund" | "workflow" | "trust" | "behavior";
+                    weight: number;
+                    passed: boolean;
+                    advice?: string | undefined;
+                }[];
+            }[];
+        }, {
+            advice: string[];
+            level: "low" | "medium_low" | "medium_high" | "high";
+            total: number;
+            red_flags: string[];
+            dimensions: {
+                name: "fund" | "workflow" | "trust" | "behavior";
+                score: number;
+                max_score: number;
+                checks: {
+                    description: string;
+                    id: string;
+                    dimension: "fund" | "workflow" | "trust" | "behavior";
+                    weight: number;
+                    passed: boolean;
+                    advice?: string | undefined;
+                }[];
+            }[];
+        }>>;
+        info_puzzle: z.ZodOptional<z.ZodObject<{
+            completeness: z.ZodNumber;
+            gaps: z.ZodArray<z.ZodString, "many">;
+            assembled_at: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            completeness: number;
+            gaps: string[];
+            assembled_at: number;
+        }, {
+            completeness: number;
+            gaps: string[];
+            assembled_at: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        trust_score: {
+            score: number;
+            summary: string;
+            warnings: string[];
+            level: "high_risk" | "caution" | "moderate" | "trusted";
+            breakdown: {
+                description: string;
+                score: number;
+                maxScore: number;
+                humanReadable: string;
+            }[];
+        };
+        service_id: string;
+        order_amount: string;
+        depth: "browse" | "evaluate" | "preorder";
+        service_name: string;
+        service_basics: {
+            bPublished: boolean;
+            bPaused: boolean;
+            sales_count: number;
+            has_machine: boolean;
+            has_buy_guard: boolean;
+            has_um_contact: boolean;
+            arbitrations_count: number;
+        };
+        risk_score?: {
+            advice: string[];
+            level: "low" | "medium_low" | "medium_high" | "high";
+            total: number;
+            red_flags: string[];
+            dimensions: {
+                name: "fund" | "workflow" | "trust" | "behavior";
+                score: number;
+                max_score: number;
+                checks: {
+                    description: string;
+                    id: string;
+                    dimension: "fund" | "workflow" | "trust" | "behavior";
+                    weight: number;
+                    passed: boolean;
+                    advice?: string | undefined;
+                }[];
+            }[];
+        } | undefined;
+        info_puzzle?: {
+            completeness: number;
+            gaps: string[];
+            assembled_at: number;
+        } | undefined;
+    }, {
+        trust_score: {
+            score: number;
+            summary: string;
+            warnings: string[];
+            level: "high_risk" | "caution" | "moderate" | "trusted";
+            breakdown: {
+                description: string;
+                score: number;
+                maxScore: number;
+                humanReadable: string;
+            }[];
+        };
+        service_id: string;
+        order_amount: string;
+        depth: "browse" | "evaluate" | "preorder";
+        service_name: string;
+        service_basics: {
+            bPublished: boolean;
+            bPaused: boolean;
+            sales_count: number;
+            has_machine: boolean;
+            has_buy_guard: boolean;
+            has_um_contact: boolean;
+            arbitrations_count: number;
+        };
+        risk_score?: {
+            advice: string[];
+            level: "low" | "medium_low" | "medium_high" | "high";
+            total: number;
+            red_flags: string[];
+            dimensions: {
+                name: "fund" | "workflow" | "trust" | "behavior";
+                score: number;
+                max_score: number;
+                checks: {
+                    description: string;
+                    id: string;
+                    dimension: "fund" | "workflow" | "trust" | "behavior";
+                    weight: number;
+                    passed: boolean;
+                    advice?: string | undefined;
+                }[];
+            }[];
+        } | undefined;
+        info_puzzle?: {
+            completeness: number;
+            gaps: string[];
+            assembled_at: number;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    result: {
+        trust_score: {
+            score: number;
+            summary: string;
+            warnings: string[];
+            level: "high_risk" | "caution" | "moderate" | "trusted";
+            breakdown: {
+                description: string;
+                score: number;
+                maxScore: number;
+                humanReadable: string;
+            }[];
+        };
+        service_id: string;
+        order_amount: string;
+        depth: "browse" | "evaluate" | "preorder";
+        service_name: string;
+        service_basics: {
+            bPublished: boolean;
+            bPaused: boolean;
+            sales_count: number;
+            has_machine: boolean;
+            has_buy_guard: boolean;
+            has_um_contact: boolean;
+            arbitrations_count: number;
+        };
+        risk_score?: {
+            advice: string[];
+            level: "low" | "medium_low" | "medium_high" | "high";
+            total: number;
+            red_flags: string[];
+            dimensions: {
+                name: "fund" | "workflow" | "trust" | "behavior";
+                score: number;
+                max_score: number;
+                checks: {
+                    description: string;
+                    id: string;
+                    dimension: "fund" | "workflow" | "trust" | "behavior";
+                    weight: number;
+                    passed: boolean;
+                    advice?: string | undefined;
+                }[];
+            }[];
+        } | undefined;
+        info_puzzle?: {
+            completeness: number;
+            gaps: string[];
+            assembled_at: number;
+        } | undefined;
+    };
+}, {
+    result: {
+        trust_score: {
+            score: number;
+            summary: string;
+            warnings: string[];
+            level: "high_risk" | "caution" | "moderate" | "trusted";
+            breakdown: {
+                description: string;
+                score: number;
+                maxScore: number;
+                humanReadable: string;
+            }[];
+        };
+        service_id: string;
+        order_amount: string;
+        depth: "browse" | "evaluate" | "preorder";
+        service_name: string;
+        service_basics: {
+            bPublished: boolean;
+            bPaused: boolean;
+            sales_count: number;
+            has_machine: boolean;
+            has_buy_guard: boolean;
+            has_um_contact: boolean;
+            arbitrations_count: number;
+        };
+        risk_score?: {
+            advice: string[];
+            level: "low" | "medium_low" | "medium_high" | "high";
+            total: number;
+            red_flags: string[];
+            dimensions: {
+                name: "fund" | "workflow" | "trust" | "behavior";
+                score: number;
+                max_score: number;
+                checks: {
+                    description: string;
+                    id: string;
+                    dimension: "fund" | "workflow" | "trust" | "behavior";
+                    weight: number;
+                    passed: boolean;
+                    advice?: string | undefined;
+                }[];
+            }[];
+        } | undefined;
+        info_puzzle?: {
+            completeness: number;
+            gaps: string[];
+            assembled_at: number;
+        } | undefined;
+    };
+}>;

package/dist/schema/trust/index.js

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { NameOrAddressSchema } from "../common/index.js";
+export const TrustScoreInputSchema = z
+    .object({
+    service: NameOrAddressSchema.describe("Service object ID or local_mark name to evaluate. " +
+        "Must reference an existing Service object on-chain."),
+    order_amount: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Optional order amount (in smallest token unit, e.g. 2000000000 for 2 WOW). " +
+        "Used for fund-safety dimension risk assessment. " +
+        "If omitted, the first active sale price of the service is used."),
+    depth: z
+        .enum(["browse", "evaluate", "preorder"])
+        .optional()
+        .describe("InfoPuzzle collection depth. " +
+        "browse: only Service basics + trust score; " +
+        "evaluate (default): + workflow/fund/trust dimensions risk assessment; " +
+        "preorder: + merchant behavior + market context (most thorough)."),
+    network: z
+        .string()
+        .optional()
+        .describe("Network override (e.g. 'mainnet', 'testnet'). If omitted, uses default."),
+    no_cache: z
+        .boolean()
+        .optional()
+        .describe("Skip object cache and force a fresh on-chain query."),
+})
+    .strict();
+export const TrustScoreOutputSchema = z
+    .object({
+    result: z
+        .object({
+        service_id: z.string().describe("The Service object ID or local_mark that was evaluated."),
+        service_name: z.string().describe("Service display name (falls back to service_id if unnamed)."),
+        service_basics: z
+            .object({
+            bPublished: z.boolean().describe("Whether the Service is published (open for orders)."),
+            bPaused: z.boolean().describe("Whether the Service is temporarily paused."),
+            sales_count: z.number().int().nonnegative().describe("Number of active (non-suspended) sale entries."),
+            has_machine: z.boolean().describe("Whether a Machine workflow is attached."),
+            has_buy_guard: z.boolean().describe("Whether a buy-side Guard is configured."),
+            has_um_contact: z.boolean().describe("Whether a Messenger (um) contact is configured."),
+            arbitrations_count: z.number().int().nonnegative().describe("Number of arbitration entries attached to the Service."),
+        })
+            .describe("Service snapshot — basic on-chain state."),
+        trust_score: z
+            .object({
+            score: z.number().min(0).max(100).describe("Overall trust score (0-100, higher = more trustworthy)."),
+            level: z
+                .enum(["high_risk", "caution", "moderate", "trusted"])
+                .describe("Trust level label derived from the score."),
+            summary: z.string().describe("One-line human-readable trust summary."),
+            warnings: z.array(z.string()).describe("Trust warnings (e.g. low arbitration dimension score)."),
+            breakdown: z
+                .array(z.object({
+                score: z.number().describe("Dimension score achieved."),
+                maxScore: z.number().describe("Dimension max possible score."),
+                description: z.string().describe("Dimension name / description."),
+                humanReadable: z.string().describe("Human-readable dimension explanation."),
+            }))
+                .describe("5-dimension breakdown: arbitration / reviews / fulfillment / fund_safety / transparency."),
+        })
+            .describe("ServiceTrustScore — 0-100 score across 5 trust dimensions."),
+        order_amount: z
+            .string()
+            .describe("Order amount used for fund-safety assessment, in smallest token unit (bigint as string)."),
+        depth: z
+            .enum(["browse", "evaluate", "preorder"])
+            .describe("Actual InfoPuzzle collection depth used (defaults to 'evaluate')."),
+        risk_score: z
+            .object({
+            total: z.number().min(0).max(100).describe("Overall risk score (0-100, higher = riskier)."),
+            level: z
+                .enum(["low", "medium_low", "medium_high", "high"])
+                .describe("Risk level label derived from the total score."),
+            red_flags: z.array(z.string()).describe("Critical risk red flags detected."),
+            advice: z.array(z.string()).describe("Risk mitigation advice."),
+            dimensions: z
+                .array(z.object({
+                name: z
+                    .enum(["workflow", "fund", "trust", "behavior"])
+                    .describe("Risk dimension name."),
+                score: z.number().describe("Dimension score achieved."),
+                max_score: z.number().describe("Dimension max possible score."),
+                checks: z.array(z.object({
+                    id: z.string().describe("Check identifier."),
+                    dimension: z
+                        .enum(["workflow", "fund", "trust", "behavior"])
+                        .describe("Dimension this check belongs to."),
+                    description: z.string().describe("Check description."),
+                    weight: z.number().describe("Check weight within its dimension (percentage)."),
+                    passed: z.boolean().describe("Whether the check passed."),
+                    advice: z.string().optional().describe("Advice when the check failed."),
+                })).describe("Individual risk checks within this dimension."),
+            }))
+                .describe("4-dimension breakdown: workflow / fund / trust / behavior."),
+        })
+            .optional()
+            .describe("RiskScore — present only when depth >= 'evaluate'."),
+        info_puzzle: z
+            .object({
+            completeness: z.number().min(0).max(1).describe("InfoPuzzle completeness ratio (0-1)."),
+            gaps: z.array(z.string()).describe("Missing key puzzle pieces."),
+            assembled_at: z.number().describe("Assembly timestamp (ms since epoch)."),
+        })
+            .optional()
+            .describe("InfoPuzzle summary — present only when depth >= 'evaluate'."),
+    })
+        .describe("Trust score result. Contains: trust_score (ServiceTrustScore), " +
+        "risk_score (RiskScore, when depth >= evaluate), info_puzzle summary, " +
+        "and service_basics snapshot."),
+});

package/dist/schemas/account_operation.output.json

@@ -686,14 +686,7 @@
                                       },
                                       "parsedJson": {
                                         "type": "object",
-                                        "additionalProperties": {
-                                          "type": [
-                                            "string",
-                                            "number",
-                                            "boolean",
-                                            "null"
-                                          ]
-                                        },
+                                        "additionalProperties": {},
                                         "description": "Parsed JSON value of the event"
                                       },
                                       "sender": {
@@ -763,14 +756,7 @@
                                       },
                                       "parsedJson": {
                                         "type": "object",
-                                        "additionalProperties": {
-                                          "type": [
-                                            "string",
-                                            "number",
-                                            "boolean",
-                                            "null"
-                                          ]
-                                        },
+                                        "additionalProperties": {},
                                         "description": "Parsed JSON value of the event"
                                       },
                                       "sender": {
@@ -1375,6 +1361,29 @@
                 "error": {
                   "type": "string",
                   "description": "Error message"
+                },
+                "error_code": {
+                  "type": "string",
+                  "enum": [
+                    "invalid_parameter",
+                    "guard_rejected",
+                    "state_conflict",
+                    "insufficient_balance",
+                    "object_not_found",
+                    "permission_denied",
+                    "immutable_violation",
+                    "network_error",
+                    "unknown"
+                  ],
+                  "description": "Error classification for programmatic recovery"
+                },
+                "retryable": {
+                  "type": "boolean",
+                  "description": "Whether the operation can be retried as-is"
+                },
+                "recovery_hint": {
+                  "type": "string",
+                  "description": "Recovery suggestion for AI or user"
                 }
               },
               "required": [

package/dist/schemas/account_operation.schema.json

@@ -72,7 +72,7 @@
           "properties": {
             "address": {
               "type": "string",
-              "description": "Valid ID: 0x prefix + 64 hex characters, or builtin ID (0x5-0x9, @0xaaa, @0xaab, @0x403, @0xacc, @0xc)"
+              "description": "Valid ID: 0x prefix + 64 hex characters, or builtin ID (0x5-0x9, 0xa, 0xc, 0xd, 0x403, 0xaaa, 0xaab, 0xacc)"
             },
             "name": {
               "$ref": "#/definitions/account_operation/properties/gen/properties/name",