@wowok/agent-mcp 2.3.16 → 2.3.18

package/dist/schema/query/index.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { TokenTypeInfoSchema, QueryLocalMarkListResultSchema, QueryAccountListResultSchema, QueryLocalInfoListResultSchema, QueryLocalTokenListResultSchema, QueryAccountResultSchema } from "../local/index.js";
 import { AccountOrMark_AddressSchema, BalanceTypeSchema, CacheExpireTypeSchema, EntrypointSchema, GuardIdentifierSchema, GuardTableItemSchema, NameOrAddressSchema, ObjectBaseSchema, ObjectTypeSchema, QueryIdSchema, SupportedValueSchema, ValueTypeSchema, QueryReceivedResultSchema, LongNameSchema, DescriptionSchema } from "../common/index.js";
-const SemanticSummarySchema = z.any();
+import { SemanticSummarySchema } from "../call/index.js";
 import { isValidPermissionIndex } from '../utils/permission-index-utils.js';
 import { isValidGuardQueryId, isValidGuardQueryIdOrName } from '../utils/guard-query-utils.js';
 import { ENTITY_LINKER_ADDRESS, ENTITY_REGISTRAR_ADDRESS, isWitnessType, } from "@wowok/wowok";
@@ -1035,7 +1035,7 @@ export const OnchainEventsInputSchema = z.object({
     order: z.union([z.literal("ascending"), z.literal("descending"), z.null()]).optional().describe("Sort order for results: 'ascending' (oldest first) or 'descending' (newest first). Use null for default order"),
     no_cache: z.boolean().optional().describe("Whether to bypass cache and fetch fresh data from the blockchain"),
     network: EntrypointSchema.optional().describe("Network to query: 'mainnet' or 'testnet'. Uses default network if not specified"),
-}).describe("Input parameters for querying on-chain WOWOK events");
+}).strict().describe("Input parameters for querying on-chain WOWOK events");
 export const OnchainEventsResultSchema = z.object({
     result: z.union([EventAnswerSchema, z.null()]).describe("Event query result containing list of events and pagination info, or null if no data found"),
     semantic: SemanticSummarySchema.optional().describe("Business semantic summary for the event query"),
@@ -1203,24 +1203,24 @@ export const BridgeTokenInfoSchema = z.object({
 export const ProtocolInfoQuerySchema = z.discriminatedUnion('info', [
     z.object({
         info: z.literal('constants')
-    }).describe('Constants query'),
+    }).strict().describe('Constants query'),
     z.object({
         info: z.literal('built-in permissions'),
         filter: z.optional(PermissionFilterSchema).describe('Filter for built-in permissions')
-    }).describe('Built-in permissions query'),
+    }).strict().describe('Built-in permissions query'),
     z.object({
         info: z.literal('guard instructions'),
         filter: z.optional(GuardInstructFilterOptionsSchema).describe('Filter for guard instructions')
-    }).describe('Guard instructions and wowok object queries'),
+    }).strict().describe('Guard instructions and wowok object queries'),
     z.object({
         info: z.literal('current network')
-    }).describe('Current network entrypoint'),
+    }).strict().describe('Current network entrypoint'),
     z.object({
         info: z.literal('value types')
-    }).describe('Value types query - returns all supported value types with their numeric and string representations'),
+    }).strict().describe('Value types query - returns all supported value types with their numeric and string representations'),
     z.object({
         info: z.literal('mainnet bridge tokens')
-    }).describe('Mainnet Bridge tokens query - returns all tokens deployed on the mainnet bridge with their symbol, WOW-side type tag, EVM address, decimals, and description')
+    }).strict().describe('Mainnet Bridge tokens query - returns all tokens deployed on the mainnet bridge with their symbol, WOW-side type tag, EVM address, decimals, and description')
 ]).describe('WoWok Build-in infomation query');
 export const BuiltinPermissionSchema = z.object({
     result: z.array(PermissionInfoTypeSchema).describe('Built-in permissions result')

package/dist/schema/schema-query/index.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export declare const SchemaQueryInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["list", "get", "get_output", "search", "list_operations"]>;
+    name: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    action: "get" | "search" | "list" | "get_output" | "list_operations";
+    name?: string | undefined;
+    query?: string | undefined;
+}, {
+    action: "get" | "search" | "list" | "get_output" | "list_operations";
+    name?: string | undefined;
+    query?: string | undefined;
+}>;
+export declare const SchemaQueryOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    action: z.ZodString;
+    data: z.ZodAny;
+    message: z.ZodString;
+    suggestions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+    action: string;
+    data?: any;
+    suggestions?: string[] | undefined;
+}, {
+    message: string;
+    success: boolean;
+    action: string;
+    data?: any;
+    suggestions?: string[] | undefined;
+}>;

package/dist/schema/schema-query/index.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export const SchemaQueryInputSchema = z
+    .object({
+    action: z
+        .enum([
+        "list",
+        "get",
+        "get_output",
+        "search",
+        "list_operations",
+    ])
+        .describe("Action to perform: 'list' to see all available schemas, 'get' to retrieve a specific input schema, 'get_output' to retrieve a tool's output schema, 'search' to find schemas by keyword, 'list_operations' to list all on-chain operations"),
+    name: z
+        .string()
+        .optional()
+        .describe("Schema/tool name for 'get'/'get_output' action (e.g., 'onchain_operations', 'account_operation', 'onchain_operations_permission')"),
+    query: z
+        .string()
+        .optional()
+        .describe("Search query for 'search' action"),
+})
+    .strict();
+export const SchemaQueryOutputSchema = z
+    .object({
+    success: z.boolean().describe("Whether the request was successful"),
+    action: z.string().describe("The action that was performed"),
+    data: z
+        .any()
+        .describe("Response data - JSON Schema object for 'get'/'get_output', array of schema info for 'list'/'search'/'list_operations'"),
+    message: z.string().describe("Human-readable message describing the result"),
+    suggestions: z
+        .array(z.string())
+        .optional()
+        .describe("Suggested next steps or alternatives"),
+})
+    .strict();

package/dist/schema/schema-version.d.ts

@@ -0,0 +1,25 @@
+export declare const MCP_SCHEMA_VERSION = "1.0.0";
+export interface SchemaVersions {
+    sdk: string;
+    mcp: string;
+}
+export declare function getSchemaVersions(): SchemaVersions;
+export type SchemaCompatibilityMode = "warn" | "strict";
+export interface SchemaCheckOptions {
+    mode?: SchemaCompatibilityMode;
+}
+export interface SchemaCheckResult {
+    compatible: boolean;
+    warnings: string[];
+    errors: string[];
+    versions: SchemaVersions;
+    client_version?: string;
+}
+export declare function checkClientSchemaCompatibility(clientSchemaVersion: string | undefined, options?: SchemaCheckOptions): SchemaCheckResult;
+export declare function attachSchemaWarning<T extends {
+    result?: unknown;
+    message?: string;
+    semantic?: {
+        warnings?: string[];
+    };
+}>(output: T, schemaCheck: SchemaCheckResult): T;

package/dist/schema/schema-version.js

@@ -0,0 +1,76 @@
+import * as wowok from "@wowok/wowok";
+const SDK_SCHEMA_VERSION = wowok.SCHEMA_VERSION ?? "1.0.0";
+const checkSchemaCompatibility = wowok
+    .checkSchemaCompatibility ??
+    ((_client, _server) => ({ compatible: true }));
+export const MCP_SCHEMA_VERSION = "1.0.0";
+export function getSchemaVersions() {
+    return {
+        sdk: SDK_SCHEMA_VERSION,
+        mcp: MCP_SCHEMA_VERSION,
+    };
+}
+export function checkClientSchemaCompatibility(clientSchemaVersion, options = {}) {
+    const versions = getSchemaVersions();
+    const result = {
+        compatible: true,
+        warnings: [],
+        errors: [],
+        versions,
+        client_version: clientSchemaVersion,
+    };
+    if (!clientSchemaVersion) {
+        return result;
+    }
+    const sdkCheck = checkSchemaCompatibility(clientSchemaVersion, versions.sdk);
+    if (!sdkCheck.compatible) {
+        result.compatible = false;
+        const message = `SDK schema incompatibility: ${sdkCheck.reason}`;
+        if (options.mode === "strict") {
+            result.errors.push(message);
+        }
+        else {
+            result.warnings.push(message);
+        }
+    }
+    const mcpCheck = checkSchemaCompatibility(clientSchemaVersion, versions.mcp);
+    if (!mcpCheck.compatible) {
+        result.compatible = false;
+        const message = `MCP schema incompatibility: ${mcpCheck.reason}`;
+        if (options.mode === "strict") {
+            result.errors.push(message);
+        }
+        else {
+            result.warnings.push(message);
+        }
+    }
+    return result;
+}
+export function attachSchemaWarning(output, schemaCheck) {
+    if (schemaCheck.warnings.length === 0 && schemaCheck.errors.length === 0) {
+        return output;
+    }
+    const warnings = [];
+    if (schemaCheck.warnings.length > 0) {
+        warnings.push(...schemaCheck.warnings);
+    }
+    if (schemaCheck.errors.length > 0) {
+        warnings.push(...schemaCheck.errors);
+    }
+    const semantic = output.semantic
+        ? {
+            ...output.semantic,
+            warnings: [...(output.semantic.warnings || []), ...warnings],
+        }
+        : undefined;
+    return {
+        ...output,
+        semantic,
+        schema_warning: {
+            compatible: schemaCheck.compatible,
+            warnings,
+            client_version: schemaCheck.client_version,
+            server_versions: schemaCheck.versions,
+        },
+    };
+}

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;
+    };
+}>;