@leaflow/sdk 0.187.2 → 0.189.0

package/README.md

@@ -1,12 +1,12 @@
 # Leaflow TypeScript SDK
 
-Native Orval fetch functions, a native models.ts and request-only Zod schemas live together under
-`src/<service>/v1/generated`. Module entry points stay outside that generated directory.
-Root namespaces, versioned subpath imports and each module's `schemas`
-export are preserved. `src/routes.ts` retains the static routing and authentication facts.
+TypeScript SDK for the Leaflow platform, generated from the [leaflowapis](https://github.com/leaflowapis/leaflowapis) contracts.
 
-Validate requests with generated schemas before invoking native operations. Responses retain their
-native models and return types. Credentials remain in RequestInit and the existing fetch transport.
+```sh
+npm install @leaflow/sdk
+```
+
+Clients, models, and request validation schemas live under `src/<service>/<version>/generated`. Validate requests with the generated schemas before calling an operation.
 
 ## Generate and build
 
@@ -18,15 +18,12 @@ npm run generate
 npm run build
 ```
 
-`orval.config.mjs` is plain official Orval configuration that recursively discovers OpenAPI entry documents. The Canopy hook chooses JSON or Blob for the chat completion response according to Content-Type,
-so JSON and SSE retain their respective response formats. No compatibility forwarding layer is used. For local generation, CONTRACTS_DIR
-may point to an existing clean checkout of the exact CONTRACTS_REF commit. CI checks out that commit.
+The contract version is recorded in `CONTRACTS_REF`. `CONTRACTS_DIR` may point to a clean checkout at that ref.
 
 ## Protocol messages
 
-The contract's protobuf messages, currently the Fleet protocol spoken by VirtualDesktop viewers, are
-generated with protoc-gen-es under `src/proto`, keeping their proto paths. Import a file by that
-path and encode or decode with `@bufbuild/protobuf`; no gRPC or Connect transport is involved:
+Protobuf messages from the contract are generated with protoc-gen-es under `src/proto`, preserving their
+proto paths. Import them by path and encode or decode with `@bufbuild/protobuf`:
 
 ```ts
 import { create, toBinary } from "@bufbuild/protobuf";
@@ -36,9 +33,3 @@ const bytes = toBinary(ClientMessageSchema, create(ClientMessageSchema, {}));
 ```
 
 `npm run generate` runs Orval and then `buf generate` on the same contract checkout.
-
-## Canopy migration
-
-Project inference and management are exported from `canopy` and `@leaflow/sdk/canopy/v1`.
-Replace `canopyInference` and `@leaflow/sdk/canopy/inference/v1` imports with the shared Canopy module.
-The OpenAI-compatible `/v1` paths, management `/api/v1` paths and scoped-token authentication are unchanged.

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;
@@ -534,10 +546,10 @@ export declare const getSendMcpRequestUrl: (machineId: string, serverName: strin
  * `tools/call`, `resources/read` or `prompts/get`, and returns the server's response. The
  * machine starts or connects to the server if it is not running, and handles its
  * initialization itself; a request still running when `timeout_seconds` passes is cancelled
- * at the server. Requests the server makes of the client, such as for sampling, are refused,
- * and its notifications, such as of progress, are dropped. A response with a JSON-RPC error
- * is a successful request. Neither the request nor the response is hidden from the
- * platform. Requires `fleet:machines.login` on the machine.
+ * at the server. Requests the server makes of the client are answered as by a client that
+ * offers no sampling, elicitation or roots, and its notifications, such as of progress, are
+ * dropped. A response with a JSON-RPC error is a successful request. Neither the request nor
+ * the response is hidden from the platform. Requires `fleet:machines.login` on the machine.
  *
  * Fails with:
  * - `MCP_SERVER_NOT_FOUND` when the server is not configured;
@@ -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

@@ -334,10 +334,10 @@ export const getSendMcpRequestUrl = (machineId, serverName) => {
  * `tools/call`, `resources/read` or `prompts/get`, and returns the server's response. The
  * machine starts or connects to the server if it is not running, and handles its
  * initialization itself; a request still running when `timeout_seconds` passes is cancelled
- * at the server. Requests the server makes of the client, such as for sampling, are refused,
- * and its notifications, such as of progress, are dropped. A response with a JSON-RPC error
- * is a successful request. Neither the request nor the response is hidden from the
- * platform. Requires `fleet:machines.login` on the machine.
+ * at the server. Requests the server makes of the client are answered as by a client that
+ * offers no sampling, elicitation or roots, and its notifications, such as of progress, are
+ * dropped. A response with a JSON-RPC error is a successful request. Neither the request nor
+ * the response is hidden from the platform. Requires `fleet:machines.login` on the machine.
  *
  * Fails with:
  * - `MCP_SERVER_NOT_FOUND` when the server is not configured;
@@ -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
@@ -787,14 +799,12 @@ export interface McpConfigurationFile {
     set_aside: string | null;
 }
 /**
- * `stdio` for a program the machine starts as the account, `http` for Streamable HTTP and
- * `sse` for HTTP with Server-Sent Events, the transport of earlier revisions of MCP
+ * `stdio` for a program the machine starts as the account, `http` for Streamable HTTP
  */
 export type McpTransport = (typeof McpTransport)[keyof typeof McpTransport];
 export declare const McpTransport: {
     readonly stdio: "stdio";
     readonly http: "http";
-    readonly sse: "sse";
 };
 /**
  * `stopped` before its first use or after it was idle, `starting`, `running`, `failed`
@@ -838,7 +848,7 @@ export interface McpServerResource {
     args: string[];
     /** The variables `env` sets; their values are never returned */
     env_keys: string[];
-    /** With `http` and `sse`, the endpoint */
+    /** With `http`, the endpoint */
     url: string;
     /** The headers `headers` sends; their values are never returned */
     header_keys: string[];
@@ -870,7 +880,7 @@ export type UpdateMcpServerRequestEnv = {
     [key: string]: string;
 };
 /**
- * With `http` and `sse`, headers sent with every request
+ * With `http`, headers sent with every request
  */
 export type UpdateMcpServerRequestHeaders = {
     [key: string]: string;
@@ -892,11 +902,11 @@ export interface UpdateMcpServerRequest {
     /** With `stdio`, variables added to the account's environment */
     env?: UpdateMcpServerRequestEnv;
     /**
-     * With `http` and `sse`, the endpoint; shown to anyone who reads the configuration
+     * With `http`, the endpoint; shown to anyone who reads the configuration
      * @maxLength 4096
      */
     url?: string;
-    /** With `http` and `sse`, headers sent with every request */
+    /** With `http`, headers sent with every request */
     headers?: UpdateMcpServerRequestHeaders;
     /** Configured but kept stopped */
     disabled?: boolean;
@@ -1041,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
@@ -1051,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
@@ -1069,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
@@ -1117,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

@@ -50,7 +50,6 @@ export const McpConfigurationFileState = {
 export const McpTransport = {
     stdio: "stdio",
     http: "http",
-    sse: "sse",
 };
 export const McpServerResourceState = {
     stopped: "stopped",
@@ -69,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
@@ -391,7 +403,6 @@ export declare const UpdateMcpServerParams: zod.ZodObject<{
 }, zod.z.core.$strict>;
 export declare const UpdateMcpServerBody: zod.ZodObject<{
     transport: zod.ZodOptional<zod.ZodEnum<{
-        sse: "sse";
         stdio: "stdio";
         http: "http";
     }>>;
@@ -426,10 +437,10 @@ export declare const DeleteMcpServerQueryParams: zod.ZodObject<{
  * `tools/call`, `resources/read` or `prompts/get`, and returns the server's response. The
  * machine starts or connects to the server if it is not running, and handles its
  * initialization itself; a request still running when `timeout_seconds` passes is cancelled
- * at the server. Requests the server makes of the client, such as for sampling, are refused,
- * and its notifications, such as of progress, are dropped. A response with a JSON-RPC error
- * is a successful request. Neither the request nor the response is hidden from the
- * platform. Requires `fleet:machines.login` on the machine.
+ * at the server. Requests the server makes of the client are answered as by a client that
+ * offers no sampling, elicitation or roots, and its notifications, such as of progress, are
+ * dropped. A response with a JSON-RPC error is a successful request. Neither the request nor
+ * the response is hidden from the platform. Requires `fleet:machines.login` on the machine.
  *
  * Fails with:
  * - `MCP_SERVER_NOT_FOUND` when the server is not configured;
@@ -521,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>;
 /**
@@ -593,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";
@@ -456,10 +469,10 @@ export const DeleteMcpServerQueryParams = zod.strictObject({
  * `tools/call`, `resources/read` or `prompts/get`, and returns the server's response. The
  * machine starts or connects to the server if it is not running, and handles its
  * initialization itself; a request still running when `timeout_seconds` passes is cancelled
- * at the server. Requests the server makes of the client, such as for sampling, are refused,
- * and its notifications, such as of progress, are dropped. A response with a JSON-RPC error
- * is a successful request. Neither the request nor the response is hidden from the
- * platform. Requires `fleet:machines.login` on the machine.
+ * at the server. Requests the server makes of the client are answered as by a client that
+ * offers no sampling, elicitation or roots, and its notifications, such as of progress, are
+ * dropped. A response with a JSON-RPC error is a successful request. Neither the request nor
+ * the response is hidden from the platform. Requires `fleet:machines.login` on the machine.
  *
  * Fails with:
  * - `MCP_SERVER_NOT_FOUND` when the server is not configured;
@@ -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