@zktx.io/sui-mcp 0.5.0 → 0.6.1

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

@@ -1,4 +1,4 @@
-import { CONNECTION_CONFLICT_MESSAGE } from "../../../core/session/walletConnection.js";
+import { CONNECTION_CONFLICT_MESSAGE, 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";
@@ -41,7 +41,7 @@ export async function resolveExplicitOrActiveAccount(input, deps) {
         };
     }
     try {
-        const context = deps.workflow?.readConnectionContext();
+        const context = deps.workflow?.reconcileConnectionContext();
         if (context?.assetReadAccount.status === "available")
             return { status: "ok", account: context.assetReadAccount.account };
         const availability = context?.walletAvailability ?? walletUnavailable("initialization_failed");
@@ -51,13 +51,14 @@ 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?.connectionConflict ? CONNECTION_CONFLICT_MESSAGE : "This tool requires a selected account with a usable wallet connection. An address alone cannot be used.",
+                        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 } : {}),
+                        ...(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.` } } }) };
         }
-        const message = 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." : context?.connectionConflict ? CONNECTION_CONFLICT_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.";
         return { status: "address_required", message, result: errorToolResult({ kind: "input_invalid",

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

@@ -5,7 +5,6 @@ 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";
-// Executable swap adapters precede protocol-notes-only entries.
 export const SUPPORTED_PROTOCOLS = [
     { id: "deepbook-v3", status: "mainnet", support: "read_and_local_review" },
     { id: "deepbook-margin", status: "mainnet", support: "protocol_notes_only" }

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, hasRequest: !!request, hasExecutionResult: !!request?.execution }) });
+            return okToolResult({ ...reviewStatusResponse(state), userAnswerUse: executionResultUserAnswerUse({ hasConnectionConflict: !!state.connectionConflict, 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.signal });
             return okToolResult({ waitOutcome: result.waitOutcome, ...reviewStatusResponse(result),
-                userAnswerUse: executionResultUserAnswerUse({ hasConnectionConflict: !!result.connectionConflict, hasRequest: !!result.request, hasExecutionResult: !!result.request?.execution, hasWaitOutcome: true }) });
+                userAnswerUse: executionResultUserAnswerUse({ hasConnectionConflict: !!result.connectionConflict, 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

@@ -15,6 +15,7 @@ export function executionStatusCategorySchema() { return z.enum(EXECUTION_STATUS
 export const timeoutInputSchema = z.number().int().min(1).max(MAX_WAIT_TIMEOUT_MS).default(DEFAULT_WAIT_TIMEOUT_MS).optional();
 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,
     reviewSessionId: z.string(), status: internalSessionStatusSchema, reviewRevision: z.number().int().nonnegative(),
     account: z.string().optional(), plans: z.array(actionPlanSchema), reviewState: reviewStateOutputSchema.optional(),
@@ -26,8 +27,6 @@ export function latest(items) {
     const sorted = [...items].sort((left, right) => right.lastActivityAt.localeCompare(left.lastActivityAt));
     return { limit: INTERACTION_STATUS_LIMIT, items: sorted.slice(0, INTERACTION_STATUS_LIMIT), truncated: sorted.length > INTERACTION_STATUS_LIMIT };
 }
-// Runtime workflows own reconciliation/observation. A server without a wallet
-// workflow can still expose ordinary preparation facts, with explicit absence.
 export async function readCurrentReview(deps, id, explicitResult = false) {
     if (deps.workflow)
         return deps.workflow.readReview(id, explicitResult);

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

@@ -18,6 +18,7 @@ export function registerSessionStatusTools(server, deps) {
         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(),
             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() })) }),
@@ -33,16 +34,14 @@ export function registerSessionStatusTools(server, deps) {
             return activityStoreToolError(error, deps.logger);
         }
         try {
-            // Connection reconciliation can invalidate reviews and interrupt requests.
-            // Complete that maintenance before projecting its dependent review facts.
-            const context = deps.workflow?.readConnectionContext() ?? { connections: [],
+            const context = deps.workflow?.reconcileConnectionContext() ?? { connections: [], manageableConnectionIds: [],
                 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) });
+                userAnswerUse: interactionStatusUserAnswerUse("walletObservation" in context && context.walletObservation !== undefined, "connectionConflict" in context && !!context.connectionConflict, "connectionReconciliationRequired" in context && !!context.connectionReconciliationRequired) });
         }
         catch (error) {
             return sessionStoreToolError(error, deps.logger);
@@ -60,7 +59,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) });
+                userAnswerUse: reviewStatusUserAnswerUse(!!session.reviewState, !!session.reviewState?.adapterLifecycle, !!session.reviewState?.humanReadableReview, !!session.reviewState?.simulation, !!state.connectionConflict, !!state.connectionReconciliationRequired) });
         }
         catch (error) {
             return sessionStoreToolError(error, deps.logger);

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

@@ -1,10 +1,13 @@
 import { z } from "zod";
 import { SETTINGS_APPLIES_AFTER_RESTART } from "../../../core/preferences/preferencesStore.js";
 import { registerSuiMcpTool } from "../../registerTool.js";
-import { errorToolResult, okToolResult } from "../../result.js";
+import { okToolResult } from "../../result.js";
 import { noParamsInputSchema, successOutputSchema } from "../../schemas.js";
 import { localSettingsToolError, sessionStoreToolError } from "../../toolErrors.js";
 import { TOOL_NAMES } from "../../toolNames.js";
+import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
+import { cardMetadata, createWorkflowCard } from "../../../mcp-ui/tools.js";
+import { cardSnapshotSchema } from "../../../mcp-ui/contracts.js";
 const endpointSettingSchema = z.object({
     storedValue: z.string(),
     effectiveValue: z.string(),
@@ -13,34 +16,11 @@ const endpointSettingSchema = z.object({
     appliesAfter: z.literal(SETTINGS_APPLIES_AFTER_RESTART).optional()
 });
 export function registerSettingsTools(server, deps) {
-    server.registerTool(TOOL_NAMES.settingsCreateLocalSettingsSession, {
-        title: "Create local settings session",
-        description: "Create a local settings page session.",
-        inputSchema: noParamsInputSchema,
-        outputSchema: successOutputSchema({
-            settingsSessionId: z.string(),
-            settingsUrl: z.string(),
-            status: z.literal("created"),
-            openTarget: z.literal("system_browser"),
-            accessScope: z.literal("same_machine_loopback"),
-            expiresAt: z.string(),
-            lastActivityAt: z.string()
-        }),
-        annotations: { readOnlyHint: false, openWorldHint: false }
-    }, async () => {
+    registerAppTool(server, TOOL_NAMES.settingsCreateLocalSettingsSession, { title: "Settings", description: "Open a local settings card.", inputSchema: noParamsInputSchema,
+        outputSchema: successOutputSchema(cardSnapshotSchema.shape), _meta: cardMetadata("settings"),
+        annotations: { readOnlyHint: false, openWorldHint: false } }, async () => {
         try {
-            if (!deps.reviewBaseUrl)
-                return errorToolResult({ kind: "ui_unavailable", details: { reason: "Settings UI is unavailable in this runtime." } });
-            const created = await deps.sessions.createSettingsSession();
-            return okToolResult({
-                settingsSessionId: created.session.id,
-                settingsUrl: `${deps.reviewBaseUrl}/settings/${created.session.id}#${created.token}`,
-                status: "created",
-                openTarget: "system_browser",
-                accessScope: "same_machine_loopback",
-                expiresAt: created.session.expiresAt,
-                lastActivityAt: created.session.lastActivityAt
-            });
+            return await createWorkflowCard(server, deps, "settings", {});
         }
         catch (error) {
             return sessionStoreToolError(error, deps.logger);