vpsnet-mcp 2.3.4 → 2.3.6

package/README.md

@@ -153,7 +153,7 @@ replacement is conclusively contained; uncertain outcomes fail closed.
 
 An immutable update is available only when `get_application_installation`
 returns an `available_actions` entry with `type: "update"`. After explicit user
-confirmation, call `manage_application` with `action: "update"`, the exact
+confirmation, call `update_application` with the exact
 advertised `expected_blueprint_version` and `expected_upstream_version`, and a
 new idempotency key. Keys are client-global: reuse a key only to replay the
 exact same request, never for another service or operation. The
@@ -186,7 +186,7 @@ rather than attempting an action and reading the failure.
 
 Uninstall permanently deletes the managed containers, configuration, saved
 credentials, and application data; existing server backups are retained. The
-`manage_application` call requires `acknowledge_data_loss=true` for uninstall,
+`uninstall_application` call requires `acknowledge_data_loss=true`,
 and it must only be set after explicit user confirmation.
 
 The MCP surface is task-oriented rather than a one-to-one mirror of every REST
@@ -224,7 +224,8 @@ paying twice for names already covered by base/www or wildcard/base rules.
 During the final 30 days, an eligible next term uses
 `quote_automatic_ssl_renewal` → `order_automatic_ssl_renewal` and is prepaid
 from account balance only after the exact EUR total is approved. Cancellation,
-domain removal, and same-type correction use `manage_automatic_ssl_subscription`;
+domain removal, and same-type correction use `cancel_automatic_ssl_subscription`,
+`remove_automatic_ssl_domain`, and `replace_automatic_ssl_domain`;
 ambiguous state is reconciled with `refresh_automatic_ssl_subscription`, never
 by inventing a second mutation. Private ACME server and EAB credentials stay
 in the two-factor-protected customer portal and are intentionally unavailable
@@ -241,7 +242,7 @@ There is no dialog on this surface to collect that confirmation, so the tool
 does not manufacture it. `acknowledge_data_replacement` and
 `acknowledge_restore_charge` must each be `true`, and are only to be set after
 the user has actually approved the disk replacement and the charge — the same
-rule as `acknowledge_data_loss` on `manage_application`. Omitting either is a
+rule as `acknowledge_data_loss` on `uninstall_application`. Omitting either is a
 schema error, so an unattended caller cannot fall through to a charge: nothing
 is even quoted.
 
@@ -545,13 +546,13 @@ Follow the [Windsurf MCP documentation](https://docs.windsurf.com/windsurf/mcp).
 | Variable | Required | Description |
 |----------|----------|-------------|
 | `VPSNET_API_KEY` | Yes | Your VPSnet.com API key |
-| `VPSNET_API_URL` | No | API base URL (defaults to `https://api.vpsnet.com`); any `https://*.vpsnet.com` host, e.g. a staging API |
+| `VPSNET_API_URL` | No | API base URL (defaults to `https://api.vpsnet.com`); any `https://*.vpsnet.com` host configured for your deployment |
 | `VPSNET_AI_URL` | No | Delegated SSH runtime; production uses `https://ai.vpsnet.com`. Non-production requires the approved API origin followed by `/ai-control`. |
 | `VPSNET_AI_API_ORIGIN` | Non-production SSH only | Operator-approved HTTPS VPSnet API origin; must exactly match `VPSNET_API_URL`. Set both runtime variables privately for a non-production deployment. |
 | `VPSNET_API_TIMEOUT_MS` | No | Per-request timeout (default 45000) |
 
 Requests go out from the machine that runs this server, not from your browser. A
-host that admits only listed addresses (a staging API does) answers such a
+deployment that restricts access by source address can answer a blocked
 request with an HTML `403` page from its web server; the tool result then says
 so (`non_api_response: true`, `http_status: 403`) instead of passing the page on.
 Every error result carries `http_status`; a `429` also carries `retry_after`.
@@ -644,7 +645,14 @@ everything else.
 | `install_application` | Queue a confirmed, version-pinned managed installation | `applications:manage` | free |
 | `configure_application_access` | Queue a confirmed platform-hostname, private, public-IP, managed-HTTPS, or customer-managed external-HTTPS access change | `applications:manage` | free |
 | `configure_application_resource_thresholds` | Replace confirmed non-enforcing application resource thresholds and reached/recovered email preference | `applications:manage` | free |
-| `manage_application` | Queue a confirmed lifecycle action, including an eligible immutable update; uninstall also requires explicit data-loss acknowledgement | `applications:manage` | free |
+| `manage_application` | Compatibility tool for older clients; use the individual actions below | `applications:manage` | free |
+| `reconcile_application` | Reconcile an application with its declared configuration | `applications:manage` | free |
+| `repair_application` | Repair an application runtime | `applications:manage` | free |
+| `restart_application` | Restart an application after confirming interruption | `applications:manage` | free |
+| `start_application` | Start a stopped application | `applications:manage` | free |
+| `stop_application` | Stop an application after confirming interruption | `applications:manage` | free |
+| `uninstall_application` | Delete an application after explicit data-loss approval | `applications:manage` | free |
+| `update_application` | Apply the eligible immutable update with exact version preconditions | `applications:manage` | free |
 | `cancel_application_action` | Cancel the exact latest queued action only while the backend advertises it as cancellable | `applications:manage` | free |
 
 ### Service Actions
@@ -752,7 +760,11 @@ cannot be performed by an MCP connection authenticated with an API key.
 | `get_free_certificate_instruction` | Read automatic-DNS status or every required external-DNS CNAME | `certificates:read` | free |
 | `create_free_certificate` | Create one explicitly approved, idempotent no-cost DV request | `certificates:manage` | free |
 | `download_free_certificate` | Retrieve only the issued public leaf and chain, never a private key | `certificates:read` | free |
-| `manage_free_certificate` | Renew, revoke, recheck, or cancel an eligible request | `certificates:manage` | free |
+| `manage_free_certificate` | Compatibility tool for older clients; use the individual actions below | `certificates:manage` | free |
+| `renew_free_certificate` | Request early renewal for the authorized certificate names | `certificates:manage` | free |
+| `revoke_free_certificate` | Revoke an owned certificate after explicit approval | `certificates:manage` | free |
+| `recheck_free_certificate` | Recheck validation for a pending certificate | `certificates:manage` | free |
+| `cancel_free_certificate` | Cancel an eligible pending certificate request | `certificates:manage` | free |
 
 For portable API or assistant installation, use `customer_csr` and retain the
 private key where the CSR was generated. A managed request can renew unattended,
@@ -773,7 +785,10 @@ not treat a queued request as issued.
 | `order_automatic_ssl_domain` | Confirm and pay for the explicitly approved DNS-name quote | `certificates:read` | Paid: `certificates:order` |
 | `quote_automatic_ssl_renewal` | Quote the next eligible subscription term in EUR | `certificates:read` | Quote: `certificates:order` |
 | `order_automatic_ssl_renewal` | Prepay the explicitly approved next term from account balance | `certificates:read` | Paid: `certificates:order` |
-| `manage_automatic_ssl_subscription` | Cancel, remove a name, or correct an eligible name idempotently | `certificates:manage` | free |
+| `manage_automatic_ssl_subscription` | Compatibility tool for older clients; use the individual actions below | `certificates:manage` | free |
+| `cancel_automatic_ssl_subscription` | Cancel an owned Automatic SSL subscription | `certificates:manage` | free |
+| `remove_automatic_ssl_domain` | Remove one eligible DNS name from a subscription | `certificates:manage` | free |
+| `replace_automatic_ssl_domain` | Correct an eligible DNS name within its correction window | `certificates:manage` | free |
 
 Automatic SSL is a portable paid ACME subscription. It works with a compatible
 client on VPSnet or another provider; it is not limited to managed
@@ -794,7 +809,12 @@ tool or API-key response, so an assistant cannot copy them into model context.
 | `download_certificate` | Download the issued public leaf and chain; private keys are never returned | `certificates:read` | free |
 | `list_certificate_actions` | List durable customer-visible management actions | `certificates:read` | free |
 | `refresh_certificate` | Schedule a read-only certificate-authority status reconciliation | `certificates:manage` | free |
-| `manage_certificate` | Queue an idempotent cancellation, validation, or same-name reissue action | `certificates:manage` | free |
+| `manage_certificate` | Compatibility tool for older clients; use the individual actions below | `certificates:manage` | free |
+| `cancel_certificate` | Cancel an eligible pending certificate order | `certificates:manage` | free |
+| `recheck_certificate_validation` | Recheck certificate validation | `certificates:manage` | free |
+| `resend_certificate_validation` | Resend a certificate validation message after approval | `certificates:manage` | free |
+| `change_certificate_validation` | Change the validation method for one certificate name | `certificates:manage` | free |
+| `reissue_certificate` | Request a same-name reissue with a new public CSR | `certificates:manage` | free |
 
 Paid certificates are portable account products: customers may install them on
 Nginx, Apache, lighttpd, OpenLiteSpeed, HAProxy, Caddy, mail, API, load-balancer,
@@ -906,9 +926,9 @@ short-lived quote token.
 Customer ordering is disabled while the on-demand server lifecycle is being
 validated. Current options disclose that automatic backups and snapshots are
 not included and outbound connections to mail-delivery TCP ports 25, 2525,
-465, and 587 are restricted. Existing internal test sessions remain available
-through list/get/delete for cleanup. Fixed-TTL and prepaid fields in the
-disabled compatibility schema are not a launch promise; the flexible duration
+465, and 587 are restricted. Existing sessions remain available through
+list/get/delete for cleanup. Fixed-TTL and prepaid fields in the disabled
+compatibility schema are not a launch promise; the flexible duration
 and metered-billing contract must be published consistently before ordering is
 enabled.
 

package/build/certificate-contract.js

@@ -100,11 +100,11 @@ export const certificateAcmeSubscriptionActionRequestSchema = z.discriminatedUni
     }).strict(),
     z.object({
         action: z.literal("remove_domain"),
-        domain_id: z.number().int().positive(),
+        domain_id: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
     }).strict(),
     z.object({
         action: z.literal("replace_domain"),
-        domain_id: z.number().int().positive(),
+        domain_id: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
         new_domain: certificateDnsIdentifierSchema,
     }).strict(),
 ]);

package/build/index.js

@@ -66,7 +66,7 @@ export function createVpsnetServer(options = {}) {
             "Managed application reads require applications:read. Install and ordinary lifecycle changes require applications:manage plus an idempotencyKey and are not paid API-key operations. Selective data restore is paid and additionally requires the quote/confirm flow and applications:restore paid scope.",
             "Application CPU, RAM, and disk figures are sizing recommendations. Do not reject an installation or filter an otherwise supported order plan because it is below those figures; product, OS, architecture, and runtime compatibility remain hard requirements.",
             "Uninstall permanently deletes the managed containers, configuration, saved credentials, and application data. Existing server backups are retained. Set acknowledge_data_loss=true only after the user explicitly confirms that loss.",
-            "install_application and manage_application are asynchronous. A queued response is not proof that the application is healthy; poll get_application_installation and inspect get_application_events.",
+            "install_application and application lifecycle tools are asynchronous. A queued response is not proof that the application is healthy; poll get_application_installation and inspect get_application_events.",
             "Use configure_application_access to change an installed application's access mode. Read the installation first and pass its current revision. When access.request.schema_version=2, submit every exact access.endpoints key once and match the user's requested service by endpoint service and port; array order and primary=true are metadata, not a recommendation. platform_https allocates an opaque VPSnet hostname with automatic DNS and HTTPS; private has no public listener; public_http uses the server's public IP over HTTP; managed_https uses a selected VPSnet-managed DNS zone and may add additional_addresses such as the bare domain without www; external_https records a customer-managed HTTPS address and does not configure or validate DNS, TLS, or the customer's reverse proxy.",
             "get_application_installation includes bounded application and per-container resource history plus optional display thresholds when the worker supports those measurements. Use configure_application_resource_thresholds only at the user's request. Thresholds highlight CPU, memory, network-per-minute, or restart-delta samples but do not reserve or enforce resources, trigger server actions, or affect billing. Email is disabled by default; when the user enables it, VPSnet sends one reached and one recovered message per threshold episode without repeating while the metric remains high.",
             "Use list_application_registry_credentials only for non-secret private registry credential metadata. Exact custom HTTPS registry hostnames are supported. Registry token creation and rotation are intentionally unavailable through MCP because secrets must not enter model prompts or tool arguments; use the VPSnet panel or direct REST API.",
@@ -144,14 +144,14 @@ export function createVpsnetServer(options = {}) {
             "## TLS certificates and Automatic SSL",
             "Free portable certificates are separate from paid portable certificates, paid Automatic SSL subscriptions, and application Managed HTTPS. Start with get_free_certificate_eligibility and preflight_free_certificate. Only create when preflight says issuable and the user explicitly approves the exact names, CA, validation, delivery, and key-custody mode.",
             "For API/AI-managed deployment outside VPSnet, use customer_csr: generate and keep the private key on the destination, send only its public PKCS#10 CSR, then retrieve the public leaf and chain with download_free_certificate. In managed mode VPSnet stores an encrypted key for unattended early renewal, but that key is portal-only behind two-factor verification and is never available to MCP or API keys. Never imply that a public-only download is a deployable key pair.",
-            "Free-certificate issuance is asynchronous and quota-controlled. Poll get_free_certificate; use get_free_certificate_instruction for external-DNS CNAME delegation and download_free_certificate only after download_available=true. A queued request is not proof of issuance. Managed-key renewals are scheduled early with bounded jitter; customer_csr renewals require a new CSR. Read state before manage_free_certificate, explicitly approve revoke/cancel/renew, and after any ambiguous response re-read state before deciding whether another action is needed.",
+            "Free-certificate issuance is asynchronous and quota-controlled. Poll get_free_certificate; use get_free_certificate_instruction for external-DNS CNAME delegation and download_free_certificate only after download_available=true. A queued request is not proof of issuance. Managed-key renewals are scheduled early with bounded jitter; customer_csr renewals require a new CSR. Read state before renew_free_certificate, revoke_free_certificate, recheck_free_certificate or cancel_free_certificate; explicitly approve the requested action, and after any ambiguous response re-read state before deciding whether another action is needed.",
             "Paid TLS certificates are portable account products, not managed-application-only features. They can be installed on customer Nginx, Apache, lighttpd, OpenLiteSpeed, HAProxy, Caddy, mail, API, load-balancer, or other TLS endpoints.",
             "Managed HTTPS for VPSnet applications, Automatic SSL subscriptions for a customer ACME client, and portable certificate files are three separate choices. Do not place a paid order merely because an application already has managed platform HTTPS.",
             "Automatic SSL flow: list_certificate_catalog → quote_automatic_ssl_subscription → order_automatic_ssl_subscription. It works with compatible ACME clients on VPSnet or another provider. A base domain includes its www alias; apex and wildcard names are separate subscribed identifiers and may be ordered together. Choose auto_renew explicitly; every next term is still quoted and prepaid from balance during the final 30 days.",
             "After payment, poll get_automatic_ssl_subscription until state=active and credentials_available=true. The private ACME server URL and EAB credentials are intentionally portal-only behind two-factor verification; they are not MCP or API-key tools and must never enter model context.",
             "Add a DNS name with quote_automatic_ssl_domain → order_automatic_ssl_domain using the exact quote token and unchanged idempotency key. The quote prevents duplicate coverage from base/www and wildcard/base relationships.",
             "When renewal.available=true, use quote_automatic_ssl_renewal → order_automatic_ssl_renewal. Renewal is balance-only and must be explicitly approved; payment_processing or manual_review is not success.",
-            "Use list_automatic_ssl_actions before manage_automatic_ssl_subscription. Cancellation, removal, and same-type correction are durable and idempotent. Reuse a key only for the exact same request. For reconciliation_required or outcome_ambiguous, call refresh_automatic_ssl_subscription and read state instead of creating a new mutation.",
+            "Use list_automatic_ssl_actions before cancel_automatic_ssl_subscription, remove_automatic_ssl_domain or replace_automatic_ssl_domain. Cancellation, removal, and same-type correction are durable and idempotent. Reuse a key only for the exact same request. For reconciliation_required or outcome_ambiguous, call refresh_automatic_ssl_subscription and read state instead of creating a new mutation.",
             "Flow: list_certificate_catalog → quote_certificate → order_certificate. The quote returns the final customer price in EUR including VAT, a short-lived quote token, and the exact public-key type derived from the CSR. Disclose the exact total and obtain explicit approval before ordering.",
             "The customer creates and retains the private key. Certificate tools accept only a signed public PKCS#10 CSR. Never ask for, accept, store, repeat, or place a private key in a tool argument or model context.",
             "Use the same client-global idempotencyKey and exact unchanged order fields for quote_certificate and order_certificate. API keys require certificates:read for reads, certificates:manage for management, and paid operations plus certificates:order and spend caps for quote/order.",
@@ -179,7 +179,7 @@ export function createVpsnetServer(options = {}) {
         .min(1)
         .max(64)
         .regex(/^[A-Za-z0-9-]+$/, "Use the exact service order number returned by list_services")
-        .describe("Tenant-owned service order number: 1-64 ASCII letters, digits or hyphens, e.g. VP88318 or VP88318-1");
+        .describe("Tenant-owned service order number: 1-64 ASCII letters, digits or hyphens, e.g. VP12345 or VP12345-1");
     const positiveIdSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
     // Same shape OrderPrivateNetworkAdmission::admit() accepts for an order-time network.
     const privateNetworkIdSchema = z
@@ -604,7 +604,7 @@ export function createVpsnetServer(options = {}) {
         return { content: [{ type: "text", text: formatJson(data) }] };
     });
     server.registerTool("configure_application_resource_thresholds", {
-        description: "Replace the complete optional resource-threshold set and email preference for one owned managed application. Read get_application_installation first. Omitted or null numeric fields disable that threshold; omitted email_enabled is false; omitting all four thresholds clears the preferences and disables email. Thresholds highlight measured CPU, memory, combined network-per-minute, and restart-delta samples. When email is enabled, VPSnet sends one account email when a configured threshold is reached and one when it recovers, without repeating while it remains high. Thresholds do not reserve or enforce resources, restart containers, or affect billing. Confirm the exact thresholds and email preference with the user first. Requires applications:manage and is not a paid API-key operation.",
+        description: "Replace the complete optional resource-threshold set and email preference for one owned managed application. Read get_application_installation first. Omitted or null numeric fields disable that threshold; omitted email_enabled is false; omitting all four thresholds clears the preferences and disables email. Thresholds highlight measured CPU, memory, combined network-per-minute, and restart-delta samples. When email is enabled, VPSnet sends one account email when a configured threshold is reached and one when it recovers, without repeating while it remains high. Replacing thresholds can stop existing alerts. Thresholds do not reserve or enforce resources, restart containers, or affect billing. Confirm the exact thresholds and email preference with the user first. Requires applications:manage and is not a paid API-key operation.",
         inputSchema: {
             orderNo: applicationOrderNoSchema,
             installation_id: applicationInstallationIdSchema,
@@ -620,7 +620,7 @@ export function createVpsnetServer(options = {}) {
         annotations: {
             title: "Configure application resource thresholds",
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: true,
         },
     }, async ({ orderNo, installation_id, cpu_percent, email_enabled, memory_mib, network_mib_per_minute, restart_delta, }) => {
@@ -925,7 +925,7 @@ export function createVpsnetServer(options = {}) {
         };
     });
     server.registerTool("validate_application_recipe", {
-        description: "Resolve image tags to immutable digests, then validate the resulting customer-owned Docker Compose document with the authoritative policy on the target Firecracker worker. The successful result includes the exact digest-pinned definition to store. This does not create, install, or modify a project or container. The queued validation is polled for about 30 seconds and may still return pending. Requires applications:manage.",
+        description: "Resolve image tags from their registries to immutable digests, then validate the resulting customer-owned Docker Compose document with the authoritative policy on the target Firecracker worker. The successful result includes the exact digest-pinned definition to store. This does not create, install, or modify a project or container. The queued validation is polled for about 30 seconds and may still return pending. Requires applications:manage.",
         inputSchema: {
             orderNo: applicationOrderNoSchema,
             compose_yaml: customProjectComposeSchema,
@@ -936,6 +936,7 @@ export function createVpsnetServer(options = {}) {
             readOnlyHint: false,
             destructiveHint: false,
             idempotentHint: true,
+            openWorldHint: true,
         },
     }, async ({ orderNo, compose_yaml, registry_credential_ids }) => {
         const basePath = applicationPath(orderNo, "custom-projects");
@@ -989,7 +990,7 @@ export function createVpsnetServer(options = {}) {
         };
     });
     server.registerTool("create_application_recipe", {
-        description: "Resolve image tags, validate the resulting digest-pinned Compose definition, and freeze that exact definition as the first immutable customer-owned recipe revision. This saves a definition only and does not install or start containers. Plain environment values belong in env; secret_names contain names only. Confirm the exact service, name, Compose definition, variable names, and registry bindings first. Requires applications:manage.",
+        description: "Resolve image tags from their registries, validate the resulting digest-pinned Compose definition, and freeze that exact definition as the first immutable customer-owned recipe revision. This saves a definition only and does not install or start containers. Plain environment values belong in env; secret_names contain names only. Confirm the exact service, name, Compose definition, variable names, and registry bindings first. Requires applications:manage.",
         inputSchema: {
             orderNo: applicationOrderNoSchema,
             name: customProjectNameSchema,
@@ -1005,6 +1006,7 @@ export function createVpsnetServer(options = {}) {
             readOnlyHint: false,
             destructiveHint: false,
             idempotentHint: true,
+            openWorldHint: true,
         },
     }, async ({ orderNo, name, compose_yaml, env, secret_names, registry_credential_ids, idempotencyKey, }) => {
         const basePath = applicationPath(orderNo, "custom-projects");
@@ -1046,7 +1048,7 @@ export function createVpsnetServer(options = {}) {
         };
     });
     server.registerTool("create_application_recipe_revision", {
-        description: "Resolve image tags, validate the resulting digest-pinned Compose definition, and freeze that exact definition as a later immutable customer-owned recipe revision. This does not update the running installation. In-place updates retain the existing secret names and registry bindings for rollback safety; create a separate project when those bindings must change. Requires applications:manage.",
+        description: "Resolve image tags from their registries, validate the resulting digest-pinned Compose definition, and freeze that exact definition as a later immutable customer-owned recipe revision. This does not update the running installation. In-place updates retain the existing secret names and registry bindings for rollback safety; create a separate project when those bindings must change. Requires applications:manage.",
         inputSchema: {
             orderNo: applicationOrderNoSchema,
             project_id: customProjectIdSchema,
@@ -1062,6 +1064,7 @@ export function createVpsnetServer(options = {}) {
             readOnlyHint: false,
             destructiveHint: false,
             idempotentHint: true,
+            openWorldHint: true,
         },
     }, async ({ orderNo, project_id, compose_yaml, env, secret_names, registry_credential_ids, idempotencyKey, }) => {
         const basePath = applicationPath(orderNo, "custom-projects");
@@ -1320,7 +1323,7 @@ export function createVpsnetServer(options = {}) {
         annotations: {
             title: "Configure application access",
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: true,
         },
     }, async ({ orderNo, installation_id, access, expected_revision, idempotencyKey, }) => {
@@ -1334,107 +1337,137 @@ export function createVpsnetServer(options = {}) {
             ],
         };
     });
-    server.registerTool("manage_application", {
-        description: "Queue one supported lifecycle action for an owned managed application. Confirm the exact action with the user first. For update, first read get_application_installation and copy the exact advertised blueprint_version and upstream_version as execution preconditions. The backend still selects and freezes the eligible immutable release; callers cannot choose an arbitrary target. Stop interrupts service. Uninstall permanently deletes the managed containers, configuration, saved credentials, and application data; existing server backups are retained. Uninstall requires acknowledge_data_loss=true after explicit user confirmation. A queued response must be verified with get_application_installation and get_application_events. Selective data restore is a separate operation exposed by list_application_restore_points and restore_application_data. Requires applications:manage and is not a paid API-key operation.",
-        inputSchema: {
-            orderNo: applicationOrderNoSchema,
-            installation_id: applicationInstallationIdSchema,
-            action: applicationActionSchema,
-            idempotencyKey: idempotencyKeySchema.describe("Client-global unique key. Reuse it only to replay this exact lifecycle request; never reuse it for another service or request."),
-            expected_blueprint_version: applicationExpectedVersionSchema
-                .optional()
-                .describe("Required for update: exact blueprint_version from the current available_actions update capability"),
-            expected_upstream_version: applicationExpectedVersionSchema
-                .optional()
-                .describe("Required for update: exact upstream_version from the current available_actions update capability"),
-            confirmed: z
-                .literal(true)
-                .describe("True only after the user confirmed this lifecycle action"),
-            acknowledge_data_loss: z
-                .literal(true)
-                .optional()
-                .describe("Required for uninstall only. Set true after the user explicitly confirms permanent deletion of managed configuration, credentials, and application data."),
-        },
-        annotations: {
-            title: "Manage application lifecycle",
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: true,
-        },
-    }, async ({ orderNo, installation_id, action, idempotencyKey, expected_blueprint_version, expected_upstream_version, acknowledge_data_loss, }) => {
+    async function performApplicationLifecycleAction({ orderNo, installation_id, action, idempotencyKey, expected_blueprint_version, expected_upstream_version, acknowledge_data_loss, }) {
         if (action === "uninstall" && acknowledge_data_loss !== true) {
             return {
                 isError: true,
-                content: [
-                    {
-                        type: "text",
-                        text: formatJson({
+                content: [{ type: "text", text: formatJson({
                             success: false,
                             error_codes: ["applicationUninstallConfirmationRequired"],
-                        }),
-                    },
-                ],
+                        }) }],
             };
         }
         if (action === "update") {
             if (!expected_blueprint_version || !expected_upstream_version) {
                 return {
                     isError: true,
-                    content: [{
-                            type: "text",
-                            text: formatJson({
+                    content: [{ type: "text", text: formatJson({
                                 success: false,
                                 error_codes: ["applicationUpdateExpectationRequired"],
-                            }),
-                        }],
+                            }) }],
                 };
             }
             const current = await apiRequest("GET", applicationPath(orderNo, `installations/${encodeURIComponent(installation_id)}`));
-            if (current.status < 200
-                || current.status >= 300
+            if (current.status < 200 || current.status >= 300
                 || !applicationUpdateCandidateMatches(current.data, {
                     blueprintVersion: expected_blueprint_version,
                     upstreamVersion: expected_upstream_version,
                 })) {
                 return {
                     isError: true,
-                    content: [{
-                            type: "text",
-                            text: formatJson({
+                    content: [{ type: "text", text: formatJson({
                                 success: false,
                                 error_codes: ["applicationUpdateExpectationChanged"],
-                            }),
-                        }],
+                            }) }],
                 };
             }
         }
         else if (expected_blueprint_version || expected_upstream_version) {
             return {
                 isError: true,
-                content: [{
-                        type: "text",
-                        text: formatJson({
+                content: [{ type: "text", text: formatJson({
                             success: false,
                             error_codes: ["applicationUpdateExpectationUnexpected"],
-                        }),
-                    }],
+                        }) }],
             };
         }
         const { status, data } = await apiRequest("POST", applicationPath(orderNo, `installations/${encodeURIComponent(installation_id)}/actions`), applicationLifecycleRequestBody(action, acknowledge_data_loss === true, action === "update"
-            ? {
-                blueprintVersion: expected_blueprint_version,
-                upstreamVersion: expected_upstream_version,
-            }
+            ? { blueprintVersion: expected_blueprint_version, upstreamVersion: expected_upstream_version }
             : undefined), { "Idempotency-Key": idempotencyKey });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: safeApplicationMutationResult(status, data, orderNo),
-                },
-            ],
-        };
-    });
+        return { content: [{ type: "text", text: safeApplicationMutationResult(status, data, orderNo) }] };
+    }
+    server.registerTool("manage_application", {
+        description: "Queue one supported lifecycle action for an owned managed application. Confirm the exact action with the user first. For update, first read get_application_installation and copy the exact advertised blueprint_version and upstream_version as execution preconditions. The backend still selects and freezes the eligible immutable release; callers cannot choose an arbitrary target. Stop interrupts service. Uninstall permanently deletes the managed containers, configuration, saved credentials, and application data; existing server backups are retained. Uninstall requires acknowledge_data_loss=true after explicit user confirmation. A queued response must be verified with get_application_installation and get_application_events. Selective data restore is a separate operation exposed by list_application_restore_points and restore_application_data. Requires applications:manage and is not a paid API-key operation.",
+        inputSchema: {
+            orderNo: applicationOrderNoSchema,
+            installation_id: applicationInstallationIdSchema,
+            action: applicationActionSchema,
+            idempotencyKey: idempotencyKeySchema.describe("Client-global unique key. Reuse it only to replay this exact lifecycle request; never reuse it for another service or request."),
+            expected_blueprint_version: applicationExpectedVersionSchema
+                .optional()
+                .describe("Required for update: exact blueprint_version from the current available_actions update capability"),
+            expected_upstream_version: applicationExpectedVersionSchema
+                .optional()
+                .describe("Required for update: exact upstream_version from the current available_actions update capability"),
+            confirmed: z
+                .literal(true)
+                .describe("True only after the user confirmed this lifecycle action"),
+            acknowledge_data_loss: z
+                .literal(true)
+                .optional()
+                .describe("Required for uninstall only. Set true after the user explicitly confirms permanent deletion of managed configuration, credentials, and application data."),
+        },
+        annotations: {
+            title: "Manage application lifecycle",
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+        },
+    }, performApplicationLifecycleAction);
+    const applicationLifecycleBaseShape = {
+        orderNo: applicationOrderNoSchema,
+        installation_id: applicationInstallationIdSchema,
+        idempotencyKey: idempotencyKeySchema.describe("Client-global unique key for this exact lifecycle request. Reuse only for an unchanged retry."),
+        confirmed: z.literal(true).describe("True only after the user confirms this exact action"),
+    };
+    const applicationActionAnnotations = {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    server.registerTool("reconcile_application", {
+        description: "Reconcile an owned managed application with its declared configuration. Read the installation first; confirm the action, then poll installation and events until the queued operation completes. Requires applications:manage and a client-global idempotency key.",
+        inputSchema: applicationLifecycleBaseShape,
+        annotations: { ...applicationActionAnnotations, title: "Reconcile application" },
+    }, async (input) => performApplicationLifecycleAction({ ...input, action: "reconcile" }));
+    server.registerTool("repair_application", {
+        description: "Repair an owned managed application's runtime. Read current health and events first; confirm the action, then poll installation and events until the queued operation completes. Requires applications:manage and a client-global idempotency key.",
+        inputSchema: applicationLifecycleBaseShape,
+        annotations: { ...applicationActionAnnotations, title: "Repair application" },
+    }, async (input) => performApplicationLifecycleAction({ ...input, action: "repair" }));
+    server.registerTool("restart_application", {
+        description: "Restart an owned managed application. This interrupts service. Confirm the interruption, then poll installation and events until the queued operation completes. Requires applications:manage and a client-global idempotency key.",
+        inputSchema: applicationLifecycleBaseShape,
+        annotations: { ...applicationActionAnnotations, title: "Restart application" },
+    }, async (input) => performApplicationLifecycleAction({ ...input, action: "restart" }));
+    server.registerTool("start_application", {
+        description: "Start a stopped owned managed application. Confirm the action, then poll installation and events until the queued operation completes. Requires applications:manage and a client-global idempotency key.",
+        inputSchema: applicationLifecycleBaseShape,
+        annotations: { ...applicationActionAnnotations, title: "Start application", destructiveHint: false },
+    }, async (input) => performApplicationLifecycleAction({ ...input, action: "start" }));
+    server.registerTool("stop_application", {
+        description: "Stop an owned managed application. This interrupts service. Confirm the interruption, then poll installation and events until the queued operation completes. Requires applications:manage and a client-global idempotency key.",
+        inputSchema: applicationLifecycleBaseShape,
+        annotations: { ...applicationActionAnnotations, title: "Stop application" },
+    }, async (input) => performApplicationLifecycleAction({ ...input, action: "stop" }));
+    server.registerTool("uninstall_application", {
+        description: "Permanently delete an owned managed application's containers, configuration, saved credentials, and application data; server backups remain. Read the installation and obtain explicit user confirmation of data loss before calling. Poll installation and events for the final result. Requires applications:manage.",
+        inputSchema: {
+            ...applicationLifecycleBaseShape,
+            acknowledge_data_loss: z.literal(true).describe("The user explicitly confirmed permanent deletion of managed configuration, credentials, and application data"),
+        },
+        annotations: { title: "Uninstall application", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async (input) => performApplicationLifecycleAction({ ...input, action: "uninstall" }));
+    server.registerTool("update_application", {
+        description: "Queue the backend-selected newer immutable release for an owned managed application. First read get_application_installation and copy the exact advertised blueprint_version and upstream_version as execution preconditions; these are not caller-selected targets. Confirm the update, then poll installation and events for the final result. Requires applications:manage.",
+        inputSchema: {
+            ...applicationLifecycleBaseShape,
+            expected_blueprint_version: applicationExpectedVersionSchema.describe("Exact blueprint_version from the current available_actions update capability"),
+            expected_upstream_version: applicationExpectedVersionSchema.describe("Exact upstream_version from the current available_actions update capability"),
+        },
+        annotations: { title: "Update application", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async (input) => performApplicationLifecycleAction({ ...input, action: "update" }));
     server.registerTool("cancel_application_action", {
         description: "Request pre-dispatch cancellation of the exact latest action for one owned managed application. This is available only while get_application_installation advertises latest_action.cancellable=true for the same action UUID. The tool re-reads the installation immediately before submitting the cancellation and refuses stale, different, or non-cancellable actions. Cancellation never stops or interrupts a running worker job. Requires applications:manage, the exact latest_action.id UUID, and a fresh client-global idempotencyKey that was not used for the original action or another request. Reuse that key only to replay this exact cancellation request. This is not a paid API-key operation.",
         inputSchema: {
@@ -1446,7 +1479,7 @@ export function createVpsnetServer(options = {}) {
         annotations: {
             title: "Cancel queued application action",
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: true,
         },
     }, async ({ orderNo, installation_id, action_id, idempotencyKey }) => {
@@ -1681,7 +1714,7 @@ export function createVpsnetServer(options = {}) {
         return { content: [{ type: "text", text: formatJson(data) }] };
     });
     server.registerTool("reinstall_os", {
-        description: "Reinstall OS on VPS. WARNING: destroys existing data; confirm with the user before reinstalling. Cloud VPS and Firecracker VPS: reinstall also deletes existing snapshots, so they cannot provide rollback after reinstall. Read get_os_options.snapshotDeletion first; when snapshots exist, set confirmSnapshotDelete to true only after the user explicitly confirms their deletion. A pending snapshot action blocks reinstall until it finishes. Container VPS has no snapshots. Returns a noty UUID for acceptance; follow get_service_history for completion. Password rules: 6-40 chars, alphanumeric, must contain uppercase + lowercase + digit. Requires services:manage and a full-access API key.",
+        description: "Reinstall OS on VPS. WARNING: destroys existing data; confirm with the user before reinstalling. Cloud VPS and Firecracker VPS: reinstall also deletes existing snapshots, so they cannot provide rollback after reinstall. Read get_os_options.snapshotDeletion first; when snapshots exist, set confirmSnapshotDelete to true only after the user explicitly confirms their deletion. A pending snapshot action blocks reinstall until it finishes. Container VPS has no snapshots. Returns a noty UUID for acceptance; follow get_service_history for completion. Password rules: 6-40 chars, alphanumeric, must contain uppercase + lowercase + digit. OAuth requires services:reinstall; API keys require full access.",
         inputSchema: {
             orderNo: serviceOrderNoSchema,
             osVersion: z
@@ -1696,6 +1729,11 @@ export function createVpsnetServer(options = {}) {
                 .optional()
                 .describe("Cloud VPS and Firecracker VPS only: set true only after the user explicitly confirms deletion of the existing snapshots shown by get_os_options.snapshotDeletion. They cannot provide rollback after reinstall. Never inferred or enabled automatically."),
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+        },
     }, async ({ orderNo, osVersion, rootPassword, confirmSnapshotDelete }) => {
         const body = { osVersion };
         if (rootPassword)
@@ -2179,6 +2217,11 @@ export function createVpsnetServer(options = {}) {
                 }],
         };
     });
+    async function performFreeCertificateAction(free_certificate_request_id, request) {
+        const { action, body } = freeCertificateActionRequestBody(request);
+        const { status, data } = await apiRequest("POST", certificatePath(`/free/${encodeURIComponent(free_certificate_request_id)}/actions/${encodeURIComponent(action)}`), body);
+        return { content: [{ type: "text", text: formatJson(safeCertificatePayload("free-action", status, data)) }] };
+    }
     server.registerTool("manage_free_certificate", {
         description: "Request one free-certificate lifecycle action after reading its current state: early renew, revoke, recheck validation, or cancel before issuance. A customer_csr renewal requires a new public CSR for the unchanged authorized names; managed-key renewal normally happens automatically. Call only after explicit user approval. If the response is ambiguous, read get_free_certificate before deciding whether another action is needed. This tool cannot export a private key. Requires certificates:manage.",
         inputSchema: {
@@ -2198,15 +2241,32 @@ export function createVpsnetServer(options = {}) {
         if (acknowledge_free_certificate_action !== true) {
             throw new Error("Explicit free-certificate action approval is required.");
         }
-        const { action, body } = freeCertificateActionRequestBody(request);
-        const { status, data } = await apiRequest("POST", certificatePath(`/free/${encodeURIComponent(free_certificate_request_id)}/actions/${encodeURIComponent(action)}`), body);
-        return {
-            content: [{
-                    type: "text",
-                    text: formatJson(safeCertificatePayload("free-action", status, data)),
-                }],
-        };
+        return performFreeCertificateAction(free_certificate_request_id, request);
     });
+    const freeCertificateActionBaseShape = {
+        free_certificate_request_id: freeCertificateRequestIdSchema,
+        acknowledge_free_certificate_action: z.literal(true).describe("The user approved this exact free-certificate action"),
+    };
+    server.registerTool("renew_free_certificate", {
+        description: "Request early renewal of an owned free TLS certificate after reading its current state. A customer_csr certificate requires a new public CSR for the same authorized names; managed-key certificates normally renew automatically. Approval is required. Issuance is asynchronous: poll get_free_certificate. An ambiguous response requires reading state before retrying. Requires certificates:manage; no private key is returned.",
+        inputSchema: { ...freeCertificateActionBaseShape, csr: freeCertificateActionRequestSchema.options[0].shape.csr },
+        annotations: { title: "Renew free TLS certificate", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async ({ free_certificate_request_id, csr }) => performFreeCertificateAction(free_certificate_request_id, { action: "renew", csr }));
+    server.registerTool("revoke_free_certificate", {
+        description: "Revoke an owned free TLS certificate after checking its state and obtaining explicit user approval. Revocation invalidates the certificate; read get_free_certificate for the final state. Requires certificates:manage.",
+        inputSchema: { ...freeCertificateActionBaseShape, reason: freeCertificateActionRequestSchema.options[1].shape.reason },
+        annotations: { title: "Revoke free TLS certificate", readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+    }, async ({ free_certificate_request_id, reason }) => performFreeCertificateAction(free_certificate_request_id, { action: "revoke", reason }));
+    server.registerTool("recheck_free_certificate", {
+        description: "Recheck validation for an owned pending free TLS certificate after reading its current state. Approval is required; poll get_free_certificate for the final result. Requires certificates:manage.",
+        inputSchema: freeCertificateActionBaseShape,
+        annotations: { title: "Recheck free TLS certificate", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async ({ free_certificate_request_id }) => performFreeCertificateAction(free_certificate_request_id, { action: "recheck" }));
+    server.registerTool("cancel_free_certificate", {
+        description: "Cancel an owned pending free TLS certificate request before issuance. Read its current state and obtain explicit user approval; poll get_free_certificate for the final result. Requires certificates:manage.",
+        inputSchema: freeCertificateActionBaseShape,
+        annotations: { title: "Cancel free TLS certificate", readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+    }, async ({ free_certificate_request_id }) => performFreeCertificateAction(free_certificate_request_id, { action: "cancel" }));
     server.registerTool("list_automatic_ssl_subscriptions", {
         description: "List customer-owned Automatic SSL subscriptions, subscribed DNS names, paid term, final EUR amount, public state, and whether portal-only setup credentials are ready. This never returns the private ACME server URL, account ID, EAB KID, or EAB HMAC key. Requires certificates:read.",
         inputSchema: {},
@@ -2450,6 +2510,11 @@ export function createVpsnetServer(options = {}) {
                 }],
         };
     });
+    async function performAutomaticSslAction(certificate_subscription_id, request, idempotencyKey) {
+        const { action, body } = certificateAcmeSubscriptionActionRequestBody(request);
+        const { status, data } = await apiRequest("POST", certificatePath(`/acme-subscriptions/${encodeURIComponent(certificate_subscription_id)}/actions/${encodeURIComponent(action)}`), body, { "Idempotency-Key": idempotencyKey });
+        return { content: [{ type: "text", text: formatJson(safeCertificatePayload("acme-subscription-action", status, data)) }] };
+    }
     server.registerTool("manage_automatic_ssl_subscription", {
         description: "Queue one exact idempotent Automatic SSL action: cancel the subscription, remove an eligible purchased DNS name, or replace an eligible purchased DNS name during its correction window. Read the subscription and its actions first, and call only after explicit approval. If the result becomes ambiguous, reuse the same key only for an unchanged retry or call refresh_automatic_ssl_subscription—never submit a new mutation key. Requires certificates:manage.",
         inputSchema: {
@@ -2470,15 +2535,32 @@ export function createVpsnetServer(options = {}) {
         if (acknowledge_automatic_ssl_action !== true) {
             throw new Error("Explicit Automatic SSL action approval is required.");
         }
-        const { action, body } = certificateAcmeSubscriptionActionRequestBody(request);
-        const { status, data } = await apiRequest("POST", certificatePath(`/acme-subscriptions/${encodeURIComponent(certificate_subscription_id)}/actions/${encodeURIComponent(action)}`), body, { "Idempotency-Key": idempotencyKey });
-        return {
-            content: [{
-                    type: "text",
-                    text: formatJson(safeCertificatePayload("acme-subscription-action", status, data)),
-                }],
-        };
+        return performAutomaticSslAction(certificate_subscription_id, request, idempotencyKey);
     });
+    const automaticSslActionBaseShape = {
+        certificate_subscription_id: certificateSubscriptionIdSchema,
+        acknowledge_automatic_ssl_action: z.literal(true).describe("The user approved this exact Automatic SSL action"),
+        idempotencyKey: paidIdempotencyKeySchema.describe("Client-global key for this exact action; reuse only for an unchanged retry"),
+    };
+    server.registerTool("cancel_automatic_ssl_subscription", {
+        description: "Cancel an owned Automatic SSL subscription after reading get_automatic_ssl_subscription and list_automatic_ssl_actions. Requires explicit approval. The action is durable and idempotent; for an ambiguous outcome, refresh and read state instead of using a new key. Requires certificates:manage.",
+        inputSchema: { ...automaticSslActionBaseShape, reason: certificateAcmeSubscriptionActionRequestSchema.options[0].shape.reason },
+        annotations: { title: "Cancel Automatic SSL subscription", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ certificate_subscription_id, reason, idempotencyKey }) => performAutomaticSslAction(certificate_subscription_id, { action: "cancel", reason }, idempotencyKey));
+    server.registerTool("remove_automatic_ssl_domain", {
+        description: "Remove one eligible purchased DNS name from an owned Automatic SSL subscription. Read the subscription and list_automatic_ssl_actions to verify eligibility and the exact domain ID, then obtain explicit approval. For an ambiguous outcome, refresh and read state instead of using a new key. Requires certificates:manage.",
+        inputSchema: { ...automaticSslActionBaseShape, domain_id: certificateAcmeSubscriptionActionRequestSchema.options[1].shape.domain_id },
+        annotations: { title: "Remove Automatic SSL domain", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ certificate_subscription_id, domain_id, idempotencyKey }) => performAutomaticSslAction(certificate_subscription_id, { action: "remove_domain", domain_id }, idempotencyKey));
+    server.registerTool("replace_automatic_ssl_domain", {
+        description: "Replace one eligible purchased DNS name during its Automatic SSL correction window. Read the subscription and list_automatic_ssl_actions to verify the exact domain ID and allowed replacement type, then obtain explicit approval. For an ambiguous outcome, refresh and read state instead of using a new key. Requires certificates:manage.",
+        inputSchema: {
+            ...automaticSslActionBaseShape,
+            domain_id: certificateAcmeSubscriptionActionRequestSchema.options[2].shape.domain_id,
+            new_domain: certificateAcmeSubscriptionActionRequestSchema.options[2].shape.new_domain,
+        },
+        annotations: { title: "Replace Automatic SSL domain", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ certificate_subscription_id, domain_id, new_domain, idempotencyKey }) => performAutomaticSslAction(certificate_subscription_id, { action: "replace_domain", domain_id, new_domain }, idempotencyKey));
     server.registerTool("list_certificate_catalog", {
         description: "List published paid TLS certificate products and final customer offers in EUR. Products disclose validation level, public certificate-authority brand, supported names, SAN limits, management capabilities, term, and final retail prices. Only customer-visible catalog data is returned. Paid certificates are portable and are not limited to managed applications. Requires certificates:read.",
         inputSchema: {},
@@ -2693,6 +2775,11 @@ export function createVpsnetServer(options = {}) {
                 }],
         };
     });
+    async function performPaidCertificateAction(certificate_order_id, request, idempotencyKey) {
+        const { action, body } = certificateActionRequestBody(request);
+        const { status, data } = await apiRequest("POST", certificatePath(`/${encodeURIComponent(certificate_order_id)}/actions/${encodeURIComponent(action)}`), body, { "Idempotency-Key": idempotencyKey });
+        return { content: [{ type: "text", text: formatJson(safeCertificatePayload("action", status, data)) }] };
+    }
     server.registerTool("manage_certificate", {
         description: "Queue one exact idempotent paid-certificate management action: cancel an eligible pending order, recheck or resend validation, change one validation method, or request a free same-name reissue with a new public CSR. Read the product capabilities, current order, validation, and actions first. Call only after explicit approval. A reissue must preserve the paid name set and never sends a private key. If the outcome becomes ambiguous, reuse the same key only for the exact retry or call refresh_certificate—never submit a new mutation key. Requires certificates:manage.",
         inputSchema: {
@@ -2713,15 +2800,47 @@ export function createVpsnetServer(options = {}) {
         if (acknowledge_certificate_action !== true) {
             throw new Error("Explicit certificate-action approval is required.");
         }
-        const { action, body } = certificateActionRequestBody(request);
-        const { status, data } = await apiRequest("POST", certificatePath(`/${encodeURIComponent(certificate_order_id)}/actions/${encodeURIComponent(action)}`), body, { "Idempotency-Key": idempotencyKey });
-        return {
-            content: [{
-                    type: "text",
-                    text: formatJson(safeCertificatePayload("action", status, data)),
-                }],
-        };
+        return performPaidCertificateAction(certificate_order_id, request, idempotencyKey);
     });
+    const paidCertificateActionBaseShape = {
+        certificate_order_id: certificateOrderIdSchema,
+        acknowledge_certificate_action: z.literal(true).describe("The user approved this exact paid-certificate action"),
+        idempotencyKey: paidIdempotencyKeySchema.describe("Client-global key for this exact action; reuse only for an unchanged retry"),
+    };
+    server.registerTool("cancel_certificate", {
+        description: "Cancel an eligible pending paid TLS certificate order. Read the product capabilities, current order and list_certificate_actions, then obtain explicit approval. If the outcome is ambiguous, refresh and read state before retrying. Requires certificates:manage.",
+        inputSchema: { ...paidCertificateActionBaseShape, reason: certificateActionRequestSchema.options[0].shape.reason },
+        annotations: { title: "Cancel paid TLS certificate", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ certificate_order_id, reason, idempotencyKey }) => performPaidCertificateAction(certificate_order_id, { action: "cancel", reason }, idempotencyKey));
+    server.registerTool("recheck_certificate_validation", {
+        description: "Recheck validation for the specified DNS names in an owned paid TLS certificate order. Read current validation and list_certificate_actions first, then obtain explicit approval. Poll get_certificate_validation for the final result. Requires certificates:manage.",
+        inputSchema: { ...paidCertificateActionBaseShape, domains: certificateActionRequestSchema.options[1].shape.domains },
+        annotations: { title: "Recheck paid certificate validation", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ certificate_order_id, domains, idempotencyKey }) => performPaidCertificateAction(certificate_order_id, { action: "recheck_validation", domains }, idempotencyKey));
+    server.registerTool("resend_certificate_validation", {
+        description: "Resend validation instructions for an owned paid TLS certificate order. Read current validation and list_certificate_actions first, then obtain explicit approval. Poll get_certificate_validation for the final result. Requires certificates:manage.",
+        inputSchema: paidCertificateActionBaseShape,
+        annotations: { title: "Resend paid certificate validation", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ certificate_order_id, idempotencyKey }) => performPaidCertificateAction(certificate_order_id, { action: "resend_validation" }, idempotencyKey));
+    server.registerTool("change_certificate_validation", {
+        description: "Change the validation method for one authorized DNS name on an owned paid TLS certificate order. Read current validation and list_certificate_actions first, then obtain explicit approval. For an ambiguous outcome, refresh and read state instead of using a new key. Requires certificates:manage.",
+        inputSchema: {
+            ...paidCertificateActionBaseShape,
+            domain: certificateActionRequestSchema.options[3].shape.domain,
+            validation_method: certificateActionRequestSchema.options[3].shape.validation_method,
+        },
+        annotations: { title: "Change paid certificate validation", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ certificate_order_id, domain, validation_method, idempotencyKey }) => performPaidCertificateAction(certificate_order_id, { action: "change_validation", domain, validation_method }, idempotencyKey));
+    server.registerTool("reissue_certificate", {
+        description: "Request a free same-name reissue of an owned paid TLS certificate using a new public CSR. Read the product, current order and list_certificate_actions; keep the paid DNS name set unchanged and obtain explicit approval. Never provide a private key. For an ambiguous outcome, refresh and read state instead of using a new key. Requires certificates:manage.",
+        inputSchema: {
+            ...paidCertificateActionBaseShape,
+            csr: certificateActionRequestSchema.options[4].shape.csr,
+            common_name: certificateActionRequestSchema.options[4].shape.common_name,
+            alternative_names: certificateActionRequestSchema.options[4].shape.alternative_names,
+        },
+        annotations: { title: "Reissue paid TLS certificate", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ certificate_order_id, csr, common_name, alternative_names, idempotencyKey }) => performPaidCertificateAction(certificate_order_id, { action: "reissue", csr, common_name, alternative_names }, idempotencyKey));
     // --- DNS ---
     server.registerTool("list_domains", {
         description: "List domains owned by the account, including status, expiry, nameservers, DNS zone link, and renewal settings. Requires domains:read when using an API key.",
@@ -3540,7 +3659,7 @@ export function createVpsnetServer(options = {}) {
         return { content: [{ type: "text", text: formatJson(data) }] };
     });
     server.registerTool("create_function", {
-        description: "Create a Firecracker Function. Requires name, runtime_os_id, and code. Read list_functions for current runtimes and limits. Retain the idempotency key for creation recovery. Invocations are usage-billed (CPU + memory seconds) from the account balance.",
+        description: "Create a Firecracker Function. Requires name, runtime_os_id, and code. Read list_functions for current runtimes and limits. Retain the idempotency key for creation recovery. webhook_enabled exposes a public URL for external callers. Invocations are usage-billed (CPU + memory seconds) from the account balance.",
         inputSchema: {
             ...functionFieldsSchema,
             idempotency_key: z.string().min(16).max(190).regex(/^[A-Za-z0-9._:-]+$/).optional().describe("Stable key for this exact creation. Reuse it after an uncertain response; do not create a second function."),
@@ -3551,12 +3670,17 @@ export function createVpsnetServer(options = {}) {
         return { content: [{ type: "text", text: formatJson(data) }] };
     });
     server.registerTool("update_function", {
-        description: "Update a Firecracker Function's code or configuration. Call get_function first. If integrity.unreadable_fields names code or environment, the backend refuses the update unless the user explicitly approves replacing every unavailable value from a trusted copy and acknowledge_unreadable_replacement=true is passed. Leave that flag false for ordinary updates.",
+        description: "Update a Firecracker Function's code or configuration. This replaces submitted fields and can change or disable a public webhook. Call get_function first. If integrity.unreadable_fields names code or environment, the backend refuses the update unless the user explicitly approves replacing every unavailable value from a trusted copy and acknowledge_unreadable_replacement=true is passed. Leave that flag false for ordinary updates.",
         inputSchema: {
             function_id: positiveIdSchema.describe("Function ID from list_functions"),
             ...functionFieldsSchema,
             acknowledge_unreadable_replacement: z.boolean().optional().describe("Explicit customer approval to replace code or environment named by integrity.unreadable_fields; default false"),
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
     }, async ({ function_id, ...input }) => {
         const { data } = await apiRequest("POST", `/account/firecracker/functions/${encodeURIComponent(String(function_id))}`, functionBodyFromInput(input));
         return { content: [{ type: "text", text: formatJson(data) }] };
@@ -3831,6 +3955,11 @@ export function createVpsnetServer(options = {}) {
                 .optional()
                 .describe("Required for secondary zones. Base64 TSIG secret, 32-64 decoded bytes, e.g. openssl rand -base64 32. It is encrypted and never returned."),
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
     }, async ({ zone, kind, secondary_masters, secondary_tsig_key_name, secondary_tsig_algorithm, secondary_tsig_secret }) => {
         const body = {
             zone_name: zone,

package/build/networking-tools.js

@@ -109,18 +109,18 @@ export const networkingTools = [
     tool("get_private_network", "GET", networks, "Read one owned network including DHCP reservations, DNS change progress, generation and project_id."),
     tool("create_private_network", "POST", `${N}/networks`, "Create a private network intent. Every subnet is unique on the whole platform and comes from 100.64.0.0/10. Omit subnet and the platform allocates a free block of subnet_prefix_length (28..24, default 26 = 64 addresses; capabilities.private_network.subnet_sizes lists each size with its server count and suggested block); or name an aligned /28 through /24 inside 100.64.0.0/10 that no network holds (409 subnet_in_use), never both. Creation does not itself attach a server or buy a public address.", { name, subnet: z.object({ cidr: z.string().regex(/^100\.(?:6[4-9]|[7-9]\d|1[01]\d|12[0-7])(?:\.\d{1,3}){2}\/(?:2[4-8])$/) }).strict().optional(), subnet_prefix_length: z.union([z.literal(24), z.literal(25), z.literal(26), z.literal(27), z.literal(28)]).optional().describe("Size of the allocated subnet when subnet is omitted; default 26"), settings: settings.optional(), default_policy: z.enum(["accept", "deny"]).optional() }, { idempotent: true }),
     tool("delete_private_network", "DELETE", networks, "Request deletion of an empty network. Referenced appliances/ports may prevent deletion; quota is released only after verified cleanup.", { expected_generation: generation }, { idempotent: true, destructive: true }),
-    tool("retry_private_network", "POST", `${networks}/retry`, "Retry the failed current network operation only; preserve its current generation. This is not a new create.", { expected_generation: generation }, { idempotent: true }),
+    tool("retry_private_network", "POST", `${networks}/retry`, "Retry the failed current network operation only; preserve its current generation. It may resume a failed deletion or settings change, so inspect the failed operation before retrying.", { expected_generation: generation }, { idempotent: true, destructive: true }),
     tool("set_private_network_dns", "POST", `${networks}/dns`, "Change DHCP DNS servers in place. Use dns_servers only for custom mode. Poll get_private_network.settings.dns_change; its DNS update UUID is not in the network operations feed.", { dns_mode: dnsMode, dns_servers: z.array(ipv4).min(1).max(3).optional() }, { idempotent: true }),
-    tool("set_private_network_names", "PUT", `${networks}/names`, "Replace the complete internal DNS zone label and alias list. Server names are automatic; these names resolve only inside this network. Omitted aliases are not preserved.", { zone_label: dnsLabel, aliases: z.array(dnsAlias).max(64) }),
+    tool("set_private_network_names", "PUT", `${networks}/names`, "Replace the complete internal DNS zone label and alias list. Server names are automatic; these names resolve only inside this network. Omitted aliases are removed and may stop resolving.", { zone_label: dnsLabel, aliases: z.array(dnsAlias).max(64) }, { destructive: true }),
     tool("list_private_network_ports", "GET", `${networks}/ports`, "Read owned network ports, their fixed DHCP addresses, generations and attachment states. Reserved is not connected."),
     tool("list_service_private_ports", "GET", `${N}/services/{service_id}/ports`, "Read private ports and order attachment recovery state for one owned service order number."),
     tool("list_network_attachment_candidates", "GET", `${networks}/attachment-candidates`, "Read attachable services and each attachment_mode. Follow next_cursor using after when candidates_has_more is true; service_id selects an owned service.", { after: z.string().optional(), service_id: serviceId.optional() }, { query: ["after", "service_id"] }),
     tool("attach_private_network_port", "POST", `${networks}/ports`, "Attach an owned service; omit ipv4 for automatic allocation or pass a fixed usable address. Check attachment-candidates first; restart=true is explicit permission for a required restart.", { service_id: serviceId, ipv4: ipv4.optional(), restart }, { idempotent: true }),
     tool("detach_private_network_port", "DELETE", `${networks}/ports/{port_id}`, "Detach the owned server port. Use the PORT generation and confirm any required restart.", { expected_generation: generation, restart }, { idempotent: true, destructive: true }),
-    tool("retry_private_network_port", "POST", `${networks}/ports/{port_id}/retry`, "Retry the failed current port operation with the PORT generation and any required restart approval.", { expected_generation: generation, restart }, { idempotent: true }),
+    tool("retry_private_network_port", "POST", `${networks}/ports/{port_id}/retry`, "Retry the failed current port operation with the PORT generation and any required restart approval. Inspect the failed operation: a detach retry can remove the server's private connectivity.", { expected_generation: generation, restart }, { idempotent: true, destructive: true }),
     tool("get_network_vpn_summary", "GET", `${networks}/vpn`, "Read the network's VPN summary, including truthful absence. Native site-to-site is not supported by this tool set."),
     tool("get_network_routed_egress", "GET", `${networks}/routed-egress`, "Read this network's NAT/internet access, public address and qualification state."),
-    tool("set_network_routed_egress", "POST", `${networks}/routed-egress`, "Request the currently supported NAT transition for an owned network; the backend may refuse mode changes. public_address_id attaches an already-owned paid address and may move it from a server. This never purchases an address.", { internet_access: internetAccess, expected_generation: generation, public_address_id: uuid.optional() }),
+    tool("set_network_routed_egress", "POST", `${networks}/routed-egress`, "Request the currently supported NAT transition for an owned network; the backend may refuse mode changes. This can replace the network's Internet route. public_address_id attaches an already-owned paid address and may remove it from a server. This never purchases an address.", { internet_access: internetAccess, expected_generation: generation, public_address_id: uuid.optional() }, { destructive: true }),
     tool("get_security_group_capabilities", "GET", `${N}/security-groups/capabilities`, "Read security-group availability and whether the network default policy can be changed."),
     tool("list_network_security_groups", "GET", sg, "List groups in the owned project. Copy project_id from the network; do not invent an account identifier."),
     tool("create_network_security_group", "POST", sg, "Create a named allow-rule set. Optional network_id scopes it to that network; otherwise it belongs to the project. IPv6 rules are unavailable.", { name, rules: z.array(rule).max(256), network_id: uuid.optional() }, { idempotent: true }),
@@ -130,7 +130,7 @@ export const networkingTools = [
     tool("get_network_security_policy", "GET", policy, "Read default policy, assigned groups and policy application state. Policy generation differs from network and port generations."),
     tool("set_network_default_security_policy", "PUT", policy, "Change accept/deny for servers without custom groups. Explicit custom groups remain restrictive. Use policy generation and default-group revision from get_network_security_policy.", { default_policy: z.enum(["accept", "deny"]), expected_generation: policyGeneration, expected_default_revision: generation }, { idempotent: true, destructive: true }),
     tool("set_private_port_security_groups", "PUT", `${project}/networks/{network_id}/ports/{port_id}/security-groups`, "Replace the port's complete customer-group list. Empty list selects the network default; at most seven customer groups fit alongside platform DNS. Use policy and port generations separately.", { group_ids: z.array(uuid).max(7), expected_generation: policyGeneration, expected_port_generation: generation }, { idempotent: true, destructive: true }),
-    tool("retry_network_security_policy", "POST", `${policy}/retry`, "Retry the failed network security policy using its current desired state.", {}, { idempotent: true }),
+    tool("retry_network_security_policy", "POST", `${policy}/retry`, "Retry the failed network security policy using its current desired state. The pending policy may replace firewall rules and remove network access; inspect its desired state first.", {}, { idempotent: true, destructive: true }),
     tool("retire_network_security_policy", "DELETE", policy, "Retire the policy only after its server ports are gone. Removing firewall policy requires explicit user approval.", { expected_generation: generation }, { idempotent: true, destructive: true }),
     tool("get_network_appliance_capabilities", "GET", `${A}/capabilities`, "Read available load balancer providers/tiers, public qualification, VPN capabilities and quota. Tier availability and prices are returned by the backend, never hardcoded."),
     tool("list_network_appliances", "GET", A, "Read owned load balancers and VPN gateways with one stream cursor."),

package/build/remote-policy.js

@@ -1,5 +1,6 @@
 import { RemoteAuthError } from './remote-auth-error.js';
 import { z } from "zod";
+import { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { networkingTools } from "./networking-tools.js";
 import { authorizationContext } from "./request-context.js";
 export const remoteInstructions = [
@@ -33,7 +34,7 @@ export const supportedScopes = ["services:read", "services:manage", "application
 const readServices = ["get_service_rescue", "get_guest_agent_status", "get_plan_options", "get_plan_resources", "calculate_plan_change", "get_period_options", "list_restore_points", "list_restore_file_points", "browse_restore_files", "get_restore_file_browse", "list_services", "get_service", "get_service_graphs", "get_service_history", "get_hostname", "get_title", "get_rdns", "get_os_options", "get_backup_status", "get_backup_history", "list_snapshots", "list_firecracker_snapshots", "get_firecracker_backup_status", "get_firecracker_backup_history"];
 const manageServices = ["suspend_service", "resume_service", "flush_iptables", "toggle_ipv6", "toggle_extra_settings", "reinstall_os", "rollback_snapshot", "delete_snapshot", "rollback_firecracker_snapshot", "delete_firecracker_snapshot", "start_service", "stop_service", "restart_service", "change_hostname", "reset_hostname", "change_title", "change_rdns", "clear_rdns"];
 const readApps = ["list_application_registry_credentials", "get_application_data_restore", "list_application_catalog", "list_service_applications", "get_application_installation", "get_application_events", "get_application_health", "get_application_logs", "list_application_recipes", "list_application_recipe_revisions", "export_application_recipe", "discover_service_containers", "get_application_compose_adoption"];
-const manageApps = ["configure_application_resource_thresholds", "validate_application_recipe", "create_application_recipe", "create_application_recipe_revision", "install_application_recipe", "prepare_application_compose_adoption", "confirm_application_compose_adoption", "install_application", "configure_application_access", "manage_application", "cancel_application_action"];
+const manageApps = ["configure_application_resource_thresholds", "validate_application_recipe", "create_application_recipe", "create_application_recipe_revision", "install_application_recipe", "prepare_application_compose_adoption", "confirm_application_compose_adoption", "install_application", "configure_application_access", "manage_application", "reconcile_application", "repair_application", "restart_application", "start_application", "stop_application", "uninstall_application", "update_application", "cancel_application_action"];
 const permissions = new Map([
     ["get_event", "services:read"], ["wait_for_event", "services:read"],
     ...readServices.map(n => [n, "services:read"]), ...manageServices.map(n => [n, "services:manage"]),
@@ -49,11 +50,13 @@ const permissions = new Map([
     ["create_free_certificate", "certificates:manage"],
     ["download_free_certificate", "certificates:read"],
     ["manage_free_certificate", "certificates:manage"],
+    ...["renew_free_certificate", "revoke_free_certificate", "recheck_free_certificate", "cancel_free_certificate"].map(n => [n, "certificates:manage"]),
     ["list_automatic_ssl_subscriptions", "certificates:read"],
     ["get_automatic_ssl_subscription", "certificates:read"],
     ["list_automatic_ssl_actions", "certificates:read"],
     ["refresh_automatic_ssl_subscription", "certificates:manage"],
     ["manage_automatic_ssl_subscription", "certificates:manage"],
+    ...["cancel_automatic_ssl_subscription", "remove_automatic_ssl_domain", "replace_automatic_ssl_domain"].map(n => [n, "certificates:manage"]),
     ["list_certificate_catalog", "certificates:read"],
     ["get_certificate_catalog_product", "certificates:read"],
     ["list_certificates", "certificates:read"],
@@ -63,6 +66,7 @@ const permissions = new Map([
     ["list_certificate_actions", "certificates:read"],
     ["refresh_certificate", "certificates:manage"],
     ["manage_certificate", "certificates:manage"],
+    ...["cancel_certificate", "recheck_certificate_validation", "resend_certificate_validation", "change_certificate_validation", "reissue_certificate"].map(n => [n, "certificates:manage"]),
     ["list_domains", "domains:read"],
     ["get_domain", "domains:read"],
     ["list_domain_tlds", "domains:read"],
@@ -154,17 +158,41 @@ const additiveTools = new Set([
 ]);
 const externalTools = new Set([
     'run_vm_command', 'invoke_function', 'install_application', 'install_application_recipe',
+    'create_function', 'update_function', 'create_dns_zone',
+    'validate_application_recipe', 'create_application_recipe', 'create_application_recipe_revision',
     'read_vm_file', 'write_vm_file', 'manage_application', 'get_application_health', 'get_application_logs',
+    'reconcile_application', 'repair_application', 'restart_application', 'start_application',
+    'stop_application', 'uninstall_application', 'update_application',
     'verify_dns_zone', 'reissue_dns_zone_verification', 'get_dns_zone_diagnostics',
     'create_free_certificate', 'manage_free_certificate', 'refresh_automatic_ssl_subscription',
     'manage_automatic_ssl_subscription', 'refresh_certificate', 'manage_certificate',
+    'renew_free_certificate', 'revoke_free_certificate', 'recheck_free_certificate', 'cancel_free_certificate',
+    'cancel_automatic_ssl_subscription', 'remove_automatic_ssl_domain', 'replace_automatic_ssl_domain',
+    'cancel_certificate', 'recheck_certificate_validation', 'resend_certificate_validation',
+    'change_certificate_validation', 'reissue_certificate',
 ]);
 const deduplicatedTools = new Set([
     'run_vm_command', 'inspect_vm', 'read_vm_file', 'write_vm_file', 'create_vm_file', 'cancel_vm_operation',
     'create_function', 'invoke_function', 'confirm_service_order', 'confirm_domain_register',
 ]);
+// Keep cached aggregate calls valid, but advertise the individually scoped
+// actions to new directory clients. The SDK uses one handler for tools/list;
+// filtering its result leaves the normal tools/call dispatcher intact.
+const legacyAggregateTools = new Set([
+    'manage_application', 'manage_free_certificate',
+    'manage_automatic_ssl_subscription', 'manage_certificate',
+]);
 /** Keep management tools discoverable for incremental consent; order tools require granted authority. */
 export function installRemotePolicy(server, scopes, profile = 'directory') {
+    const setRequestHandler = server.server.setRequestHandler.bind(server.server);
+    server.server.setRequestHandler = ((schema, handler) => {
+        if (schema !== ListToolsRequestSchema)
+            return setRequestHandler(schema, handler);
+        return setRequestHandler(schema, async (...args) => {
+            const response = await handler(...args);
+            return { ...response, tools: response.tools.filter((tool) => !legacyAggregateTools.has(tool.name)) };
+        });
+    });
     const original = server.registerTool.bind(server);
     const register = (name, config, handler) => {
         const required = remoteScope(name, profile);
@@ -175,13 +203,13 @@ export function installRemotePolicy(server, scopes, profile = 'directory') {
             return undefined;
         const requiredScopes = required === "authenticated" ? [] : required === "vm:session"
             ? (scopes.some(s => s.startsWith("vm:")) ? scopes.filter(s => s.startsWith("vm:")) : ["vm:diagnostics"]) : [required];
-        const readOnly = name === 'validate_application_recipe' || required === "authenticated" || required.endsWith(":read") || required === "vm:diagnostics";
+        const readOnly = required === "authenticated" || required.endsWith(":read") || required === "vm:diagnostics";
         const securitySchemes = [{ type: "oauth2", scopes: requiredScopes }];
         const annotations = {
             readOnlyHint: readOnly, destructiveHint: !readOnly && !additiveTools.has(name),
             idempotentHint: readOnly || deduplicatedTools.has(name),
-            ...(config.annotations || {}),
             openWorldHint: externalTools.has(name),
+            ...(config.annotations || {}),
         };
         if (name.startsWith('quote_')) {
             annotations.readOnlyHint = false;
@@ -193,8 +221,6 @@ export function installRemotePolicy(server, scopes, profile = 'directory') {
             annotations.readOnlyHint = true;
             annotations.destructiveHint = false;
         }
-        if (additiveTools.has(name))
-            annotations.destructiveHint = false;
         if (deduplicatedTools.has(name))
             annotations.idempotentHint = true;
         const inputSchema = { ...config.inputSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vpsnet-mcp",
-  "version": "2.3.4",
+  "version": "2.3.6",
   "type": "module",
   "description": "MCP server for managing VPSnet.com services, applications, DNS, domains, billing, and server lifecycle operations",
   "bin": {