@zktx.io/sui-mcp 0.7.0 → 0.8.1

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

@@ -37,6 +37,7 @@ export const TOOL_NAMES = {
     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",

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

@@ -9,7 +9,7 @@ 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) {
@@ -18,7 +18,7 @@ export function registerActionTools(server, deps) {
         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,7 +69,7 @@ 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);

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.sessionGetWalletConnectionCard} or ${TOOL_NAMES.sessionWaitWalletConnectionCard}. If no operation is pending and the user requests connection or account selection, open ${TOOL_NAMES.sessionOpenWalletConnectionCard}. 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/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";
@@ -11,43 +14,52 @@ import { sessionStoreToolError } from "../../toolErrors.js";
 export function registerWalletConnectionTools(server, deps) {
     const failure = (error) => sessionStoreToolError(error, deps.logger);
     server.registerTool(TOOL_NAMES.sessionOpenWalletConnectionCard, {
-        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),
+        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.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 the saved state of one wallet connection card.",
-        inputSchema: z.object({ cardId: z.string().min(1) }), outputSchema: successOutputSchema(cardSnapshotSchema.shape),
+        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.sessionWaitWalletConnectionCard, {
-        title: "Wait for wallet connection card", 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 }),
+        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);

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

@@ -1,3 +1,5 @@
+import { settingsCardInputSchema } from "../../../core/session/settingsOperation.js";
+import { walletChainsSchema } from "../../../core/session/chainAccounts.js";
 import { z } from "zod";
 import { SETTINGS_APPLIES_AFTER_RESTART } from "../../../core/preferences/preferencesStore.js";
 import { registerSuiMcpTool } from "../../registerTool.js";
@@ -16,11 +18,11 @@ const endpointSettingSchema = z.object({
     appliesAfter: z.literal(SETTINGS_APPLIES_AFTER_RESTART).optional()
 });
 export function registerSettingsTools(server, deps) {
-    registerAppTool(server, TOOL_NAMES.settingsCreateLocalSettingsSession, { title: "Settings", description: "Open a local settings card.", inputSchema: noParamsInputSchema,
+    registerAppTool(server, TOOL_NAMES.settingsCreateLocalSettingsSession, { title: "Settings", description: "Open local settings, read a recorded operation, or request delivery of an existing backup.", inputSchema: settingsCardInputSchema,
         outputSchema: successOutputSchema(cardSnapshotSchema.shape), _meta: cardMetadata("settings"),
-        annotations: { readOnlyHint: false, openWorldHint: false } }, async () => {
+        annotations: { readOnlyHint: false, openWorldHint: false } }, async (input) => {
         try {
-            return await createWorkflowCard(server, deps, "settings", {});
+            return await createWorkflowCard(server, deps, "settings", input);
         }
         catch (error) {
             return sessionStoreToolError(error, deps.logger);
@@ -32,7 +34,8 @@ export function registerSettingsTools(server, deps) {
         inputSchema: noParamsInputSchema,
         outputSchema: successOutputSchema({
             suiGrpcUrl: endpointSettingSchema,
-            suiGraphqlUrl: endpointSettingSchema
+            suiGraphqlUrl: endpointSettingSchema,
+            walletConnectionChains: walletChainsSchema
         }),
         annotations: { readOnlyHint: true, openWorldHint: false }
     }, async () => {