@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/extensions/registry.js

@@ -1,3 +1,4 @@
+import { UserModeStorage } from "@wowok/wowok";
 import { CapabilityRegistry } from "./capability-manifest.js";
 import { ModeEvaluator } from "./mode-evaluator.js";
 import { MetricRegistry } from "./metric-registry.js";
@@ -10,6 +11,8 @@ export class IndustryModeRegistry {
     aliases = new Map();
     evaluator;
     initialized = false;
+    persistence = new UserModeStorage();
+    userModesLoaded = false;
     static Instance() {
         if (!IndustryModeRegistry.instance) {
             IndustryModeRegistry.instance = new IndustryModeRegistry();
@@ -100,7 +103,8 @@ export class IndustryModeRegistry {
         }
         return this.evaluator.evaluateMigration(source, target);
     }
-    registerUserMode(mode, userId) {
+    async registerUserMode(mode, userId) {
+        await this.ensureUserModesLoaded();
         if (!mode.name || !mode.owner || !mode.machine_shape)
             return false;
         if (mode.source !== "custom")
@@ -116,13 +120,15 @@ export class IndustryModeRegistry {
             mode.evolution_history = [{
                     version: mode.version || "v1",
                     changed_at: Date.now(),
-                    changes: ["初始注册（registerUserMode）"],
+                    changes: ["Initial registration (registerUserMode)"],
                 }];
         }
         this.userModes.set(userKey, mode);
+        await this.persistUserMode(mode);
         return true;
     }
-    deriveMode(sourceMode, modifications, userId, newName, newDisplayName) {
+    async deriveMode(sourceMode, modifications, userId, newName, newDisplayName) {
+        await this.ensureUserModesLoaded();
         const source = this.getMode(sourceMode);
         if (!source)
             return undefined;
@@ -161,13 +167,15 @@ export class IndustryModeRegistry {
             evolution_history: [{
                     version: "v1",
                     changed_at: Date.now(),
-                    changes: [`从 builtin '${sourceMode}' 派生`],
+                    changes: [`Derived from builtin '${sourceMode}'`],
                 }],
         };
         this.userModes.set(userKey, derived);
+        await this.persistUserMode(derived);
         return derived;
     }
-    evolveMode(modeName, updates, userId, changeDescription, bumpVersion = true) {
+    async evolveMode(modeName, updates, userId, changeDescription, bumpVersion = true) {
+        await this.ensureUserModesLoaded();
         const userKey = this.userModeKey(userId, modeName);
         const existing = this.userModes.get(userKey);
         if (!existing)
@@ -193,9 +201,11 @@ export class IndustryModeRegistry {
             version: newVersion,
         };
         this.userModes.set(userKey, evolved);
+        await this.persistUserMode(evolved);
         return evolved;
     }
-    listUserModes(userId) {
+    async listUserModes(userId) {
+        await this.ensureUserModesLoaded();
         const result = [];
         for (const mode of this.userModes.values()) {
             if (mode.owner === userId) {
@@ -204,26 +214,71 @@ export class IndustryModeRegistry {
         }
         return result;
     }
-    getUserMode(modeName, userId) {
+    async getUserMode(modeName, userId) {
+        await this.ensureUserModesLoaded();
         const userKey = this.userModeKey(userId, modeName);
         return this.userModes.get(userKey);
     }
-    unregisterUserMode(modeName, userId) {
+    async unregisterUserMode(modeName, userId) {
+        await this.ensureUserModesLoaded();
         const userKey = this.userModeKey(userId, modeName);
-        return this.userModes.delete(userKey);
+        const removed = this.userModes.delete(userKey);
+        if (removed) {
+            await this.unpersistUserMode(userId, modeName);
+        }
+        return removed;
     }
     userModeKey(owner, name) {
         return `${owner}:${name}`;
     }
+    async ensureUserModesLoaded() {
+        if (this.userModesLoaded)
+            return;
+        this.userModesLoaded = true;
+        try {
+            const rows = await this.persistence.list();
+            for (const row of rows) {
+                try {
+                    const mode = JSON.parse(row.data);
+                    if (mode?.name && mode?.owner && mode?.machine_shape) {
+                        this.userModes.set(this.userModeKey(row.owner, row.name), mode);
+                    }
+                }
+                catch {
+                    console.warn(`[IndustryModeRegistry] Skipping corrupt user_modes row '${row.owner}:${row.name}'.`);
+                }
+            }
+        }
+        catch (err) {
+            console.warn("[IndustryModeRegistry] Failed to load persisted user modes:", err.message);
+        }
+    }
+    async persistUserMode(mode) {
+        try {
+            await this.persistence.save(mode.owner, mode.name, JSON.stringify(mode));
+        }
+        catch (err) {
+            console.warn(`[IndustryModeRegistry] Failed to persist user mode '${mode.owner}:${mode.name}':`, err.message);
+        }
+    }
+    async unpersistUserMode(owner, name) {
+        try {
+            await this.persistence.delete(owner, name);
+        }
+        catch (err) {
+            console.warn(`[IndustryModeRegistry] Failed to delete persisted user mode '${owner}:${name}':`, err.message);
+        }
+    }
     bumpPatchVersion(version) {
-        const parts = version.replace(/^v/, "").split(".");
+        const stripped = version.replace(/^v/, "");
+        const parts = stripped.split(".");
         if (parts.length < 2)
-            return `v${version}.1`;
+            return `v${stripped}.1`;
         const patch = parseInt(parts[1] ?? "0", 10);
         parts[1] = String(patch + 1);
         return `v${parts.join(".")}`;
     }
-    applyTemplate(name, intent, context) {
+    async applyTemplate(name, intent, context) {
         const builtinMode = this.getMode(name);
         if (builtinMode) {
             const blueprint = this.doApplyTemplate(builtinMode, intent, context);
@@ -232,7 +287,7 @@ export class IndustryModeRegistry {
         }
         if (name.includes(":")) {
             const [owner, modeName] = name.split(":", 2);
-            const userMode = this.getUserMode(modeName, owner);
+            const userMode = await this.getUserMode(modeName, owner);
             if (userMode) {
                 const blueprint = this.doApplyTemplate(userMode, intent, context);
                 this.recordCapabilitiesUsed(userMode);
@@ -247,8 +302,8 @@ export class IndustryModeRegistry {
         this.recordCapabilitiesUsed(general);
         return blueprint;
     }
-    applyUserMode(modeName, userId, intent, context) {
-        const userMode = this.getUserMode(modeName, userId);
+    async applyUserMode(modeName, userId, intent, context) {
+        const userMode = await this.getUserMode(modeName, userId);
         if (!userMode) {
             throw new Error(`User mode '${modeName}' not found for user '${userId}'`);
         }
@@ -333,22 +388,33 @@ export class IndustryModeRegistry {
         const objects = [];
         objects.push(this.makeObject("permission", `${prefix}_permission`, {
             name: `${prefix}_permission`,
-            description: `Permission: 角色权限索引（${mode.display_name}）`,
+            description: `Permission: role permission index (${mode.display_name})`,
             permission_indexes: this.buildPermissionIndexes(mode),
             tags: [`industry:${mode.name}`],
         }));
-        objects.push(this.makeObject("guard", `${prefix}_guard_buy`, {
-            name: `${prefix}_guard_buy`,
-            description: `Guard: 下单验证（${mode.display_name}）`,
-            host: "service",
-            templates: mode.guards.filter(g => g.host === "service").map(g => g.template_id),
-            tags: [`industry:${mode.name}`],
-        }));
+        const serviceGuardName = this.getFirstServiceGuardName(mode, prefix);
+        for (const guard of mode.guards) {
+            const shortName = this.deriveGuardShortName(guard.template_id);
+            const guardName = `${prefix}_guard_${shortName}`;
+            objects.push(this.makeObject("guard", guardName, {
+                name: guardName,
+                description: `Guard: ${guard.purpose} (${mode.display_name})`,
+                host: guard.host,
+                template_id: guard.template_id,
+                tags: [`industry:${mode.name}`, `host:${guard.host}`],
+            }));
+        }
         objects.push(this.makeObject("machine", `${prefix}_machine`, {
             name: `${prefix}_machine`,
-            description: `Machine: 工作流拓扑（${mode.display_name}）— ${mode.machine_shape.length} 节点`,
+            description: `Machine: workflow topology (${mode.display_name}) — ${mode.machine_shape.length} nodes`,
             nodes: mode.machine_shape.map(n => ({ name: n.name, role: n.role })),
-            guard_templates: mode.guards.filter(g => g.host === "machine").map(g => g.template_id),
+            guard_objects: mode.guards
+                .filter(g => g.host === "machine")
+                .map(g => ({
+                template_id: g.template_id,
+                object_name: `${prefix}_guard_${this.deriveGuardShortName(g.template_id)}`,
+                purpose: g.purpose,
+            })),
             permission: `${prefix}_permission`,
             entry_node_forward_hint: {
                 entry_node_name: mode.machine_shape[0]?.name ?? "paid",
@@ -366,31 +432,32 @@ export class IndustryModeRegistry {
         }, true));
         objects.push(this.makeObject("treasury", `${prefix}_treasury`, {
             name: `${prefix}_treasury`,
-            description: `Treasury: 资金托管（${mode.display_name}）`,
+            description: `Treasury: fund escrow (${mode.display_name})`,
             owner_receive: true,
             tags: [`industry:${mode.name}`],
         }));
         objects.push(this.makeObject("allocation", `${prefix}_allocation`, {
             name: `${prefix}_allocation`,
-            description: `Allocation: 分账策略（${mode.display_name}）— ${mode.allocator.description}`,
+            description: `Allocation: allocation strategy (${mode.display_name}) — ${mode.allocator.description}`,
             strategy: mode.allocator,
             treasury: `${prefix}_treasury`,
-            guard: `${prefix}_guard_buy`,
+            guard: serviceGuardName,
             tags: [`industry:${mode.name}`],
         }));
         objects.push(this.makeObject("service", `${prefix}_service`, {
             name: `${prefix}_service`,
-            description: `Service: 业务服务（${mode.display_name}）— ${intent.slice(0, 100)}`,
+            description: `Service: business service (${mode.display_name}) — ${intent.slice(0, 100)}`,
             machine: `${prefix}_machine`,
-            buy_guard: `${prefix}_guard_buy`,
+            buy_guard: serviceGuardName,
             permission: `${prefix}_permission`,
             order_allocators: [`${prefix}_allocation`],
             compensation_fund_balance: 0,
             compensation_fund_required: mode.risk_constraints?.require_compensation_fund ?? false,
+            compensation_fund_coverage_ratio: mode.risk_constraints?.compensation_fund_coverage_ratio ?? 5,
             compensation_fund_add_hint: "Call service.compensation_fund_add with a Coin<T> to deposit. " +
                 "The compensation_fund is a Balance<T> (numeric), not a Treasury object reference. " +
                 "Without deposit, arbitration rulings that award refunds to buyers cannot be paid out. " +
-                "Recommend 5× the max single-order amount (P1-1 evaluation rule).",
+                `Recommend ${mode.risk_constraints?.compensation_fund_coverage_ratio ?? 5}× the max single-order amount (P1-1 evaluation rule, industry: ${mode.name}).`,
             arbitrations: [`${prefix}_arb`],
             rewards: [`${prefix}_reward`],
             business_intent: intent,
@@ -399,25 +466,25 @@ export class IndustryModeRegistry {
         }, true));
         objects.push(this.makeObject("progress", `${prefix}_progress`, {
             name: `${prefix}_progress`,
-            description: `Progress: 订单履约进度（${mode.display_name}）`,
+            description: `Progress: order fulfillment progress (${mode.display_name})`,
             parent: `${prefix}_machine`,
             tags: [`industry:${mode.name}`],
         }));
         objects.push(this.makeObject("arb", `${prefix}_arb`, {
             name: `${prefix}_arb`,
-            description: `Arbitration: 仲裁规则（${mode.display_name}）— ${mode.key_risk}`,
+            description: `Arbitration: arbitration rules (${mode.display_name}) — ${mode.key_risk}`,
             guard: `${prefix}_guard_buy`,
             tags: [`industry:${mode.name}`],
         }));
         objects.push(this.makeObject("reward", `${prefix}_reward`, {
             name: `${prefix}_reward`,
-            description: `Reward: 激励规则（${mode.display_name}）`,
+            description: `Reward: incentive rules (${mode.display_name})`,
             claim_guard: `${prefix}_guard_buy`,
             tags: [`industry:${mode.name}`],
         }));
         objects.push(this.makeObject("contact", `${prefix}_contact`, {
             name: `${prefix}_contact`,
-            description: `Contact: 客服联系（${mode.display_name}）`,
+            description: `Contact: customer service contact (${mode.display_name})`,
             tags: [`industry:${mode.name}`],
         }));
         return objects;
@@ -501,21 +568,21 @@ export class IndustryModeRegistry {
             ?? "";
         const service = find(`${prefix}_service`);
         const machine = find(`${prefix}_machine`);
-        const guard = find(`${prefix}_guard_buy`);
         const permission = find(`${prefix}_permission`);
         const allocation = find(`${prefix}_allocation`);
         const treasury = find(`${prefix}_treasury`);
         const arb = find(`${prefix}_arb`);
         const reward = find(`${prefix}_reward`);
         const progress = find(`${prefix}_progress`);
-        if (!service || !machine || !guard || !permission) {
+        const allGuards = objects.filter(o => o.object_type === "guard");
+        const serviceGuard = allGuards.find(g => g.config?.host === "service");
+        const machineGuards = allGuards.filter(g => g.config?.host === "machine");
+        if (!service || !machine || !permission) {
             const missing = [];
             if (!service)
                 missing.push("service");
             if (!machine)
                 missing.push("machine");
-            if (!guard)
-                missing.push("guard");
             if (!permission)
                 missing.push("permission");
             console.warn(`[buildEdges] Missing core objects: ${missing.join(", ")}. ` +
@@ -524,7 +591,9 @@ export class IndustryModeRegistry {
             return edges;
         }
         edges.push(this.makeEdge(service, machine, "machine", "service.machine", true));
-        edges.push(this.makeEdge(service, guard, "buy_guard", "service.buy_guard", true));
+        if (serviceGuard) {
+            edges.push(this.makeEdge(service, serviceGuard, "buy_guard", "service.buy_guard", true));
+        }
         edges.push(this.makeEdge(service, permission, "permission", "service.permission", true));
         if (allocation)
             edges.push(this.makeEdge(service, allocation, "order_allocators", "service.order_allocators", true));
@@ -533,12 +602,15 @@ export class IndustryModeRegistry {
         if (reward)
             edges.push(this.makeEdge(service, reward, "rewards", "service.rewards", false));
         edges.push(this.makeEdge(machine, permission, "permission", "machine.permission", false));
+        for (const mg of machineGuards) {
+            edges.push(this.makeEdge(machine, mg, "guard", "machine.forwards.guard", false));
+        }
         if (progress)
             edges.push(this.makeEdge(progress, machine, "parent", "progress.parent", false));
         if (allocation && treasury)
             edges.push(this.makeEdge(allocation, treasury, "treasury", "allocation.treasury", false));
-        if (allocation && guard)
-            edges.push(this.makeEdge(allocation, guard, "buy_guard", "allocation.guard", false));
+        if (allocation && serviceGuard)
+            edges.push(this.makeEdge(allocation, serviceGuard, "buy_guard", "allocation.guard", false));
         return edges;
     }
     makeEdge(from, to, edge_kind, field_path, required_at_publish) {
@@ -590,7 +662,7 @@ export class IndustryModeRegistry {
         const service = objects.find(o => o.object_type === "service");
         return [{
                 scenario_id: `${mode.name}_primary`,
-                description: `${mode.display_name} 主流程：${intent.slice(0, 80)}`,
+                description: `${mode.display_name} main flow: ${intent.slice(0, 80)}`,
                 primary_object: service?.entry_id ?? "",
                 supporting_objects: objects.filter(o => o.object_type !== "service").map(o => o.entry_id),
             }];
@@ -607,6 +679,22 @@ export class IndustryModeRegistry {
         catch {
         }
     }
+    deriveGuardShortName(templateId) {
+        if (templateId.startsWith("tpl_")) {
+            const parts = templateId.split("_");
+            return parts[parts.length - 1] || templateId;
+        }
+        const match = templateId.match(/^([a-z]+)_guard_/);
+        if (match)
+            return match[1];
+        return templateId.split("_")[0] || templateId;
+    }
+    getFirstServiceGuardName(mode, prefix) {
+        const serviceGuard = mode.guards.find(g => g.host === "service");
+        if (!serviceGuard)
+            return "";
+        return `${prefix}_guard_${this.deriveGuardShortName(serviceGuard.template_id)}`;
+    }
     makeObject(type, name, config, publish_required = false) {
         return {
             entry_id: `${type}:${name}`,
@@ -626,4 +714,4 @@ export class IndustryModeRegistry {
 export function getIndustryModeRegistry() {
     return IndustryModeRegistry.Instance();
 }
-export const INDUSTRY_MODE_REGISTRY_VERSION = 2.1;
+export const INDUSTRY_MODE_REGISTRY_VERSION = 2.2;

package/dist/extensions/types.d.ts

@@ -68,6 +68,7 @@ export interface ModeRiskConstraints {
     require_compensation_fund: boolean;
     require_wip_evidence: boolean;
     max_single_transaction?: number;
+    compensation_fund_coverage_ratio?: number;
     other_constraints?: string[];
 }
 export interface ModeApplicableConditions {
@@ -110,6 +111,7 @@ export interface IndustryMode {
     applicable_conditions: ModeApplicableConditions;
     similar_industries?: string[];
     novel_capabilities?: string[];
+    disabled_builtin_constraints?: string[];
 }
 export interface UserDefinedMode extends IndustryMode {
     owner: string;

package/dist/index.js

@@ -14,6 +14,47 @@ import { registerAllTools } from "./tools/index.js";
 if (process.env.WOWOK_TELEMETRY === "false" || process.env.WOWOK_TELEMETRY === "0") {
     setTelemetryEnabled(false);
 }
+process.on("unhandledRejection", (reason, promise) => {
+    const reasonStr = reason instanceof Error
+        ? `${reason.name}: ${reason.message}\n${reason.stack ?? ""}`
+        : String(reason);
+    console.error(`[unhandledRejection] ${new Date().toISOString()}`);
+    console.error(`  reason: ${reasonStr}`);
+});
+process.on("uncaughtException", (error) => {
+    console.error(`[uncaughtException] ${new Date().toISOString()}`);
+    console.error(`  name: ${error.name}`);
+    console.error(`  message: ${error.message}`);
+    console.error(`  stack: ${error.stack ?? ""}`);
+});
+process.on("beforeExit", (code) => {
+    console.error(`[beforeExit] ${new Date().toISOString()} code=${code} — event loop empty, process would exit`);
+    console.error(`  active handles: ${process._getActiveHandles?.()?.length ?? "?"}`);
+    console.error(`  active requests: ${process._getActiveRequests?.()?.length ?? "?"}`);
+});
+process.on("exit", (code) => {
+    console.error(`[exit] ${new Date().toISOString()} code=${code} — process exiting`);
+});
+process.stdin.on("end", () => {
+    console.error(`[stdin end] ${new Date().toISOString()} — MCP client closed stdin`);
+});
+process.stdin.on("close", () => {
+    console.error(`[stdin close] ${new Date().toISOString()} — stdin stream closed`);
+});
+let keepaliveTimer = null;
+function startKeepalive() {
+    if (keepaliveTimer)
+        return;
+    keepaliveTimer = setInterval(() => {
+        const mem = process.memoryUsage();
+        const heapUsedMB = Math.round(mem.heapUsed / 1024 / 1024);
+        const heapTotalMB = Math.round(mem.heapTotal / 1024 / 1024);
+        const rssMB = Math.round(mem.rss / 1024 / 1024);
+        const level = heapUsedMB > 1200 ? "WARNING" : heapUsedMB > 800 ? "INFO" : "DEBUG";
+        console.error(`[memory ${level}] heap=${heapUsedMB}MB/${heapTotalMB}MB rss=${rssMB}MB`);
+    }, 60_000);
+}
+startKeepalive();
 const SERVER_DESCRIPTION = `WoWok MCP Server - Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.
 
 ## CRITICAL: Unified Single-Tool Architecture
@@ -210,5 +251,14 @@ async function main() {
         await server.close();
         process.exit(0);
     });
+    process.on("SIGTERM", async () => {
+        console.error(`[SIGTERM] ${new Date().toISOString()} — graceful shutdown`);
+        try {
+            await server.close();
+        }
+        catch {
+        }
+        process.exit(0);
+    });
 }
 main().catch(console.error);

package/dist/knowledge/deployment-scanner.js

@@ -672,7 +672,7 @@ export function analyzeMachineAndServiceReadiness(input) {
                 add(findings, "D-20", "warning", `No Service block in the deployment doc includes a compensation_fund_add step. ` +
                     `Without deposit, arbitration rulings that award refunds to buyers cannot be paid out from the Service. ` +
                     `Industries like freelance may not require this (info), but rental/travel/education typically do.`, "§3.2 / §4.2 Service blocks", `Add a compensation_fund_add step for the Service (e.g., data.compensation_fund_add = {balance: <amount>}). ` +
-                    `Recommended: 5× the max single-order amount (P1-1 evaluation rule).`);
+                    `Recommended: 3-10× the max single-order amount, depending on industry (subscription: 3×, retail: 5×, rental: 10×). See P1-1 evaluation rule.`);
             }
         }
     }

package/dist/knowledge/fund-layer.d.ts

@@ -0,0 +1,138 @@
+import type { ENTRYPOINT } from "@wowok/wowok";
+export interface OfficialTokenEntry {
+    type: string;
+    symbol: string;
+    decimals: number;
+    name: string;
+    description: string;
+}
+export type TokenNetwork = "gas" | "testnet" | "mainnet";
+export declare const OFFICIAL_TOKEN_REGISTRY: Record<TokenNetwork, OfficialTokenEntry[]>;
+export declare function getRegistryForNetwork(network?: string): OfficialTokenEntry[];
+export type TokenSource = "registry" | "cache" | "onchain";
+export interface TokenResolution {
+    type: string;
+    symbol: string;
+    decimals: number;
+    name: string;
+    source: TokenSource;
+    verified: boolean;
+}
+export declare function findInRegistryByType(tokenType: string, network?: string): OfficialTokenEntry | undefined;
+export declare function findInRegistryBySymbol(symbol: string, network?: string): OfficialTokenEntry[];
+export declare function resolveTokenByType(tokenType: string, network?: ENTRYPOINT): Promise<TokenResolution | undefined>;
+export declare function resolveTokensBySymbol(symbol: string, network?: ENTRYPOINT, preferredType?: string): Promise<TokenResolution[]>;
+export interface ParsedAmount {
+    smallestUnit: bigint;
+    displayAmount: string;
+    originalInput: string | number;
+    tokenType: string;
+    tokenSymbol: string;
+    decimals: number;
+    converted: boolean;
+    source: TokenSource;
+    verified: boolean;
+    precision_known: boolean;
+}
+export declare function isAmountWithSymbol(value: unknown): boolean;
+export declare function parseAmount(amount: string | number, tokenType: string, network?: ENTRYPOINT): Promise<ParsedAmount>;
+export declare function smallestToDisplay(value: bigint, decimals: number): string;
+export declare function displayStringToSmallest(display: string, decimals: number): bigint;
+export interface FundFieldConfirmation {
+    path: string;
+    displayAmount: string;
+    tokenType: string;
+    tokenSymbol: string;
+    verified: boolean;
+    source: TokenSource;
+    converted: boolean;
+    context: string;
+}
+export interface TokenAmbiguity {
+    symbol: string;
+    candidates: {
+        type: string;
+        decimals: number;
+        source: TokenSource;
+        verified: boolean;
+    }[];
+}
+export interface FundConfirmationRequest {
+    requiresConfirmation: boolean;
+    reason: string;
+    fields: FundFieldConfirmation[];
+    ambiguities: TokenAmbiguity[];
+    message: string;
+}
+export declare function generateFundConfirmation(fields: FundFieldConfirmation[], ambiguities?: TokenAmbiguity[]): FundConfirmationRequest;
+export interface FundProcessResult {
+    convertedData: any;
+    warnings: string[];
+    errors: string[];
+    confirmation: FundConfirmationRequest | null;
+}
+export interface FundProcessOptions {
+    objectTokenType?: string;
+}
+export declare function processFundOperation(data: any, operationType: string, network?: ENTRYPOINT, options?: FundProcessOptions): Promise<FundProcessResult>;
+export declare function generateSkillsHint(confirmation: FundConfirmationRequest | null): string | null;
+export interface ChainValueDisplay {
+    raw: string;
+    display: string;
+    symbol?: string;
+    decimals?: number;
+    token_type: string;
+    precision_known: boolean;
+    text: string;
+}
+export declare function formatChainValue(raw: string | number | bigint, tokenType: string, network?: ENTRYPOINT): Promise<ChainValueDisplay>;
+export interface TokenDisplayHint {
+    decimals?: number;
+    symbol?: string;
+}
+export declare function registryDisplayHint(tokenType: string | undefined, network?: string): TokenDisplayHint | undefined;
+export declare function clearFundResolutionCaches(): void;
+export declare function knownTokenSuggestions(network?: string): string;
+export declare function formatAmountText(raw: string | number | bigint, decimals?: number, symbol?: string): string;
+export interface TokenValueConversion {
+    token_type: string;
+    symbol?: string;
+    decimals?: number;
+    precision_known: boolean;
+    direction: "raw_to_unit" | "unit_to_raw";
+    input: string;
+    output: string;
+    error?: string;
+    text: string;
+}
+export declare function convertTokenValue(tokenType: string, value: {
+    raw?: string | number | bigint;
+    unit?: string | number;
+}, network?: ENTRYPOINT): Promise<TokenValueConversion>;
+export declare const TOKEN_GENERIC_OBJECT_TYPES: readonly string[];
+export declare function extractGenericTokenType(typeRaw: string | null | undefined): string | undefined;
+export interface ObjectTokenResolution {
+    tokenType?: string;
+    objectType?: string;
+    typeRaw?: string;
+}
+export declare function resolveObjectTokenType(objectRef: string, network?: ENTRYPOINT): Promise<ObjectTokenResolution | undefined>;
+export declare function resolveOperationObjectTokenType(data: any, operationType: string, network?: ENTRYPOINT): Promise<string | undefined>;
+export interface TokenMatchValidation {
+    errors: string[];
+    warnings: string[];
+    objectTokenType?: string;
+}
+export declare function validateOperationTokenMatch(data: any, operationType: string, objectTokenType?: string, network?: ENTRYPOINT): Promise<TokenMatchValidation>;
+export declare function annotateObjectMonetaryFields(obj: any, network?: ENTRYPOINT): Promise<void>;
+export declare function resolveParentObjectTokenType(parentRef: string, network?: ENTRYPOINT): Promise<string | undefined>;
+export declare function annotateTableItemMonetaryFields(item: any, parentTokenType: string | undefined, network?: ENTRYPOINT): Promise<void>;
+export declare function annotateEventMonetaryFields(event: any, network?: ENTRYPOINT): Promise<void>;
+export declare function annotateEventsMonetaryFields(events: any[], network?: ENTRYPOINT): Promise<void>;
+export declare function annotateBalanceChanges(changes: any[], network?: ENTRYPOINT): Promise<void>;
+export interface PreparedFundOperation extends FundProcessResult {
+    matchErrors: string[];
+    objectTokenType?: string;
+    blockingErrors: string[];
+}
+export declare function prepareFundOperation(data: any, operationType: string, network?: ENTRYPOINT): Promise<PreparedFundOperation>;