@zktx.io/sui-mcp 0.6.2 → 0.8.0

package/dist/core/session/workflowState.js

@@ -1,80 +1,146 @@
-import { walletConnectionSelection } from "./walletConnection.js";
+import { CONNECTION_RECONCILIATION_MESSAGE, walletConnectionEligibility, usableWalletConnection, connectionHasSuiSigningScope, projectWalletConnection } from "./walletConnection.js";
 import { isInitialChainObservation } from "./transactionRequest.js";
-export const workflowActions = ["connect", "disconnect", "use_account", "stop_connection", "prepare_review",
+import { SUI_MAINNET_WALLET_CHAIN } from "./chainAccounts.js";
+import { parseSuiAddress } from "../suiAddress.js";
+export const workflowActions = ["connect", "disconnect", "stop_connection", "prepare_review",
     "request_signature", "cancel", "stop_waiting", "read_result"];
-export function reviewPreparationAccount(boundAccount, activeAccount, selectedAccount = activeAccount) {
-    if (!activeAccount)
-        return { allowed: false, message: "No account from a connected wallet is selected for this review." };
-    if (boundAccount && boundAccount !== activeAccount)
-        return { allowed: false,
-            message: `This review uses ${boundAccount}, but the currently selected account is ${activeAccount}.` };
-    if (selectedAccount !== activeAccount)
-        return { allowed: false,
-            message: "The selected account has changed since this request was made." };
-    return { allowed: true, account: activeAccount };
+export const workflowNextSteps = ["none", "wait", "check_status", "open_settings", "request_disconnect", "request_review"];
+function walletServiceNextStep(status) {
+    if (status === "available")
+        return undefined;
+    return { kind: status === "unavailable" ? "open_settings" : "wait", reason: "wallet_unavailable",
+        message: status === "unavailable" ? "Open Settings, then Troubleshooting, to restart the connection service. No wallet request was sent."
+            : "Wait for the connection service to finish starting, then check status." };
+}
+export function walletActionDecision(facts, action, targetId) {
+    const deny = (kind, reason, message) => ({ allowed: false, nextStep: { kind, reason, message } });
+    const service = walletServiceNextStep(facts.walletAvailability.status);
+    if (service)
+        return { allowed: false, nextStep: service };
+    if (facts.pendingOperation)
+        return deny("check_status", "operation_busy", "Wait for the current wallet operation and its cleanup to finish, then check this request's status.");
+    const selection = walletConnectionEligibility(facts.connection, Date.parse(facts.evaluatedAt), facts.connectionPresence, facts.activeAccount, facts.readAddressCleared);
+    if (!facts.connectionPresence.confirmed || !facts.connectionPresence.managed || selection.connectionReconciliationRequired)
+        return deny("check_status", "connection_state_unconfirmed", selection.connectionReconciliationRequired ? CONNECTION_RECONCILIATION_MESSAGE : "The wallet session has not been confirmed. Check its status before continuing.");
+    if (action === "connect") {
+        if (!facts.requestedChains.length)
+            return deny("open_settings", "wallet_networks_required", "Choose networks in Settings before requesting a wallet connection.");
+        return selection.pairingAllowed ? { allowed: true, nextStep: { kind: "none" } }
+            : deny("request_disconnect", "connection_present", "Ask in chat for a Disconnect card before requesting a new wallet connection.");
+    }
+    if (targetId && facts.connection?.connectionId !== targetId)
+        return deny("check_status", "connection_target_changed", "The wallet session for this card is no longer current. Ask in chat for current connection status.");
+    return selection.manageable ? { allowed: true, nextStep: { kind: "none" } }
+        : deny("none", "no_session_to_disconnect", "There is no current wallet session to disconnect. No request was sent.");
+}
+export function fixedReviewTarget(session, input) {
+    const hasInputTarget = input?.connectionId !== undefined || input?.account !== undefined;
+    const inputId = typeof input?.connectionId === "string" && input.connectionId.length ? input.connectionId : undefined;
+    const inputAccount = typeof input?.account === "string" ? parseSuiAddress(input.account) : undefined;
+    if (hasInputTarget && (!inputId || !inputAccount))
+        return undefined;
+    if (inputId && session.walletConnectionId && inputId !== session.walletConnectionId ||
+        inputAccount && session.account && inputAccount !== session.account)
+        return undefined;
+    const connectionId = inputId ?? session.walletConnectionId, account = inputAccount ?? session.account;
+    return connectionId && account ? { connectionId, account } : undefined;
 }
 export function workflowConnectionEligibility(facts) {
-    const selection = walletConnectionSelection(facts.connections, Date.parse(facts.evaluatedAt), facts.connectionPresence, facts.activeAccount ? { address: facts.activeAccount, walletId: facts.activeAccountConnectionId } : undefined);
+    const selection = walletConnectionEligibility(facts.connection, Date.parse(facts.evaluatedAt), facts.connectionPresence, facts.activeAccount, facts.readAddressCleared);
     const available = facts.walletAvailability.status === "available", dependent = facts.walletDependent !== false;
-    const usableConnectionId = available && dependent ? selection.connection?.connectionId : undefined;
-    const assetReadAccount = !dependent ? undefined
-        : usableConnectionId ? selection.assetReadAccount : { status: "address_required" };
-    return { selection, usableConnectionId, assetReadAccount, connectionConflict: selection.conflict,
-        manageableConnectionIds: available ? selection.manageableConnectionIds : [],
+    return { selection, usableConnectionId: available && dependent ? selection.connection?.connectionId : undefined,
+        assetReadAccount: !dependent ? undefined : available ? selection.assetReadAccount : { status: "address_required" },
+        connection: projectWalletConnection(facts.connection, Date.parse(facts.evaluatedAt), facts.connectionPresence, available),
+        pendingOperation: facts.pendingOperation,
+        canDisconnect: available && selection.manageable,
         connectionReconciliationRequired: available && dependent ? selection.connectionReconciliationRequired : undefined };
 }
 export function workflowEligibility(facts) {
     const { record, session, request, authority, walletAvailability } = facts;
     const at = Date.parse(facts.evaluatedAt);
-    const cardRemaining = record?.ownerId === facts.ownerId ? Math.max(0, Date.parse(record.state.expiresAt) - at) : 0;
+    const cardRemaining = record?.ownerId === facts.ownerId && record.state.reason !== "cancelled"
+        ? Math.max(0, Date.parse(record.state.expiresAt) - at) : 0;
     const remaining = record?.scope === "review" && session && !request
         ? Math.min(cardRemaining, Math.max(0, Date.parse(session.expiresAt) - at)) : cardRemaining;
     const inputAvailable = remaining > 0 && record?.state.state === "ready" && record.acceptedInput === undefined;
     const allowedActions = [];
     const { selection, ...connectionEligibility } = workflowConnectionEligibility(facts);
-    const { assetReadAccount } = connectionEligibility;
-    let preparationIssue;
-    if (record?.scope === "connect") {
+    const reviewTarget = session && !session.plans[0]?.reviewModel ? fixedReviewTarget(session, record?.state.input) : undefined;
+    const targetId = reviewTarget?.connectionId, targetAccount = reviewTarget?.account;
+    const reviewConnection = walletAvailability.status === "available" && !facts.connectionPresence.unrecorded && facts.walletDependent !== false && targetId && targetAccount
+        ? usableWalletConnection(facts.connection, at, facts.connectionPresence, targetId, SUI_MAINNET_WALLET_CHAIN, targetAccount) : undefined;
+    const preparationIssue = session && record?.scope === "review" && !session.plans[0]?.reviewModel && !reviewTarget
+        ? "This review has no matching fixed wallet target. Start a new review." : undefined;
+    const scopedDisconnect = record?.scope === "disconnect";
+    const walletDecision = walletActionDecision(facts, scopedDisconnect ? "disconnect" : "connect", scopedDisconnect ? String(record?.state.input.connectionId) : undefined);
+    let nextStep = facts.operation?.status === "running" && facts.operation.cardId === record?.state.cardId
+        ? { kind: "wait" } : walletDecision.nextStep;
+    const disconnectTargetMatches = !scopedDisconnect || record.state.input.connectionId === facts.connection?.connectionId;
+    if (record?.scope === "connect" || scopedDisconnect) {
         if (inputAvailable) {
             allowedActions.push("cancel");
             if (walletAvailability.status === "available") {
-                if (["connect", "manage"].includes(String(record.state.input.intent)) && selection.pairingAllowed)
+                if (record.scope === "connect" && walletDecision.allowed)
                     allowedActions.push("connect");
-                if (selection.manageableConnectionIds.length)
+                if (scopedDisconnect && walletDecision.allowed)
                     allowedActions.push("disconnect");
-                if (selection.connection)
-                    allowedActions.push("use_account");
             }
         }
-        if (remaining > 0 && facts.connection?.status === "awaiting_approval")
+        if (record.state.state !== "closed" && remaining > 0 && facts.operation?.action === "connect" && facts.operation.status === "running")
             allowedActions.push("stop_connection");
     }
     if (session && inputAvailable && record?.scope === "review" && session.status !== "expired" && Date.parse(session.expiresAt) > at && !session.preparationId) {
         allowedActions.push("cancel");
-        if (walletAvailability.status === "available" && selection.connection && !session.plans[0]?.reviewModel) {
-            const account = reviewPreparationAccount(session.account, assetReadAccount?.status === "available" ? assetReadAccount.account : undefined);
-            if (!account.allowed)
-                preparationIssue = account.message;
-            else if (!facts.busyForAccount)
+        if (walletAvailability.status === "available" && reviewConnection && !session.plans[0]?.reviewModel) {
+            if (!facts.busyForAccount)
                 allowedActions.push("prepare_review");
-            if (!facts.busyForAccount && session.status === "ready_for_wallet_review" && session.reviewState?.transactionReviewData &&
+            if (!facts.busyForAccount && connectionHasSuiSigningScope(reviewConnection, targetAccount) && session.status === "ready_for_wallet_review" && session.reviewState?.transactionReviewData &&
                 (!request || request.reviewRevision !== session.reviewRevision))
                 allowedActions.push("request_signature");
         }
     }
-    if (record && session && remaining > 0 && request && request.reviewSessionId === session.id &&
+    if (record && record.state.state !== "closed" && session && remaining > 0 && request && request.reviewSessionId === session.id &&
         authority?.owner_id === facts.ownerId &&
         (record.operationId === request.attemptId || record.scope === "review_manage" && record.state.input.attemptId === request.attemptId)) {
-        if (["awaiting_signature", "submitting", "awaiting_chain_result"].includes(request.requestStatus))
+        if (request.requestStatus === "awaiting_signature" || !authority.observation_stopped && isInitialChainObservation(request.requestStatus))
             allowedActions.push("stop_waiting");
-        if (isInitialChainObservation(request.requestStatus) || request.requestStatus === "outcome_unknown")
+        if (record.scope === "review_manage" && record.state.state === "ready" && record.acceptedInput === undefined && (isInitialChainObservation(request.requestStatus) || request.requestStatus === "outcome_unknown"))
             allowedActions.push("read_result");
     }
     const expiry = session && inputAvailable && record?.scope === "review" && !session.preparationId &&
         session.status === "ready_for_wallet_review" && (!request || request.reviewRevision !== session.reviewRevision)
         ? session.reviewState?.humanReadableReview?.freshness.expiresAt : undefined;
-    const nextRead = expiry && session ? Math.min(remaining, Date.parse(session.expiresAt) - at, Date.parse(expiry) - at) : undefined;
-    return { allowedActions, preparationIssue, ...connectionEligibility,
+    const reviewRead = expiry && session ? Math.min(remaining, Date.parse(session.expiresAt) - at, Date.parse(expiry) - at) : undefined;
+    const connectionDeadlines = inputAvailable && facts.walletDependent !== false && facts.connection?.status === "connected" &&
+        (["connect", "disconnect"].includes(record?.scope ?? "") || facts.connection.connectionId === reviewTarget?.connectionId)
+        ? [Date.parse(facts.connection.expiresAt) - at].filter((delay) => delay > 0) : [];
+    const readDelays = [reviewRead, ...connectionDeadlines].filter((delay) => delay !== undefined && delay > 0);
+    const nextRead = readDelays.length ? Math.min(...readDelays) : undefined;
+    if (session) {
+        nextStep = { kind: "none" };
+        if (!session.plans[0]?.reviewModel && !request) {
+            const service = walletServiceNextStep(walletAvailability.status);
+            if (service)
+                nextStep = service;
+            else if (facts.connectionPresence.unrecorded)
+                nextStep = { kind: "check_status", reason: "connection_state_unconfirmed", message: CONNECTION_RECONCILIATION_MESSAGE };
+            else if (facts.pendingOperation)
+                nextStep = { kind: "check_status", reason: "operation_busy", message: "Wait for the current wallet operation and its cleanup to finish, then check this review's status." };
+            else if (reviewTarget && connectionEligibility.connection?.connectionId === targetId && connectionEligibility.connection?.sessionPresence === "absent")
+                nextStep = { kind: "request_review", message: "The original wallet session is no longer present. Reconnect a wallet and ask in chat for a new transaction review." };
+            else if (reviewTarget && facts.connection && facts.connection.connectionId !== targetId)
+                nextStep = { kind: "request_review", message: "This review belongs to the earlier wallet connection. Ask in chat for a new transaction review." };
+            else if (!reviewConnection && connectionEligibility.canDisconnect && facts.connection?.connectionId === targetId)
+                nextStep = { kind: "request_disconnect", message: "The original wallet connection is unavailable. Ask in chat for a Disconnect card, then start a new review after reconnecting." };
+            else if (!reviewConnection)
+                nextStep = { kind: "check_status", message: "This review keeps its original account and connection. Ask in chat to check that wallet connection's status before continuing." };
+            else if (facts.busyForAccount)
+                nextStep = { kind: "wait", message: "A previous transaction request for this Sui account is still pending. Wait for it to finish, then check this review's status." };
+        }
+    }
+    return { allowedActions, preparationIssue, nextStep, ...connectionEligibility, reviewTarget,
+        canDisconnect: connectionEligibility.canDisconnect && disconnectTargetMatches,
+        ...(session ? { usableConnectionId: reviewConnection?.connectionId } : {}),
         actionRemainingMs: remaining, inputRemainingMs: inputAvailable ? remaining : 0,
         ...(nextRead !== undefined && nextRead > 0 ? { nextStateReadAfterMs: nextRead } : {}) };
 }

package/dist/core/session/workflowView.js

@@ -1,84 +1,86 @@
-import { workflowActions } from "./workflowState.js";
+import { workflowActions, workflowNextSteps } from "./workflowState.js";
 import { z } from "zod";
-import { suiAddressStringSchema, parseSuiAddress } from "../suiAddress.js";
+import { suiAddressStringSchema } from "../suiAddress.js";
 import { actionPlanSchema, internalSessionStatusSchema, reviewStateOutputSchema } from "../action/schemas.js";
-import { walletConnectionSchema, walletAvailabilitySchema, workflowProgressSchema, WALLET_CONNECTION_POLL_SECONDS, connectionConflictSchema, assetReadAccountSchema } from "./walletConnection.js";
+import { walletConnectionSchema, walletAvailabilitySchema, workflowProgressSchema, WALLET_CONNECTION_POLL_SECONDS, connectionChainStateSchema } from "./walletConnection.js";
 import { transactionRequestSchema } from "./transactionRequest.js";
 import { workflowProgress } from "./walletConnection.js";
 import { reviewProgress, EXECUTION_POLLING_INTERVAL_SECONDS } from "./status.js";
-import { walletRunIdSchema, walletRecoverySchema, walletObservationSchema } from "./walletRuntime.js";
+import { walletRunIdSchema, walletObservationSchema } from "./walletRuntime.js";
+import { walletConnectionActionSchema, walletConnectionOperationSchema } from "./walletConnectionOperations.js";
+import { walletChainSchema, walletChainsSchema, SUI_MAINNET_WALLET_CHAIN, normalizeChainAddress } from "./chainAccounts.js";
 export const CONNECT_BOUNDARY = "A wallet connection provides account context; it is not a transaction approval or proof of address ownership.";
 export const REVIEW_BOUNDARY = "Review evidence is not a safety guarantee. Only an explicit card action and wallet approval may authorize this exact transaction.";
-export const connectionViewSchema = walletConnectionSchema.extend({ pendingAction: z.literal("disconnect").optional() });
+export const connectionViewSchema = walletConnectionSchema.extend({
+    sessionPresence: z.enum(["present", "absent", "unusable", "unconfirmed"]),
+    chainStates: z.array(connectionChainStateSchema).optional(),
+    disconnectImpact: z.object({ impactId: z.string(), requestCount: z.number().int().nonnegative(), chains: walletChainsSchema }).strict().optional()
+});
 export { assetReadAccountSchema } from "./walletConnection.js";
-export const pendingConnectionStatusSchema = z.enum(["input_required", "awaiting_approval", "disconnect_pending"]);
-const connectAction = z.object({ action: z.literal("connect"), walletRunId: walletRunIdSchema }).strict();
-const disconnectAction = z.object({ action: z.literal("disconnect"), walletRunId: walletRunIdSchema, connectionId: z.string().min(1) }).strict();
-const accountAction = z.object({ action: z.literal("use_account"), walletRunId: walletRunIdSchema, connectionId: z.string().min(1), account: suiAddressStringSchema }).strict();
+export const pendingConnectionStatusSchema = z.enum(["awaiting_approval", "disconnect_pending", "cleanup_pending"]);
 const reviewAction = z.object({ action: z.enum(["prepare_review", "request_signature"]), connectionId: z.string().min(1),
     walletRunId: walletRunIdSchema, account: suiAddressStringSchema, reviewRevision: z.number().int().nonnegative() }).strict();
-const simpleAction = z.object({ action: z.enum(["cancel", "stop_connection", "stop_waiting", "read_result"]) }).strict();
-export const workflowActionSchema = z.union([connectAction, disconnectAction, accountAction, reviewAction, simpleAction]);
-export const automaticWorkflowActionSchema = z.union([connectAction, reviewAction.extend({ action: z.literal("prepare_review") })]);
+const simpleAction = z.object({ action: z.enum(["cancel", "stop_waiting", "read_result"]) }).strict();
+const stopConnectionAction = z.object({ action: z.literal("stop_connection"), operationId: z.string().uuid() }).strict();
+export const workflowActionSchema = z.union([walletConnectionActionSchema, stopConnectionAction, reviewAction, simpleAction]);
+export const automaticWorkflowActionSchema = z.union([walletConnectionActionSchema.options[0], reviewAction.extend({ action: z.literal("prepare_review") })]);
 export function parseWorkflowAction(input) {
     const action = workflowActionSchema.parse(input);
-    return "account" in action ? { ...action, account: parseSuiAddress(action.account) } : action;
-}
-export const workflowViewSchema = z.object({
-    kind: z.enum(["connect", "review"]),
-    mode: z.enum(["connect", "review", "review_manage"]),
-    allowedActions: z.array(z.enum(workflowActions)),
-    actionRemainingMs: z.number().int().nonnegative(),
-    nextStateReadAfterMs: z.number().int().nonnegative().optional(),
-    automaticAction: automaticWorkflowActionSchema.optional(),
-    observe: z.boolean(),
-    walletAvailability: walletAvailabilitySchema,
-    walletObservation: walletObservationSchema.optional(),
-    runtimeRecovery: walletRecoverySchema.optional(),
-    connectionConflict: connectionConflictSchema.optional(),
-    manageableConnectionIds: z.array(z.string().min(1)),
-    connectionReconciliationRequired: z.literal(true).optional(),
-    usableConnectionId: z.string().min(1).optional(),
-    assetReadAccount: assetReadAccountSchema.optional(),
-    acceptedWalletRunId: walletRunIdSchema.optional(),
-    progress: workflowProgressSchema,
-    boundary: z.enum([CONNECT_BOUNDARY, REVIEW_BOUNDARY]),
-    connections: z.array(connectionViewSchema),
-    activeAccount: z.string().optional(),
-    connection: connectionViewSchema.optional(),
-    connectionAction: z.enum(["connect", "disconnect"]).optional(),
-    review: z.object({
-        reviewSessionId: z.string(), plan: actionPlanSchema, reviewRevision: z.number().int().nonnegative(),
-        status: internalSessionStatusSchema, account: z.string().optional(), preparing: z.boolean(),
-        accountRequestPending: z.literal(true).optional(),
-        error: z.string().optional(),
-        state: reviewStateOutputSchema.optional()
-    }).strict().optional(),
-    request: transactionRequestSchema.optional(),
-    receipt: z.unknown().optional(),
-    netGasMist: z.string().regex(/^-?[0-9]+$/).optional(),
-    observationStopped: z.boolean().optional()
-}).strict().superRefine((view, context) => {
-    const connection = view.connections.find((item) => item.connectionId === view.usableConnectionId);
-    if (view.usableConnectionId && (!connection || connection.status !== "connected" ||
-        view.walletAvailability.status !== "available" || view.connectionConflict || view.connectionReconciliationRequired ||
-        view.connections.some((item) => item.pendingAction || item.status === "awaiting_approval"))) {
-        context.addIssue({ code: "custom", path: ["usableConnectionId"], message: "The usable connection must match current connection facts." });
-    }
-    if (new Set(view.manageableConnectionIds).size !== view.manageableConnectionIds.length ||
-        view.manageableConnectionIds.some((id) => !view.connections.some((item) => item.connectionId === id &&
-            !item.pendingAction && item.status !== "awaiting_approval"))) {
-        context.addIssue({ code: "custom", path: ["manageableConnectionIds"], message: "Management must name distinct recorded targets without pending operations." });
+    if ("account" in action) {
+        const account = normalizeChainAddress(SUI_MAINNET_WALLET_CHAIN, action.account);
+        if (!account)
+            throw new Error("A valid chain account is required.");
+        return { ...action, account };
     }
-    if (view.connectionReconciliationRequired && (view.usableConnectionId || view.assetReadAccount?.status === "available" ||
-        view.allowedActions.some((action) => ["connect", "use_account", "prepare_review", "request_signature"].includes(action)))) {
-        context.addIssue({ code: "custom", path: ["connectionReconciliationRequired"], message: "Unrecorded SDK connections cannot authorize connection or account use." });
-    }
-    if (view.assetReadAccount?.status === "available" && (!connection ||
-        !connection.accounts.includes(view.assetReadAccount.account) || view.activeAccount !== view.assetReadAccount.account)) {
-        context.addIssue({ code: "custom", path: ["assetReadAccount"], message: "The default address must belong to the usable connection and stored selection." });
+    return action;
+}
+function checkReviewAccount(view, context) {
+    if (view.reviewTarget && (view.review?.account && view.review.account !== view.reviewTarget.account ||
+        view.request && view.request.account !== view.reviewTarget.account)) {
+        context.addIssue({ code: "custom", path: ["reviewTarget"], message: "The fixed review target must match its recorded account and request." });
     }
-});
+}
+const nextStepSchema = z.object({ kind: z.enum(workflowNextSteps), message: z.string().optional(), reason: z.string().optional() }).strict();
+const liveFields = {
+    allowedActions: z.array(z.enum(workflowActions)), actionRemainingMs: z.number().int().nonnegative(),
+    nextStateReadAfterMs: z.number().int().nonnegative().optional(), observe: z.boolean(),
+    walletAvailability: walletAvailabilitySchema, walletObservation: walletObservationSchema.optional(),
+    progress: workflowProgressSchema, nextStep: nextStepSchema
+};
+export const connectViewSchema = z.object({ ...liveFields, kind: z.literal("connect"), mode: z.literal("connect"),
+    allowedActions: z.array(z.enum(["connect", "cancel", "stop_connection"])),
+    boundary: z.literal(CONNECT_BOUNDARY), requestedChains: walletChainsSchema,
+    operation: walletConnectionOperationSchema.optional(), automaticAction: walletConnectionActionSchema.options[0].optional() }).strict();
+export const disconnectViewSchema = z.object({ ...liveFields, kind: z.literal("disconnect"), mode: z.literal("disconnect"),
+    allowedActions: z.array(z.enum(["disconnect", "cancel"])),
+    boundary: z.literal(CONNECT_BOUNDARY), connection: connectionViewSchema.optional(),
+    operation: walletConnectionOperationSchema.optional() }).strict();
+const reviewPayloadSchema = z.object({
+    reviewSessionId: z.string(), plan: actionPlanSchema, reviewRevision: z.number().int().nonnegative(),
+    status: internalSessionStatusSchema, account: z.string().optional(), preparing: z.boolean(),
+    accountRequestPending: z.literal(true).optional(), error: z.string().optional(), state: reviewStateOutputSchema.optional()
+}).strict();
+const reviewTargetSchema = z.object({ connectionId: z.string(), account: suiAddressStringSchema }).strict();
+const netGasSchema = z.string().regex(/^-?[0-9]+$/).optional();
+export const reviewViewSchema = z.object({ ...liveFields, kind: z.literal("review"), mode: z.enum(["review", "review_manage"]),
+    allowedActions: z.array(z.enum(["prepare_review", "request_signature", "read_result", "stop_waiting", "cancel"])),
+    boundary: z.literal(REVIEW_BOUNDARY), reviewTarget: reviewTargetSchema.optional(), review: reviewPayloadSchema,
+    walletName: z.string().optional(), acceptedWalletRunId: walletRunIdSchema.optional(),
+    automaticAction: reviewAction.extend({ action: z.literal("prepare_review") }).optional(),
+    request: transactionRequestSchema.optional(), receipt: z.unknown().optional(), netGasMist: netGasSchema,
+    observationStopped: z.boolean().optional()
+}).strict().superRefine(checkReviewAccount);
+export const workflowViewSchema = z.discriminatedUnion("kind", [connectViewSchema, disconnectViewSchema, reviewViewSchema]);
+const closedResult = z.object({ message: z.string(), recordedAt: z.string().datetime() }).strict();
+const closedFields = { allowedActions: z.array(z.never()), observe: z.literal(false), actionRemainingMs: z.literal(0), result: closedResult };
+export const closedWalletCardSchema = z.object({ ...closedFields, kind: z.enum(["connect", "disconnect"]),
+    result: closedResult.extend({ pendingWork: z.enum(["approval_response", "session_removal", "session_status"]).optional() }), walletName: z.string().optional(),
+    networks: z.array(z.object({ chainId: walletChainSchema, status: z.enum(["bound", "not_approved", "multiple_accounts", "invalid_response"]) }).strict()) }).strict();
+export const closedReviewCardSchema = z.object({ ...closedFields, kind: z.literal("review"),
+    mode: z.enum(["review", "review_manage"]), review: reviewPayloadSchema.optional(),
+    reviewTarget: reviewTargetSchema.optional(), request: transactionRequestSchema.optional(),
+    receipt: z.unknown().optional(), netGasMist: netGasSchema,
+    observationStopped: z.boolean().optional(), boundary: z.literal(REVIEW_BOUNDARY) }).strict().superRefine(checkReviewAccount);
 function automaticReviewAction(input) {
     const { record, session, request } = input;
     if (!session || record?.scope !== "review" || request || session.preparationError ||
@@ -86,18 +88,11 @@ function automaticReviewAction(input) {
         return undefined;
     const needsPreparation = !session.reviewState && session.reviewRevision === 0 ||
         session.reviewState?.status === "refresh_required" && session.reviewState.refreshReason === "review_evidence_stale";
-    if (!needsPreparation || input.assetReadAccount?.status !== "available")
-        return undefined;
-    const account = input.assetReadAccount.account;
-    const candidates = reviewWalletChoices(input, account);
-    if (candidates.length !== 1)
+    if (!needsPreparation || !input.reviewTarget)
         return undefined;
-    return { action: "prepare_review", walletRunId: input.walletAvailability.walletRunId, connectionId: candidates[0].connectionId,
-        account, reviewRevision: session.reviewRevision };
-}
-export function reviewWalletChoices(selection, account, requireSigningMethod = false) {
-    return selection.connections.filter((item) => item.connectionId === selection.usableConnectionId && item.accounts.includes(account) &&
-        (!requireSigningMethod || item.methods.includes("sui_signTransaction")));
+    const account = input.reviewTarget.account;
+    return { action: "prepare_review", walletRunId: input.walletAvailability.walletRunId,
+        connectionId: input.reviewTarget.connectionId, account, reviewRevision: session.reviewRevision };
 }
 function nextStateRead(input) {
     const walletInput = input.record?.state.state === "ready" && input.record.scope !== "review_manage" && !input.request &&
@@ -109,24 +104,20 @@ function nextStateRead(input) {
     return delays.length ? Math.min(...delays) : undefined;
 }
 export function projectConnectionView(input) {
-    const { walletAvailability } = input;
-    const stored = input.record?.state.data;
-    const connection = input.record?.acceptedInput?.action === "disconnect" && stored?.disconnectOutcome
-        ? connectionViewSchema.parse(stored.disconnectOutcome) : input.connection;
-    const readAfter = nextStateRead(input);
-    const progress = input.runtimeRecovery ? { status: "phase" in input.runtimeRecovery ? "waiting" : "idle" } :
-        workflowProgress(connection?.status === "awaiting_approval" || connection?.pendingAction === "disconnect", true, walletAvailability);
-    return workflowViewSchema.parse({ kind: "connect", mode: "connect", allowedActions: input.allowedActions,
-        actionRemainingMs: input.actionRemainingMs, observe: progress.status === "waiting", progress, walletAvailability,
-        ...(input.record?.state.input.intent === "connect" && input.allowedActions.includes("connect")
-            ? { automaticAction: { action: "connect", walletRunId: walletAvailability.walletRunId } } : {}),
-        runtimeRecovery: input.runtimeRecovery, walletObservation: input.walletObservation,
-        connectionConflict: input.connectionConflict, usableConnectionId: input.usableConnectionId, assetReadAccount: input.assetReadAccount,
-        manageableConnectionIds: input.manageableConnectionIds, connectionReconciliationRequired: input.connectionReconciliationRequired,
-        connectionAction: ["connect", "disconnect"].includes(String(input.record?.acceptedInput?.action)) ? input.record?.acceptedInput?.action : undefined,
-        acceptedWalletRunId: input.record?.acceptedInput?.walletRunId,
-        ...(readAfter === undefined ? {} : { nextStateReadAfterMs: readAfter }),
-        connections: input.connections, activeAccount: input.activeAccount, connection, boundary: CONNECT_BOUNDARY });
+    const { walletAvailability, operation } = input, readAfter = nextStateRead(input);
+    const progress = workflowProgress(!!operation && operation.status === "running", true, walletAvailability);
+    const common = { allowedActions: input.allowedActions, actionRemainingMs: input.actionRemainingMs,
+        observe: progress.status === "waiting", progress, walletAvailability, walletObservation: input.walletObservation,
+        operation, nextStep: input.nextStep, boundary: CONNECT_BOUNDARY,
+        ...(readAfter === undefined ? {} : { nextStateReadAfterMs: readAfter }) };
+    if (input.record?.scope === "disconnect")
+        return disconnectViewSchema.parse({ ...common, kind: "disconnect", mode: "disconnect",
+            connection: input.connection?.connectionId === input.record.state.input.connectionId ? input.connection : undefined });
+    return connectViewSchema.parse({ ...common, kind: "connect", mode: "connect",
+        requestedChains: walletChainsSchema.parse(input.record?.state.input.requestedChains ?? input.requestedChains),
+        ...(!operation && input.record?.operationId && input.allowedActions.includes("connect")
+            ? { automaticAction: { action: "connect", operationId: input.record.operationId, walletRunId: walletAvailability.walletRunId,
+                    chains: input.record.state.input.requestedChains } } : {}) });
 }
 export function projectReviewView(input) {
     const { record, session, request, authority, walletAvailability, boundReview } = input;
@@ -139,11 +130,11 @@ export function projectReviewView(input) {
     const gas = displayedReview?.simulation?.gasCostSummary;
     const automaticAction = automaticReviewAction(input);
     const readAfter = nextStateRead(input);
-    return workflowViewSchema.parse({ kind: "review", mode: record.scope === "review_manage" ? "review_manage" : "review",
+    return reviewViewSchema.parse({ kind: "review", mode: record.scope === "review_manage" ? "review_manage" : "review",
         allowedActions: input.allowedActions, actionRemainingMs: input.actionRemainingMs, observe: progress.status === "waiting", progress, walletAvailability,
-        connections: input.connections, connectionConflict: input.connectionConflict, usableConnectionId: input.usableConnectionId,
-        manageableConnectionIds: input.manageableConnectionIds, connectionReconciliationRequired: input.connectionReconciliationRequired,
-        assetReadAccount: input.assetReadAccount, activeAccount: input.activeAccount, boundary: REVIEW_BOUNDARY, receipt: input.receipt,
+        reviewTarget: input.reviewTarget, nextStep: input.nextStep,
+        walletName: input.connection?.connectionId === input.reviewTarget?.connectionId ? input.connection?.walletName : undefined,
+        boundary: REVIEW_BOUNDARY, receipt: input.receipt,
         walletObservation: input.walletObservation,
         acceptedWalletRunId: record.acceptedInput?.walletRunId,
         ...(readAfter === undefined ? {} : { nextStateReadAfterMs: readAfter }),
@@ -153,7 +144,7 @@ export function projectReviewView(input) {
             status: boundReview?.status ?? session.status, account: boundReview?.account ?? session.account,
             ...(!request && !session.plans[0]?.reviewModel && input.busyForAccount ? { accountRequestPending: true } : {}),
             preparing: !boundReview && !!session.preparationId,
-            error: !boundReview ? [input.preparationIssue && `Current account selection: ${input.preparationIssue}`,
+            error: !boundReview ? [input.preparationIssue && `Review target: ${input.preparationIssue}`,
                 session.preparationError && `Earlier review message: “${session.preparationError}”`].filter(Boolean).join("\n\n") || undefined : undefined,
             state: displayedReview },
         request, observationStopped: authority ? authority.observation_stopped === 1 : undefined });

package/dist/mcp/activeAccountResponse.js

@@ -1,8 +1,10 @@
+import { walletChainSchema } from "../core/session/chainAccounts.js";
 import { z } from "zod";
 export const activeAccountResponseSchema = z.discriminatedUnion("status", [
     z.object({
         status: z.literal("set"),
         account: z.string(),
+        chainId: walletChainSchema,
         source: z.literal("wallet_connection"),
         setAt: z.string(),
         boundary: z.literal("read_context_only_not_signing_authorization")
@@ -16,6 +18,7 @@ export function activeAccountResponse(active) {
         ? {
             status: "set",
             account: active.address,
+            chainId: active.chainId,
             source: active.source,
             setAt: active.setAt,
             boundary: "read_context_only_not_signing_authorization"

package/dist/mcp/prompts.js

@@ -8,7 +8,7 @@ export const MCP_PROMPTS = [
         description: "Review current supported mainnet surfaces and tool status.",
         text: [
             "Inspect the Sui MCP server status and supported mainnet Sui protocol surfaces.",
-            "Use read.get_server_status first, then read.list_supported_protocols.",
+            "Use read_get_server_status first, then read_list_supported_protocols.",
             "Report implemented tools separately from unavailable or blocked surfaces."
         ].join("\n")
     },
@@ -18,8 +18,8 @@ export const MCP_PROMPTS = [
         description: "Prepare a local review session for a supported action proposal.",
         text: [
             "Prepare a reviewable Sui action only through Sui MCP's review-session flow.",
-            "Use action.prepare_external_proposal_review when the input is a structured external payment or Sui action proposal.",
-            "External proposals get read-only local review and never become signing material. Use action.prepare_sui_action_review for a natural-language swap intent; after a wallet account is connected, account-bound review can reach ready_for_wallet_review, where an explicit Review card action can request approval in the user’s wallet through the backend.",
+            "Use action_create_proposal_review when the input is a structured external payment or Sui action proposal.",
+            "External proposals get read-only local review and never become signing material. Use action_start_review for a natural-language swap intent; after a wallet account is connected, account-bound review can reach ready_for_wallet_review, where an explicit Review card action can request approval in the user’s wallet through the backend.",
             "Present the internal Review card and summarize the returned review checks. This MCP response never contains signing data, transaction bytes, or signing readiness; only an explicit UI action and wallet approval authorize the backend request; request status is separate from server-verified chain execution facts."
         ].join("\n")
     }
@@ -56,6 +56,7 @@ function registerSurfacePrompt(server, name, surface, description) {
     }));
 }
 export function registerMcpPrompts(server, surfaces = []) {
+    const registeredNames = [];
     for (const prompt of MCP_PROMPTS) {
         server.registerPrompt(prompt.name, {
             title: prompt.title,
@@ -72,13 +73,18 @@ export function registerMcpPrompts(server, surfaces = []) {
                 }
             ]
         }));
+        registeredNames.push(prompt.name);
     }
     for (const surface of surfaces) {
-        registerSurfacePrompt(server, promptNameFor(surface), surface, surface.description);
+        const name = promptNameFor(surface);
+        registerSurfacePrompt(server, name, surface, surface.description);
+        registeredNames.push(name);
     }
     for (const [action, group] of actionGroups(surfaces)) {
         registerBareActionPrompt(server, action, group);
+        registeredNames.push(action);
     }
+    return registeredNames;
 }
 export function bareActionPromptText(action, group, intent, protocol) {
     const chosen = group.length === 1 ? group[0] : group.find((surface) => surface.protocolSlug === (protocol ?? "").trim());

package/dist/mcp/resources.js

@@ -42,7 +42,7 @@ export const MCP_RESOURCES = [
         name: "deepbook-v3",
         uri: "suimcp://protocols/deepbook-v3",
         title: "DeepBookV3",
-        description: "Protocol reference only; use MCP tool responses and read.list_supported_protocols for current support.",
+        description: "Protocol reference only; use MCP tool responses and read_list_supported_protocols for current support.",
         path: "protocols/deepbook-v3.md"
     },
     {

package/dist/mcp/responseGuidance.js

@@ -1,13 +1,12 @@
 import { EXTERNAL_PROPOSAL_SETTLEMENT_TOKEN_SELECTION_UNSUPPORTED_CLAIM_ID } from "../core/proposal/types.js";
 import { TOOL_NAMES } from "./toolNames.js";
-export function interactionStatusUserAnswerUse(hasWalletObservation = false, hasConnectionConflict = false, reconciliationRequired = false) {
+export function interactionStatusUserAnswerUse(hasWalletObservation = false, reconciliationRequired = false) {
     return {
         canAnswer: [
             "stored_active_account_read_context",
             "wallet_connections_when_wallet_availability_is_available",
             "connection_qualified_default_asset_account",
             "pending_local_wallet_connection_interactions",
-            ...(hasConnectionConflict ? ["multiple_saved_connections_require_user_targeted_disconnection"] : []),
             ...(reconciliationRequired ? ["unrecorded_service_connection_requires_wallet_removal_and_confirmed_absence"] : []),
             "pending_local_review_interactions",
             "wallet_operation_availability_separate_from_stored_transaction_facts"
@@ -25,11 +24,10 @@ export function interactionStatusUserAnswerUse(hasWalletObservation = false, has
             "complete_wallet_history",
             "profit_or_pnl"
         ],
-        preconditionFields: ["walletAvailability", "assetReadAccount", ...(hasConnectionConflict ? ["connectionConflict"] : []),
+        preconditionFields: ["walletAvailability", "assetReadAccount",
             ...(reconciliationRequired ? ["connectionReconciliationRequired"] : [])],
-        answerFields: ["activeAccount", "connections", "assetReadAccount", "pendingWalletConnections", "pendingReviewSessions", "walletAvailability",
-            ...(hasConnectionConflict ? ["connectionConflict"] : []),
-            "manageableConnectionIds", ...(reconciliationRequired ? ["connectionReconciliationRequired"] : []),
+        answerFields: ["activeAccount", "requestedChains", "connection", "assetReadAccount", "pendingWalletConnections", "pendingReviewSessions", "walletAvailability",
+            "canDisconnect", ...(reconciliationRequired ? ["connectionReconciliationRequired"] : []),
             ...(hasWalletObservation ? ["walletObservation"] : [])],
         diagnosticOnlyFields: [
             "pendingWalletConnections.truncated",
@@ -69,7 +67,7 @@ export function executionResultUserAnswerUse(fields = {}) {
             "profit_or_pnl"
         ],
         answerFields: [
-            "walletAvailability", "progress", ...(fields.hasConnectionConflict ? ["connectionConflict"] : []),
+            "walletAvailability", "progress",
             ...(fields.reconciliationRequired ? ["connectionReconciliationRequired"] : []), ...(hasWaitOutcome ? ["waitOutcome"] : []),
             "reviewSessionId",
             "status",
@@ -95,7 +93,7 @@ export function executionResultUserAnswerUse(fields = {}) {
         }
     };
 }
-export function reviewStatusUserAnswerUse(hasReviewState, hasAdapterLifecycle = false, hasHumanReadableReview = false, hasSimulation = false, hasConnectionConflict = false, reconciliationRequired = false) {
+export function reviewStatusUserAnswerUse(hasReviewState, hasAdapterLifecycle = false, hasHumanReadableReview = false, hasSimulation = false, reconciliationRequired = false) {
     return {
         canAnswer: [
             "current_local_review_session_status",
@@ -119,7 +117,7 @@ export function reviewStatusUserAnswerUse(hasReviewState, hasAdapterLifecycle =
             "profit_or_pnl"
         ],
         answerFields: [
-            "walletAvailability", "progress", ...(hasConnectionConflict ? ["connectionConflict"] : []),
+            "walletAvailability", "progress",
             ...(reconciliationRequired ? ["connectionReconciliationRequired"] : []), "reviewSessionId",
             "status",
             "pollingStatus",

package/dist/mcp/server.js

@@ -19,9 +19,9 @@ export function createMcpServer(deps) {
     });
     registerMcpResources(server);
     registerReadCards(server, deps);
-    registerMcpPrompts(server, deps.promptSurfaces ?? []);
+    const registeredPromptNames = registerMcpPrompts(server, deps.promptSurfaces ?? []);
     registerAccountTools(server, deps);
-    registerReadTools(server, deps);
+    registerReadTools(server, deps, registeredPromptNames);
     registerSettingsTools(server, deps);
     registerActionTools(server, deps);
     registerSessionTools(server, deps);