@leaflow/sdk 0.0.0-dev.460.gd867712 → 0.0.0-dev.462.g9520bb3

package/dist/fleet/v1/generated/functions.d.ts

@@ -139,16 +139,28 @@
  * applies:
  *
  * - inside a command run through this API, by the request itself;
- * - at once, while the user has approved their requests on the machine without asking, for a
- *   while or until removed (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`);
+ * - by the user's automatic approval for the machine, for a while or until removed
+ *   (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`), in one of two modes:
+ *   - `automatic_review`, the recommended one: a large language model reviews each request and
+ *     approves or denies it with a reason. It stops most dangerous requests, but not all of
+ *     them. Each review is a request to Canopy, the model platform, through the project's
+ *     Canopy service, and may incur Canopy charges; the project needs Canopy enabled. A
+ *     request that cannot be reviewed, such as when the project has not enabled Canopy or the
+ *     review does not complete in time, is denied with a reason saying so;
+ *   - `always_approve`: every request is approved at once. This is dangerous: any program that
+ *     runs as the account, such as a script or an AI agent, becomes root without anyone being
+ *     asked;
  * - by the user, on any of their devices, for a request listed by `GET /api/v1/privilege-requests`
  *   (`POST …:approve` or `…:deny`), or on a participant of the session the asking process belongs
  *   to. A request nobody decides expires, and sudo fails.
  *
+ * A denied sudo shows whoever ran it the reason, when the denial gave one.
+ *
  * Requests reach the user's devices as they happen through EventBus: the event
- * `leaflow.fleet.privilege.requested` when one is waiting and `leaflow.fleet.privilege.decided`
- * when it ends, each addressed to the user in the current project and carrying the request's
- * `id`. A client that subscribes to them needs no polling; one that does not can list the
+ * `leaflow.fleet.privilege.requested` when one waits for the user and
+ * `leaflow.fleet.privilege.decided` when it ends, each addressed to the user in the current
+ * project and carrying the request's `id`. Requests decided without asking the user raise
+ * neither. A client that subscribes to them needs no polling; one that does not can list the
  * pending requests.
  *
  * ## Connections that drop
@@ -223,7 +235,7 @@
  * revoked. A participant whose creation failed is not announced.
  * OpenAPI spec version: 1.0.0
  */
-import type { AccountList, AccountResource, ApproveEnrollmentRequest, CallMcpToolRequest, CallMcpToolResponse, CreateGroupMemberRequest, CreateGroupRequest, CreateMachineRegistrationRequest, CreateMachineRegistrationResponse, CreateParticipantRequest, CreateParticipantResponse, CreatePeerConnectionCandidatesRequest, CreatePeerConnectionRequest, CreateSessionRequest, DeleteMcpServerParams, EnrollmentResource, Error, FindEnrollmentByPairingCodeParams, FindEnrollmentResponse, GroupList, GroupResource, ListAccountsParams, ListGroupMembersParams, ListGroupsParams, ListMachineEventsParams, ListMachineRegistrationsParams, ListMachinesParams, ListMcpToolsParams, ListPrivilegeAutoApprovalsParams, ListPrivilegeRequestsParams, ListSessionsParams, MachineEventList, MachineList, MachineRegistrationList, MachineRegistrationResource, MachineResource, McpConfigurationFile, McpConfigurationResource, McpToolList, MigrationStep, ParticipantList, ParticipantResource, PeerConnection, PrivilegeAutoApprovalList, PrivilegeAutoApprovalResource, PrivilegeRequestList, PrivilegeRequestResource, RenewParticipantRequest, RenewParticipantResponse, ReplaceMcpConfigurationRequest, RtcConfiguration, RunCommandRequest, RunCommandResponse, SendMcpRequestRequest, SendMcpRequestResponse, SessionList, SessionResource, UpdateAccountRequest, UpdateGroupRequest, UpdateMachineRequest, UpdateMcpServerRequest, UpdateMcpServerResponse, UpdatePrivilegeAutoApprovalRequest } from "./models.js";
+import type { AccountList, AccountResource, ApproveEnrollmentRequest, CallMcpToolRequest, CallMcpToolResponse, CreateGroupMemberRequest, CreateGroupRequest, CreateMachineRegistrationRequest, CreateMachineRegistrationResponse, CreateParticipantRequest, CreateParticipantResponse, CreatePeerConnectionCandidatesRequest, CreatePeerConnectionRequest, CreateSessionRequest, DeleteMcpServerParams, DenyPrivilegeRequestRequest, EnrollmentResource, Error, FindEnrollmentByPairingCodeParams, FindEnrollmentResponse, GroupList, GroupResource, ListAccountsParams, ListGroupMembersParams, ListGroupsParams, ListMachineEventsParams, ListMachineRegistrationsParams, ListMachinesParams, ListMcpToolsParams, ListPrivilegeAutoApprovalsParams, ListPrivilegeRequestsParams, ListSessionsParams, MachineEventList, MachineList, MachineRegistrationList, MachineRegistrationResource, MachineResource, McpConfigurationFile, McpConfigurationResource, McpToolList, MigrationStep, ParticipantList, ParticipantResource, PeerConnection, PrivilegeAutoApprovalList, PrivilegeAutoApprovalResource, PrivilegeRequestList, PrivilegeRequestResource, RenewParticipantRequest, RenewParticipantResponse, ReplaceMcpConfigurationRequest, RtcConfiguration, RunCommandRequest, RunCommandResponse, SendMcpRequestRequest, SendMcpRequestResponse, SessionList, SessionResource, UpdateAccountRequest, UpdateGroupRequest, UpdateMachineRequest, UpdateMcpServerRequest, UpdateMcpServerResponse, UpdatePrivilegeAutoApprovalRequest } from "./models.js";
 export type HTTPStatusCode1xx = 100 | 101 | 102 | 103;
 export type HTTPStatusCode2xx = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207;
 export type HTTPStatusCode3xx = 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308;
@@ -660,12 +672,14 @@ export type updatePrivilegeAutoApprovalResponseError = updatePrivilegeAutoApprov
 export type updatePrivilegeAutoApprovalResponse = updatePrivilegeAutoApprovalResponseSuccess | updatePrivilegeAutoApprovalResponseError;
 export declare const getUpdatePrivilegeAutoApprovalUrl: (machineId: string) => string;
 /**
- * Approves the caller's privilege requests on the machine at once, until `expires_at`, or
- * until removed when `expires_at` is null, replacing any earlier automatic approval. It
- * applies to the caller's own account only, which is created if the caller has none yet,
- * and only while they may become root on the machine. Fails with `INVALID_ARGUMENT` when
+ * Has the caller's privilege requests on the machine decided without asking them, in
+ * `mode`, until `expires_at`, or until removed when `expires_at` is null, replacing any
+ * earlier automatic approval. `automatic_review` is recommended; with `always_approve` any
+ * program that runs as the account becomes root without anyone being asked. It applies to
+ * the caller's own account only, which is created if the caller has none yet, and only
+ * while they may become root on the machine. Fails with `INVALID_ARGUMENT` when
  * `expires_at` has passed.
- * @summary Approve the caller's privilege requests on a machine without asking
+ * @summary Decide the caller's privilege requests on a machine without asking
  */
 export declare const updatePrivilegeAutoApproval: (machineId: string, updatePrivilegeAutoApprovalRequest: UpdatePrivilegeAutoApprovalRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updatePrivilegeAutoApprovalResponse>;
 export type deletePrivilegeAutoApprovalResponse204 = {
@@ -795,11 +809,11 @@ export type denyPrivilegeRequestResponseError = denyPrivilegeRequestResponseDefa
 export type denyPrivilegeRequestResponse = denyPrivilegeRequestResponseSuccess | denyPrivilegeRequestResponseError;
 export declare const getDenyPrivilegeRequestUrl: (requestId: string) => string;
 /**
- * Denies one of the caller's pending requests; the waiting sudo fails. Fails with
- * `PRIVILEGE_REQUEST_CLOSED` as for approving.
+ * Denies one of the caller's pending requests; the waiting sudo fails and shows `reason`,
+ * when given, to whoever ran it. Fails with `PRIVILEGE_REQUEST_CLOSED` as for approving.
  * @summary Deny a privilege request
  */
-export declare const denyPrivilegeRequest: (requestId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<denyPrivilegeRequestResponse>;
+export declare const denyPrivilegeRequest: (requestId: string, denyPrivilegeRequestRequest?: DenyPrivilegeRequestRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<denyPrivilegeRequestResponse>;
 export type findEnrollmentByPairingCodeResponse200 = {
     data: FindEnrollmentResponse;
     status: 200;

package/dist/fleet/v1/generated/functions.js

@@ -483,12 +483,14 @@ export const getUpdatePrivilegeAutoApprovalUrl = (machineId) => {
     return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/privilege-auto-approval`;
 };
 /**
- * Approves the caller's privilege requests on the machine at once, until `expires_at`, or
- * until removed when `expires_at` is null, replacing any earlier automatic approval. It
- * applies to the caller's own account only, which is created if the caller has none yet,
- * and only while they may become root on the machine. Fails with `INVALID_ARGUMENT` when
+ * Has the caller's privilege requests on the machine decided without asking them, in
+ * `mode`, until `expires_at`, or until removed when `expires_at` is null, replacing any
+ * earlier automatic approval. `automatic_review` is recommended; with `always_approve` any
+ * program that runs as the account becomes root without anyone being asked. It applies to
+ * the caller's own account only, which is created if the caller has none yet, and only
+ * while they may become root on the machine. Fails with `INVALID_ARGUMENT` when
  * `expires_at` has passed.
- * @summary Approve the caller's privilege requests on a machine without asking
+ * @summary Decide the caller's privilege requests on a machine without asking
  */
 export const updatePrivilegeAutoApproval = async (machineId, updatePrivilegeAutoApprovalRequest, options, fetchFn) => {
     const getHeaders = (h) => {
@@ -623,14 +625,31 @@ export const getDenyPrivilegeRequestUrl = (requestId) => {
     return `https://fleet.leaflow.cloud/api/v1/privilege-requests/${encodeURIComponent(String(requestId))}:deny`;
 };
 /**
- * Denies one of the caller's pending requests; the waiting sudo fails. Fails with
- * `PRIVILEGE_REQUEST_CLOSED` as for approving.
+ * Denies one of the caller's pending requests; the waiting sudo fails and shows `reason`,
+ * when given, to whoever ran it. Fails with `PRIVILEGE_REQUEST_CLOSED` as for approving.
  * @summary Deny a privilege request
  */
-export const denyPrivilegeRequest = async (requestId, options, fetchFn) => {
+export const denyPrivilegeRequest = async (requestId, denyPrivilegeRequestRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     const res = await (fetchFn ?? fetch)(getDenyPrivilegeRequestUrl(requestId), {
         ...options,
         method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(denyPrivilegeRequestRequest),
     });
     const body = [204, 205, 304].includes(res.status) ? null : await res.text();
     const data = body ? JSON.parse(body) : {};

package/dist/fleet/v1/generated/models.d.ts

@@ -139,16 +139,28 @@
  * applies:
  *
  * - inside a command run through this API, by the request itself;
- * - at once, while the user has approved their requests on the machine without asking, for a
- *   while or until removed (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`);
+ * - by the user's automatic approval for the machine, for a while or until removed
+ *   (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`), in one of two modes:
+ *   - `automatic_review`, the recommended one: a large language model reviews each request and
+ *     approves or denies it with a reason. It stops most dangerous requests, but not all of
+ *     them. Each review is a request to Canopy, the model platform, through the project's
+ *     Canopy service, and may incur Canopy charges; the project needs Canopy enabled. A
+ *     request that cannot be reviewed, such as when the project has not enabled Canopy or the
+ *     review does not complete in time, is denied with a reason saying so;
+ *   - `always_approve`: every request is approved at once. This is dangerous: any program that
+ *     runs as the account, such as a script or an AI agent, becomes root without anyone being
+ *     asked;
  * - by the user, on any of their devices, for a request listed by `GET /api/v1/privilege-requests`
  *   (`POST …:approve` or `…:deny`), or on a participant of the session the asking process belongs
  *   to. A request nobody decides expires, and sudo fails.
  *
+ * A denied sudo shows whoever ran it the reason, when the denial gave one.
+ *
  * Requests reach the user's devices as they happen through EventBus: the event
- * `leaflow.fleet.privilege.requested` when one is waiting and `leaflow.fleet.privilege.decided`
- * when it ends, each addressed to the user in the current project and carrying the request's
- * `id`. A client that subscribes to them needs no polling; one that does not can list the
+ * `leaflow.fleet.privilege.requested` when one waits for the user and
+ * `leaflow.fleet.privilege.decided` when it ends, each addressed to the user in the current
+ * project and carrying the request's `id`. Requests decided without asking the user raise
+ * neither. A client that subscribes to them needs no polling; one that does not can list the
  * pending requests.
  *
  * ## Connections that drop
@@ -1039,7 +1051,25 @@ export interface McpToolList {
     /** Servers whose tools are missing because they could not be started or reached */
     unavailable_servers: McpUnavailableServer[];
 }
+/**
+ * How the caller's privilege requests on the machine are decided without asking them:
+ * - `automatic_review`, recommended: a large language model reviews each request from what
+ *   the machine reports about it, chiefly the command line, and approves or denies it with
+ *   a reason. It stops most dangerous requests, but not all of them. Each review is a
+ *   request to Canopy through the project's Canopy service and may incur Canopy charges. A
+ *   request that cannot be reviewed, such as when the project has not enabled Canopy, is
+ *   denied.
+ * - `always_approve`: every request is approved at once. Dangerous: any program that runs
+ *   as the account, such as a script or an AI agent, becomes root without anyone being
+ *   asked.
+ */
+export type PrivilegeAutoApprovalMode = (typeof PrivilegeAutoApprovalMode)[keyof typeof PrivilegeAutoApprovalMode];
+export declare const PrivilegeAutoApprovalMode: {
+    readonly automatic_review: "automatic_review";
+    readonly always_approve: "always_approve";
+};
 export interface UpdatePrivilegeAutoApprovalRequest {
+    mode: PrivilegeAutoApprovalMode;
     /**
      * When the automatic approval ends; null for one that lasts until removed
      * @nullable
@@ -1049,6 +1079,7 @@ export interface UpdatePrivilegeAutoApprovalRequest {
 export interface PrivilegeAutoApprovalResource {
     id: string;
     machine_id: string;
+    mode: PrivilegeAutoApprovalMode;
     /**
      * When the automatic approval ends; null for one that lasts until removed
      * @nullable
@@ -1067,14 +1098,23 @@ export interface PrivilegeAutoApprovalList {
     page_size: number;
 }
 /**
- * Who decided a request on the platform: `user` the user, or `auto_approval` the user's
- * automatic approval for the machine, at once.
+ * Who decided a request on the platform: `user` the user, `always_approve` the user's
+ * automatic approval that approves every request, or `automatic_review` the large language
+ * model that reviewed it.
  */
 export type PrivilegeDecider = (typeof PrivilegeDecider)[keyof typeof PrivilegeDecider];
 export declare const PrivilegeDecider: {
     readonly user: "user";
-    readonly auto_approval: "auto_approval";
+    readonly always_approve: "always_approve";
+    readonly automatic_review: "automatic_review";
 };
+export interface DenyPrivilegeRequestRequest {
+    /**
+     * Why, shown to whoever ran sudo: plain text without control characters
+     * @maxLength 200
+     */
+    reason?: string;
+}
 /**
  * `pending` waits for a decision; `approved` and `denied` were decided on the platform, as
  * `decided_by` tells; `expired` was not decided in time; `cancelled` means the machine
@@ -1115,6 +1155,13 @@ export interface PrivilegeRequestResource {
     state: PrivilegeRequestState;
     /** Who decided an `approved` or `denied` request; null in any other state */
     decided_by: PrivilegeDecider | null;
+    /**
+     * Why the request was decided so: as the user gave it when denying, or as the automatic
+     * review gave it, including why a review could not be made; null when none was given
+     * @maxLength 200
+     * @nullable
+     */
+    reason: string | null;
     created_at: string;
     expires_at: string;
     /**

package/dist/fleet/v1/generated/models.js

@@ -68,9 +68,14 @@ export const McpServerFailure = {
     protocol_error: "protocol_error",
     timeout: "timeout",
 };
+export const PrivilegeAutoApprovalMode = {
+    automatic_review: "automatic_review",
+    always_approve: "always_approve",
+};
 export const PrivilegeDecider = {
     user: "user",
-    auto_approval: "auto_approval",
+    always_approve: "always_approve",
+    automatic_review: "automatic_review",
 };
 export const PrivilegeRequestState = {
     pending: "pending",

package/dist/fleet/v1/generated/schemas.zod.d.ts

@@ -139,16 +139,28 @@
  * applies:
  *
  * - inside a command run through this API, by the request itself;
- * - at once, while the user has approved their requests on the machine without asking, for a
- *   while or until removed (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`);
+ * - by the user's automatic approval for the machine, for a while or until removed
+ *   (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`), in one of two modes:
+ *   - `automatic_review`, the recommended one: a large language model reviews each request and
+ *     approves or denies it with a reason. It stops most dangerous requests, but not all of
+ *     them. Each review is a request to Canopy, the model platform, through the project's
+ *     Canopy service, and may incur Canopy charges; the project needs Canopy enabled. A
+ *     request that cannot be reviewed, such as when the project has not enabled Canopy or the
+ *     review does not complete in time, is denied with a reason saying so;
+ *   - `always_approve`: every request is approved at once. This is dangerous: any program that
+ *     runs as the account, such as a script or an AI agent, becomes root without anyone being
+ *     asked;
  * - by the user, on any of their devices, for a request listed by `GET /api/v1/privilege-requests`
  *   (`POST …:approve` or `…:deny`), or on a participant of the session the asking process belongs
  *   to. A request nobody decides expires, and sudo fails.
  *
+ * A denied sudo shows whoever ran it the reason, when the denial gave one.
+ *
  * Requests reach the user's devices as they happen through EventBus: the event
- * `leaflow.fleet.privilege.requested` when one is waiting and `leaflow.fleet.privilege.decided`
- * when it ends, each addressed to the user in the current project and carrying the request's
- * `id`. A client that subscribes to them needs no polling; one that does not can list the
+ * `leaflow.fleet.privilege.requested` when one waits for the user and
+ * `leaflow.fleet.privilege.decided` when it ends, each addressed to the user in the current
+ * project and carrying the request's `id`. Requests decided without asking the user raise
+ * neither. A client that subscribes to them needs no polling; one that does not can list the
  * pending requests.
  *
  * ## Connections that drop
@@ -520,17 +532,23 @@ export declare const GetPrivilegeAutoApprovalParams: zod.ZodObject<{
     machineId: zod.ZodUUID;
 }, zod.z.core.$strict>;
 /**
- * Approves the caller's privilege requests on the machine at once, until `expires_at`, or
- * until removed when `expires_at` is null, replacing any earlier automatic approval. It
- * applies to the caller's own account only, which is created if the caller has none yet,
- * and only while they may become root on the machine. Fails with `INVALID_ARGUMENT` when
+ * Has the caller's privilege requests on the machine decided without asking them, in
+ * `mode`, until `expires_at`, or until removed when `expires_at` is null, replacing any
+ * earlier automatic approval. `automatic_review` is recommended; with `always_approve` any
+ * program that runs as the account becomes root without anyone being asked. It applies to
+ * the caller's own account only, which is created if the caller has none yet, and only
+ * while they may become root on the machine. Fails with `INVALID_ARGUMENT` when
  * `expires_at` has passed.
- * @summary Approve the caller's privilege requests on a machine without asking
+ * @summary Decide the caller's privilege requests on a machine without asking
  */
 export declare const UpdatePrivilegeAutoApprovalParams: zod.ZodObject<{
     machineId: zod.ZodUUID;
 }, zod.z.core.$strict>;
 export declare const UpdatePrivilegeAutoApprovalBody: zod.ZodObject<{
+    mode: zod.ZodEnum<{
+        automatic_review: "automatic_review";
+        always_approve: "always_approve";
+    }>;
     expires_at: zod.ZodNullable<zod.z.ZodISODateTime>;
 }, zod.z.core.$strict>;
 /**
@@ -592,13 +610,16 @@ export declare const ApprovePrivilegeRequestParams: zod.ZodObject<{
     requestId: zod.ZodUUID;
 }, zod.z.core.$strict>;
 /**
- * Denies one of the caller's pending requests; the waiting sudo fails. Fails with
- * `PRIVILEGE_REQUEST_CLOSED` as for approving.
+ * Denies one of the caller's pending requests; the waiting sudo fails and shows `reason`,
+ * when given, to whoever ran it. Fails with `PRIVILEGE_REQUEST_CLOSED` as for approving.
  * @summary Deny a privilege request
  */
 export declare const DenyPrivilegeRequestParams: zod.ZodObject<{
     requestId: zod.ZodUUID;
 }, zod.z.core.$strict>;
+export declare const DenyPrivilegeRequestBody: zod.ZodObject<{
+    reason: zod.ZodOptional<zod.ZodString>;
+}, zod.z.core.$strict>;
 /**
  * Returns the pending enrollment request whose pairing code matches, or no enrollment when
  * none does. Mistyped codes are expected and are not an error. Letters are matched

package/dist/fleet/v1/generated/schemas.zod.js

@@ -139,16 +139,28 @@
  * applies:
  *
  * - inside a command run through this API, by the request itself;
- * - at once, while the user has approved their requests on the machine without asking, for a
- *   while or until removed (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`);
+ * - by the user's automatic approval for the machine, for a while or until removed
+ *   (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`), in one of two modes:
+ *   - `automatic_review`, the recommended one: a large language model reviews each request and
+ *     approves or denies it with a reason. It stops most dangerous requests, but not all of
+ *     them. Each review is a request to Canopy, the model platform, through the project's
+ *     Canopy service, and may incur Canopy charges; the project needs Canopy enabled. A
+ *     request that cannot be reviewed, such as when the project has not enabled Canopy or the
+ *     review does not complete in time, is denied with a reason saying so;
+ *   - `always_approve`: every request is approved at once. This is dangerous: any program that
+ *     runs as the account, such as a script or an AI agent, becomes root without anyone being
+ *     asked;
  * - by the user, on any of their devices, for a request listed by `GET /api/v1/privilege-requests`
  *   (`POST …:approve` or `…:deny`), or on a participant of the session the asking process belongs
  *   to. A request nobody decides expires, and sudo fails.
  *
+ * A denied sudo shows whoever ran it the reason, when the denial gave one.
+ *
  * Requests reach the user's devices as they happen through EventBus: the event
- * `leaflow.fleet.privilege.requested` when one is waiting and `leaflow.fleet.privilege.decided`
- * when it ends, each addressed to the user in the current project and carrying the request's
- * `id`. A client that subscribes to them needs no polling; one that does not can list the
+ * `leaflow.fleet.privilege.requested` when one waits for the user and
+ * `leaflow.fleet.privilege.decided` when it ends, each addressed to the user in the current
+ * project and carrying the request's `id`. Requests decided without asking the user raise
+ * neither. A client that subscribes to them needs no polling; one that does not can list the
  * pending requests.
  *
  * ## Connections that drop
@@ -233,6 +245,7 @@ import { CreateParticipantRequest } from "./validators/createParticipantRequest.
 import { CreatePeerConnectionCandidatesRequest } from "./validators/createPeerConnectionCandidatesRequest.zod.js";
 import { CreatePeerConnectionRequest } from "./validators/createPeerConnectionRequest.zod.js";
 import { CreateSessionRequest } from "./validators/createSessionRequest.zod.js";
+import { DenyPrivilegeRequestRequest } from "./validators/denyPrivilegeRequestRequest.zod.js";
 import { MigrationStep } from "./validators/migrationStep.zod.js";
 import { RenewParticipantRequest } from "./validators/renewParticipantRequest.zod.js";
 import { ReplaceMcpConfigurationRequest } from "./validators/replaceMcpConfigurationRequest.zod.js";
@@ -567,12 +580,14 @@ export const GetPrivilegeAutoApprovalParams = zod.strictObject({
     machineId: zod.uuid(),
 });
 /**
- * Approves the caller's privilege requests on the machine at once, until `expires_at`, or
- * until removed when `expires_at` is null, replacing any earlier automatic approval. It
- * applies to the caller's own account only, which is created if the caller has none yet,
- * and only while they may become root on the machine. Fails with `INVALID_ARGUMENT` when
+ * Has the caller's privilege requests on the machine decided without asking them, in
+ * `mode`, until `expires_at`, or until removed when `expires_at` is null, replacing any
+ * earlier automatic approval. `automatic_review` is recommended; with `always_approve` any
+ * program that runs as the account becomes root without anyone being asked. It applies to
+ * the caller's own account only, which is created if the caller has none yet, and only
+ * while they may become root on the machine. Fails with `INVALID_ARGUMENT` when
  * `expires_at` has passed.
- * @summary Approve the caller's privilege requests on a machine without asking
+ * @summary Decide the caller's privilege requests on a machine without asking
  */
 export const UpdatePrivilegeAutoApprovalParams = zod.strictObject({
     machineId: zod.uuid(),
@@ -654,13 +669,14 @@ export const ApprovePrivilegeRequestParams = zod.strictObject({
     requestId: zod.uuid(),
 });
 /**
- * Denies one of the caller's pending requests; the waiting sudo fails. Fails with
- * `PRIVILEGE_REQUEST_CLOSED` as for approving.
+ * Denies one of the caller's pending requests; the waiting sudo fails and shows `reason`,
+ * when given, to whoever ran it. Fails with `PRIVILEGE_REQUEST_CLOSED` as for approving.
  * @summary Deny a privilege request
  */
 export const DenyPrivilegeRequestParams = zod.strictObject({
     requestId: zod.uuid(),
 });
+export const DenyPrivilegeRequestBody = DenyPrivilegeRequestRequest;
 /**
  * Returns the pending enrollment request whose pairing code matches, or no enrollment when
  * none does. Mistyped codes are expected and are not an error. Letters are matched

package/dist/fleet/v1/generated/validators/accountList.zod.d.ts

@@ -139,16 +139,28 @@
  * applies:
  *
  * - inside a command run through this API, by the request itself;
- * - at once, while the user has approved their requests on the machine without asking, for a
- *   while or until removed (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`);
+ * - by the user's automatic approval for the machine, for a while or until removed
+ *   (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`), in one of two modes:
+ *   - `automatic_review`, the recommended one: a large language model reviews each request and
+ *     approves or denies it with a reason. It stops most dangerous requests, but not all of
+ *     them. Each review is a request to Canopy, the model platform, through the project's
+ *     Canopy service, and may incur Canopy charges; the project needs Canopy enabled. A
+ *     request that cannot be reviewed, such as when the project has not enabled Canopy or the
+ *     review does not complete in time, is denied with a reason saying so;
+ *   - `always_approve`: every request is approved at once. This is dangerous: any program that
+ *     runs as the account, such as a script or an AI agent, becomes root without anyone being
+ *     asked;
  * - by the user, on any of their devices, for a request listed by `GET /api/v1/privilege-requests`
  *   (`POST …:approve` or `…:deny`), or on a participant of the session the asking process belongs
  *   to. A request nobody decides expires, and sudo fails.
  *
+ * A denied sudo shows whoever ran it the reason, when the denial gave one.
+ *
  * Requests reach the user's devices as they happen through EventBus: the event
- * `leaflow.fleet.privilege.requested` when one is waiting and `leaflow.fleet.privilege.decided`
- * when it ends, each addressed to the user in the current project and carrying the request's
- * `id`. A client that subscribes to them needs no polling; one that does not can list the
+ * `leaflow.fleet.privilege.requested` when one waits for the user and
+ * `leaflow.fleet.privilege.decided` when it ends, each addressed to the user in the current
+ * project and carrying the request's `id`. Requests decided without asking the user raise
+ * neither. A client that subscribes to them needs no polling; one that does not can list the
  * pending requests.
  *
  * ## Connections that drop

package/dist/fleet/v1/generated/validators/accountList.zod.js

@@ -139,16 +139,28 @@
  * applies:
  *
  * - inside a command run through this API, by the request itself;
- * - at once, while the user has approved their requests on the machine without asking, for a
- *   while or until removed (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`);
+ * - by the user's automatic approval for the machine, for a while or until removed
+ *   (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`), in one of two modes:
+ *   - `automatic_review`, the recommended one: a large language model reviews each request and
+ *     approves or denies it with a reason. It stops most dangerous requests, but not all of
+ *     them. Each review is a request to Canopy, the model platform, through the project's
+ *     Canopy service, and may incur Canopy charges; the project needs Canopy enabled. A
+ *     request that cannot be reviewed, such as when the project has not enabled Canopy or the
+ *     review does not complete in time, is denied with a reason saying so;
+ *   - `always_approve`: every request is approved at once. This is dangerous: any program that
+ *     runs as the account, such as a script or an AI agent, becomes root without anyone being
+ *     asked;
  * - by the user, on any of their devices, for a request listed by `GET /api/v1/privilege-requests`
  *   (`POST …:approve` or `…:deny`), or on a participant of the session the asking process belongs
  *   to. A request nobody decides expires, and sudo fails.
  *
+ * A denied sudo shows whoever ran it the reason, when the denial gave one.
+ *
  * Requests reach the user's devices as they happen through EventBus: the event
- * `leaflow.fleet.privilege.requested` when one is waiting and `leaflow.fleet.privilege.decided`
- * when it ends, each addressed to the user in the current project and carrying the request's
- * `id`. A client that subscribes to them needs no polling; one that does not can list the
+ * `leaflow.fleet.privilege.requested` when one waits for the user and
+ * `leaflow.fleet.privilege.decided` when it ends, each addressed to the user in the current
+ * project and carrying the request's `id`. Requests decided without asking the user raise
+ * neither. A client that subscribes to them needs no polling; one that does not can list the
  * pending requests.
  *
  * ## Connections that drop

package/dist/fleet/v1/generated/validators/accountResource.zod.d.ts

@@ -139,16 +139,28 @@
  * applies:
  *
  * - inside a command run through this API, by the request itself;
- * - at once, while the user has approved their requests on the machine without asking, for a
- *   while or until removed (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`);
+ * - by the user's automatic approval for the machine, for a while or until removed
+ *   (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`), in one of two modes:
+ *   - `automatic_review`, the recommended one: a large language model reviews each request and
+ *     approves or denies it with a reason. It stops most dangerous requests, but not all of
+ *     them. Each review is a request to Canopy, the model platform, through the project's
+ *     Canopy service, and may incur Canopy charges; the project needs Canopy enabled. A
+ *     request that cannot be reviewed, such as when the project has not enabled Canopy or the
+ *     review does not complete in time, is denied with a reason saying so;
+ *   - `always_approve`: every request is approved at once. This is dangerous: any program that
+ *     runs as the account, such as a script or an AI agent, becomes root without anyone being
+ *     asked;
  * - by the user, on any of their devices, for a request listed by `GET /api/v1/privilege-requests`
  *   (`POST …:approve` or `…:deny`), or on a participant of the session the asking process belongs
  *   to. A request nobody decides expires, and sudo fails.
  *
+ * A denied sudo shows whoever ran it the reason, when the denial gave one.
+ *
  * Requests reach the user's devices as they happen through EventBus: the event
- * `leaflow.fleet.privilege.requested` when one is waiting and `leaflow.fleet.privilege.decided`
- * when it ends, each addressed to the user in the current project and carrying the request's
- * `id`. A client that subscribes to them needs no polling; one that does not can list the
+ * `leaflow.fleet.privilege.requested` when one waits for the user and
+ * `leaflow.fleet.privilege.decided` when it ends, each addressed to the user in the current
+ * project and carrying the request's `id`. Requests decided without asking the user raise
+ * neither. A client that subscribes to them needs no polling; one that does not can list the
  * pending requests.
  *
  * ## Connections that drop

package/dist/fleet/v1/generated/validators/accountResource.zod.js

@@ -139,16 +139,28 @@
  * applies:
  *
  * - inside a command run through this API, by the request itself;
- * - at once, while the user has approved their requests on the machine without asking, for a
- *   while or until removed (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`);
+ * - by the user's automatic approval for the machine, for a while or until removed
+ *   (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`), in one of two modes:
+ *   - `automatic_review`, the recommended one: a large language model reviews each request and
+ *     approves or denies it with a reason. It stops most dangerous requests, but not all of
+ *     them. Each review is a request to Canopy, the model platform, through the project's
+ *     Canopy service, and may incur Canopy charges; the project needs Canopy enabled. A
+ *     request that cannot be reviewed, such as when the project has not enabled Canopy or the
+ *     review does not complete in time, is denied with a reason saying so;
+ *   - `always_approve`: every request is approved at once. This is dangerous: any program that
+ *     runs as the account, such as a script or an AI agent, becomes root without anyone being
+ *     asked;
  * - by the user, on any of their devices, for a request listed by `GET /api/v1/privilege-requests`
  *   (`POST …:approve` or `…:deny`), or on a participant of the session the asking process belongs
  *   to. A request nobody decides expires, and sudo fails.
  *
+ * A denied sudo shows whoever ran it the reason, when the denial gave one.
+ *
  * Requests reach the user's devices as they happen through EventBus: the event
- * `leaflow.fleet.privilege.requested` when one is waiting and `leaflow.fleet.privilege.decided`
- * when it ends, each addressed to the user in the current project and carrying the request's
- * `id`. A client that subscribes to them needs no polling; one that does not can list the
+ * `leaflow.fleet.privilege.requested` when one waits for the user and
+ * `leaflow.fleet.privilege.decided` when it ends, each addressed to the user in the current
+ * project and carrying the request's `id`. Requests decided without asking the user raise
+ * neither. A client that subscribes to them needs no polling; one that does not can list the
  * pending requests.
  *
  * ## Connections that drop

package/dist/fleet/v1/generated/validators/approveEnrollmentRequest.zod.d.ts

@@ -139,16 +139,28 @@
  * applies:
  *
  * - inside a command run through this API, by the request itself;
- * - at once, while the user has approved their requests on the machine without asking, for a
- *   while or until removed (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`);
+ * - by the user's automatic approval for the machine, for a while or until removed
+ *   (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`), in one of two modes:
+ *   - `automatic_review`, the recommended one: a large language model reviews each request and
+ *     approves or denies it with a reason. It stops most dangerous requests, but not all of
+ *     them. Each review is a request to Canopy, the model platform, through the project's
+ *     Canopy service, and may incur Canopy charges; the project needs Canopy enabled. A
+ *     request that cannot be reviewed, such as when the project has not enabled Canopy or the
+ *     review does not complete in time, is denied with a reason saying so;
+ *   - `always_approve`: every request is approved at once. This is dangerous: any program that
+ *     runs as the account, such as a script or an AI agent, becomes root without anyone being
+ *     asked;
  * - by the user, on any of their devices, for a request listed by `GET /api/v1/privilege-requests`
  *   (`POST …:approve` or `…:deny`), or on a participant of the session the asking process belongs
  *   to. A request nobody decides expires, and sudo fails.
  *
+ * A denied sudo shows whoever ran it the reason, when the denial gave one.
+ *
  * Requests reach the user's devices as they happen through EventBus: the event
- * `leaflow.fleet.privilege.requested` when one is waiting and `leaflow.fleet.privilege.decided`
- * when it ends, each addressed to the user in the current project and carrying the request's
- * `id`. A client that subscribes to them needs no polling; one that does not can list the
+ * `leaflow.fleet.privilege.requested` when one waits for the user and
+ * `leaflow.fleet.privilege.decided` when it ends, each addressed to the user in the current
+ * project and carrying the request's `id`. Requests decided without asking the user raise
+ * neither. A client that subscribes to them needs no polling; one that does not can list the
  * pending requests.
  *
  * ## Connections that drop