@wowok/agent-mcp 2.3.16 → 2.3.18

package/dist/schema/call/semantic.js

@@ -1,9 +1,11 @@
 import { auditService } from "../../knowledge/index.js";
 import { getExperienceFeedback, recordOperationOutcome } from "../../experience/index.js";
 import { isEnabled as isRuntimeEnabled, listServices } from "../../config/index.js";
-import { generateReminders } from "../../customer/reminder-system.js";
+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 { assessGuardRisksForOperation, getRiskSummary } from "../../knowledge/guard-risk.js";
 function booleanFromSignals(positive, negative) {
     if (positive)
         return true;
@@ -13,78 +15,405 @@ function booleanFromSignals(positive, negative) {
 }
 const ERROR_RULES = [
     {
-        patterns: [/insufficient\s*(gas|balance|coin|fund)/i, /ENOTENOUGH/i, /not\s*enough\s*(coin|gas|balance)/i, /gas\s*budget/i],
+        patterns: [
+            /too\s*many\s*requests/i,
+            /rate\s*limit/i,
+            /429/i,
+            /throttl/i,
+            /faucet.*rate/i,
+            /request.*limit.*exceeded/i,
+        ],
+        error_code: "rate_limit",
+        retryable: true,
+        recovery_hint: "Rate limit hit (HTTP 429). Wait with exponential backoff and retry. To check existing balance, use account_balance query.",
+    },
+    {
+        patterns: [
+            /gas.*budget.*exceeded/i,
+            /out\s*of\s*gas/i,
+            /gas\s*exceeded/i,
+            /insufficient\s*gas/i,
+            /not\s*enough\s*gas/i,
+            /could not automatically determine a budget/i,
+            /dry run failed.*budget/i,
+            /Maximum gas/i,
+        ],
+        error_code: "gas_exceeded",
+        retryable: true,
+        recovery_hint: "Gas budget exceeded. Increase the gas_budget parameter or claim more gas tokens, then retry",
+    },
+    {
+        patterns: [
+            /insufficient\s*(balance|coin|fund)/i,
+            /ENOTENOUGH/i,
+            /not\s*enough\s*(coin|balance)/i,
+            /coin\s*not\s*enough/i,
+            /balance\s*not\s*enough/i,
+            /stock\s*not\s*enough/i,
+            /fee\s*not\s*enough/i,
+            /Insufficient balance/i,
+        ],
         error_code: "insufficient_balance",
         retryable: true,
         recovery_hint: "Claim faucet tokens via account_operation (faucet) then retry the call",
     },
     {
-        patterns: [/network/i, /timeout/i, /ECONNRESET/i, /ETIMEDOUT/i, /RPC\s*(error|failed|unreachable)/i, /socket\s*hang\s*up/i, /fetch\s*failed/i],
+        patterns: [
+            /bcs.*(error|fail|invalid)/i,
+            /BCS serialization/i,
+            /serialization\s*(failure|error)/i,
+            /deserialization\s*(failure|error)/i,
+            /invalid bcs type/i,
+            /Out of range.*bcs/i,
+            /Length out of range/i,
+            /parse object content failed/i,
+        ],
+        error_code: "bcs_error",
+        retryable: false,
+        recovery_hint: "BCS serialization/deserialization error. Verify data types and structure match the expected schema",
+    },
+    {
+        patterns: [
+            /signature.*(invalid|fail|error|verif)/i,
+            /invalid\s*signature/i,
+            /signature\s*verification\s*failed/i,
+            /bad\s*signature/i,
+            /signing\s*fail/i,
+            /crypto.*signature/i,
+            /ed25519.*(fail|error|invalid)/i,
+            /secp256k1.*(fail|error|invalid)/i,
+        ],
+        error_code: "signature_error",
+        retryable: false,
+        recovery_hint: "Signature verification failed. Check that the correct private key and network configuration are correct",
+    },
+    {
+        patterns: [
+            /config.*(not set|not found|invalid|missing)/i,
+            /RPC\s*not\s*configured/i,
+            /network.*not\s*specified/i,
+            /protocol network not specified/i,
+            /account persistent storage not set/i,
+            /config persistent storage not set/i,
+            /account persistent storage not found/i,
+            /no\s*rpc\s*url/i,
+        ],
+        error_code: "config_error",
+        retryable: false,
+        recovery_hint: "Configuration error. Verify that network, RPC endpoints, and required environment variables are properly configured",
+    },
+    {
+        patterns: [
+            /network/i,
+            /timeout/i,
+            /ECONNRESET/i,
+            /ETIMEDOUT/i,
+            /ECONNREFUSED/i,
+            /EAI_AGAIN/i,
+            /RPC\s*(error|failed|unreachable)/i,
+            /socket\s*hang\s*up/i,
+            /fetch\s*failed/i,
+            /connection\s*(refused|reset|lost)/i,
+            /dns\s*(error|fail)/i,
+        ],
         error_code: "network_error",
         retryable: true,
         recovery_hint: "Retry the call; if it persists, switch RPC endpoint or check connectivity",
     },
     {
-        patterns: [/faucet/i, /too\s*many\s*requests/i, /rate\s*limit/i, /429/i],
-        error_code: "network_error",
-        retryable: true,
-        recovery_hint: "Faucet rate limit hit (HTTP 429). Wait a few minutes and retry. To check existing balance, use account_balance query.",
-    },
-    {
-        patterns: [/guard.*(reject|fail|denied)/i, /verification\s*failed/i, /submission.*(invalid|fail|required)/i, /passport.*(invalid|fail)/i, /move[._-]?abort.*guard/i],
+        patterns: [
+            /guard.*(reject|fail|denied|verif)/i,
+            /verification\s*failed/i,
+            /submission.*(invalid|fail|required)/i,
+            /passport.*(invalid|fail|verif)/i,
+            /move[._-]?abort.*guard/i,
+            /Guard count exceeded limit/i,
+            /Submission size exceeded limit/i,
+            /Submission not found/i,
+            /Guard not found/i,
+            /Impact guard not found/i,
+        ],
         error_code: "guard_rejected",
         retryable: false,
         recovery_hint: "Fill the Guard submission data (see the 'submission' field) and resubmit via call_with_submission",
     },
     {
-        patterns: [/already\s*publish/i, /immutable/i, /cannot\s*(modify|change|mutate)/i, /locked/i, /is\s*published/i],
+        patterns: [
+            /already\s*publish/i,
+            /immutable/i,
+            /cannot\s*(modify|change|mutate)/i,
+            /locked/i,
+            /is\s*published/i,
+            /Service already published/i,
+            /Machine already published/i,
+            /setting lock duration not exceeded/i,
+        ],
         error_code: "immutable_violation",
         retryable: false,
         recovery_hint: "Object is in an immutable state (e.g. Service already published). Recreate the object if a different config is needed",
     },
     {
-        patterns: [/permission/i, /unauthorized/i, /forbidden/i, /not\s*(the\s*)?owner/i, /access\s*denied/i],
+        patterns: [
+            /permission/i,
+            /unauthorized/i,
+            /forbidden/i,
+            /not\s*(the\s*)?owner/i,
+            /access\s*denied/i,
+            /no permission/i,
+            /Permission denied/i,
+            /Not the builder/i,
+            /Not admin/i,
+            /No operation permission/i,
+            /Not the holder/i,
+        ],
         error_code: "permission_denied",
         retryable: false,
         recovery_hint: "Use an account with the required permission, or pass permission_guard IDs via env.permission_guard",
     },
     {
-        patterns: [/not\s*found/i, /does\s*not\s*exist/i, /ENOTFOUND/i, /no\s*such\s*object/i, /unknown\s*object/i],
+        patterns: [
+            /not\s*found/i,
+            /does\s*not\s*exist/i,
+            /ENOTFOUND/i,
+            /no\s*such\s*object/i,
+            /unknown\s*object/i,
+            /account not found/i,
+            /address not found/i,
+            /token not found/i,
+            /Node not found/i,
+            /Policy not found/i,
+            /Reward not found/i,
+        ],
         error_code: "object_not_found",
         retryable: false,
         recovery_hint: "Verify the object ID/name with query_toolkit; local_mark names are case-sensitive",
     },
     {
-        patterns: [/state\s*(conflict|mismatch)/i, /already\s*exist/i, /conflict/i, /duplicate/i, /version\s*mismatch/i],
+        patterns: [
+            /state\s*(conflict|mismatch)/i,
+            /already\s*exist/i,
+            /conflict/i,
+            /duplicate/i,
+            /version\s*mismatch/i,
+            /name exist/i,
+            /Duplicate forward name/i,
+            /Duplicate node previous/i,
+            /already claimed/i,
+            /already specified/i,
+            /already accomplished/i,
+            /already used/i,
+            /Status does not match/i,
+            /does not match/i,
+        ],
         error_code: "state_conflict",
         retryable: false,
         recovery_hint: "Object state conflicts with the operation. Query the current state with query_toolkit and adjust parameters",
     },
     {
-        patterns: [/invalid/i, /missing\s*(field|param|required)/i, /required/i, /expected/i, /malformed/i, /parse\s*error/i, /type\s*mismatch/i],
+        patterns: [
+            /invalid/i,
+            /missing\s*(field|param|required)/i,
+            /required/i,
+            /expected/i,
+            /malformed/i,
+            /parse\s*error/i,
+            /type\s*mismatch/i,
+            /invalid argument/i,
+            /Invalid value/i,
+            /Invalid data value/i,
+            /Invalid string value/i,
+            /Invalid argument/i,
+            /IsValid/i,
+            /type does not match/i,
+            /value type/i,
+        ],
         error_code: "invalid_parameter",
         retryable: false,
         recovery_hint: "Check parameter format against the tool schema; consult wowok-tools Skill for the operation's requirements",
     },
 ];
-export function classifyError(errorMsg) {
+const WERROR_MAPPINGS = [
+    {
+        codes: [WErrors.AccountNotFound, WErrors.AddressNotFound, WErrors.TokenNotFoundLocally],
+        error_code: "object_not_found",
+        retryable: false,
+        recovery_hint: "Verify the object ID/name with query_toolkit; local_mark names are case-sensitive",
+    },
+    {
+        codes: [WErrors.NoPermission],
+        error_code: "permission_denied",
+        retryable: false,
+        recovery_hint: "Use an account with the required permission, or pass permission_guard IDs via env.permission_guard",
+    },
+    {
+        codes: [
+            WErrors.IsValidDescription,
+            WErrors.IsValidName,
+            WErrors.IsValidName_AllowEmpty,
+            WErrors.IsValidEndpoint,
+            WErrors.IsValidAddress,
+            WErrors.IsValidArgType,
+            WErrors.IsValidTokenType,
+            WErrors.IsValidUint,
+            WErrors.IsValidInt,
+            WErrors.IsValidU8,
+            WErrors.IsValidU16,
+            WErrors.IsValidU32,
+            WErrors.IsValidU64,
+            WErrors.IsValidU128,
+            WErrors.IsValidU256,
+            WErrors.IsValidRate,
+            WErrors.IsValidArray,
+            WErrors.IsValidObjects,
+            WErrors.AllInvalid,
+            WErrors.InvalidParam,
+            WErrors.IsValidPermissionIndex,
+            WErrors.IsValidKey,
+            WErrors.IsValidIdentifier,
+            WErrors.IsValidHttpUrl,
+            WErrors.IsValidBizPermissionIndex,
+            WErrors.IsValidServiceItemName,
+            WErrors.IsValidCoinType,
+            WErrors.IsValidGuardIdentifier,
+            WErrors.IsValidValue,
+            WErrors.IsValidValueType,
+            WErrors.IsValidLocation,
+            WErrors.WitnessTypeInvalid,
+        ],
+        error_code: "invalid_parameter",
+        retryable: false,
+        recovery_hint: "Check parameter format against the tool schema; consult wowok-tools Skill for the operation's requirements",
+    },
+    {
+        codes: [WErrors.BcsTypeInvalid, WErrors.ParseObjectContentFailed],
+        error_code: "bcs_error",
+        retryable: false,
+        recovery_hint: "BCS serialization/deserialization error. Verify data types and structure match the expected schema",
+    },
+    {
+        codes: [WErrors.NetworkInvalid],
+        error_code: "config_error",
+        retryable: false,
+        recovery_hint: "Configuration error. Verify that network, RPC endpoints, and required environment variables are properly configured",
+    },
+    {
+        codes: [
+            WErrors.AccountPersistentStorageNotSet,
+            WErrors.ConfigPersistentStorageNotSet,
+            WErrors.AccountPersistentStorageNotFound,
+        ],
+        error_code: "config_error",
+        retryable: false,
+        recovery_hint: "Persistent storage not configured. Initialize account storage before performing this operation",
+    },
+    {
+        codes: [WErrors.AccountNameExist, WErrors.LocalMarkNameExist],
+        error_code: "state_conflict",
+        retryable: false,
+        recovery_hint: "Object state conflicts with the operation. Query the current state with query_toolkit and adjust parameters",
+    },
+    {
+        codes: [WErrors.MaxObjectsPerQuery, WErrors.ResourceTagCountExceeded, WErrors.AddressCountExceeded, WErrors.NumberCountExceeded],
+        error_code: "invalid_parameter",
+        retryable: false,
+        recovery_hint: "Count limit exceeded. Reduce the number of items per request and retry",
+    },
+];
+function isWException(value) {
+    return value instanceof WException;
+}
+function classifyWException(exception) {
+    const code = exception.getErrorCode();
+    const mapping = WERROR_MAPPINGS.find((m) => m.codes.includes(code));
+    if (!mapping)
+        return undefined;
+    const result = {
+        error_code: mapping.error_code,
+        retryable: mapping.retryable,
+        recovery_hint: mapping.recovery_hint,
+    };
+    return result;
+}
+const WOWOK_ADDRESSES = new Set([
+    "0x0000000000000000000000000000000000000000000000000000000000000002",
+    "0x2",
+]);
+function extractMoveAbortInfo(errorMsg) {
+    if (!errorMsg)
+        return undefined;
+    const abortCodeMatch = errorMsg.match(/MoveAbort\([^,]+,\s*(\d+)\)/);
+    const moduleNameMatch = errorMsg.match(/name:\s*Identifier\("([^"]+)"\)/);
+    const addressMatch = errorMsg.match(/address:\s*([0-9a-fA-Fx]+)/);
+    if (abortCodeMatch && moduleNameMatch && addressMatch) {
+        const code = parseInt(abortCodeMatch[1], 10);
+        const module = moduleNameMatch[1].toLowerCase();
+        const address = addressMatch[1].toLowerCase();
+        if (WOWOK_ADDRESSES.has(address)) {
+            const description = getMoveErrorDescription(module, code) ?? undefined;
+            return { module, code, description };
+        }
+    }
+    const formattedAbortCode = errorMsg.match(/abort code:\s*(\d+)/);
+    const formattedModule = errorMsg.match(/'0x[0-9a-fA-F]+::([^:]+)::[^']+'/);
+    const formattedAddress = errorMsg.match(/'(0x[0-9a-fA-F]+)::/);
+    if (formattedAbortCode && formattedModule && formattedAddress) {
+        const code = parseInt(formattedAbortCode[1], 10);
+        const module = formattedModule[1].toLowerCase();
+        const address = formattedAddress[1].toLowerCase();
+        if (WOWOK_ADDRESSES.has(address)) {
+            const description = getMoveErrorDescription(module, code) ?? undefined;
+            return { module, code, description };
+        }
+    }
+    return undefined;
+}
+export function classifyError(errorMsg, error) {
+    if (error !== undefined && isWException(error)) {
+        const fromWException = classifyWException(error);
+        if (fromWException) {
+            const abortInfo = extractMoveAbortInfo(errorMsg);
+            if (abortInfo) {
+                fromWException.move_abort_info = abortInfo;
+                if (abortInfo.description && fromWException.recovery_hint && !fromWException.recovery_hint.includes(abortInfo.description)) {
+                    fromWException.recovery_hint = `${fromWException.recovery_hint}. Details: ${abortInfo.description}`;
+                }
+            }
+            return fromWException;
+        }
+    }
     if (!errorMsg) {
         return { error_code: "unknown", retryable: false };
     }
     for (const rule of ERROR_RULES) {
         if (rule.patterns.some((p) => p.test(errorMsg))) {
-            return {
+            const result = {
                 error_code: rule.error_code,
                 retryable: rule.retryable,
                 recovery_hint: rule.recovery_hint,
             };
+            const abortInfo = extractMoveAbortInfo(errorMsg);
+            if (abortInfo) {
+                result.move_abort_info = abortInfo;
+                if (abortInfo.description) {
+                    result.recovery_hint = `${result.recovery_hint}. Details: ${abortInfo.description}`;
+                }
+            }
+            return result;
         }
     }
-    return {
+    const abortInfo = extractMoveAbortInfo(errorMsg);
+    const fallback = {
         error_code: "unknown",
         retryable: false,
         recovery_hint: "Inspect the full error message; consult wowok-tools Skill for the operation's requirements",
     };
+    if (abortInfo) {
+        fallback.move_abort_info = abortInfo;
+        if (abortInfo.description) {
+            fallback.recovery_hint = `${abortInfo.description}. ${fallback.recovery_hint}`;
+        }
+    }
+    return fallback;
 }
 const INTENT_RULES = [
     { operation_type: "service", signals: (d) => d?.publish === true, intent: "publish_service", confidence: 0.95 },
@@ -795,6 +1124,56 @@ function buildCustomerAdvice(operation_type, data, safeResult) {
         advice.risk_level = riskLevel;
     return advice;
 }
+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,
+                };
+            }
+        }
+        if (operation_type === "gen_passport") {
+            const status = safeResult?.error ? "fail" : "pass";
+            return {
+                current_round: "R8",
+                test_result: {
+                    status: status,
+                    passport_id: status === "pass" ? safeResult?.passport : undefined,
+                    failure_node: status === "fail"
+                        ? (typeof safeResult?.error === "string" ? safeResult.error.slice(0, 120) : undefined)
+                        : undefined,
+                },
+            };
+        }
+        const errorStr = typeof safeResult?.error === "string" ? safeResult.error : "";
+        if (errorStr.includes("GUARD") || errorStr.includes("Guard") || errorStr.includes("guard")) {
+            return {
+                risk_warnings: [
+                    `Guard 验证失败: ${errorStr.slice(0, 200)}`,
+                    "建议: 检查提交数据是否符合 Guard table 声明，或查询 Guard 定义了解所需 submission",
+                ],
+            };
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function buildSemantic(safeResult, context) {
     if (!context)
         return undefined;
@@ -820,7 +1199,8 @@ export function buildSemantic(safeResult, context) {
         }
     }
     let experience;
-    if (isRuntimeEnabled("experience_layer")) {
+    const experienceLayerEnabled = isRuntimeEnabled("experience_layer");
+    if (experienceLayerEnabled) {
         try {
             const feedback = getExperienceFeedback(context.operation_type, context.data, intent);
             if (feedback) {
@@ -828,7 +1208,8 @@ export function buildSemantic(safeResult, context) {
             }
             const outcome = status === "success" ? "success" : status === "failed" ? "failed" : "partial";
             const referencedObjects = [...created, ...modified].map((o) => o.id).filter(Boolean);
-            recordOperationOutcome(context.operation_type, context.data, intent, outcome, undefined, referencedObjects);
+            const errCode = inferErrorCodeForSignal(safeResult);
+            recordOperationOutcome(context.operation_type, context.data, intent, outcome, errCode, referencedObjects);
         }
         catch {
         }
@@ -839,7 +1220,7 @@ export function buildSemantic(safeResult, context) {
             const industryHint = (typeof context.data?.industry === "string" && context.data.industry.trim())
                 ? context.data.industry.trim()
                 : undefined;
-            if (industryHint) {
+            if (industryHint && !experienceLayerEnabled) {
                 const outcome = status === "success"
                     ? { success: true }
                     : { success: false, error_code: inferErrorCodeForSignal(safeResult) };
@@ -875,6 +1256,12 @@ export function buildSemantic(safeResult, context) {
     }
     catch {
     }
+    let guard_advice;
+    try {
+        guard_advice = buildGuardAdvice(context.operation_type, context.data, safeResult);
+    }
+    catch {
+    }
     return {
         intent,
         status,
@@ -889,6 +1276,7 @@ export function buildSemantic(safeResult, context) {
         service_status,
         customer_advice,
         evolution_context,
+        guard_advice,
     };
 }
 function inferErrorCodeForSignal(safeResult) {