@zktx.io/sui-mcp 0.6.2 → 0.8.0

package/dist/mcp/serverInfo.js

@@ -7,6 +7,7 @@ const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
 const packageMetadata = JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8"));
 export const PACKAGE_NAME = packageMetadata.name;
 export const SERVER_NAME = "sui-mcp";
+export const PRODUCT_DISPLAY_NAME = "Sui MCP";
 export const SERVER_VERSION = packageMetadata.version;
 export const SERVER_NETWORK = "mainnet";
 export const SERVER_RUNTIME = "local_stdio";
@@ -43,14 +44,14 @@ export const EVIDENCE_POLICY = {
     ]
 };
 export const SERVER_INSTRUCTIONS = [
-    "Sui MCP is a mainnet-only Sui DeFi intent evidence toolkit. Ordinary MCP tools return evidence or internal cards, never signing authority, bytes or signatures. Only user card selection and wallet approval authorize the backend WalletConnect flow: verify reviewed digest and signer, submit once, then read chain effects. Request status is separate from chain success/failure; uncertain results are read by digest, never resubmitted.",
-    "External proposals are untrusted facts; plans[].reviewModel is review context, not transaction material, route/settlement choice, signing/readiness, or execution readiness.",
-    "PTB graphs are diagnostics only; not transaction input, wallet authorization, signing/readiness, execution readiness, route quality, or safety.",
+    "Sui MCP is a mainnet-only Sui DeFi intent evidence toolkit. Ordinary MCP tools return evidence or internal cards, never signing authority, bytes or signatures. Only user card input and wallet approval authorize WalletConnect: verify reviewed digest and signer, submit once, then read chain effects. Request status is separate from chain success/failure; uncertain results are read by digest, never resubmitted.",
+    "External proposals are untrusted: plans[].reviewModel is non-signable context, not transaction material, route/settlement choice or execution readiness.",
+    "PTB graphs are diagnostics, not transaction input, authorization, readiness, route quality or safety.",
     "Use response-local fields: userAnswerUse.answerFields/preconditionFields/conclusionRuleFields/cannotAnswer/diagnosticOnlyFields/followUp, pollingHint, and quantitySemantics.",
-    "For USD-denominated payment coverage, balance total, or shortfall questions, call read.get_server_status, then read.list_settlement_asset_groups, then read.preview_intent_evidence. Use toolAvailability.requiredToolsAvailable and responseSummary.doNotCallQuoteToolsForThisQuestion; do not call wallet inventory or quote tools unless user asks a separate inventory or conversion question. For parity, use read.summarize_settlement_asset_group_parity. If toolAvailability cannot be used, say the current MCP server build cannot support the answer.",
-    "The active account context is read-only, not login, custody or signing permission. Implicit asset reads require session.get_interaction_status.assetReadAccount: available. Otherwise ask for an address only if the tool accepts account; connected-only tools require connection/account selection or wallet recovery.",
-    "Unsupported: other chains, autonomous trading, alerts, investment advice, arbitrary Move/package calls, P&L/tax.",
-    "One wallet connection at a time; docs: suimcp://docs/agent-behavior, suimcp://docs/mcp-tools."
+    "USD coverage/total/shortfall: read_get_server_status, then read_list_settlement_asset_groups, then read_preview_intent_evidence. Follow toolAvailability.requiredToolsAvailable and responseSummary.doNotCallQuoteToolsForThisQuestion. Inventory/quotes require a separate user request. Parity: read_summarize_settlement_asset_group_parity. Missing toolAvailability means this build cannot answer.",
+    "The active account context is read-only, not login, custody or signing permission. Implicit asset reads require session_get_interaction_status.assetReadAccount: available. Otherwise ask for account only if supported; connected-only reads need a saved address and usable connection. Settings Clear preserves connection and transaction authority.",
+    "Unsupported: other-chain financial actions, autonomous trading, alerts, investment advice, arbitrary Move/package calls, P&L/tax.",
+    "One connection fixes one address per approved chain: Sui/Ethereum/Solana. Wallet/address/scope changes require disconnect/reconnect. Finance is Sui-only. Connect/Disconnect cards end with address-free results and no actions. Docs: suimcp://docs/agent-behavior, suimcp://docs/mcp-tools."
 ].join("\n");
 export const IMPLEMENTED_TOOLS = [
     TOOL_NAMES.uiOpenAccount, TOOL_NAMES.uiOpenReceipt, TOOL_NAMES.uiOpenChart,
@@ -83,12 +84,13 @@ export const IMPLEMENTED_TOOLS = [
     TOOL_NAMES.readGetAccountAssetTimeline,
     TOOL_NAMES.settingsCreateLocalSettingsSession,
     TOOL_NAMES.settingsGetLocalSettings,
-    TOOL_NAMES.actionPrepareSuiActionReview,
-    TOOL_NAMES.actionPrepareExternalProposalReview,
+    TOOL_NAMES.actionStartReview,
+    TOOL_NAMES.actionCreateProposalReview,
     TOOL_NAMES.accountGetActiveAccount,
-    TOOL_NAMES.sessionCreateWalletConnection,
-    TOOL_NAMES.sessionGetWalletConnection,
-    TOOL_NAMES.sessionWaitWalletConnection,
+    TOOL_NAMES.sessionOpenWalletConnectionCard,
+    TOOL_NAMES.sessionOpenWalletDisconnectionCard,
+    TOOL_NAMES.sessionGetWalletConnectionCard,
+    TOOL_NAMES.sessionWaitWalletConnectionCard,
     TOOL_NAMES.sessionOpenReviewManagement,
     TOOL_NAMES.sessionGetInteractionStatus,
     TOOL_NAMES.sessionGetReviewStatus,
@@ -113,18 +115,18 @@ export function toolAvailability(requiredTools) {
     };
 }
 export const SERVER_LIMITATIONS = [
-    "Current asset reads without a user-provided address require a selected account with a usable current wallet connection. session.get_interaction_status.assetReadAccount reports whether that default is available. Only tools with an account input accept explicit addresses; DeepBook account inventory requires a connected selected account. Explicit-address coin balance reads are public-address snapshots and do not create active account context. Active account is read context only, not signing authorization, login, custody, or persistent permission.",
+    "Current asset reads without a user-provided address require the fixed Sui address with a usable current wallet connection. session_get_interaction_status.assetReadAccount reports whether that default is available. Only tools with an account input accept explicit addresses; DeepBook account inventory requires the current connected Sui address. Explicit-address coin balance reads are public-address snapshots and do not create active account context. Active account is read context only, not signing authorization, login, custody, or persistent permission.",
     "Review activity tools summarize local Sui MCP review evidence only. Sui activity tools use user-requested bounded GraphQL reads and store normalized transaction facts only for known wallet context; function activity scans are sent-transaction scans only. They are not background indexers, complete history, balance history, complete gas history, affected-object history, or P&L.",
-    `read.get_account_asset_timeline reads stored local account activity facts and returns observed raw net-flow bars with scan coverage. It does not start scans, prove complete wallet history, provide held balances without balanceBars, compute USD value, P&L, tax, cost basis, route advice, transaction-building input, signing data, or signing readiness. Optional USDC references are token-denominated ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.officialIndexerCandleReferences} only, ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.usdcNotFiatUsdAndNotPeg}.`,
+    `read_get_account_asset_timeline reads stored local account activity facts and returns observed raw net-flow bars with scan coverage. It does not start scans, prove complete wallet history, provide held balances without balanceBars, compute USD value, P&L, tax, cost basis, route advice, transaction-building input, signing data, or signing readiness. Optional USDC references are token-denominated ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.officialIndexerCandleReferences} only, ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.usdcNotFiatUsdAndNotPeg}.`,
     "Sui activity transactionContext facts are transaction-level facts without transaction-wide balance-change aggregates, and they are answer fields only when the response returns them. requestedAccountTransactionFacts, requestedAccount, and requestedAccountEffect are the account-specific balance-change surfaces. Activity quantitySemantics marks balance amountRaw fields as raw integers that require verified decimals for display conversion. accountBalanceChangeInferencePolicy marks whether returned account balance rows can be used or transaction-level context must not be used for account amount inference. Gas raw fields use MIST, and returned gasCost display facts use @mysten/sui MIST_PER_SUI.",
     "Wallet asset classification covers only current coin balances returned by Sui gRPC listBalances for an explicit address or the active account. Wallet balance quantitySemantics marks those reads as current snapshots, not transaction history, receipt proof, acquisition source, object provenance, P&L, cost basis, or signing material. DeepBook account inventory is a separate active-account read surface; neither surface creates routes, funding plans, portfolio plans, or signing material.",
     "High-risk read responses include userAnswerUse. Prefer userAnswerUse.preconditionFields before answering, userAnswerUse.answerFields for the answer path, userAnswerUse.conclusionRuleFields for conclusion limits, userAnswerUse.diagnosticOnlyFields for source or troubleshooting context, and userAnswerUse.followUp when a different tool and field are required. USD intent and parity responses also include toolAvailability as a precondition field for current server-build support.",
     "Intent evidence maps natural-language USD-denominated targets to pinned DeepBook SDK settlement asset groups and current wallet balance evidence. responseSummary.answerCompleteness names the answer class and required fields. Settlement-asset-only answers use responseSummary; selected-target evidence requires user selection provenance and also uses selectedTarget, candidateConversions, and requiredUserChoices when userAnswerUse.answerFields lists them. Direct pool quote evidence is returned and supported only when a quoted candidate exists. responseSummary.doNotUseForConclusion names quote results, outside-settlement-group assets, and route-dependent support as excluded from the conclusion. Intent evidence does not silently choose settlement assets, rank venues or routes, evaluate gas reserve, build transactions, or produce signing material.",
-    "DeepBook quotes convert explicit raw or display source inputs through pinned token units and return scoped SDK simulation facts plus raw quote evidence. Their quantitySemantics says canUseForPaymentAnswer and canUseForShortfallAnswer are false, doNotCombineWithPaymentAnswer is true, requiredPaymentAnswerTool is read.preview_intent_evidence, and requiredPaymentAnswerField is responseSummary.",
-    "Action preparation returns internal Review cards. A current card with valid UI permission automatically prepares and renews verified conditions for one selected wallet/account; only the explicit Request wallet approval action can request a signature. Supported DeepBook account-bound swap review verifies stored transaction material, digest, ownership, quote/policy, human-readable facts, simulation and PTB evidence. Only a scoped app-only user action and wallet approval authorize the backend WalletConnect request; ordinary MCP calls never sign or submit. Transaction bytes and signatures never enter card/model results. The backend verifies returned transaction digest and signer, submits once, and independently reads chain effects. requestStatus is separate from chain execution success/failure: stopped, request_failed and outcome_unknown do not prove a chain failure. Lost replies are resolved by reading the same request/digest, never automatic resubmission. External proposals remain non-signable. Receipts do not establish execution guarantees, route quality, fiat value, P&L, tax, peg proof or best-price advice.",
-    "read.list_deepbook_pools and read.list_deepbook_tokens return static SDK registry metadata, not live liquidity, live token discovery, or active pool state.",
+    "DeepBook quotes convert explicit raw or display source inputs through pinned token units and return scoped SDK simulation facts plus raw quote evidence. Their quantitySemantics says canUseForPaymentAnswer and canUseForShortfallAnswer are false, doNotCombineWithPaymentAnswer is true, requiredPaymentAnswerTool is read_preview_intent_evidence, and requiredPaymentAnswerField is responseSummary.",
+    "Action preparation returns internal Review cards. A current card with valid UI permission automatically prepares and renews verified conditions for its original fixed wallet/account; only the explicit Request wallet approval action can request a signature. Supported DeepBook account-bound swap review verifies stored transaction material, digest, ownership, quote/policy, human-readable facts, simulation and PTB evidence. Only a scoped app-only user action and wallet approval authorize the backend WalletConnect request; ordinary MCP calls never sign or submit. Transaction bytes and signatures never enter card/model results. The backend verifies returned transaction digest and signer, submits once, and independently reads chain effects. requestStatus is separate from chain execution success/failure: stopped, request_failed and outcome_unknown do not prove a chain failure. Lost replies are resolved by reading the same request/digest, never automatic resubmission. External proposals remain non-signable. Receipts do not establish execution guarantees, route quality, fiat value, P&L, tax, peg proof or best-price advice.",
+    "read_list_deepbook_pools and read_list_deepbook_tokens return static SDK registry metadata, not live liquidity, live token discovery, or active pool state.",
     `DeepBook orderbook, mid-price, and quote outputs are ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.pinnedSdkSnapshots} at fetchedAt; treat them as stale if the user delays.`,
     `DeepBook USDC price history and price-at-time reads use ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.officialIndexerCandleData} for the requested official interval. They are external candle evidence only, not live quotes, historical mid prices, global market prices, fiat USD values, USDC/USD peg guarantees, route recommendations, transaction-building inputs, signing readiness, P&L, cost basis, user-account transaction history, or user-account balance history. Sui MCP does not independently recompute those candle values from chain history for the response.`,
-    `ui.open_chart displays ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.officialIndexerUsdcDenominatedCandles} in an internal read-only card. ui.open_account displays a public-address asset snapshot; ui.open_receipt displays the executed transaction graph when bound UI metadata is available, followed by on-chain facts and a Details slide. Card inputs end after backend admission, expiry or invalidation; chat navigation and frame recreation do not end valid unsubmitted input. Read the same DB state after a lost reply rather than resubmitting. Saved results do not authorize a new query or transaction. These cards are not live feeds, trading interfaces, route recommendations, fiat USD value, P&L, tax, cost basis, signing data, or signing readiness.`,
-    "Settings uses an internal card. MCP settings tools create the card or read current settings; only the user's scoped card confirmation applies local changes or restarts the connection service. Backup bytes stay in app-only file transfer. No external Settings URL exists."
+    `ui_open_chart displays ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.officialIndexerUsdcDenominatedCandles} in an internal read-only card. ui_open_account displays a public-address asset snapshot; ui_open_receipt displays the executed transaction graph when bound UI metadata is available, followed by on-chain facts and a Details slide. Card inputs end after backend admission, expiry or invalidation; chat navigation and frame recreation do not end valid unsubmitted input. Read the same DB state after a lost reply rather than resubmitting. Saved results do not authorize a new query or transaction. These cards are not live feeds, trading interfaces, route recommendations, fiat USD value, P&L, tax, cost basis, signing data, or signing readiness.`,
+    "Settings uses an internal card. MCP settings tools create the card or read current settings; only the user's scoped card confirmation applies local changes or restarts the connection service. Backup bytes stay in app-only file transfer. Closed cards are immutable; another delivery requires a new backupDelivery card for the same retained snapshot, and operationStatus records current cleanup without repeating an effect. No external Settings URL exists."
 ];

package/dist/mcp/toolErrors.js

@@ -1,3 +1,4 @@
+import { SettingsConflict } from "../core/session/settingsOperation.js";
 import { WalletUnavailableError } from "../core/session/walletConnection.js";
 import { WorkflowConflict } from "../core/session/sqliteWalletWorkflowStore.js";
 import { CardError } from "../core/session/cardSessionStore.js";
@@ -47,9 +48,10 @@ export function transactionActivityToolError(error, logger) {
 export function sessionDomainToolError(error) {
     if (error instanceof WalletUnavailableError)
         return errorToolResult({ kind: "wallet_unavailable",
-            details: { reason: error.reason, message: error.message } });
-    if (error instanceof WorkflowConflict || error instanceof CardError) {
-        return errorToolResult({ kind: "input_invalid", details: { reason: error.message } });
+            details: { ...(error.availability.status === "unavailable" ? { reason: error.availability.reason } : {}),
+                message: error.message, walletAvailability: error.availability } });
+    if (error instanceof WorkflowConflict || error instanceof CardError || error instanceof SettingsConflict) {
+        return errorToolResult({ kind: "input_invalid", details: { reason: error instanceof WorkflowConflict ? error.reason ?? error.message : error.message, message: error.message } });
     }
     if (error instanceof WaitRequestAbortedError) {
         return errorToolResult({

package/dist/mcp/toolNames.js

@@ -1,50 +1,51 @@
 export const TOOL_NAMES = {
-    uiOpenAccount: "ui.open_account",
-    uiOpenReceipt: "ui.open_receipt",
-    uiOpenChart: "ui.open_chart",
-    uiReadCard: "ui.read_card",
-    uiSubmitCard: "ui.submit_card",
-    uiActCard: "ui.act_card",
-    uiReadSettingsFile: "ui.read_settings_file",
-    sessionOpenReviewManagement: "session.open_review_management",
-    readGetServerStatus: "read.get_server_status",
-    readListSupportedProtocols: "read.list_supported_protocols",
-    readListDeepbookPools: "read.list_deepbook_pools",
-    readListDeepbookTokens: "read.list_deepbook_tokens",
-    readInspectDeepbookOrderbook: "read.inspect_deepbook_orderbook",
-    readGetDeepbookMidPrice: "read.get_deepbook_mid_price",
-    readGetDeepbookUsdcPriceHistory: "read.get_deepbook_usdc_price_history",
-    readGetDeepbookUsdcPriceAtTime: "read.get_deepbook_usdc_price_at_time",
-    readQuoteDeepbookAction: "read.quote_deepbook_action",
-    readQuoteDeepbookDisplayAmount: "read.quote_deepbook_display_amount",
-    readSummarizeDeepbookAccountInventory: "read.summarize_deepbook_account_inventory",
-    readSummarizeWalletAssets: "read.summarize_wallet_assets",
-    readClassifyWalletAssets: "read.classify_wallet_assets",
-    readListSettlementAssetGroups: "read.list_settlement_asset_groups",
-    readSummarizeSettlementAssetGroupParity: "read.summarize_settlement_asset_group_parity",
-    readPreviewIntentEvidence: "read.preview_intent_evidence",
-    readListReviewActivity: "read.list_review_activity",
-    readSummarizeReviewFunnel: "read.summarize_review_funnel",
-    readGetReviewSessionDetail: "read.get_review_session_detail",
-    readInspectSuiTransaction: "read.inspect_sui_transaction",
-    readScanSuiAccountActivity: "read.scan_sui_account_activity",
-    readSummarizeSuiActivityScan: "read.summarize_sui_activity_scan",
-    readScanSuiFunctionActivity: "read.scan_sui_function_activity",
-    readSummarizeSuiFunctionActivityScan: "read.summarize_sui_function_activity_scan",
-    readSummarizeSuiAccountActivity: "read.summarize_sui_account_activity",
-    readGetAccountAssetTimeline: "read.get_account_asset_timeline",
-    settingsCreateLocalSettingsSession: "settings.create_local_settings_session",
-    settingsGetLocalSettings: "settings.get_local_settings",
-    actionPrepareSuiActionReview: "action.prepare_sui_action_review",
-    actionPrepareExternalProposalReview: "action.prepare_external_proposal_review",
-    sessionCreateWalletConnection: "session.create_wallet_connection",
-    sessionGetWalletConnection: "session.get_wallet_connection",
-    sessionWaitWalletConnection: "session.wait_wallet_connection",
-    sessionGetInteractionStatus: "session.get_interaction_status",
-    sessionGetReviewStatus: "session.get_review_status",
-    sessionGetExecutionResult: "session.get_execution_result",
-    sessionWaitExecutionResult: "session.wait_execution_result",
-    accountGetActiveAccount: "account.get_active_account"
+    uiOpenAccount: "ui_open_account",
+    uiOpenReceipt: "ui_open_receipt",
+    uiOpenChart: "ui_open_chart",
+    uiReadCard: "ui_read_card",
+    uiSubmitCard: "ui_submit_card",
+    uiActCard: "ui_act_card",
+    uiReadSettingsFile: "ui_read_settings_file",
+    sessionOpenReviewManagement: "session_open_review_management",
+    readGetServerStatus: "read_get_server_status",
+    readListSupportedProtocols: "read_list_supported_protocols",
+    readListDeepbookPools: "read_list_deepbook_pools",
+    readListDeepbookTokens: "read_list_deepbook_tokens",
+    readInspectDeepbookOrderbook: "read_inspect_deepbook_orderbook",
+    readGetDeepbookMidPrice: "read_get_deepbook_mid_price",
+    readGetDeepbookUsdcPriceHistory: "read_get_deepbook_usdc_price_history",
+    readGetDeepbookUsdcPriceAtTime: "read_get_deepbook_usdc_price_at_time",
+    readQuoteDeepbookAction: "read_quote_deepbook_action",
+    readQuoteDeepbookDisplayAmount: "read_quote_deepbook_display_amount",
+    readSummarizeDeepbookAccountInventory: "read_summarize_deepbook_account_inventory",
+    readSummarizeWalletAssets: "read_summarize_wallet_assets",
+    readClassifyWalletAssets: "read_classify_wallet_assets",
+    readListSettlementAssetGroups: "read_list_settlement_asset_groups",
+    readSummarizeSettlementAssetGroupParity: "read_summarize_settlement_asset_group_parity",
+    readPreviewIntentEvidence: "read_preview_intent_evidence",
+    readListReviewActivity: "read_list_review_activity",
+    readSummarizeReviewFunnel: "read_summarize_review_funnel",
+    readGetReviewSessionDetail: "read_get_review_session_detail",
+    readInspectSuiTransaction: "read_inspect_sui_transaction",
+    readScanSuiAccountActivity: "read_scan_sui_account_activity",
+    readSummarizeSuiActivityScan: "read_summarize_sui_activity_scan",
+    readScanSuiFunctionActivity: "read_scan_sui_function_activity",
+    readSummarizeSuiFunctionActivityScan: "read_summarize_sui_function_activity_scan",
+    readSummarizeSuiAccountActivity: "read_summarize_sui_account_activity",
+    readGetAccountAssetTimeline: "read_get_account_asset_timeline",
+    settingsCreateLocalSettingsSession: "settings_create_local_settings_session",
+    settingsGetLocalSettings: "settings_get_local_settings",
+    actionStartReview: "action_start_review",
+    actionCreateProposalReview: "action_create_proposal_review",
+    sessionOpenWalletDisconnectionCard: "session_open_wallet_disconnection_card",
+    sessionOpenWalletConnectionCard: "session_open_wallet_connection_card",
+    sessionGetWalletConnectionCard: "session_get_wallet_connection_card",
+    sessionWaitWalletConnectionCard: "session_wait_wallet_connection_card",
+    sessionGetInteractionStatus: "session_get_interaction_status",
+    sessionGetReviewStatus: "session_get_review_status",
+    sessionGetExecutionResult: "session_get_execution_result",
+    sessionWaitExecutionResult: "session_wait_execution_result",
+    accountGetActiveAccount: "account_get_active_account"
 };
 export function assertValidToolName(name) {
     if (!/^[A-Za-z0-9_.-]{1,128}$/.test(name)) {

package/dist/mcp/tools/action/prepareSuiActionReview.js

@@ -9,16 +9,16 @@ import { prepareActionReviewUserAnswerUse, prepareExternalProposalReviewUserAnsw
 import { registerSuiMcpTool } from "../../registerTool.js";
 import { successOutputSchema } from "../../schemas.js";
 import { errorToolResult } from "../../result.js";
-import { activityStoreToolError, sessionStoreToolError } from "../../toolErrors.js";
+import { sessionStoreToolError } from "../../toolErrors.js";
 import { TOOL_NAMES } from "../../toolNames.js";
 import { userAnswerUseSchema } from "../read/commonSchemas.js";
 export function registerActionTools(server, deps) {
-    server.registerTool(TOOL_NAMES.actionPrepareSuiActionReview, {
-        title: "Prepare swap review",
+    server.registerTool(TOOL_NAMES.actionStartReview, {
+        title: "Start swap review",
         description: "Create a local swap review session on a supported protocol. Returns an internal review card.",
         inputSchema: z.object({
             intent: swapIntentInputSchema
-        }),
+        }).strict(),
         outputSchema: successOutputSchema({
             reviewSessionId: z.string(),
             card: cardSnapshotSchema,
@@ -32,19 +32,6 @@ export function registerActionTools(server, deps) {
         if (!supportsCards(server))
             return errorToolResult({ kind: "ui_unavailable", details: { reason: "An internal review card is required." } });
         const now = new Date();
-        let activeAccount;
-        try {
-            activeAccount = await deps.activityStore.getActiveAccount();
-        }
-        catch (error) {
-            return activityStoreToolError(error, deps.logger);
-        }
-        if (!activeAccount) {
-            return errorToolResult({
-                kind: "active_account_not_set",
-                details: { action: "connect_wallet_connection" }
-            });
-        }
         const { protocol: protocolSlug, ...swapIntent } = intent;
         const resolution = resolveIntentPlanFactory(INTENT_PLAN_FACTORIES, swapIntent.type, protocolSlug);
         if (resolution.status !== "resolved") {
@@ -67,6 +54,12 @@ export function registerActionTools(server, deps) {
         }
         const plan = resolution.factory.createPlan(swapIntent, now);
         try {
+            const target = deps.workflow?.resolveReviewTarget();
+            if (!target || target.status !== "available")
+                return errorToolResult({ kind: target?.reason === "wallet_unavailable" || !target ? "wallet_unavailable"
+                        : target.reason === "connection_required" ? "active_account_not_set" : "input_invalid",
+                    details: { reason: target?.reason ?? "wallet_unavailable", action: "check_exact_wallet_account",
+                        message: "A fixed, currently usable Sui account and its exact connection are required for this review." } });
             const { session } = await deps.sessions.createReviewSession([plan], now);
             const preliminaryChecks = plan.preliminaryChecks ?? [];
             const hasBlockingPreliminaryChecks = preliminaryChecks.some((check) => check.status === "fail");
@@ -76,14 +69,14 @@ export function registerActionTools(server, deps) {
                 preliminaryChecks,
                 userAnswerUse: prepareActionReviewUserAnswerUse({ hasBlockingPreliminaryChecks })
             };
-            return await createWorkflowCard(server, deps, "review", { reviewSessionId: session.id }, payload);
+            return await createWorkflowCard(server, deps, "review", { reviewSessionId: session.id, connectionId: target.connectionId, account: target.account }, payload);
         }
         catch (error) {
             return sessionStoreToolError(error, deps.logger);
         }
     });
-    registerSuiMcpTool(server, TOOL_NAMES.actionPrepareExternalProposalReview, {
-        title: "Prepare external proposal review",
+    registerSuiMcpTool(server, TOOL_NAMES.actionCreateProposalReview, {
+        title: "Create external proposal review",
         description: "Create a local non-signable review session from an untrusted external Sui proposal.",
         inputSchema: z.object({
             proposal: externalProposalSchema

package/dist/mcp/tools/read/deepbookReadTools.js

@@ -283,7 +283,7 @@ const deepbookQuoteQuantitySemanticsSchema = z.object({
     canUseForPaymentAnswer: z.literal(false),
     canUseForShortfallAnswer: z.literal(false),
     doNotCombineWithPaymentAnswer: z.literal(true),
-    requiredPaymentAnswerTool: z.literal("read.preview_intent_evidence"),
+    requiredPaymentAnswerTool: z.literal("read_preview_intent_evidence"),
     paymentAnswerUseBlockedReason: z.literal("quote_output_is_price_reference_not_payment_answer"),
     requiredPaymentAnswerField: z.literal("responseSummary"),
     fiatUsdCashOutAvailable: z.literal(false),

package/dist/mcp/tools/read/index.js

@@ -4,8 +4,8 @@ import { registerServerStatusTools, SUPPORTED_PROTOCOLS } from "./serverStatusTo
 import { registerTransactionActivityTools } from "./transactionActivityTools.js";
 import { registerWalletReadTools } from "./walletReadTools.js";
 export { SUPPORTED_PROTOCOLS };
-export function registerReadTools(server, deps) {
-    registerServerStatusTools(server);
+export function registerReadTools(server, deps, registeredPromptNames) {
+    registerServerStatusTools(server, registeredPromptNames);
     registerDeepbookReadTools(server, deps);
     registerWalletReadTools(server, deps);
     registerReviewActivityListTool(server, deps);

package/dist/mcp/tools/read/readToolHelpers.js

@@ -1,4 +1,4 @@
-import { CONNECTION_CONFLICT_MESSAGE, CONNECTION_RECONCILIATION_MESSAGE } from "../../../core/session/walletConnection.js";
+import { CONNECTION_RECONCILIATION_MESSAGE } from "../../../core/session/walletConnection.js";
 import { ReadServiceCacheError, ReadServiceInputError } from "../../../core/read/readService.js";
 import { parseSuiAddress } from "../../../core/suiAddress.js";
 import { errorToolResult } from "../../result.js";
@@ -51,16 +51,18 @@ export async function resolveExplicitOrActiveAccount(input, deps) {
                         details: { ...(availability.status === "unavailable" ? { reason: availability.reason } : {}), message: availability.message, walletAvailability: availability } }) };
             return { status: "error", result: errorToolResult({ kind: active ? "input_invalid" : "active_account_not_set",
                     details: { reason: "connected_account_required",
-                        message: context?.connectionReconciliationRequired ? CONNECTION_RECONCILIATION_MESSAGE : context?.connectionConflict ? CONNECTION_CONFLICT_MESSAGE : "This tool requires a selected account with a usable wallet connection. An address alone cannot be used.",
-                        ...(context?.connectionConflict ? { connectionConflict: context.connectionConflict } : {}),
+                        message: context?.connectionReconciliationRequired ? CONNECTION_RECONCILIATION_MESSAGE
+                            : context?.assetReadAccount.status === "address_required" && context.assetReadAccount.reason === "read_address_cleared"
+                                ? "The saved read address was cleared in Settings. The wallet connection and transaction permissions were not changed. This tool requires a saved Sui read address with a usable connection and does not accept an address input."
+                                : "This tool requires a current Sui address with a usable wallet connection. An address alone cannot be used.",
                         ...(context?.connectionReconciliationRequired ? { connectionReconciliationRequired: true } : {}),
                         followUp: { tool: TOOL_NAMES.sessionGetInteractionStatus,
-                            answerFields: ["walletAvailability", "connections", "pendingWalletConnections", "assetReadAccount"],
-                            reason: `Check current connections and pending operations. Use pendingWalletConnections.items[].cardId with ${TOOL_NAMES.sessionGetWalletConnection} or ${TOOL_NAMES.sessionWaitWalletConnection}. If no operation is pending and the user requests connection or account selection, open ${TOOL_NAMES.sessionCreateWalletConnection}. Only the user may act in that card.` } } }) };
+                            answerFields: ["walletAvailability", "connection", "pendingWalletConnections", "assetReadAccount"],
+                            reason: `Check the current connection and pending operations. Use pendingWalletConnections.items[].cardId with ${TOOL_NAMES.sessionGetWalletConnectionCard} or ${TOOL_NAMES.sessionWaitWalletConnectionCard}. If no operation is pending and the user requests connection, open ${TOOL_NAMES.sessionOpenWalletConnectionCard}. Only the user may act in that card.` } } }) };
         }
-        const message = context?.connectionReconciliationRequired ? CONNECTION_RECONCILIATION_MESSAGE + " Provide a Sui address in chat for this public read." : context?.connectionConflict ? CONNECTION_CONFLICT_MESSAGE + " Provide a Sui address in chat for this public read." : availability.status !== "available"
+        const message = context?.connectionReconciliationRequired ? CONNECTION_RECONCILIATION_MESSAGE + " Provide a Sui address in chat for this public read." : availability.status !== "available"
             ? "The wallet connection cannot be checked. Please provide a Sui address in chat to view its assets."
-            : "No connected wallet is available for the selected account. Please provide a Sui address in chat.";
+            : "No usable saved Sui read address is available. Please provide a Sui address in chat.";
         return { status: "address_required", message, result: errorToolResult({ kind: "input_invalid",
                 details: { field: "account", reason: "address_required", message, walletAvailability: availability } }) };
     }

package/dist/mcp/tools/read/serverStatusTools.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import { noParamsInputSchema, successOutputSchema } from "../../schemas.js";
 import { okToolResult } from "../../result.js";
-import { MCP_PROMPTS } from "../../prompts.js";
 import { MCP_RESOURCES } from "../../resources.js";
 import { EVIDENCE_POLICY, FAIL_CLOSED_TOOLS, IMPLEMENTED_TOOLS, PACKAGE_NAME, SERVER_LIMITATIONS, SERVER_NAME, SERVER_NETWORK, SERVER_RUNTIME, SERVER_TRANSPORT, SERVER_VERSION } from "../../serverInfo.js";
 import { TOOL_NAMES } from "../../toolNames.js";
@@ -9,7 +8,7 @@ export const SUPPORTED_PROTOCOLS = [
     { id: "deepbook-v3", status: "mainnet", support: "read_and_local_review" },
     { id: "deepbook-margin", status: "mainnet", support: "protocol_notes_only" }
 ];
-export function registerServerStatusTools(server) {
+export function registerServerStatusTools(server, registeredPromptNames) {
     server.registerTool(TOOL_NAMES.readGetServerStatus, {
         title: "Get server status",
         description: "Return package, runtime, tool, resource, and prompt status.",
@@ -45,7 +44,7 @@ export function registerServerStatusTools(server) {
                 count: z.number().int().nonnegative(),
                 names: z.array(z.string())
             }),
-            protocolsTool: z.literal("read.list_supported_protocols"),
+            protocolsTool: z.literal("read_list_supported_protocols"),
             limitations: z.array(z.string())
         }),
         annotations: { readOnlyHint: true, openWorldHint: false }
@@ -75,8 +74,8 @@ export function registerServerStatusTools(server) {
             }))
         },
         prompts: {
-            count: MCP_PROMPTS.length,
-            names: MCP_PROMPTS.map((prompt) => prompt.name)
+            count: registeredPromptNames.length,
+            names: [...registeredPromptNames]
         },
         protocolsTool: TOOL_NAMES.readListSupportedProtocols,
         limitations: [...SERVER_LIMITATIONS]

package/dist/mcp/tools/read/transactionActivityTools.js

@@ -171,7 +171,7 @@ const suiTransactionAuditFactSchema = z.object({
     requestedAccountEffect: transactionAccountEffectsSchema.optional(),
     transactionContext: requestedAccountTransactionContextSchema.optional(),
     detailLookup: z.object({
-        tool: z.literal("read.inspect_sui_transaction"),
+        tool: z.literal("read_inspect_sui_transaction"),
         digest: z.string()
     })
 });
@@ -194,7 +194,7 @@ const requestedAccountTransactionFactSchema = z.object({
     requestedAccountEffect: transactionAccountEffectsSchema,
     transactionContext: requestedAccountTransactionContextSchema.optional(),
     detailLookup: z.object({
-        tool: z.literal("read.inspect_sui_transaction"),
+        tool: z.literal("read_inspect_sui_transaction"),
         digest: z.string()
     })
 });
@@ -331,7 +331,7 @@ const externalActivityTransactionRecordSchema = z.object({
     compact: externalActivityTransactionCompactFactsSchema.optional(),
     details: externalActivityTransactionDetailSchema.optional(),
     detailLookup: z.object({
-        tool: z.literal("read.inspect_sui_transaction"),
+        tool: z.literal("read_inspect_sui_transaction"),
         digest: z.string()
     }).optional()
 });

package/dist/mcp/tools/session/executionResultTools.js

@@ -20,7 +20,7 @@ export function registerExecutionResultTools(server, deps) {
             if (!state)
                 return errorToolResult({ kind: "session_not_found", details: { reviewSessionId } });
             const request = state.request;
-            return okToolResult({ ...reviewStatusResponse(state), userAnswerUse: executionResultUserAnswerUse({ hasConnectionConflict: !!state.connectionConflict, reconciliationRequired: !!state.connectionReconciliationRequired, hasRequest: !!request, hasExecutionResult: !!request?.execution }) });
+            return okToolResult({ ...reviewStatusResponse(state), userAnswerUse: executionResultUserAnswerUse({ reconciliationRequired: !!state.connectionReconciliationRequired, hasRequest: !!request, hasExecutionResult: !!request?.execution }) });
         }
         catch (error) {
             return sessionStoreToolError(error, deps.logger);
@@ -35,7 +35,7 @@ export function registerExecutionResultTools(server, deps) {
         try {
             const result = await waitForExecutionResult((id) => readCurrentReview(deps, id), reviewSessionId, { timeoutMs, signal: extra.mcpReq.signal });
             return okToolResult({ waitOutcome: result.waitOutcome, ...reviewStatusResponse(result),
-                userAnswerUse: executionResultUserAnswerUse({ hasConnectionConflict: !!result.connectionConflict, reconciliationRequired: !!result.connectionReconciliationRequired, hasRequest: !!result.request, hasExecutionResult: !!result.request?.execution, hasWaitOutcome: true }) });
+                userAnswerUse: executionResultUserAnswerUse({ reconciliationRequired: !!result.connectionReconciliationRequired, hasRequest: !!result.request, hasExecutionResult: !!result.request?.execution, hasWaitOutcome: true }) });
         }
         catch (error) {
             return sessionStoreToolError(error, deps.logger);

package/dist/mcp/tools/session/shared.js

@@ -1,5 +1,5 @@
 import { walletObservationSchema } from "../../../core/session/walletRuntime.js";
-import { walletAvailabilitySchema, workflowProgressSchema, walletUnavailable, connectionConflictSchema } from "../../../core/session/walletConnection.js";
+import { walletAvailabilitySchema, workflowProgressSchema, walletUnavailable } from "../../../core/session/walletConnection.js";
 import { z } from "zod";
 import { actionPlanSchema, executionPollingStatusSchema, internalSessionStatusSchema, reviewStateOutputSchema } from "../../../core/action/schemas.js";
 import { EXECUTION_STATUS_CATEGORIES } from "../../../core/session/status.js";
@@ -16,7 +16,7 @@ export const timeoutInputSchema = z.number().int().min(1).max(MAX_WAIT_TIMEOUT_M
 export function waitExecutionInputSchema() { return { reviewSessionId: z.string().min(1), timeoutMs: timeoutInputSchema }; }
 export const reviewStatusResponseShape = {
     connectionReconciliationRequired: z.literal(true).optional(),
-    connectionConflict: connectionConflictSchema.optional(), walletAvailability: walletAvailabilitySchema, walletObservation: walletObservationSchema.optional(), progress: workflowProgressSchema,
+    walletAvailability: walletAvailabilitySchema, walletObservation: walletObservationSchema.optional(), progress: workflowProgressSchema,
     reviewSessionId: z.string(), status: internalSessionStatusSchema, reviewRevision: z.number().int().nonnegative(),
     account: z.string().optional(), plans: z.array(actionPlanSchema), reviewState: reviewStateOutputSchema.optional(),
     pollingStatus: executionPollingStatusSchema, statusCategory: executionStatusCategorySchema(), pollingHint: executionPollingHintSchema(),

package/dist/mcp/tools/session/statusTools.js

@@ -1,4 +1,5 @@
-import { walletAvailabilitySchema, workflowProgressSchema, walletUnavailable, connectionConflictSchema } from "../../../core/session/walletConnection.js";
+import { walletChainsSchema } from "../../../core/session/chainAccounts.js";
+import { walletAvailabilitySchema, workflowProgressSchema, walletUnavailable } from "../../../core/session/walletConnection.js";
 import { walletObservationSchema } from "../../../core/session/walletRuntime.js";
 import { z } from "zod";
 import { activeAccountResponse, activeAccountResponseSchema } from "../../activeAccountResponse.js";
@@ -11,17 +12,18 @@ import { userAnswerUseSchema } from "../read/commonSchemas.js";
 import { isReviewInteractionPending, reviewStatusResponse } from "../../../core/session/status.js";
 import { latest, reviewStatusResponseShape, readCurrentReview } from "./shared.js";
 import { pendingConnectionStatusSchema, connectionViewSchema, assetReadAccountSchema } from "../../../core/session/workflowView.js";
+import { pendingWalletConnectionOperationSchema } from "../../../core/session/walletConnectionOperations.js";
 export function registerSessionStatusTools(server, deps) {
     server.registerTool(TOOL_NAMES.sessionGetInteractionStatus, {
-        title: "Get local interaction status", description: "Read wallet connections, the default asset account, and pending interactions.",
+        title: "Get local interaction status", description: "Read the current wallet connection, asset read account, and pending interactions.",
         inputSchema: noParamsInputSchema,
         outputSchema: successOutputSchema({ walletAvailability: walletAvailabilitySchema, walletObservation: walletObservationSchema.optional(), activeAccount: activeAccountResponseSchema,
-            connections: z.array(connectionViewSchema), assetReadAccount: assetReadAccountSchema,
-            connectionConflict: connectionConflictSchema.optional(),
-            manageableConnectionIds: z.array(z.string().min(1)), connectionReconciliationRequired: z.literal(true).optional(),
+            requestedChains: walletChainsSchema,
+            connection: connectionViewSchema.nullable(), pendingOperation: pendingWalletConnectionOperationSchema.optional(), assetReadAccount: assetReadAccountSchema,
+            canDisconnect: z.boolean(), connectionReconciliationRequired: z.literal(true).optional(),
             pendingWalletConnections: z.object({ limit: z.number().int().positive(), truncated: z.boolean(),
                 items: z.array(z.object({ cardId: z.string(), connectionId: z.string().optional(),
-                    status: pendingConnectionStatusSchema, progress: workflowProgressSchema, lastActivityAt: z.string() })) }),
+                    operationId: z.string().uuid(), status: pendingConnectionStatusSchema, progress: workflowProgressSchema, lastActivityAt: z.string() })) }),
             pendingReviewSessions: z.object({ limit: z.number().int().positive(), truncated: z.boolean(), items: z.array(z.object(reviewStatusResponseShape)) }),
             userAnswerUse: userAnswerUseSchema }),
         annotations: { readOnlyHint: false, openWorldHint: false }
@@ -34,14 +36,14 @@ export function registerSessionStatusTools(server, deps) {
             return activityStoreToolError(error, deps.logger);
         }
         try {
-            const context = deps.workflow?.reconcileConnectionContext() ?? { connections: [], manageableConnectionIds: [],
+            const context = deps.workflow?.reconcileConnectionContext() ?? { requestedChains: [], canDisconnect: false,
                 assetReadAccount: { status: "address_required" }, walletAvailability: walletUnavailable("initialization_failed") };
             const connections = deps.workflow?.pendingConnections() ?? [];
             const states = await Promise.all(deps.sessions.reviewSessionIds().map((id) => readCurrentReview(deps, id)));
             const reviews = states.flatMap((state) => state && isReviewInteractionPending(state) ? [reviewStatusResponse(state)] : []);
             return okToolResult({ activeAccount: activeAccountResponse(active), pendingWalletConnections: latest(connections),
-                pendingReviewSessions: latest(reviews), ...context,
-                userAnswerUse: interactionStatusUserAnswerUse("walletObservation" in context && context.walletObservation !== undefined, "connectionConflict" in context && !!context.connectionConflict, "connectionReconciliationRequired" in context && !!context.connectionReconciliationRequired) });
+                pendingReviewSessions: latest(reviews), ...context, connection: "connection" in context ? context.connection ?? null : null,
+                userAnswerUse: interactionStatusUserAnswerUse("walletObservation" in context && context.walletObservation !== undefined, "connectionReconciliationRequired" in context && !!context.connectionReconciliationRequired) });
         }
         catch (error) {
             return sessionStoreToolError(error, deps.logger);
@@ -59,7 +61,7 @@ export function registerSessionStatusTools(server, deps) {
                 return errorToolResult({ kind: "session_not_found", details: { reviewSessionId } });
             const session = state.session;
             return okToolResult({ ...reviewStatusResponse(state),
-                userAnswerUse: reviewStatusUserAnswerUse(!!session.reviewState, !!session.reviewState?.adapterLifecycle, !!session.reviewState?.humanReadableReview, !!session.reviewState?.simulation, !!state.connectionConflict, !!state.connectionReconciliationRequired) });
+                userAnswerUse: reviewStatusUserAnswerUse(!!session.reviewState, !!session.reviewState?.adapterLifecycle, !!session.reviewState?.humanReadableReview, !!session.reviewState?.simulation, !!state.connectionReconciliationRequired) });
         }
         catch (error) {
             return sessionStoreToolError(error, deps.logger);

package/dist/mcp/tools/session/walletConnectionTools.js

@@ -1,3 +1,6 @@
+import { walletAvailabilitySchema } from "../../../core/session/walletConnection.js";
+import { walletConnectionOperationSchema } from "../../../core/session/walletConnectionOperations.js";
+import { walletConnectionCardInputSchema } from "../../../core/session/walletConnectionOperations.js";
 import { z } from "zod";
 import { cardMetadata, createWorkflowCard } from "../../../mcp-ui/tools.js";
 import { cardSnapshotSchema } from "../../../mcp-ui/contracts.js";
@@ -10,44 +13,53 @@ import { CardError } from "../../../core/session/cardSessionStore.js";
 import { sessionStoreToolError } from "../../toolErrors.js";
 export function registerWalletConnectionTools(server, deps) {
     const failure = (error) => sessionStoreToolError(error, deps.logger);
-    server.registerTool(TOOL_NAMES.sessionCreateWalletConnection, {
-        title: "Open wallet connection controls", description: "Open a card for Sui wallet connection, disconnection and account selection.",
-        inputSchema: z.object({ intent: z.enum(["manage", "connect", "disconnect"]).default("manage") }), outputSchema: successOutputSchema(cardSnapshotSchema.shape),
+    server.registerTool(TOOL_NAMES.sessionOpenWalletConnectionCard, {
+        title: "Connect wallet", description: "Open a card for one wallet connection request.",
+        inputSchema: walletConnectionCardInputSchema, outputSchema: successOutputSchema(cardSnapshotSchema.shape),
         _meta: cardMetadata("connect"), annotations: { readOnlyHint: false, openWorldHint: false }
-    }, async ({ intent }) => { try {
-        return await createWorkflowCard(server, deps, "connect", { intent });
+    }, async (input) => { try {
+        return await createWorkflowCard(server, deps, "connect", input);
     }
     catch (error) {
         return failure(error);
     } });
-    server.registerTool(TOOL_NAMES.sessionGetWalletConnection, {
-        title: "Get wallet connection", description: "Read the saved state of one wallet connection card.",
-        inputSchema: z.object({ cardId: z.string().min(1) }), outputSchema: successOutputSchema(cardSnapshotSchema.shape),
+    server.registerTool(TOOL_NAMES.sessionOpenWalletDisconnectionCard, {
+        title: "Disconnect wallet", description: "Open a confirmation card for the current wallet disconnection.",
+        inputSchema: walletConnectionCardInputSchema, outputSchema: successOutputSchema(cardSnapshotSchema.shape),
+        _meta: cardMetadata("disconnect"), annotations: { readOnlyHint: false, openWorldHint: false }
+    }, async (input) => { try {
+        return await createWorkflowCard(server, deps, "disconnect", input);
+    }
+    catch (error) {
+        return failure(error);
+    } });
+    const operationState = { card: cardSnapshotSchema, operation: walletConnectionOperationSchema.nullable(),
+        walletAvailability: walletAvailabilitySchema, evaluatedAt: z.string().datetime() };
+    server.registerTool(TOOL_NAMES.sessionGetWalletConnectionCard, {
+        title: "Get wallet connection card", description: "Read a wallet card and its exact operation’s current settlement.",
+        inputSchema: z.object({ cardId: z.string().min(1) }).strict(), outputSchema: successOutputSchema(operationState),
         annotations: { readOnlyHint: false, openWorldHint: false }
     }, async ({ cardId }) => {
         try {
             if (!deps.cards)
                 return failure(new CardError("Wallet card is unavailable."));
-            const snapshot = await deps.cards.store.readSaved(cardId);
-            if (snapshot.kind !== "connect")
-                return failure(new CardError("Wallet card is unavailable."));
-            return okToolResult(snapshot);
+            return okToolResult(await deps.cards.store.readWalletOperation(cardId));
         }
         catch (error) {
             return failure(error);
         }
     });
-    server.registerTool(TOOL_NAMES.sessionWaitWalletConnection, {
-        title: "Wait for wallet connection", description: "Wait briefly for a wallet connection card's approval or required user input.",
-        inputSchema: z.object({ cardId: z.string().min(1), timeoutMs: timeoutInputSchema }),
-        outputSchema: successOutputSchema({ waitOutcome: z.enum(WAIT_OUTCOMES), card: cardSnapshotSchema }),
+    server.registerTool(TOOL_NAMES.sessionWaitWalletConnectionCard, {
+        title: "Wait for wallet connection card", description: "Wait briefly for one wallet card's exact operation and cleanup.",
+        inputSchema: z.object({ cardId: z.string().min(1), timeoutMs: timeoutInputSchema }).strict(),
+        outputSchema: successOutputSchema({ ...operationState, waitOutcome: z.enum(WAIT_OUTCOMES) }),
         annotations: { readOnlyHint: false, openWorldHint: false }
     }, async ({ cardId, timeoutMs }, extra) => {
         try {
             if (!deps.cards)
                 return failure(new CardError("Wallet card is unavailable."));
             const result = await waitForWalletConnection(deps.cards.store, cardId, { timeoutMs, signal: extra.mcpReq.signal });
-            return okToolResult({ waitOutcome: result.waitOutcome, card: result.snapshot });
+            return okToolResult(result);
         }
         catch (error) {
             return failure(error);