@wowok/agent-mcp 2.6.3 → 2.6.6

package/dist/schemas/trust_score.schema.json

@@ -26,7 +26,272 @@
             "evaluate",
             "preorder"
           ],
-          "description": "InfoPuzzle collection depth. browse: only Service basics + trust score; evaluate (default): + workflow/fund/trust dimensions risk assessment; preorder: + merchant behavior + market context (most thorough)."
+          "description": "InfoPuzzle collection depth. browse: only Service basics + trust score; evaluate (default): + workflow/fund/trust dimensions risk assessment; preorder: + full preorder advice (confidence, game strategies, preference match, industry risks, blocking reminders)."
+        },
+        "industry": {
+          "type": "string",
+          "enum": [
+            "freelance",
+            "rental",
+            "education",
+            "travel",
+            "subscription",
+            "retail"
+          ],
+          "description": "Explicit industry override for industry-specific risk checks and needs matrix. If omitted at depth=preorder, the industry is inferred from the puzzle."
+        },
+        "preferences": {
+          "type": "object",
+          "properties": {
+            "price_sensitivity": {
+              "type": "string",
+              "enum": [
+                "low",
+                "medium",
+                "high"
+              ]
+            },
+            "budget_range": {
+              "type": "object",
+              "properties": {
+                "min": {
+                  "type": [
+                    "string",
+                    "number"
+                  ],
+                  "description": "Budget lower bound (smallest token unit)."
+                },
+                "max": {
+                  "type": [
+                    "string",
+                    "number"
+                  ],
+                  "description": "Budget upper bound (smallest token unit)."
+                }
+              },
+              "required": [
+                "min",
+                "max"
+              ],
+              "additionalProperties": false
+            },
+            "value_orientation": {
+              "type": "string",
+              "enum": [
+                "quality",
+                "balanced",
+                "budget"
+              ]
+            },
+            "discount_sensitivity": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "delivery_speed_priority": {
+              "type": "string",
+              "enum": [
+                "urgent",
+                "normal",
+                "flexible"
+              ]
+            },
+            "max_acceptable_cycle": {
+              "type": "number",
+              "minimum": 0,
+              "description": "Max acceptable delivery cycle (days)."
+            },
+            "response_time_expectation": {
+              "type": "number",
+              "minimum": 0,
+              "description": "Expected merchant response time (hours)."
+            },
+            "merchant_preference": {
+              "type": "string",
+              "enum": [
+                "established",
+                "emerging",
+                "neutral"
+              ]
+            },
+            "min_order_history": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "bargain_hunting": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "reward_seeking": {
+              "type": "boolean"
+            },
+            "referral_participation": {
+              "type": "boolean"
+            },
+            "communication_style": {
+              "type": "string",
+              "enum": [
+                "formal",
+                "casual",
+                "friendly"
+              ]
+            },
+            "transparency_demand": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "after_sales_expectation": {
+              "type": "string",
+              "enum": [
+                "full",
+                "basic",
+                "minimal"
+              ]
+            },
+            "risk_appetite": {
+              "type": "string",
+              "enum": [
+                "conservative",
+                "balanced",
+                "aggressive"
+              ]
+            },
+            "min_trust_score": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 100
+            },
+            "require_arbitration": {
+              "type": "boolean"
+            },
+            "require_compensation_fund": {
+              "type": "boolean"
+            },
+            "preferred_industries": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "preferred_tokens": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "preferred_merchants": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          },
+          "additionalProperties": false,
+          "description": "Optional user preference overrides (partial; merged over profile-derived defaults). Only used at depth=preorder for preference matching and pref-aware strategies."
+        },
+        "user_metrics": {
+          "type": "object",
+          "properties": {
+            "metrics": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "name": {
+                    "type": "string",
+                    "description": "Stable metric identifier (e.g. 'merchant_tenure_days')."
+                  },
+                  "label": {
+                    "type": "string",
+                    "description": "Human-readable label shown to the user."
+                  },
+                  "evaluator": {
+                    "type": "string",
+                    "enum": [
+                      "threshold",
+                      "ratio",
+                      "boolean",
+                      "presence",
+                      "regex_match",
+                      "custom_query"
+                    ],
+                    "description": "How the metric is evaluated against the puzzle context."
+                  },
+                  "params": {
+                    "type": "object",
+                    "properties": {
+                      "path": {
+                        "type": "string",
+                        "description": "JSON path in the raw data context (e.g. 'service.name')."
+                      },
+                      "threshold": {
+                        "type": [
+                          "string",
+                          "number"
+                        ],
+                        "description": "Threshold value (threshold/presence evaluators)."
+                      },
+                      "invert": {
+                        "type": "boolean",
+                        "description": "true: pass when value <= threshold."
+                      },
+                      "min": {
+                        "type": "number",
+                        "description": "Min ratio (ratio evaluator)."
+                      },
+                      "max": {
+                        "type": "number",
+                        "description": "Max ratio (ratio evaluator)."
+                      },
+                      "pattern": {
+                        "type": "string",
+                        "description": "Regex pattern (regex_match evaluator)."
+                      },
+                      "query_key": {
+                        "type": "string",
+                        "description": "Custom query identifier (custom_query evaluator)."
+                      }
+                    },
+                    "additionalProperties": false
+                  },
+                  "weight": {
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1,
+                    "description": "Relative weight vs other user metrics (0-1)."
+                  },
+                  "advice_on_fail": {
+                    "type": "string"
+                  },
+                  "advice_on_pass": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "name",
+                  "label",
+                  "evaluator",
+                  "params",
+                  "weight"
+                ],
+                "additionalProperties": false
+              },
+              "minItems": 1,
+              "description": "User-defined scoring factors."
+            },
+            "adjustment_cap": {
+              "type": "number",
+              "exclusiveMinimum": 0,
+              "description": "Global cap for the composite confidence adjustment (default ±10 points)."
+            }
+          },
+          "required": [
+            "metrics"
+          ],
+          "additionalProperties": false,
+          "description": "Optional user-controllable scoring factors (评分体系用户可控). Evaluated at depth=preorder; the composite adjustment (±cap) nudges the order confidence score."
         },
         "network": {
           "type": "string",
@@ -35,6 +300,15 @@
         "no_cache": {
           "type": "boolean",
           "description": "Skip object cache and force a fresh on-chain query."
+        },
+        "compare_with": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "minItems": 1,
+          "maxItems": 9,
+          "description": "Optional candidate Service addresses/LocalMark names (1-9) for deterministic multi-service comparison. Only used at depth=preorder. The SAME preferences/user_metrics/industry are applied uniformly to all candidates; output gains a `comparison` block with per-metric bests (NO overall ranking — the buyer decides)."
         }
       },
       "required": [

package/dist/tools/handlers/onchain.js

@@ -6,7 +6,7 @@ import { handlePermissionOperations } from "../../schema/call/permission-handler
 import { collectPermissionIndexes, checkPermissionAuthorization, formatPermissionWarning, } from "../../schema/utils/permission-machine-check.js";
 import { isProjectServiceEnabled, normalize as projectNormalize, } from "../../project/index.js";
 import { getSkillsHintForOnchain } from "../../schema/utils/skills-recommendation.js";
-import { processFundOperation, generateSkillsHint as generateFundSkillsHint } from "../../knowledge/fund-layer.js";
+import { prepareFundOperation, generateSkillsHint as generateFundSkillsHint } from "../../knowledge/fund-layer.js";
 import { generateGuardSubmissionPrompt, formatSubmissionPrompt } from "../../knowledge/guard-submission-prompt.js";
 import { withHarness } from "../shared.js";
 function formatRecipientLabel(recipient) {
@@ -242,6 +242,45 @@ async function detectServiceGuardCircularDependency(data) {
         },
     };
 }
+function buildFundBlockResult(fund, operationType) {
+    const hasMismatch = fund.matchErrors.length > 0;
+    const hasInputErrors = fund.errors.length > 0;
+    const title = hasMismatch && hasInputErrors
+        ? "FUND OPERATION BLOCKED"
+        : hasMismatch
+            ? "TOKEN TYPE MISMATCH — operation blocked"
+            : "FUND INPUT BLOCKED — operation blocked";
+    const errorCode = hasMismatch && hasInputErrors
+        ? "fund_blocked"
+        : hasMismatch
+            ? "token_type_mismatch"
+            : "fund_input_error";
+    const errorText = `⛔ ${title}\n\n` +
+        fund.blockingErrors.map(e => `  • ${e}`).join("\n") +
+        `\n\nThe token type of a generic on-chain object (e.g. Treasury<T>, Service<T>) is ` +
+        `determined at creation and can NEVER be changed, and monetary input is never ` +
+        `processed with unknown token precision. This ${operationType} operation was ` +
+        `NOT executed. Fix the errors above and re-issue the operation` +
+        (fund.objectTokenType ? ` (object token type: ${fund.objectTokenType})` : "") + ".";
+    return {
+        content: [{ type: "text", text: errorText }],
+        structuredContent: {
+            result: {
+                type: "error",
+                error: fund.blockingErrors.join(" | "),
+                error_code: errorCode,
+                retryable: true,
+                recovery_hint: `Use token type ${fund.objectTokenType ?? "<the object's generic token type>"} for all ` +
+                    `amounts, coins, and receive records in this ${operationType} operation. ` +
+                    `Query the object via query_toolkit onchain_objects to confirm its generic ` +
+                    `token type (type_raw, e.g. "0x2::treasury::Treasury<0x2::wow::WOW>"). ` +
+                    `For precision-unavailable tokens, retry the operation — the on-chain ` +
+                    `metadata lookup may have been transient.`,
+            },
+            message: "Fund operation blocked before execution.",
+        },
+    };
+}
 export async function handleOnchainOperations(args) {
     let validated;
     let constraintWarnings = [];
@@ -350,7 +389,10 @@ export async function handleOnchainOperations(args) {
                 if (circularDepGuide) {
                     return circularDepGuide;
                 }
-                const fundResult = await processFundOperation(data, "service", env?.network);
+                const fundResult = await prepareFundOperation(data, "service", env?.network);
+                if (fundResult.blockingErrors.length > 0) {
+                    return buildFundBlockResult(fundResult, "service");
+                }
                 constraintWarnings.push(...fundResult.warnings);
                 if (fundResult.confirmation) {
                     constraintWarnings.push(fundResult.confirmation.message);
@@ -511,10 +553,10 @@ export async function handleOnchainOperations(args) {
                                 `  - The Order object is the bridge: it has 'progress' (Machine) and 'dispute' (Arb list) fields\n` +
                                 `  - When Arb rules, it calls order::compensate() — the ONLY connection to the business flow\n\n` +
                                 `CORRECT PATTERN:\n` +
-                                `  - Machine: business states only (ordered -> shipped -> delivered -> refunded -> completed)\n` +
+                                `  - Machine: business states only (ordered -> shipped -> delivered -> completed)\n` +
                                 `  - Arbitration: separate object with its own Permission (NOT shared with Service)\n` +
                                 `  - Arb: 7-state lifecycle (Principal_confirming -> Arbitrator_confirming -> Voting -> Arbitrated -> Objectionable -> Finished -> Withdrawn)\n` +
-                                `  - Use 'refunded'/'cancelled' nodes for the BUSINESS OUTCOME of a dispute, not 'disputed'\n\n` +
+                                `  - R-M1-11: NEVER name nodes 'refunded'/'disputed'/'arb'/'refund' — use business states ('cancelled'/'returned') for dispute OUTCOMES; refunds route via Allocator triggered by those states, disputes via the separate Arbitration object\n\n` +
                                 `If this node name is a legitimate business state (not arbitration), ignore this warning.`);
                         }
                     }
@@ -612,7 +654,10 @@ export async function handleOnchainOperations(args) {
                 return output;
             }
             case "arbitration": {
-                const arbFundResult = await processFundOperation(validated.data, "arbitration", env?.network);
+                const arbFundResult = await prepareFundOperation(validated.data, "arbitration", env?.network);
+                if (arbFundResult.blockingErrors.length > 0) {
+                    return buildFundBlockResult(arbFundResult, "arbitration");
+                }
                 constraintWarnings.push(...arbFundResult.warnings);
                 if (arbFundResult.confirmation) {
                     constraintWarnings.push(arbFundResult.confirmation.message);
@@ -638,7 +683,10 @@ export async function handleOnchainOperations(args) {
                 return output;
             }
             case "treasury": {
-                const trFundResult = await processFundOperation(validated.data, "treasury", env?.network);
+                const trFundResult = await prepareFundOperation(validated.data, "treasury", env?.network);
+                if (trFundResult.blockingErrors.length > 0) {
+                    return buildFundBlockResult(trFundResult, "treasury");
+                }
                 constraintWarnings.push(...trFundResult.warnings);
                 if (trFundResult.confirmation) {
                     constraintWarnings.push(trFundResult.confirmation.message);
@@ -655,7 +703,10 @@ export async function handleOnchainOperations(args) {
                 return output;
             }
             case "reward": {
-                const rwFundResult = await processFundOperation(validated.data, "reward", env?.network);
+                const rwFundResult = await prepareFundOperation(validated.data, "reward", env?.network);
+                if (rwFundResult.blockingErrors.length > 0) {
+                    return buildFundBlockResult(rwFundResult, "reward");
+                }
                 constraintWarnings.push(...rwFundResult.warnings);
                 if (rwFundResult.confirmation) {
                     constraintWarnings.push(rwFundResult.confirmation.message);
@@ -673,6 +724,17 @@ export async function handleOnchainOperations(args) {
                 return output;
             }
             case "allocation": {
+                const alFundResult = await prepareFundOperation(validated.data, "allocation", env?.network);
+                if (alFundResult.blockingErrors.length > 0) {
+                    return buildFundBlockResult(alFundResult, "allocation");
+                }
+                constraintWarnings.push(...alFundResult.warnings);
+                if (alFundResult.confirmation) {
+                    constraintWarnings.push(alFundResult.confirmation.message);
+                    const fundHint = generateFundSkillsHint(alFundResult.confirmation);
+                    if (fundHint)
+                        constraintWarnings.push(fundHint);
+                }
                 const callAllocation = new CallAllocation(validated.data);
                 const result = validated.submission
                     ? await callAllocation.call_with_submission(env, await transformSubmission(validated.submission))
@@ -824,7 +886,10 @@ export async function handleOnchainOperations(args) {
                 return output;
             }
             case "payment": {
-                const payFundResult = await processFundOperation(validated.data, "payment", env?.network);
+                const payFundResult = await prepareFundOperation(validated.data, "payment", env?.network);
+                if (payFundResult.blockingErrors.length > 0) {
+                    return buildFundBlockResult(payFundResult, "payment");
+                }
                 constraintWarnings.push(...payFundResult.warnings);
                 if (payFundResult.confirmation) {
                     constraintWarnings.push(payFundResult.confirmation.message);

package/dist/tools/handlers/project.js

@@ -5,6 +5,10 @@ import { validateStageGate } from "../../project/stage-gate.js";
 import { scanDeployment } from "../../knowledge/deployment-scanner.js";
 import { handleListProjects, handleCreateProject, handleCreateProjectFromOnchain, handleUpdateProject, handleGetProjectDetail, handleAddObject, handleRemoveObject, handleUpdateObject, handleCreateVersion, handleBuildGraph, handleGetGraph, handleEvaluateProject, handleSaveEvaluation, handleCompareProjects, handleRefreshObjects, handleGetObjectDiff, handleDeleteProject, handleGetMachineGraph, handleGetGuardGraph, handlePreEvaluateCheck, handleVerifyDeployment, handleCloneProjectToNetwork, handleMigrateToMainnet, } from "../../project/handlers.js";
 import { handlePlanObjectEdit, handleApplyObjectEdit, handlePatchMachineNodes, handlePatchGuardTree, } from "../../project/edit-planner.js";
+import { handleRecommendIndustry, handleListModes, handleDeriveUserMode, handleEvolveUserMode, handleRegisterUserMode, handleUnregisterUserMode, handleRegisterCustomMetric, handleRegisterCustomConstraint, handleListMetricsConstraints, } from "../../project/mode-actions.js";
+import { handleAnalyzeIntent, handleAggregateRisks, handleTraceSubsteps, } from "../../project/pipeline-actions.js";
+import { handleMerchantGuide } from "../../project/merchant-guide.js";
+import { handleParticipationRadar } from "../../project/participation-radar.js";
 import { strictParse } from "../../schema/index.js";
 import { ProjectOperationInputSchema } from "../../schema/project/index.js";
 import { getStageCache } from "../../project/index.js";
@@ -152,6 +156,48 @@ export async function handleProjectOperation(args) {
         case "patch_guard_tree":
             result = await handlePatchGuardTree(validated);
             break;
+        case "recommend_industry":
+            result = handleRecommendIndustry(validated);
+            break;
+        case "list_modes":
+            result = await handleListModes();
+            break;
+        case "derive_user_mode":
+            result = await handleDeriveUserMode(validated);
+            break;
+        case "evolve_user_mode":
+            result = await handleEvolveUserMode(validated);
+            break;
+        case "register_user_mode":
+            result = await handleRegisterUserMode(validated);
+            break;
+        case "unregister_user_mode":
+            result = await handleUnregisterUserMode(validated);
+            break;
+        case "register_custom_metric":
+            result = handleRegisterCustomMetric(validated);
+            break;
+        case "register_custom_constraint":
+            result = handleRegisterCustomConstraint(validated);
+            break;
+        case "list_metrics_constraints":
+            result = handleListMetricsConstraints(validated);
+            break;
+        case "analyze_intent":
+            result = handleAnalyzeIntent(validated);
+            break;
+        case "aggregate_risks":
+            result = handleAggregateRisks(validated);
+            break;
+        case "trace_substeps":
+            result = handleTraceSubsteps(validated);
+            break;
+        case "merchant_guide":
+            result = await handleMerchantGuide(validated);
+            break;
+        case "participation_radar":
+            result = await handleParticipationRadar(validated);
+            break;
         default:
             throw new Error(`Unknown project_operation action: ${String(action)}`);
     }

package/dist/tools/handlers/query.js

@@ -1,7 +1,46 @@
 import { strictParse, WatchQueryOperationsSchema, OnchainTableDataSchema, OnchainEventsInputSchema, ProtocolInfoQuerySchema, } from "../../schema/index.js";
 import { query_local_mark_list, query_account_list, query_local_info_list, query_local_token_list, query_account, GetLocalNamesByAddresses, query_personal, query_objects, query_table, query_tableItem, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_received, queryProtocolInfo, query_events, query_transaction, query_object_history, query_address_activity, generateNodeComments, } from "@wowok/wowok";
 import { buildDataSemantic, } from "../../schema/call/semantic.js";
+import { formatChainValue, annotateObjectMonetaryFields, annotateTableItemMonetaryFields, annotateEventsMonetaryFields, annotateBalanceChanges, resolveParentObjectTokenType, convertTokenValue, } from "../../knowledge/fund-layer.js";
 import { normalizeAccountOrMark } from "./messenger.js";
+async function annotateAccountBalance(result, network) {
+    if (!result || typeof result !== "object")
+        return;
+    const displays = {};
+    const convert = (raw, coinType) => {
+        if (raw === null || raw === undefined)
+            return undefined;
+        if (typeof raw !== "string" && typeof raw !== "number" && typeof raw !== "bigint")
+            return undefined;
+        if (typeof coinType !== "string" || !coinType)
+            return undefined;
+        return formatChainValue(raw, coinType, network);
+    };
+    const balance = result.balance;
+    if (balance && typeof balance === "object") {
+        const coinType = balance.coinType;
+        const total = await convert(balance.totalBalance, coinType);
+        if (total)
+            displays["balance.totalBalance"] = total;
+        if (balance.lockedBalance !== undefined) {
+            const locked = await convert(balance.lockedBalance, coinType);
+            if (locked)
+                displays["balance.lockedBalance"] = locked;
+        }
+    }
+    const coinData = result.coin?.data;
+    if (Array.isArray(coinData)) {
+        for (let i = 0; i < coinData.length; i++) {
+            const c = coinData[i];
+            const d = await convert(c?.balance, c?.coinType);
+            if (d)
+                displays[`coin.data[${i}].balance`] = d;
+        }
+    }
+    if (Object.keys(displays).length > 0) {
+        result._money_display = displays;
+    }
+}
 export async function handleWatchQueryOperations(args) {
     const validated = strictParse(WatchQueryOperationsSchema, args, "watch_and_query input");
     let result;
@@ -34,6 +73,7 @@ export async function handleWatchQueryOperations(args) {
                 coin: validated.coin,
                 network: validated.network,
             });
+            await annotateAccountBalance(queryResult, validated.network);
             result = { query_type: "account_balance", result: queryResult };
             break;
         }
@@ -100,6 +140,13 @@ export async function handleWatchQueryOperations(args) {
                     }
                     return obj;
                 });
+                for (const obj of queryResult.objects) {
+                    try {
+                        await annotateObjectMonetaryFields(obj, validated.network);
+                    }
+                    catch {
+                    }
+                }
             }
             result = { query_type: "onchain_objects", result: queryResult };
             break;
@@ -113,7 +160,37 @@ export async function handleWatchQueryOperations(args) {
                 no_cache: validated.no_cache,
                 network: validated.network,
             });
-            result = { query_type: "onchain_received", result: queryResult };
+            const qr = queryResult;
+            if (qr && typeof qr === "object" && typeof qr.balance === "bigint") {
+                const tokenType = qr.token_type;
+                qr.balance = qr.balance.toString();
+                if (Array.isArray(qr.received)) {
+                    for (const item of qr.received) {
+                        if (item && typeof item.balance === "bigint") {
+                            item.balance = item.balance.toString();
+                        }
+                    }
+                }
+                if (tokenType) {
+                    try {
+                        const displays = {
+                            balance: await formatChainValue(qr.balance, tokenType, validated.network),
+                        };
+                        if (Array.isArray(qr.received)) {
+                            for (let i = 0; i < qr.received.length; i++) {
+                                const b = qr.received[i]?.balance;
+                                if (b !== undefined && b !== null) {
+                                    displays[`received[${i}].balance`] = await formatChainValue(b, tokenType, validated.network);
+                                }
+                            }
+                        }
+                        qr._money_display = displays;
+                    }
+                    catch {
+                    }
+                }
+            }
+            result = { query_type: "onchain_received", result: qr };
             break;
         }
         case "onchain_transaction": {
@@ -122,6 +199,11 @@ export async function handleWatchQueryOperations(args) {
                 no_cache: validated.no_cache,
                 network: validated.network,
             });
+            try {
+                await annotateBalanceChanges(queryResult?.balance_changes, validated.network);
+            }
+            catch {
+            }
             result = { query_type: "onchain_transaction", result: queryResult };
             break;
         }
@@ -152,8 +234,20 @@ export async function handleWatchQueryOperations(args) {
             result = { query_type: "onchain_address_activity", result: queryResult };
             break;
         }
+        case "token_value_convert": {
+            const hasRaw = validated.raw !== undefined;
+            const hasUnit = validated.unit !== undefined;
+            if (hasRaw === hasUnit) {
+                throw new Error(`token_value_convert: provide EXACTLY ONE of 'raw' (u64 smallest units → unit value) ` +
+                    `or 'unit' (unit value → u64 raw). Received raw=${JSON.stringify(validated.raw)}, ` +
+                    `unit=${JSON.stringify(validated.unit)}.`);
+            }
+            const conversion = await convertTokenValue(validated.token_type, hasRaw ? { raw: validated.raw } : { unit: validated.unit }, validated.network);
+            result = { query_type: "token_value_convert", result: conversion };
+            break;
+        }
         default:
-            throw new Error(`Unknown query type. Valid query_types are: "local_mark_list", "account_list", "local_info_list", "token_list", "account_balance", "local_names", "onchain_personal_profile", "onchain_objects", "onchain_received", "onchain_transaction", "onchain_object_history", "onchain_address_activity". For table queries, use the "onchain_table_data" tool.`);
+            throw new Error(`Unknown query type. Valid query_types are: "local_mark_list", "account_list", "local_info_list", "token_list", "account_balance", "local_names", "onchain_personal_profile", "onchain_objects", "onchain_received", "onchain_transaction", "onchain_object_history", "onchain_address_activity", "token_value_convert". For table queries, use the "onchain_table_data" tool.`);
     }
     return {
         content: [{ type: "text", text: JSON.stringify({ result }) }],
@@ -202,6 +296,14 @@ export async function handleOnchainTableData(args) {
                 parent: validated.parent, address: validated.address,
                 no_cache: validated.no_cache, network: validated.network,
             });
+            if (queryResult) {
+                try {
+                    const parentToken = await resolveParentObjectTokenType(validated.parent, validated.network);
+                    await annotateTableItemMonetaryFields(queryResult, parentToken, validated.network);
+                }
+                catch {
+                }
+            }
             result = { query_type: "onchain_table_item_reward_record", result: queryResult };
             break;
         }
@@ -218,6 +320,14 @@ export async function handleOnchainTableData(args) {
                 parent: validated.parent, address: validated.address,
                 no_cache: validated.no_cache, network: validated.network,
             });
+            if (queryResult) {
+                try {
+                    const parentToken = await resolveParentObjectTokenType(validated.parent, validated.network);
+                    await annotateTableItemMonetaryFields(queryResult, parentToken, validated.network);
+                }
+                catch {
+                }
+            }
             result = { query_type: "onchain_table_item_treasury_history", result: queryResult };
             break;
         }
@@ -298,6 +408,11 @@ export async function handleOnchainEvents(args) {
         no_cache: validated.no_cache,
         network: validated.network,
     });
+    try {
+        await annotateEventsMonetaryFields(queryResult?.data, validated.network);
+    }
+    catch {
+    }
     return {
         content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
         structuredContent: {