@ornncompute/cli 0.2.8 → 0.2.10

package/vendor/capabilities/capabilities/staff-commerce.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineStaffMcpCapability, preview } from "../capability.js";
-import { mapBody, seg } from "./staff-shared.js";
+import { errorTextOf, mapBody, requireUuid, resolveVersion, seg, statusOf } from "./staff-shared.js";
 // Staff commerce verbs: reservations, bids, forward inventory, and the tenant
 // credit profile. MCP-only — see `defineStaffMcpCapability`.
 export const reservationCancelInput = z.object({
@@ -28,8 +28,6 @@ export const reservationCancelCapability = defineStaffMcpCapability({
 export const reservationTransferInput = z.object({
     reservationId: z.string(),
     targetTenantId: z.string(),
-    targetAuthUserId: z.string().optional(),
-    nodeId: z.string().optional(),
     reservedStrategy: z.enum(["reject", "park"]),
     confirmReservedTransfer: z.boolean().optional(),
     notes: z.string().max(2000).optional(),
@@ -39,35 +37,50 @@ export const reservationTransferCapability = defineStaffMcpCapability({
     id: "reservation.transfer",
     domain: "reservations",
     roles: ["admin"],
-    description: "Internal staff only: transfer a reservation to a different tenant/node. Mirrors the internal node-overlay transfer action. " +
+    description: "Internal staff only: transfer a reservation to a different tenant. Mirrors the internal node-overlay transfer action. " +
         "reservedStrategy has no default and must be chosen explicitly: \"reject\" (transfer only if the reservation isn't " +
         "currently provisioned/assigned) or \"park\" (clean up old access and park it for the target tenant, for a live handoff). " +
         "The dashboard always computes this from the reservation's live state before sending it rather than relying on the " +
         "backend's own default of \"reject\", because a silent \"reject\" default on a reservation the backend doesn't detect as " +
-        "actively provisioned/assigned would transfer it without ever asking for confirm_reserved_transfer.",
+        "actively provisioned/assigned would transfer it without ever asking for confirmReservedTransfer.",
     mutation: "preview-confirm",
     http: { method: "POST", path: "/internal/reservations/{reservationId}/transfer" },
     input: reservationTransferInput,
     execute: async (ctx, input) => {
         const parsed = reservationTransferInput.parse(input);
+        // camelCase: commerce's transferReservationRequest has no snake aliases,
+        // so the previous all-snake body bound nothing but `notes` and every
+        // transfer failed with "targetOrganizationId is required".
         const body = {
-            target_tenant_id: parsed.targetTenantId,
-            reserved_strategy: parsed.reservedStrategy,
-            confirm_reserved_transfer: parsed.confirmReservedTransfer ?? false,
-            ...mapBody(parsed, {
-                targetAuthUserId: "target_auth_user_id",
-                nodeId: "node_id",
-                notes: "notes",
-            }),
+            targetOrganizationId: requireUuid(parsed.targetTenantId, "targetTenantId"),
+            reservedStrategy: parsed.reservedStrategy,
+            confirmReservedTransfer: parsed.confirmReservedTransfer ?? false,
+            ...mapBody(parsed, { notes: "notes" }),
         };
         if (!ctx.confirmed)
             return preview("reservation.transfer", body);
-        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/transfer`, {
-            method: "POST",
-            body,
-        });
+        try {
+            return await ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/transfer`, {
+                method: "POST",
+                body,
+            });
+        }
+        catch (error) {
+            throw inTenantVocabulary(error);
+        }
     },
 });
+/**
+ * Commerce names the transfer target `targetOrganizationId`; this tool's
+ * parameter is `targetTenantId`. Passing the wire name through tells the
+ * caller to go fix a parameter that does not exist, so translate it back.
+ */
+function inTenantVocabulary(error) {
+    const text = errorTextOf(error);
+    if (!text.includes("targetOrganizationId"))
+        return error;
+    return new Error(text.replaceAll("targetOrganizationId", "targetTenantId"));
+}
 export const reservationMachinesListInput = z.object({ reservationId: z.string() });
 export const reservationMachinesListCapability = defineStaffMcpCapability({
     id: "reservation.machines.list",
@@ -86,32 +99,55 @@ export const reservationMachinesListCapability = defineStaffMcpCapability({
 });
 export const reservationSshKeyAddInput = z.object({
     reservationId: z.string(),
+    tenantId: z.string(),
     userId: z.string(),
-    publicKey: z.string().min(1),
+    sshKeyId: z.string().optional(),
+    keyId: z.string().optional(),
+    publicKey: z.string().min(1).optional(),
     label: z.string().optional(),
-    nodeId: z.string().optional(),
     confirm: z.boolean().optional(),
 });
 export const reservationSshKeyAddCapability = defineStaffMcpCapability({
     id: "reservation.ssh-key.add",
     domain: "reservations",
     roles: ["admin"],
-    description: "Internal staff only: add an SSH key to a reservation and queue sync to its machines. Requires confirm: true.",
+    description: "Internal staff only: attach an SSH key to a reservation for a tenant user. " +
+        "Pass sshKeyId to attach a key the organization already has, or publicKey (with label) to register a new " +
+        "organization key and attach it. Attaching does not itself push the key to live machines; use ssh_key_push for that. " +
+        "Requires confirm: true.",
     mutation: "preview-confirm",
     http: { method: "POST", path: "/internal/v1/reservations/{reservationId}/ssh-keys" },
     input: reservationSshKeyAddInput,
     execute: async (ctx, input) => {
         const parsed = reservationSshKeyAddInput.parse(input);
-        const body = {
-            user_id: parsed.userId,
-            public_key: parsed.publicKey,
-            ...mapBody(parsed, { label: "label", nodeId: "node_id" }),
-        };
-        if (!ctx.confirmed)
-            return preview("reservation.ssh-key.add", body);
+        const keyId = parsed.sshKeyId ?? parsed.keyId;
+        if (!keyId && !parsed.publicKey) {
+            throw new Error("Pass sshKeyId to attach an existing organization key, or publicKey to register a new one.");
+        }
+        if (!ctx.confirmed) {
+            return preview("reservation.ssh-key.add", {
+                reservationId: parsed.reservationId,
+                userId: parsed.userId,
+                ...(keyId ? { sshKeyId: keyId } : { publicKey: parsed.publicKey, label: parsed.label }),
+            });
+        }
+        // Commerce attaches an existing authorization key by id; it reads only
+        // sshKeyId/userId. The old body also sent public_key, label and node_id,
+        // which bound nothing, so a publicKey-only call always failed.
+        let sshKeyId = keyId;
+        if (!sshKeyId) {
+            const registered = (await ctx.fetch(`/v1/organizations/${seg(parsed.tenantId)}/ssh-keys`, {
+                method: "POST",
+                body: { public_key: parsed.publicKey, ...mapBody(parsed, { label: "label" }) },
+            }));
+            if (!registered.id) {
+                throw new Error("Authorization did not return an SSH key id.");
+            }
+            sshKeyId = registered.id;
+        }
         return ctx.fetch(`/internal/v1/reservations/${seg(parsed.reservationId)}/ssh-keys`, {
             method: "POST",
-            body,
+            body: { sshKeyId, userId: parsed.userId },
         });
     },
 });
@@ -119,69 +155,181 @@ export const reservationSshKeyRemoveInput = z.object({
     reservationId: z.string(),
     keyId: z.string(),
     userId: z.string(),
-    nodeId: z.string().optional(),
     confirm: z.boolean().optional(),
 });
 export const reservationSshKeyRemoveCapability = defineStaffMcpCapability({
     id: "reservation.ssh-key.remove",
     domain: "reservations",
     roles: ["admin"],
-    description: "Internal staff only: remove an SSH key from a reservation and queue cleanup on its machines. Requires confirm: true.",
+    description: "Internal staff only: detach an SSH key from a reservation for a tenant user. " +
+        "Detaching does not itself remove the key from live machines; use ssh_key_push to resync them. Requires confirm: true.",
     mutation: "preview-confirm",
     http: { method: "DELETE", path: "/internal/v1/reservations/{reservationId}/ssh-keys/{keyId}" },
     input: reservationSshKeyRemoveInput,
     execute: async (ctx, input) => {
         const parsed = reservationSshKeyRemoveInput.parse(input);
-        const body = {
-            user_id: parsed.userId,
-            ...mapBody(parsed, { nodeId: "node_id" }),
-        };
-        if (!ctx.confirmed)
-            return preview("reservation.ssh-key.remove", body);
-        return ctx.fetch(`/internal/v1/reservations/${seg(parsed.reservationId)}/ssh-keys/${seg(parsed.keyId)}`, { method: "DELETE", body });
+        if (!ctx.confirmed) {
+            return preview("reservation.ssh-key.remove", {
+                reservationId: parsed.reservationId,
+                keyId: parsed.keyId,
+                userId: parsed.userId,
+            });
+        }
+        // The handler reads userId from the query string, not the body. Sent as a
+        // body it was dropped and the detach ran unscoped across every user.
+        const result = await ctx.fetch(`/internal/v1/reservations/${seg(parsed.reservationId)}/ssh-keys/${seg(parsed.keyId)}?userId=${seg(parsed.userId)}`, { method: "DELETE" });
+        return (result ?? {
+            removed: true,
+            reservationId: parsed.reservationId,
+            keyId: parsed.keyId,
+            userId: parsed.userId,
+        });
     },
 });
 export const reservationPublishInput = z.object({
-    reservationId: z.string(),
+    reservationId: z.string().optional(),
+    reservation_id: z.string().optional(),
+    version: z.number().int().positive().optional(),
+    awaitDownPayment: z.boolean().optional(),
+    await_down_payment: z.boolean().optional(),
     confirm: z.boolean().optional(),
 });
 export const reservationPublishCapability = defineStaffMcpCapability({
     id: "reservation.publish",
     domain: "reservations",
     roles: ["admin"],
-    description: "Internal staff only: publish a commerce draft into a live Commerce reservation. Requires confirm: true.",
+    description: "Internal staff only: publish a commerce draft or uncommitted bid reservation into a live Commerce reservation. Requires confirm: true.",
     mutation: "preview-confirm",
     http: { method: "POST", path: "/internal/reservations/{reservationId}/publish" },
     input: reservationPublishInput,
     execute: async (ctx, input) => {
         const parsed = reservationPublishInput.parse(input);
+        const reservationId = parsed.reservationId || parsed.reservation_id;
+        if (!reservationId) {
+            throw new Error("reservationId is required");
+        }
+        const version = await resolveVersion(ctx, `/internal/reservations/${seg(reservationId)}`, parsed.version);
+        const awaitDownPayment = parsed.awaitDownPayment ?? parsed.await_down_payment;
+        const body = {
+            ...(version !== undefined ? { version } : {}),
+            ...(awaitDownPayment !== undefined ? { awaitDownPayment, await_down_payment: awaitDownPayment } : {}),
+        };
         if (!ctx.confirmed) {
-            return preview("reservation.publish", { reservationId: parsed.reservationId });
+            return preview("reservation.publish", { reservationId, ...body });
         }
-        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/publish`, {
+        return ctx.fetch(`/internal/reservations/${seg(reservationId)}/publish`, {
             method: "POST",
+            ...(Object.keys(body).length > 0 ? { body } : {}),
         });
     },
 });
+export const reservationShowInput = z.object({ reservationId: z.string() });
+// Accepting a bid inserts its fill reservation as 'uncommitted' (commerce's
+// InsertBidFillReservation): it holds no capacity and carries no invoice until
+// it is published, and buyer-facing reads deliberately filter it out. Staff had
+// no read of their own, so the reservationId that bid.accept returns could not
+// be looked up anywhere at all. These two verbs are the admin-side read, which
+// does surface uncommitted rows.
+export const reservationShowCapability = defineStaffMcpCapability({
+    id: "reservation.show",
+    domain: "reservations",
+    roles: ["reviewer", "admin"],
+    description: "Internal staff only: show one commerce reservation, including draft and uncommitted rows that " +
+        "customer-facing reads hide (an accepted bid's fill reservation is uncommitted until it is published).",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/reservations/{reservationId}" },
+    input: reservationShowInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationShowInput.parse(input);
+        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}`, { method: "GET" });
+    },
+});
+export const reservationListInput = z.object({
+    organizationId: z.string().optional(),
+    status: z.string().optional(),
+    cursor: z.string().optional(),
+    limit: z.number().int().min(1).max(500).optional(),
+});
+export const reservationListCapability = defineStaffMcpCapability({
+    id: "reservation.list",
+    domain: "reservations",
+    roles: ["reviewer", "admin"],
+    description: "Internal staff only: list commerce reservations, optionally filtered by tenant and status. " +
+        "Includes draft and uncommitted rows that customer-facing reads hide.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/reservations" },
+    input: reservationListInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationListInput.parse(input ?? {});
+        const parts = [];
+        if (parsed.organizationId) {
+            parts.push(`organization_id=${encodeURIComponent(parsed.organizationId)}`);
+        }
+        if (parsed.status)
+            parts.push(`status=${encodeURIComponent(parsed.status)}`);
+        if (parsed.cursor)
+            parts.push(`cursor=${encodeURIComponent(parsed.cursor)}`);
+        if (parsed.limit)
+            parts.push(`limit=${encodeURIComponent(String(parsed.limit))}`);
+        const qs = parts.length > 0 ? `?${parts.join("&")}` : "";
+        return ctx.fetch(`/internal/reservations${qs}`, { method: "GET" });
+    },
+});
+// Kept a plain object because tool registration reads `schema.shape`; the
+// required-ness is enforced in execute below.
 export const bidAcceptInput = z.object({
-    bidId: z.string(),
+    bidId: z.string().optional(),
+    bid_id: z.string().optional(),
     acceptedGpuCount: z.number().int().min(1).optional(),
+    accepted_gpu_count: z.number().int().min(1).optional(),
+    fillNodeCount: z.number().int().min(1).optional(),
+    fill_node_count: z.number().int().min(1).optional(),
     confirm: z.boolean().optional(),
 });
 export const bidAcceptCapability = defineStaffMcpCapability({
     id: "bid.accept",
     domain: "bids",
     roles: ["admin"],
-    description: "Internal staff only: accept an active bid. Optionally set acceptedGpuCount (defaults to the bid's full gpu_count). Mirrors the internal dashboard's Accept action.",
+    description: "Internal staff only: accept an active bid. acceptedGpuCount (alias fillNodeCount) is required - commerce " +
+        "has no default; pass the bid's full nodeCount to fill it completely, or a smaller number for a partial " +
+        "fill. Mirrors the internal dashboard's Accept action. Automatically publishes the resulting reservation " +
+        "so it holds capacity and is immediately visible to customer reads.",
     mutation: "preview-confirm",
     http: { method: "POST", path: "/internal/bids/{bidId}/accept" },
     input: bidAcceptInput,
     execute: async (ctx, input) => {
         const parsed = bidAcceptInput.parse(input);
-        const body = mapBody(parsed, { acceptedGpuCount: "accepted_gpu_count" });
+        const bidId = parsed.bidId || parsed.bid_id;
+        if (!bidId) {
+            throw new Error("bidId is required");
+        }
+        const count = parsed.acceptedGpuCount ?? parsed.accepted_gpu_count ?? parsed.fillNodeCount ?? parsed.fill_node_count;
+        // commerce's acceptBidRequest.Validate rejects a missing count outright
+        // (services/commerce/internal/api/admin/bid_types.go), so refuse here
+        // rather than sending a call that always 400s.
+        if (count === undefined) {
+            throw new Error("acceptedGpuCount (or fillNodeCount) is required; commerce has no default fill count. Pass the bid's nodeCount to fill it completely.");
+        }
+        const body = { accepted_gpu_count: count };
         if (!ctx.confirmed)
-            return preview("bid.accept", { bidId: parsed.bidId, ...body });
-        return ctx.fetch(`/internal/bids/${seg(parsed.bidId)}/accept`, { method: "POST", body });
+            return preview("bid.accept", { bidId, ...body });
+        const accepted = (await ctx.fetch(`/internal/bids/${seg(bidId)}/accept`, { method: "POST", body }));
+        const reservationId = (accepted?.reservationId ?? accepted?.reservation_id);
+        if (reservationId) {
+            try {
+                await ctx.fetch(`/internal/reservations/${seg(reservationId)}/publish`, {
+                    method: "POST",
+                    body: {},
+                });
+            }
+            catch (publishErr) {
+                return {
+                    ...accepted,
+                    publishWarning: `Bid accepted successfully, but automatic reservation publish failed: ${publishErr instanceof Error ? publishErr.message : String(publishErr)}. Use admin_reservation_publish to retry.`,
+                };
+            }
+        }
+        return accepted;
     },
 });
 export const bidRejectInput = z.object({
@@ -203,10 +351,44 @@ export const bidRejectCapability = defineStaffMcpCapability({
         return ctx.fetch(`/internal/bids/${seg(parsed.bidId)}/reject`, { method: "POST" });
     },
 });
+export const bidShowInput = z.object({
+    bidId: z.string().optional(),
+    bid_id: z.string().optional(),
+});
+export const bidShowCapability = defineStaffMcpCapability({
+    id: "bid.show",
+    domain: "bids",
+    roles: ["reviewer", "admin"],
+    description: "Internal staff only: fetch a single buyer bid by ID.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/bids/{bidId}" },
+    input: bidShowInput,
+    execute: async (ctx, input) => {
+        const parsed = bidShowInput.parse(input);
+        const bidId = parsed.bidId || parsed.bid_id;
+        if (!bidId) {
+            throw new Error("bidId is required");
+        }
+        return ctx.fetch(`/internal/bids/${seg(bidId)}`, { method: "GET" });
+    },
+});
+/** Commerce parses listing windows as RFC3339 timestamps, not bare dates. */
+function rfc3339(value) {
+    const trimmed = value.trim();
+    if (!trimmed.includes("T"))
+        return `${trimmed}T00:00:00Z`;
+    return trimmed.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(trimmed) ? trimmed : `${trimmed}Z`;
+}
 export const inventoryUpdateInput = z.object({
     inventoryId: z.string(),
-    siteOperator: z.string().min(1).optional(),
-    siteNickname: z.string().min(1).optional(),
+    version: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Optimistic-concurrency version. Read from the listing when omitted."),
+    operatorId: z.string().min(1).optional(),
+    facilityId: z.string().min(1).optional(),
     gpuType: z.string().min(1).optional(),
     nodeCount: z
         .number()
@@ -215,16 +397,15 @@ export const inventoryUpdateInput = z.object({
         .optional()
         .describe("Total nodes (listing capacity), not total GPUs."),
     gpusPerNode: z.number().int().min(1).max(32).optional(),
-    availableFrom: z.string().nullable().optional(),
-    availableTo: z.string().nullable().optional(),
-    availableStartAt: z.string().nullable().optional(),
-    availableEndAt: z.string().nullable().optional(),
+    availableFrom: z.string().optional(),
+    availableTo: z.string().optional(),
+    availableStartAt: z.string().optional(),
+    availableEndAt: z.string().optional(),
     cpu: z.string().nullable().optional(),
     ram: z.string().nullable().optional(),
     fabricType: z.string().nullable().optional(),
     storage: z.string().nullable().optional(),
     internet: z.string().nullable().optional(),
-    networkHardware: z.string().nullable().optional(),
     buyNowPricePerGpuHour: z.number().positive().nullable().optional(),
     confirm: z.boolean().optional(),
 });
@@ -233,30 +414,40 @@ export const inventoryUpdateCapability = defineStaffMcpCapability({
     domain: "listings",
     roles: ["admin"],
     description: "Internal staff only: patch editable fields on a forward inventory listing. Requires confirm: true. " +
-        "At least one editable field is required. buyNowPricePerGpuHour may be null to clear the price.",
+        "At least one editable field is required. buyNowPricePerGpuHour may be null to clear the price. " +
+        "operatorId/facilityId take UUIDs. Site nickname and network hardware are not patchable on a listing.",
     mutation: "preview-confirm",
     http: { method: "PATCH", path: "/inventory/{inventoryId}" },
     input: inventoryUpdateInput,
     execute: async (ctx, input) => {
         const parsed = inventoryUpdateInput.parse(input);
         const body = mapBody(parsed, {
-            siteOperator: "site_operator",
-            siteNickname: "site_nickname",
-            gpuType: "gpu_type",
-            nodeCount: "node_count",
-            gpusPerNode: "gpus_per_node",
-            availableFrom: "available_from",
-            availableTo: "available_to",
-            availableStartAt: "available_start_at",
-            availableEndAt: "available_end_at",
+            operatorId: "operatorId",
+            facilityId: "facilityId",
+            gpuType: "gpuType",
+            nodeCount: "capacityNodes",
+            gpusPerNode: "gpusPerNode",
             cpu: "cpu",
             ram: "ram",
-            fabricType: "fabric_type",
+            fabricType: "fabricType",
             storage: "storage",
             internet: "internet",
-            networkHardware: "network_hardware",
-            buyNowPricePerGpuHour: "buy_now_price_per_gpu_hour",
         });
+        const startAt = parsed.availableStartAt ?? parsed.availableFrom;
+        if (startAt !== undefined)
+            body.startAt = rfc3339(startAt);
+        const endAt = parsed.availableEndAt ?? parsed.availableTo;
+        if (endAt !== undefined)
+            body.endAt = rfc3339(endAt);
+        // The rate is a decimal string on the wire; null clears the buy-now price.
+        if (parsed.buyNowPricePerGpuHour !== undefined) {
+            body.buyNowRatePerGpuHour =
+                parsed.buyNowPricePerGpuHour === null ? null : String(parsed.buyNowPricePerGpuHour);
+        }
+        // commerce's patchListingRequest.Validate refuses version <= 0, and the
+        // schema never carried one, so every update 400'd with "missing version".
+        // Resolve it the way inventory.delist does.
+        body.version = await resolveVersion(ctx, `/inventory/${seg(parsed.inventoryId)}`, parsed.version);
         if (!ctx.confirmed)
             return preview("inventory.update", body);
         return ctx.fetch(`/inventory/${seg(parsed.inventoryId)}`, { method: "PATCH", body });
@@ -273,18 +464,226 @@ export const tenantCreditProfileShowCapability = defineStaffMcpCapability({
     input: tenantCreditProfileShowInput,
     execute: async (ctx, input) => {
         const parsed = tenantCreditProfileShowInput.parse(input);
-        return ctx.fetch(`/internal/organizations/${seg(parsed.tenantId)}`, { method: "GET" });
+        try {
+            return await ctx.fetch(`/internal/organizations/${seg(parsed.tenantId)}`, { method: "GET" });
+        }
+        catch (error) {
+            // Commerce holds a projection, not the roster: an organization only
+            // appears there once authorization has pushed it across, so this read
+            // returned ORGANIZATION_NOT_FOUND for live tenants that had never
+            // transacted. Authorization owns the record, so fall back to it and say
+            // plainly that no commerce credit profile exists yet.
+            if (statusOf(error) !== 404)
+                throw error;
+            const organization = await ctx.fetch(`/v1/organizations/${seg(parsed.tenantId)}`, {
+                method: "GET",
+            });
+            return { organization, creditProfile: null, creditProfileSource: "authorization" };
+        }
+    },
+});
+export const reservationDraftCreateInput = z.object({
+    organizationId: z.string(),
+    nodeCount: z.number().int().positive(),
+    startAt: z.string(),
+    endAt: z.string(),
+    billingMode: z.string().default("reserved"),
+    pricePerGpuHr: z.string(),
+    listingId: z.string().optional(),
+    accessMode: z.string().optional(),
+    notes: z.string().optional(),
+    confirm: z.boolean().optional(),
+});
+export const reservationDraftCreateCapability = defineStaffMcpCapability({
+    id: "reservation.draft-create",
+    domain: "reservations",
+    roles: ["admin"],
+    description: "Internal staff only: create a draft reservation in Commerce. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/reservations" },
+    input: reservationDraftCreateInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationDraftCreateInput.parse(input);
+        const body = {
+            organizationId: parsed.organizationId,
+            nodeCount: parsed.nodeCount,
+            startAt: parsed.startAt,
+            endAt: parsed.endAt,
+            billingMode: parsed.billingMode,
+            pricePerGpuHr: parsed.pricePerGpuHr,
+            draft: true,
+            ...mapBody(parsed, {
+                listingId: "listingId",
+                accessMode: "accessMode",
+                notes: "notes",
+            }),
+        };
+        if (!ctx.confirmed)
+            return preview("reservation.draft-create", body);
+        return ctx.fetch("/internal/reservations", { method: "POST", body });
+    },
+});
+export const reservationUpdateInput = z.object({
+    reservationId: z.string(),
+    startAt: z.string().optional(),
+    endAt: z.string().optional(),
+    nodeCount: z.number().int().positive().optional(),
+    notes: z.string().nullable().optional(),
+    expectedStatus: z.string().optional(),
+    confirm: z.boolean().optional(),
+});
+export const reservationUpdateCapability = defineStaffMcpCapability({
+    id: "reservation.update",
+    domain: "reservations",
+    roles: ["admin"],
+    description: "Internal staff only: update an existing reservation's dates, node count, notes, or draft status. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "PATCH", path: "/internal/reservations/{reservationId}" },
+    input: reservationUpdateInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationUpdateInput.parse(input);
+        const body = mapBody(parsed, {
+            startAt: "startAt",
+            endAt: "endAt",
+            nodeCount: "nodeCount",
+            notes: "notes",
+            expectedStatus: "expectedStatus",
+        });
+        if (!ctx.confirmed) {
+            return preview("reservation.update", { reservationId: parsed.reservationId, ...body });
+        }
+        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}`, {
+            method: "PATCH",
+            body,
+        });
+    },
+});
+export const reservationActivateInput = z.object({
+    reservationId: z.string(),
+    version: z.number().int().optional(),
+    confirm: z.boolean().optional(),
+});
+export const reservationActivateCapability = defineStaffMcpCapability({
+    id: "reservation.activate",
+    domain: "reservations",
+    roles: ["admin"],
+    description: "Internal staff only: activate a confirmed reservation. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/reservations/{reservationId}/activate" },
+    input: reservationActivateInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationActivateInput.parse(input);
+        const body = {
+            version: await resolveVersion(ctx, `/internal/reservations/${seg(parsed.reservationId)}`, parsed.version),
+        };
+        if (!ctx.confirmed)
+            return preview("reservation.activate", { reservationId: parsed.reservationId, ...body });
+        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/activate`, {
+            method: "POST",
+            body,
+        });
+    },
+});
+export const reservationCompleteInput = z.object({
+    reservationId: z.string(),
+    version: z.number().int().optional(),
+    confirm: z.boolean().optional(),
+});
+export const reservationCompleteCapability = defineStaffMcpCapability({
+    id: "reservation.complete",
+    domain: "reservations",
+    roles: ["admin"],
+    description: "Internal staff only: complete an active reservation. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/reservations/{reservationId}/complete" },
+    input: reservationCompleteInput,
+    execute: async (ctx, input) => {
+        const parsed = reservationCompleteInput.parse(input);
+        const body = {
+            version: await resolveVersion(ctx, `/internal/reservations/${seg(parsed.reservationId)}`, parsed.version),
+        };
+        if (!ctx.confirmed)
+            return preview("reservation.complete", { reservationId: parsed.reservationId, ...body });
+        return ctx.fetch(`/internal/reservations/${seg(parsed.reservationId)}/complete`, {
+            method: "POST",
+            body,
+        });
+    },
+});
+export const inventoryDelistInput = z.object({
+    inventoryId: z.string(),
+    version: z.number().int().positive().optional(),
+    confirm: z.boolean().optional(),
+});
+export const inventoryDelistCapability = defineStaffMcpCapability({
+    id: "inventory.delist",
+    domain: "listings",
+    roles: ["admin"],
+    description: "Internal staff only: delist an inventory listing. Sets its state to delisted. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "PATCH", path: "/inventory/{inventoryId}" },
+    input: inventoryDelistInput,
+    execute: async (ctx, input) => {
+        const parsed = inventoryDelistInput.parse(input);
+        const body = {
+            state: "delisted",
+            version: await resolveVersion(ctx, `/inventory/${seg(parsed.inventoryId)}`, parsed.version),
+        };
+        if (!ctx.confirmed)
+            return preview("inventory.delist", { inventoryId: parsed.inventoryId, ...body });
+        return ctx.fetch(`/inventory/${seg(parsed.inventoryId)}`, {
+            method: "PATCH",
+            body,
+        });
+    },
+});
+export const billingInvoicesListInput = z.object({
+    status: z
+        .enum(["due", "open", "paid", "draft", "void", "uncollectible"])
+        .default("due")
+        .optional(),
+    cursor: z.string().optional(),
+    limit: z.number().int().positive().max(100).optional(),
+});
+export const billingInvoicesListCapability = defineStaffMcpCapability({
+    id: "billing.invoices-list",
+    domain: "billing",
+    roles: ["reviewer", "admin"],
+    description: "Internal staff only: list commerce invoices with an optional status filter (defaults to due).",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/invoices" },
+    input: billingInvoicesListInput,
+    execute: async (ctx, input) => {
+        const parsed = billingInvoicesListInput.parse(input ?? {});
+        const parts = [];
+        if (parsed.status)
+            parts.push(`status=${encodeURIComponent(parsed.status)}`);
+        if (parsed.cursor)
+            parts.push(`cursor=${encodeURIComponent(parsed.cursor)}`);
+        if (parsed.limit)
+            parts.push(`limit=${encodeURIComponent(String(parsed.limit))}`);
+        const qs = parts.length > 0 ? `?${parts.join("&")}` : "";
+        return ctx.fetch(`/internal/invoices${qs}`, { method: "GET" });
     },
 });
 export const staffCommerceCapabilities = [
+    reservationShowCapability,
+    reservationListCapability,
     reservationCancelCapability,
     reservationTransferCapability,
     reservationMachinesListCapability,
     reservationSshKeyAddCapability,
     reservationSshKeyRemoveCapability,
     reservationPublishCapability,
+    reservationDraftCreateCapability,
+    reservationUpdateCapability,
+    reservationActivateCapability,
+    reservationCompleteCapability,
+    bidShowCapability,
     bidAcceptCapability,
     bidRejectCapability,
     inventoryUpdateCapability,
+    inventoryDelistCapability,
     tenantCreditProfileShowCapability,
+    billingInvoicesListCapability,
 ];