@wowok/agent-mcp 2.3.18 → 2.4.1

package/dist/schema/call/semantic.js

@@ -5,7 +5,11 @@ import { generateReminders } from "../../customer/index.js";
 import { getProfile } from "../../experience/user-profile.js";
 import { injectEvolutionContext, recordIndustrySignal } from "../../knowledge/flywheel-loop.js";
 import { WException, getMoveErrorDescription, WErrors } from "@wowok/wowok";
+import { GUARDQUERY } from "@wowok/wowok";
 import { assessGuardRisksForOperation, getRiskSummary } from "../../knowledge/guard-risk.js";
+import { derivePuzzleFromCallData, getPuzzleStatusBooleans, getPendingQuestions, generateConfirmationText, } from "../../knowledge/guard-puzzle.js";
+import { inferSceneFromAction } from "../../knowledge/guard-ledger.js";
+import { matchSemanticPattern } from "../../knowledge/guard-translation.js";
 function booleanFromSignals(positive, negative) {
     if (positive)
         return true;
@@ -1102,11 +1106,11 @@ function buildCustomerAdvice(operation_type, data, safeResult) {
         if (r.action)
             recommendations.push(r.action);
     }
-    if (noArbitration && !recommendations.some((r) => r.includes("仲裁"))) {
-        recommendations.push("要求商家配置 Arbitration 服务后再下单");
+    if (noArbitration && !recommendations.some((r) => r.includes("arbitration"))) {
+        recommendations.push("Require the merchant to configure an Arbitration service before placing the order");
     }
-    if (noCompensation && !recommendations.some((r) => r.includes("赔偿金"))) {
-        recommendations.push("要求商家设置 compensation_fund（赔偿金）以保障订单失败时自动赔付");
+    if (noCompensation && !recommendations.some((r) => r.includes("compensation"))) {
+        recommendations.push("Require the merchant to set a compensation_fund to guarantee automatic payout when the order fails");
     }
     const advice = {
         recommendations,
@@ -1127,24 +1131,7 @@ function buildCustomerAdvice(operation_type, data, safeResult) {
 function buildGuardAdvice(operation_type, data, safeResult) {
     try {
         if (operation_type === "guard") {
-            const assessment = assessGuardRisksForOperation(operation_type, data);
-            if (assessment) {
-                const summary = getRiskSummary(assessment);
-                const riskWarnings = assessment.risks.map((r) => `[${r.level.toUpperCase()}] ${r.title}: ${r.description}`);
-                return {
-                    current_round: "R7",
-                    risk_assessment: {
-                        overall_risk: summary.risk_count > 0 ? assessment.overall_risk : "info",
-                        risk_count: summary.risk_count,
-                        critical_count: summary.critical_count,
-                        high_count: summary.high_count,
-                        needs_human_review: summary.needs_human_review,
-                        top_risks: summary.top_risks,
-                        stakeholder_advice: assessment.stakeholder_advice,
-                    },
-                    risk_warnings: riskWarnings.length > 0 ? riskWarnings : undefined,
-                };
-            }
+            return buildGuardCreateAdvice(data);
         }
         if (operation_type === "gen_passport") {
             const status = safeResult?.error ? "fail" : "pass";
@@ -1163,8 +1150,8 @@ function buildGuardAdvice(operation_type, data, safeResult) {
         if (errorStr.includes("GUARD") || errorStr.includes("Guard") || errorStr.includes("guard")) {
             return {
                 risk_warnings: [
-                    `Guard 验证失败: ${errorStr.slice(0, 200)}`,
-                    "建议: 检查提交数据是否符合 Guard table 声明，或查询 Guard 定义了解所需 submission",
+                    `Guard verification failed: ${errorStr.slice(0, 200)}`,
+                    "Suggestion: check whether the submission data matches the Guard table declaration, or query the Guard definition to learn the required submission",
                 ],
             };
         }
@@ -1174,6 +1161,223 @@ function buildGuardAdvice(operation_type, data, safeResult) {
         return undefined;
     }
 }
+function buildGuardCreateAdvice(data) {
+    if (!data)
+        return undefined;
+    const puzzleInput = convertCallDataToPuzzleInput(data);
+    const puzzle = derivePuzzleFromCallData(puzzleInput);
+    const puzzleStatusBooleans = getPuzzleStatusBooleans(puzzle);
+    let matchedScene;
+    let sceneDescription;
+    let sceneConstraints;
+    if (data.binding_hint?.action) {
+        matchedScene = inferSceneFromAction(data.binding_hint.action);
+        if (matchedScene) {
+            sceneDescription = matchedScene.name;
+            sceneConstraints = matchedScene.special_constraints;
+        }
+    }
+    let suggestedPatterns;
+    const intentText = data.binding_hint?.rule_sentence
+        || data.binding_hint?.action
+        || "";
+    if (intentText) {
+        const matched = matchSemanticPattern(intentText);
+        if (matched.length > 0) {
+            suggestedPatterns = matched.map((m) => `${m.id}: ${m.pattern_name}`);
+        }
+    }
+    let confirmationText;
+    try {
+        const text = generateConfirmationText(puzzle);
+        if (!text.startsWith("[Puzzle incomplete]")) {
+            confirmationText = text;
+        }
+    }
+    catch {
+    }
+    let pendingQuestions;
+    const pendingQs = getPendingQuestions(puzzle);
+    if (pendingQs.length > 0) {
+        pendingQuestions = pendingQs;
+    }
+    let availableQueries;
+    if (matchedScene) {
+        const sceneObjectType = mapSceneToObjectType(matchedScene);
+        if (sceneObjectType) {
+            const filtered = GUARDQUERY
+                .filter((q) => q.objectType === sceneObjectType)
+                .slice(0, 10)
+                .map((q) => ({
+                id: q.id,
+                name: q.name,
+                objectType: String(q.objectType),
+                returnType: String(q.return),
+                description: q.description,
+            }));
+            if (filtered.length > 0) {
+                availableQueries = filtered;
+            }
+        }
+    }
+    const assessment = assessGuardRisksForOperation("guard", data);
+    let riskAssessment;
+    let riskWarnings;
+    if (assessment) {
+        const summary = getRiskSummary(assessment);
+        riskAssessment = {
+            overall_risk: summary.risk_count > 0 ? assessment.overall_risk : "info",
+            risk_count: summary.risk_count,
+            critical_count: summary.critical_count,
+            high_count: summary.high_count,
+            needs_human_review: summary.needs_human_review,
+            top_risks: summary.top_risks,
+            stakeholder_advice: assessment.stakeholder_advice,
+        };
+        const warnings = assessment.risks.map((r) => `[${r.level.toUpperCase()}] ${r.title}: ${r.description}`);
+        if (warnings.length > 0) {
+            riskWarnings = warnings;
+        }
+    }
+    const advice = {
+        current_round: "R7",
+        puzzle_status: puzzleStatusBooleans,
+    };
+    if (matchedScene)
+        advice.matched_scene = matchedScene.id;
+    if (sceneDescription)
+        advice.scene_description = sceneDescription;
+    if (sceneConstraints)
+        advice.scene_constraints = sceneConstraints;
+    if (suggestedPatterns)
+        advice.suggested_patterns = suggestedPatterns;
+    if (availableQueries)
+        advice.available_queries = availableQueries;
+    if (riskWarnings)
+        advice.risk_warnings = riskWarnings;
+    if (pendingQuestions)
+        advice.pending_questions = pendingQuestions;
+    if (confirmationText)
+        advice.confirmation_text = confirmationText;
+    if (riskAssessment)
+        advice.risk_assessment = riskAssessment;
+    return advice;
+}
+function convertCallDataToPuzzleInput(data) {
+    const result = {};
+    if (Array.isArray(data.table)) {
+        result.table = data.table.map((item) => ({
+            identifier: item.identifier,
+            b_submission: item.b_submission,
+            value_type: typeof item.value_type === "string" ? item.value_type : String(item.value_type),
+            value: convertValueSnapshot(item.value),
+            name: item.name ?? "",
+            object_type: item.object_type,
+        }));
+    }
+    if (data.root && typeof data.root === "object") {
+        const rootObj = data.root;
+        if (rootObj.type !== "file" && rootObj.type !== "node") {
+            result.root = convertNodeToSnapshot(data.root);
+        }
+        else if (rootObj.type === "node" && data.root.node) {
+            result.root = convertNodeToSnapshot(data.root.node);
+        }
+    }
+    if (data.rely && Array.isArray(data.rely.guards)) {
+        result.rely = {
+            guards: data.rely.guards.map((g) => typeof g === "string" ? g : String(g)),
+            logic_or: data.rely.logic_or,
+        };
+    }
+    if (data.binding_hint) {
+        const bh = data.binding_hint;
+        const bindingHint = {
+            action: bh.action,
+            host_object: bh.host_object,
+            binding_field: bh.binding_field,
+        };
+        if (bh.rule_sentence !== undefined)
+            bindingHint.rule_sentence = bh.rule_sentence;
+        if (bh.failure_conditions !== undefined)
+            bindingHint.failure_conditions = bh.failure_conditions;
+        if (bh.circular_reference !== undefined)
+            bindingHint.circular_reference = bh.circular_reference;
+        result.binding_hint = bindingHint;
+    }
+    return result;
+}
+function convertNodeToSnapshot(node) {
+    if (!node || typeof node !== "object") {
+        return { type: "unknown" };
+    }
+    const snapshot = {
+        type: String(node.type ?? "unknown"),
+    };
+    if (typeof node.identifier === "number") {
+        snapshot.identifier = node.identifier;
+    }
+    if (node.query !== undefined) {
+        snapshot.query = typeof node.query === "number" ? node.query : String(node.query);
+    }
+    if (node.object && typeof node.object === "object") {
+        const obj = {
+            identifier: Number(node.object.identifier),
+        };
+        if (typeof node.object.convert_witness === "number") {
+            obj.convert_witness = node.object.convert_witness;
+        }
+        snapshot.object = obj;
+    }
+    if (Array.isArray(node.parameters)) {
+        snapshot.parameters = node.parameters.map((p) => convertNodeToSnapshot(p));
+    }
+    if (typeof node.context === "string") {
+        const ctxValue = node.context;
+        if (ctxValue === "Clock" || ctxValue === "Guard" || ctxValue === "Signer") {
+            snapshot.context = ctxValue;
+        }
+    }
+    if (Array.isArray(node.nodes)) {
+        snapshot.nodes = node.nodes.map((n) => convertNodeToSnapshot(n));
+    }
+    if (node.node) {
+        snapshot.node = convertNodeToSnapshot(node.node);
+    }
+    if (node.nodeLeft) {
+        snapshot.nodeLeft = convertNodeToSnapshot(node.nodeLeft);
+    }
+    if (node.nodeRight) {
+        snapshot.nodeRight = convertNodeToSnapshot(node.nodeRight);
+    }
+    return snapshot;
+}
+function convertValueSnapshot(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const allString = value.every((v) => typeof v === "string");
+        if (allString)
+            return value;
+        const allNumber = value.every((v) => typeof v === "number");
+        if (allNumber)
+            return value;
+        const allBool = value.every((v) => typeof v === "boolean");
+        if (allBool)
+            return value;
+        return JSON.stringify(value);
+    }
+    return JSON.stringify(value);
+}
+function mapSceneToObjectType(scene) {
+    const hostObject = scene.host_object;
+    if (hostObject === "Standalone")
+        return undefined;
+    return hostObject;
+}
 export function buildSemantic(safeResult, context) {
     if (!context)
         return undefined;

package/dist/schema/local/wip.d.ts

@@ -136,8 +136,8 @@ export declare const WipSignatureArraySchema: z.ZodUnion<[z.ZodObject<{
 }>, "many">]>;
 export declare const WipMetaSchema: z.ZodObject<{
     type: z.ZodLiteral<"wip">;
-    version: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
-    created: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    version: z.ZodString;
+    created: z.ZodString;
     hash: z.ZodString;
     algorithm: z.ZodLiteral<"sha256">;
     signature: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
@@ -173,9 +173,9 @@ export declare const WipMetaSchema: z.ZodObject<{
     }>, "many">]>>;
 }, "strip", z.ZodTypeAny, {
     type: "wip";
-    version: string | number;
+    version: string;
     algorithm: "sha256";
-    created: string | number;
+    created: string;
     hash: string;
     signature?: {
         value: string;
@@ -190,9 +190,9 @@ export declare const WipMetaSchema: z.ZodObject<{
     }[] | undefined;
 }, {
     type: "wip";
-    version: string | number;
+    version: string;
     algorithm: "sha256";
-    created: string | number;
+    created: string;
     hash: string;
     signature?: {
         value: string;
@@ -260,8 +260,8 @@ export declare const WipFileSchema: z.ZodObject<{
     }>;
     meta: z.ZodObject<{
         type: z.ZodLiteral<"wip">;
-        version: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
-        created: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        version: z.ZodString;
+        created: z.ZodString;
         hash: z.ZodString;
         algorithm: z.ZodLiteral<"sha256">;
         signature: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
@@ -297,9 +297,9 @@ export declare const WipFileSchema: z.ZodObject<{
         }>, "many">]>>;
     }, "strip", z.ZodTypeAny, {
         type: "wip";
-        version: string | number;
+        version: string;
         algorithm: "sha256";
-        created: string | number;
+        created: string;
         hash: string;
         signature?: {
             value: string;
@@ -314,9 +314,9 @@ export declare const WipFileSchema: z.ZodObject<{
         }[] | undefined;
     }, {
         type: "wip";
-        version: string | number;
+        version: string;
         algorithm: "sha256";
-        created: string | number;
+        created: string;
         hash: string;
         signature?: {
             value: string;
@@ -346,9 +346,9 @@ export declare const WipFileSchema: z.ZodObject<{
     };
     meta: {
         type: "wip";
-        version: string | number;
+        version: string;
         algorithm: "sha256";
-        created: string | number;
+        created: string;
         hash: string;
         signature?: {
             value: string;
@@ -378,9 +378,9 @@ export declare const WipFileSchema: z.ZodObject<{
     };
     meta: {
         type: "wip";
-        version: string | number;
+        version: string;
         algorithm: "sha256";
-        created: string | number;
+        created: string;
         hash: string;
         signature?: {
             value: string;
@@ -740,7 +740,19 @@ export declare const WipOperationOutputSchema: z.ZodDiscriminatedUnion<"type", [
     hashValid: z.ZodBoolean;
     signatureValid: z.ZodOptional<z.ZodBoolean>;
     hasSignature: z.ZodBoolean;
-    signatures: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    signatures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        publicKey: z.ZodString;
+        address: z.ZodOptional<z.ZodString>;
+        valid: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        valid: boolean;
+        publicKey: string;
+        address?: string | undefined;
+    }, {
+        valid: boolean;
+        publicKey: string;
+        address?: string | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     valid: boolean;
     type: "verify";
@@ -748,7 +760,11 @@ export declare const WipOperationOutputSchema: z.ZodDiscriminatedUnion<"type", [
     hasSignature: boolean;
     error?: string | undefined;
     signatureValid?: boolean | undefined;
-    signatures?: any[] | undefined;
+    signatures?: {
+        valid: boolean;
+        publicKey: string;
+        address?: string | undefined;
+    }[] | undefined;
 }, {
     valid: boolean;
     type: "verify";
@@ -756,7 +772,11 @@ export declare const WipOperationOutputSchema: z.ZodDiscriminatedUnion<"type", [
     hasSignature: boolean;
     error?: string | undefined;
     signatureValid?: boolean | undefined;
-    signatures?: any[] | undefined;
+    signatures?: {
+        valid: boolean;
+        publicKey: string;
+        address?: string | undefined;
+    }[] | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"sign">;
     filePath: z.ZodString;

package/dist/schema/local/wip.js

@@ -51,7 +51,7 @@ export const WipPayloadSchema = z
 export const WipSignatureSchema = z
     .object({
     value: z.string().describe("Base64 encoded signature value"),
-    publicKey: z.string().describe("Verification public key (Base64 encoded 32 bytes) or DID"),
+    publicKey: z.string().describe("Verification public key (Base64 encoded, 897 bytes for Falcon-512)"),
     algorithm: SignatureAlgorithmSchema.describe("Signature algorithm"),
     address: z.string().optional().describe("Signer address"),
 })
@@ -62,9 +62,9 @@ export const WipSignatureArraySchema = z
 export const WipMetaSchema = z
     .object({
     type: z.literal("wip").describe("File type identifier, fixed as wip"),
-    version: z.union([z.string(), z.number()]).describe("Format version number"),
-    created: z.union([z.string(), z.number()]).describe("Creation time (ISO 8601 format)"),
-    hash: z.string().describe("SHA-256 hash of payload, format: sha256:hexString"),
+    version: z.string().describe("Format version number"),
+    created: z.string().describe("Creation time in ISO 8601 format"),
+    hash: z.string().describe("SHA-256 hash of { wip, payload } as a lowercase hex string (no prefix)"),
     algorithm: HashAlgorithmSchema.describe("Hash algorithm identifier"),
     signature: WipSignatureArraySchema.optional().describe("Optional digital signature"),
 })
@@ -172,7 +172,7 @@ export const WipOperationOutputSchema = z.discriminatedUnion("type", [
         hashValid: z.boolean(),
         signatureValid: z.boolean().optional(),
         hasSignature: z.boolean(),
-        signatures: z.array(z.any()).optional(),
+        signatures: z.array(WipSignatureVerificationSchema).optional(),
     }),
     z.object({
         type: z.literal("sign"),

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

@@ -527,7 +527,7 @@ export declare const MessageFilterSchema: z.ZodObject<{
     hasLastReceivedIndexOnly?: boolean | undefined;
     lastReceivedIndexMin?: number | undefined;
     lastReceivedIndexMax?: number | undefined;
-    listFilterMode?: "guard" | "friends" | "stranger" | "any" | undefined;
+    listFilterMode?: "guard" | "any" | "friends" | "stranger" | undefined;
     customListFilter?: {
         relation?: "union" | "intersection" | undefined;
         includeAddresses?: string[] | undefined;
@@ -569,7 +569,7 @@ export declare const MessageFilterSchema: z.ZodObject<{
     hasLastReceivedIndexOnly?: boolean | undefined;
     lastReceivedIndexMin?: number | undefined;
     lastReceivedIndexMax?: number | undefined;
-    listFilterMode?: "guard" | "friends" | "stranger" | "any" | undefined;
+    listFilterMode?: "guard" | "any" | "friends" | "stranger" | undefined;
     customListFilter?: {
         relation?: "union" | "intersection" | undefined;
         includeAddresses?: string[] | undefined;
@@ -891,8 +891,8 @@ export declare const WtsSignatureVerificationSchema: z.ZodObject<{
 export declare const WtsVerificationResultSchema: z.ZodObject<{
     valid: z.ZodBoolean;
     error: z.ZodOptional<z.ZodString>;
-    hashValid: z.ZodOptional<z.ZodBoolean>;
-    hasSignature: z.ZodOptional<z.ZodBoolean>;
+    hashValid: z.ZodBoolean;
+    hasSignature: z.ZodBoolean;
     signatureValid: z.ZodOptional<z.ZodBoolean>;
     signatures: z.ZodOptional<z.ZodArray<z.ZodObject<{
         publicKey: z.ZodString;
@@ -909,10 +909,10 @@ export declare const WtsVerificationResultSchema: z.ZodObject<{
     }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     valid: boolean;
+    hashValid: boolean;
+    hasSignature: boolean;
     error?: string | undefined;
-    hashValid?: boolean | undefined;
     signatureValid?: boolean | undefined;
-    hasSignature?: boolean | undefined;
     signatures?: {
         valid: boolean;
         publicKey: string;
@@ -920,10 +920,10 @@ export declare const WtsVerificationResultSchema: z.ZodObject<{
     }[] | undefined;
 }, {
     valid: boolean;
+    hashValid: boolean;
+    hasSignature: boolean;
     error?: string | undefined;
-    hashValid?: boolean | undefined;
     signatureValid?: boolean | undefined;
-    hasSignature?: boolean | undefined;
     signatures?: {
         valid: boolean;
         publicKey: string;
@@ -1692,7 +1692,7 @@ export declare const MessengerOperationInputSchema: z.ZodDiscriminatedUnion<"ope
         hasLastReceivedIndexOnly?: boolean | undefined;
         lastReceivedIndexMin?: number | undefined;
         lastReceivedIndexMax?: number | undefined;
-        listFilterMode?: "guard" | "friends" | "stranger" | "any" | undefined;
+        listFilterMode?: "guard" | "any" | "friends" | "stranger" | undefined;
         customListFilter?: {
             relation?: "union" | "intersection" | undefined;
             includeAddresses?: string[] | undefined;
@@ -1734,7 +1734,7 @@ export declare const MessengerOperationInputSchema: z.ZodDiscriminatedUnion<"ope
         hasLastReceivedIndexOnly?: boolean | undefined;
         lastReceivedIndexMin?: number | undefined;
         lastReceivedIndexMax?: number | undefined;
-        listFilterMode?: "guard" | "friends" | "stranger" | "any" | undefined;
+        listFilterMode?: "guard" | "any" | "friends" | "stranger" | undefined;
         customListFilter?: {
             relation?: "union" | "intersection" | undefined;
             includeAddresses?: string[] | undefined;
@@ -1779,7 +1779,7 @@ export declare const MessengerOperationInputSchema: z.ZodDiscriminatedUnion<"ope
         hasLastReceivedIndexOnly?: boolean | undefined;
         lastReceivedIndexMin?: number | undefined;
         lastReceivedIndexMax?: number | undefined;
-        listFilterMode?: "guard" | "friends" | "stranger" | "any" | undefined;
+        listFilterMode?: "guard" | "any" | "friends" | "stranger" | undefined;
         customListFilter?: {
             relation?: "union" | "intersection" | undefined;
             includeAddresses?: string[] | undefined;
@@ -1824,7 +1824,7 @@ export declare const MessengerOperationInputSchema: z.ZodDiscriminatedUnion<"ope
         hasLastReceivedIndexOnly?: boolean | undefined;
         lastReceivedIndexMin?: number | undefined;
         lastReceivedIndexMax?: number | undefined;
-        listFilterMode?: "guard" | "friends" | "stranger" | "any" | undefined;
+        listFilterMode?: "guard" | "any" | "friends" | "stranger" | undefined;
         customListFilter?: {
             relation?: "union" | "intersection" | undefined;
             includeAddresses?: string[] | undefined;
@@ -3702,8 +3702,8 @@ export declare const MessengerOperationOutputSchema: z.ZodObject<{
         result: z.ZodObject<{
             valid: z.ZodBoolean;
             error: z.ZodOptional<z.ZodString>;
-            hashValid: z.ZodOptional<z.ZodBoolean>;
-            hasSignature: z.ZodOptional<z.ZodBoolean>;
+            hashValid: z.ZodBoolean;
+            hasSignature: z.ZodBoolean;
             signatureValid: z.ZodOptional<z.ZodBoolean>;
             signatures: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 publicKey: z.ZodString;
@@ -3720,10 +3720,10 @@ export declare const MessengerOperationOutputSchema: z.ZodObject<{
             }>, "many">>;
         }, "strip", z.ZodTypeAny, {
             valid: boolean;
+            hashValid: boolean;
+            hasSignature: boolean;
             error?: string | undefined;
-            hashValid?: boolean | undefined;
             signatureValid?: boolean | undefined;
-            hasSignature?: boolean | undefined;
             signatures?: {
                 valid: boolean;
                 publicKey: string;
@@ -3731,10 +3731,10 @@ export declare const MessengerOperationOutputSchema: z.ZodObject<{
             }[] | undefined;
         }, {
             valid: boolean;
+            hashValid: boolean;
+            hasSignature: boolean;
             error?: string | undefined;
-            hashValid?: boolean | undefined;
             signatureValid?: boolean | undefined;
-            hasSignature?: boolean | undefined;
             signatures?: {
                 valid: boolean;
                 publicKey: string;
@@ -3744,10 +3744,10 @@ export declare const MessengerOperationOutputSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         result: {
             valid: boolean;
+            hashValid: boolean;
+            hasSignature: boolean;
             error?: string | undefined;
-            hashValid?: boolean | undefined;
             signatureValid?: boolean | undefined;
-            hasSignature?: boolean | undefined;
             signatures?: {
                 valid: boolean;
                 publicKey: string;
@@ -3758,10 +3758,10 @@ export declare const MessengerOperationOutputSchema: z.ZodObject<{
     }, {
         result: {
             valid: boolean;
+            hashValid: boolean;
+            hasSignature: boolean;
             error?: string | undefined;
-            hashValid?: boolean | undefined;
             signatureValid?: boolean | undefined;
-            hasSignature?: boolean | undefined;
             signatures?: {
                 valid: boolean;
                 publicKey: string;
@@ -5243,10 +5243,10 @@ export declare const MessengerOperationOutputSchema: z.ZodObject<{
     } | {
         result: {
             valid: boolean;
+            hashValid: boolean;
+            hasSignature: boolean;
             error?: string | undefined;
-            hashValid?: boolean | undefined;
             signatureValid?: boolean | undefined;
-            hasSignature?: boolean | undefined;
             signatures?: {
                 valid: boolean;
                 publicKey: string;
@@ -5656,10 +5656,10 @@ export declare const MessengerOperationOutputSchema: z.ZodObject<{
     } | {
         result: {
             valid: boolean;
+            hashValid: boolean;
+            hasSignature: boolean;
             error?: string | undefined;
-            hashValid?: boolean | undefined;
             signatureValid?: boolean | undefined;
-            hasSignature?: boolean | undefined;
             signatures?: {
                 valid: boolean;
                 publicKey: string;

package/dist/schema/messenger/index.js

@@ -185,8 +185,8 @@ export const WtsSignatureVerificationSchema = z.object({
 export const WtsVerificationResultSchema = z.object({
     valid: z.boolean().describe("Whether verification succeeded"),
     error: z.string().optional().describe("Error message if verification failed"),
-    hashValid: z.boolean().optional().describe("Whether hash validation passed"),
-    hasSignature: z.boolean().optional().describe("Whether WTS has signatures"),
+    hashValid: z.boolean().describe("Whether hash validation passed"),
+    hasSignature: z.boolean().describe("Whether WTS has signatures"),
     signatureValid: z.boolean().optional().describe("Whether signature validation passed"),
     signatures: z.array(WtsSignatureVerificationSchema).optional().describe("Signature verification details"),
 }).describe("WTS verification result");