@beeuni/sdk 0.2.0 → 0.3.0

package/dist/core/client/beeuni.d.ts

@@ -106,8 +106,66 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
         listMine: typeof P.listMyAccountInvites;
         describe: typeof P.describeAccountInvite;
         accept: typeof P.acceptAccountInvite;
+        acceptAndLand: typeof P.acceptAccountInviteAndLand;
         decline: typeof P.declineAccountInvite;
     };
+    capture: {
+        account: (accountId: string) => {
+            workspace: {
+                get: () => Promise<import("../../index.js").CaptureWorkspace>;
+                setEnabled: (enabled: boolean) => Promise<import("../../index.js").CaptureWorkspace>;
+            };
+            devices: {
+                list: (opts?: Parameters<typeof import("../../index.js").listCaptureDevices>[1]) => Promise<{
+                    devices: import("../../index.js").CaptureDevice[];
+                    health: import("../../index.js").CaptureHealthSummary;
+                }>;
+                revoke: (deviceId: string) => Promise<import("../../index.js").CaptureDevice>;
+                link: (deviceId: string, userId: string | null) => Promise<import("../../index.js").CaptureDevice>;
+                assetUrl: (deviceId: string, name: string) => Promise<import("../../index.js").CaptureSignedUrl>;
+            };
+            enrollment: {
+                tokens: {
+                    list: () => Promise<{
+                        tokens: import("../../index.js").CaptureEnrollmentToken[];
+                    }>;
+                    create: (input: import("../../index.js").CaptureEnrollmentTokenInput) => Promise<import("../../index.js").CaptureEnrollmentTokenSecret>;
+                    revoke: (tokenId: string) => Promise<import("../../index.js").CaptureEnrollmentToken>;
+                };
+                list: (opts?: {
+                    status?: import("../../index.js").CaptureEnrollmentStatus;
+                }) => Promise<{
+                    enrollments: import("../../index.js").CaptureEnrollment[];
+                }>;
+                approve: (enrollmentId: string, userId?: string | null) => Promise<import("../../index.js").CaptureEnrollment>;
+                deny: (enrollmentId: string) => Promise<import("../../index.js").CaptureEnrollment>;
+            };
+            policy: {
+                get: () => Promise<import("../../index.js").CapturePolicyRecord>;
+                set: (policy: import("../../index.js").CapturePolicy) => Promise<import("../../index.js").CapturePolicyRecord>;
+            };
+            timeline: {
+                get: (query?: import("../../index.js").CaptureWindowQuery) => Promise<import("../../index.js").CaptureTimeline>;
+                items: (query?: import("../../index.js").CaptureWindowQuery) => Promise<import("../../index.js").CaptureTimelineItems>;
+                days: (query?: import("../../index.js").CaptureDaysQuery) => Promise<import("../../index.js").CaptureDays>;
+            };
+            search: (query: import("../../index.js").CaptureSearchQuery) => Promise<import("../../index.js").CaptureSearchResult>;
+            frame: (frameId: string, opts?: {
+                userId?: string;
+            }) => Promise<import("../../index.js").CaptureFrameDetail>;
+            media: (chunkId: string, opts?: {
+                userId?: string;
+            }) => Promise<import("../../index.js").CaptureChunkMedia>;
+        };
+        deviceGrant: typeof import("../../index.js").getCaptureDeviceGrant;
+        approveDevice: typeof import("../../index.js").approveCaptureDeviceGrant;
+        denyDevice: typeof import("../../index.js").denyCaptureDeviceGrant;
+        me: {
+            search: typeof import("../../index.js").searchMyCapture;
+            timeline: typeof import("../../index.js").getMyCaptureTimeline;
+            frame: typeof import("../../index.js").getMyCaptureFrame;
+        };
+    };
     projects: {
         list: typeof P.listProjects;
         listForAccount: typeof P.listProjectsForAccount;
@@ -255,6 +313,7 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
             messageAuthors: () => Promise<P.SessionMessageAuthors>;
             modelUsage: () => Promise<P.SessionModelUsage>;
             transcriptSync: (options?: Parameters<typeof P.getSessionTranscriptSync>[2]) => Promise<P.SessionTranscriptSyncEnvelope>;
+            log: (query?: Parameters<typeof P.getSessionLogPage>[2]) => Promise<import("../session-log/index.js").SessionLogPage | null>;
             turn: () => Promise<P.SessionTurnStatus>;
             prompts: {
                 create: (input: P.CreateSessionPromptInput) => Promise<P.CreateSessionPromptResult>;
@@ -273,6 +332,7 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
             };
             ensureReady: (opts?: {
                 readyTimeoutMs?: number;
+                session?: P.ProjectSession;
             }) => Promise<import("../../index.js").SessionRuntimeEntry>;
             get: (opts?: {
                 showErrors?: boolean;
@@ -285,11 +345,20 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
                 keepalive?: boolean;
             }) => Promise<import("../../index.js").ApiResponse<{
                 ok: boolean;
+                awake_until?: string | null;
+                awake_cap_at?: string | null;
             }>>;
             cost: () => Promise<P.SessionCostDetail>;
             update: (input: Parameters<typeof P.updateProjectSession>[2]) => Promise<P.ProjectSession>;
             delete: () => Promise<{
                 ok: boolean;
+                restore_until?: string;
+            }>;
+            restore: () => Promise<{
+                ok: boolean;
+            }>;
+            recover: () => Promise<{
+                ok: true;
             }>;
             start: (options?: (number | {
                 waitMs?: number;
@@ -332,6 +401,8 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
             setWatch: (watching: boolean) => Promise<{
                 watching: boolean;
             }>;
+            setPinned: (pinned: boolean) => Promise<P.SessionListState>;
+            setArchived: (archived: boolean) => Promise<P.SessionListState>;
             commit: (input?: Parameters<typeof P.commitSessionChanges>[2]) => Promise<P.CommitSessionResult>;
             publicShares: {
                 list: () => Promise<{
@@ -457,9 +528,8 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
             claimWarm: (input: Parameters<typeof P.claimWarmProjectSession>[1]) => Promise<P.ProjectSession>;
         };
         review: {
-            list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<{
-                review_items: P.ApiReviewItem[];
-            }>;
+            list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<P.ReviewItemsPage>;
+            summary: () => Promise<P.ReviewSummary>;
             get: (reviewItemId: string) => Promise<{
                 review_item: P.ApiReviewItem;
             }>;
@@ -513,8 +583,9 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
             inviteCollaborator: (githubUsername: string, permission?: "read" | "write" | undefined) => Promise<P.RepoCollaboratorInvite>;
         };
         changeRequests: {
-            list: () => Promise<{
+            list: (status?: "all" | P.ChangeRequestStatus | undefined, options?: P.ListChangeRequestsOptions | undefined) => Promise<{
                 change_requests: P.ChangeRequest[];
+                next_cursor?: string | null;
             }>;
             get: (crId: string) => Promise<P.ChangeRequestDetailResponse>;
             update: (crId: string, input: {
@@ -600,6 +671,7 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
             }>;
             setCredential: (slug: string, credential: string | P.ConnectionCredentialInput) => Promise<{
                 ok: boolean;
+                sync?: P.ConnectorSyncResult;
             }>;
             deleteCredential: (slug: string) => Promise<{
                 ok: boolean;
@@ -815,7 +887,9 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
                 restart: (appId: string, machineId: string) => Promise<P.AppMachine[]>;
                 destroy: (appId: string, machineId: string) => Promise<P.AppMachine[]>;
             };
-            scale: (appId: string, count: Record<string, number>) => Promise<{
+            scale: (appId: string, count: Record<string, number>, options?: {
+                newVolumes?: boolean;
+            } | undefined) => Promise<{
                 scale: Record<string, number>;
                 machines: P.AppMachine[];
             }>;
@@ -1020,6 +1094,7 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
         messageAuthors: () => Promise<P.SessionMessageAuthors>;
         modelUsage: () => Promise<P.SessionModelUsage>;
         transcriptSync: (options?: Parameters<typeof P.getSessionTranscriptSync>[2]) => Promise<P.SessionTranscriptSyncEnvelope>;
+        log: (query?: Parameters<typeof P.getSessionLogPage>[2]) => Promise<import("../session-log/index.js").SessionLogPage | null>;
         turn: () => Promise<P.SessionTurnStatus>;
         prompts: {
             create: (input: P.CreateSessionPromptInput) => Promise<P.CreateSessionPromptResult>;
@@ -1038,6 +1113,7 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
         };
         ensureReady: (opts?: {
             readyTimeoutMs?: number;
+            session?: P.ProjectSession;
         }) => Promise<import("../../index.js").SessionRuntimeEntry>;
         get: (opts?: {
             showErrors?: boolean;
@@ -1050,11 +1126,20 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
             keepalive?: boolean;
         }) => Promise<import("../../index.js").ApiResponse<{
             ok: boolean;
+            awake_until?: string | null;
+            awake_cap_at?: string | null;
         }>>;
         cost: () => Promise<P.SessionCostDetail>;
         update: (input: Parameters<typeof P.updateProjectSession>[2]) => Promise<P.ProjectSession>;
         delete: () => Promise<{
             ok: boolean;
+            restore_until?: string;
+        }>;
+        restore: () => Promise<{
+            ok: boolean;
+        }>;
+        recover: () => Promise<{
+            ok: true;
         }>;
         start: (options?: (number | {
             waitMs?: number;
@@ -1097,6 +1182,8 @@ export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
         setWatch: (watching: boolean) => Promise<{
             watching: boolean;
         }>;
+        setPinned: (pinned: boolean) => Promise<P.SessionListState>;
+        setArchived: (archived: boolean) => Promise<P.SessionListState>;
         commit: (input?: Parameters<typeof P.commitSessionChanges>[2]) => Promise<P.CommitSessionResult>;
         publicShares: {
             list: () => Promise<{

package/dist/core/client/beeuni.js

@@ -1,4 +1,5 @@
 import { bindCatalog } from './facade-catalog.js';
+import { captureClient } from './capture.js';
 import { bindCommerce } from './facade-commerce.js';
 import { bindIdentity } from './facade-identity.js';
 import { bindPreviewOptions } from './facade-preview.js';
@@ -60,6 +61,7 @@ export function createBeeuni(config, opts) {
         accounts,
         iam,
         accountInvites,
+        capture: captureClient,
         projects,
         connectors: connectorDataPlane(),
         connector: (slug) => connectorHandle(undefined, slug),

package/dist/core/client/capture.d.ts

@@ -0,0 +1,105 @@
+import * as C from '../rest/platform-client/capture.js';
+export declare function bindAccountCapture(accountId: string): {
+    workspace: {
+        get: () => Promise<C.CaptureWorkspace>;
+        setEnabled: (enabled: boolean) => Promise<C.CaptureWorkspace>;
+    };
+    devices: {
+        list: (opts?: Parameters<typeof C.listCaptureDevices>[1]) => Promise<{
+            devices: C.CaptureDevice[];
+            health: C.CaptureHealthSummary;
+        }>;
+        revoke: (deviceId: string) => Promise<C.CaptureDevice>;
+        link: (deviceId: string, userId: string | null) => Promise<C.CaptureDevice>;
+        assetUrl: (deviceId: string, name: string) => Promise<C.CaptureSignedUrl>;
+    };
+    enrollment: {
+        tokens: {
+            list: () => Promise<{
+                tokens: C.CaptureEnrollmentToken[];
+            }>;
+            create: (input: C.CaptureEnrollmentTokenInput) => Promise<C.CaptureEnrollmentTokenSecret>;
+            revoke: (tokenId: string) => Promise<C.CaptureEnrollmentToken>;
+        };
+        list: (opts?: {
+            status?: C.CaptureEnrollmentStatus;
+        }) => Promise<{
+            enrollments: C.CaptureEnrollment[];
+        }>;
+        approve: (enrollmentId: string, userId?: string | null) => Promise<C.CaptureEnrollment>;
+        deny: (enrollmentId: string) => Promise<C.CaptureEnrollment>;
+    };
+    policy: {
+        get: () => Promise<C.CapturePolicyRecord>;
+        set: (policy: C.CapturePolicy) => Promise<C.CapturePolicyRecord>;
+    };
+    timeline: {
+        get: (query?: C.CaptureWindowQuery) => Promise<C.CaptureTimeline>;
+        items: (query?: C.CaptureWindowQuery) => Promise<C.CaptureTimelineItems>;
+        days: (query?: C.CaptureDaysQuery) => Promise<C.CaptureDays>;
+    };
+    search: (query: C.CaptureSearchQuery) => Promise<C.CaptureSearchResult>;
+    frame: (frameId: string, opts?: {
+        userId?: string;
+    }) => Promise<C.CaptureFrameDetail>;
+    media: (chunkId: string, opts?: {
+        userId?: string;
+    }) => Promise<C.CaptureChunkMedia>;
+};
+export declare const captureClient: {
+    account: (accountId: string) => {
+        workspace: {
+            get: () => Promise<C.CaptureWorkspace>;
+            setEnabled: (enabled: boolean) => Promise<C.CaptureWorkspace>;
+        };
+        devices: {
+            list: (opts?: Parameters<typeof C.listCaptureDevices>[1]) => Promise<{
+                devices: C.CaptureDevice[];
+                health: C.CaptureHealthSummary;
+            }>;
+            revoke: (deviceId: string) => Promise<C.CaptureDevice>;
+            link: (deviceId: string, userId: string | null) => Promise<C.CaptureDevice>;
+            assetUrl: (deviceId: string, name: string) => Promise<C.CaptureSignedUrl>;
+        };
+        enrollment: {
+            tokens: {
+                list: () => Promise<{
+                    tokens: C.CaptureEnrollmentToken[];
+                }>;
+                create: (input: C.CaptureEnrollmentTokenInput) => Promise<C.CaptureEnrollmentTokenSecret>;
+                revoke: (tokenId: string) => Promise<C.CaptureEnrollmentToken>;
+            };
+            list: (opts?: {
+                status?: C.CaptureEnrollmentStatus;
+            }) => Promise<{
+                enrollments: C.CaptureEnrollment[];
+            }>;
+            approve: (enrollmentId: string, userId?: string | null) => Promise<C.CaptureEnrollment>;
+            deny: (enrollmentId: string) => Promise<C.CaptureEnrollment>;
+        };
+        policy: {
+            get: () => Promise<C.CapturePolicyRecord>;
+            set: (policy: C.CapturePolicy) => Promise<C.CapturePolicyRecord>;
+        };
+        timeline: {
+            get: (query?: C.CaptureWindowQuery) => Promise<C.CaptureTimeline>;
+            items: (query?: C.CaptureWindowQuery) => Promise<C.CaptureTimelineItems>;
+            days: (query?: C.CaptureDaysQuery) => Promise<C.CaptureDays>;
+        };
+        search: (query: C.CaptureSearchQuery) => Promise<C.CaptureSearchResult>;
+        frame: (frameId: string, opts?: {
+            userId?: string;
+        }) => Promise<C.CaptureFrameDetail>;
+        media: (chunkId: string, opts?: {
+            userId?: string;
+        }) => Promise<C.CaptureChunkMedia>;
+    };
+    deviceGrant: typeof C.getCaptureDeviceGrant;
+    approveDevice: typeof C.approveCaptureDeviceGrant;
+    denyDevice: typeof C.denyCaptureDeviceGrant;
+    me: {
+        search: typeof C.searchMyCapture;
+        timeline: typeof C.getMyCaptureTimeline;
+        frame: typeof C.getMyCaptureFrame;
+    };
+};

package/dist/core/client/capture.js

@@ -0,0 +1,48 @@
+import * as C from '../rest/platform-client/capture.js';
+export function bindAccountCapture(accountId) {
+    return {
+        workspace: {
+            get: () => C.getCaptureWorkspace(accountId),
+            setEnabled: (enabled) => C.setCaptureEnabled(accountId, enabled),
+        },
+        devices: {
+            list: (opts) => C.listCaptureDevices(accountId, opts),
+            revoke: (deviceId) => C.revokeCaptureDevice(accountId, deviceId),
+            link: (deviceId, userId) => C.linkCaptureDevice(accountId, deviceId, userId),
+            assetUrl: (deviceId, name) => C.getCaptureAssetUrl(accountId, deviceId, name),
+        },
+        enrollment: {
+            tokens: {
+                list: () => C.listCaptureEnrollmentTokens(accountId),
+                create: (input) => C.createCaptureEnrollmentToken(accountId, input),
+                revoke: (tokenId) => C.revokeCaptureEnrollmentToken(accountId, tokenId),
+            },
+            list: (opts) => C.listCaptureEnrollments(accountId, opts),
+            approve: (enrollmentId, userId) => C.approveCaptureEnrollment(accountId, enrollmentId, userId),
+            deny: (enrollmentId) => C.denyCaptureEnrollment(accountId, enrollmentId),
+        },
+        policy: {
+            get: () => C.getCapturePolicy(accountId),
+            set: (policy) => C.setCapturePolicy(accountId, policy),
+        },
+        timeline: {
+            get: (query) => C.getCaptureTimeline(accountId, query),
+            items: (query) => C.getCaptureTimelineItems(accountId, query),
+            days: (query) => C.getCaptureDays(accountId, query),
+        },
+        search: (query) => C.searchCapture(accountId, query),
+        frame: (frameId, opts) => C.getCaptureFrame(accountId, frameId, opts),
+        media: (chunkId, opts) => C.getCaptureChunkMedia(accountId, chunkId, opts),
+    };
+}
+export const captureClient = {
+    account: (accountId) => bindAccountCapture(accountId),
+    deviceGrant: C.getCaptureDeviceGrant,
+    approveDevice: C.approveCaptureDeviceGrant,
+    denyDevice: C.denyCaptureDeviceGrant,
+    me: {
+        search: C.searchMyCapture,
+        timeline: C.getMyCaptureTimeline,
+        frame: C.getMyCaptureFrame,
+    },
+};

package/dist/core/client/facade-identity.d.ts

@@ -98,6 +98,7 @@ export declare function bindIdentity(): {
         listMine: typeof P.listMyAccountInvites;
         describe: typeof P.describeAccountInvite;
         accept: typeof P.acceptAccountInvite;
+        acceptAndLand: typeof P.acceptAccountInviteAndLand;
         decline: typeof P.declineAccountInvite;
     };
 };

package/dist/core/client/facade-identity.js

@@ -27,6 +27,7 @@ export function bindIdentity() {
         listMine: P.listMyAccountInvites,
         describe: P.describeAccountInvite,
         accept: P.acceptAccountInvite,
+        acceptAndLand: P.acceptAccountInviteAndLand,
         decline: P.declineAccountInvite,
     };
     return { auth, accounts, iam, accountInvites };

package/dist/core/client/project-access-resources.d.ts

@@ -40,7 +40,9 @@ export declare function bindProjectAccessResources(projectId: string): {
             restart: (appId: string, machineId: string) => Promise<P.AppMachine[]>;
             destroy: (appId: string, machineId: string) => Promise<P.AppMachine[]>;
         };
-        scale: (appId: string, count: Record<string, number>) => Promise<{
+        scale: (appId: string, count: Record<string, number>, options?: {
+            newVolumes?: boolean;
+        } | undefined) => Promise<{
             scale: Record<string, number>;
             machines: P.AppMachine[];
         }>;

package/dist/core/client/project-access-resources.js

@@ -37,7 +37,7 @@ export function bindProjectAccessResources(projectId) {
                 restart: (appId, machineId) => P.restartAppMachine(projectId, appId, machineId),
                 destroy: (appId, machineId) => P.destroyAppMachine(projectId, appId, machineId),
             },
-            scale: (appId, count) => P.scaleApp(projectId, appId, count),
+            scale: (...a) => P.scaleApp(projectId, ...a),
             exec: (...a) => P.execInApp(projectId, ...a),
             volumes: {
                 list: (appId) => P.listAppVolumes(projectId, appId),

package/dist/core/client/project-operations-admin.d.ts

@@ -8,9 +8,8 @@ export declare function bindProjectOperationsAdmin(projectId: string): {
         claimWarm: (input: Parameters<typeof P.claimWarmProjectSession>[1]) => Promise<P.ProjectSession>;
     };
     review: {
-        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<{
-            review_items: P.ApiReviewItem[];
-        }>;
+        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<P.ReviewItemsPage>;
+        summary: () => Promise<P.ReviewSummary>;
         get: (reviewItemId: string) => Promise<{
             review_item: P.ApiReviewItem;
         }>;
@@ -64,8 +63,9 @@ export declare function bindProjectOperationsAdmin(projectId: string): {
         inviteCollaborator: (githubUsername: string, permission?: "read" | "write" | undefined) => Promise<P.RepoCollaboratorInvite>;
     };
     changeRequests: {
-        list: () => Promise<{
+        list: (status?: "all" | P.ChangeRequestStatus | undefined, options?: P.ListChangeRequestsOptions | undefined) => Promise<{
             change_requests: P.ChangeRequest[];
+            next_cursor?: string | null;
         }>;
         get: (crId: string) => Promise<P.ChangeRequestDetailResponse>;
         update: (crId: string, input: {

package/dist/core/client/project-operations-review.d.ts

@@ -9,9 +9,8 @@ export declare function bindProjectOperationsReview(projectId: string): {
         claimWarm: (input: Parameters<typeof P.claimWarmProjectSession>[1]) => Promise<P.ProjectSession>;
     };
     review: {
-        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<{
-            review_items: P.ApiReviewItem[];
-        }>;
+        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<P.ReviewItemsPage>;
+        summary: () => Promise<P.ReviewSummary>;
         get: (reviewItemId: string) => Promise<{
             review_item: P.ApiReviewItem;
         }>;

package/dist/core/client/project-operations-review.js

@@ -10,6 +10,7 @@ export function bindProjectOperationsReview(projectId) {
         },
         review: {
             list: (params) => P.listReviewItems(projectId, params),
+            summary: () => P.getReviewSummary(projectId),
             get: (reviewItemId) => P.getReviewItem(projectId, reviewItemId),
             submit: (input) => P.submitReviewItem(projectId, input),
             act: (...a) => P.actReviewItem(projectId, ...a),

package/dist/core/client/project-operations-workspace.d.ts

@@ -8,9 +8,8 @@ export declare function bindProjectOperationsWorkspace(projectId: string): {
         claimWarm: (input: Parameters<typeof P.claimWarmProjectSession>[1]) => Promise<P.ProjectSession>;
     };
     review: {
-        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<{
-            review_items: P.ApiReviewItem[];
-        }>;
+        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<P.ReviewItemsPage>;
+        summary: () => Promise<P.ReviewSummary>;
         get: (reviewItemId: string) => Promise<{
             review_item: P.ApiReviewItem;
         }>;
@@ -64,8 +63,9 @@ export declare function bindProjectOperationsWorkspace(projectId: string): {
         inviteCollaborator: (githubUsername: string, permission?: "read" | "write" | undefined) => Promise<P.RepoCollaboratorInvite>;
     };
     changeRequests: {
-        list: () => Promise<{
+        list: (status?: "all" | P.ChangeRequestStatus | undefined, options?: P.ListChangeRequestsOptions | undefined) => Promise<{
             change_requests: P.ChangeRequest[];
+            next_cursor?: string | null;
         }>;
         get: (crId: string) => Promise<P.ChangeRequestDetailResponse>;
         update: (crId: string, input: {

package/dist/core/client/project-operations-workspace.js

@@ -20,7 +20,7 @@ export function bindProjectOperationsWorkspace(projectId) {
             inviteCollaborator: (...a) => P.inviteRepoCollaborator(projectId, ...a),
         },
         changeRequests: {
-            list: () => P.listChangeRequests(projectId),
+            list: (...a) => P.listChangeRequests(projectId, ...a),
             get: (crId) => P.getChangeRequest(projectId, crId),
             update: (...a) => P.updateChangeRequest(projectId, ...a),
             diff: (crId) => P.getChangeRequestDiff(projectId, crId),

package/dist/core/client/project-operations.d.ts

@@ -9,9 +9,8 @@ export declare function bindProjectOperations(projectId: string, connections: Re
         claimWarm: (input: Parameters<typeof P.claimWarmProjectSession>[1]) => Promise<P.ProjectSession>;
     };
     review: {
-        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<{
-            review_items: P.ApiReviewItem[];
-        }>;
+        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<P.ReviewItemsPage>;
+        summary: () => Promise<P.ReviewSummary>;
         get: (reviewItemId: string) => Promise<{
             review_item: P.ApiReviewItem;
         }>;
@@ -65,8 +64,9 @@ export declare function bindProjectOperations(projectId: string, connections: Re
         inviteCollaborator: (githubUsername: string, permission?: "read" | "write" | undefined) => Promise<P.RepoCollaboratorInvite>;
     };
     changeRequests: {
-        list: () => Promise<{
+        list: (status?: "all" | P.ChangeRequestStatus | undefined, options?: P.ListChangeRequestsOptions | undefined) => Promise<{
             change_requests: P.ChangeRequest[];
+            next_cursor?: string | null;
         }>;
         get: (crId: string) => Promise<P.ChangeRequestDetailResponse>;
         update: (crId: string, input: {
@@ -152,6 +152,7 @@ export declare function bindProjectOperations(projectId: string, connections: Re
         }>;
         setCredential: (slug: string, credential: string | P.ConnectionCredentialInput) => Promise<{
             ok: boolean;
+            sync?: P.ConnectorSyncResult;
         }>;
         deleteCredential: (slug: string) => Promise<{
             ok: boolean;

package/dist/core/client/session-context.d.ts

@@ -1,3 +1,4 @@
+import type { ProjectSession } from '../rest/projects-client/sessions.js';
 import type { ResolvedPreviewOptions } from '../session/preview-options.js';
 import type { SessionRuntimeEntry } from '../session/session-runtime-registry.js';
 import type { SessionModel } from './session-shared.js';
@@ -6,6 +7,7 @@ export type SessionBindingContext = {
     sessionId: string;
     ensureReady: (opts?: {
         readyTimeoutMs?: number;
+        session?: ProjectSession;
     }) => Promise<SessionRuntimeEntry>;
     tryResolveReady: () => SessionRuntimeEntry | null;
     requireReady: (action: string) => SessionRuntimeEntry;

package/dist/core/client/session-handle.d.ts

@@ -115,6 +115,7 @@ export declare function session(projectId: string, sessionId: string, config: Be
     messageAuthors: () => Promise<import("../../index.js").SessionMessageAuthors>;
     modelUsage: () => Promise<import("../../index.js").SessionModelUsage>;
     transcriptSync: (options?: Parameters<typeof import("../../index.js").getSessionTranscriptSync>[2]) => Promise<import("../../index.js").SessionTranscriptSyncEnvelope>;
+    log: (query?: Parameters<typeof import("../../index.js").getSessionLogPage>[2]) => Promise<import("../session-log/index.js").SessionLogPage | null>;
     turn: () => Promise<import("../../index.js").SessionTurnStatus>;
     prompts: {
         create: (input: import("../../index.js").CreateSessionPromptInput) => Promise<import("../../index.js").CreateSessionPromptResult>;
@@ -133,6 +134,7 @@ export declare function session(projectId: string, sessionId: string, config: Be
     };
     ensureReady: (opts?: {
         readyTimeoutMs?: number;
+        session?: import("../../index.js").ProjectSession;
     }) => Promise<import("../../index.js").SessionRuntimeEntry>;
     get: (opts?: {
         showErrors?: boolean;
@@ -145,11 +147,20 @@ export declare function session(projectId: string, sessionId: string, config: Be
         keepalive?: boolean;
     }) => Promise<import("../../index.js").ApiResponse<{
         ok: boolean;
+        awake_until?: string | null;
+        awake_cap_at?: string | null;
     }>>;
     cost: () => Promise<import("../../index.js").SessionCostDetail>;
     update: (input: Parameters<typeof import("../../index.js").updateProjectSession>[2]) => Promise<import("../../index.js").ProjectSession>;
     delete: () => Promise<{
         ok: boolean;
+        restore_until?: string;
+    }>;
+    restore: () => Promise<{
+        ok: boolean;
+    }>;
+    recover: () => Promise<{
+        ok: true;
     }>;
     start: (options?: (number | {
         waitMs?: number;
@@ -192,6 +203,8 @@ export declare function session(projectId: string, sessionId: string, config: Be
     setWatch: (watching: boolean) => Promise<{
         watching: boolean;
     }>;
+    setPinned: (pinned: boolean) => Promise<import("../../index.js").SessionListState>;
+    setArchived: (archived: boolean) => Promise<import("../../index.js").SessionListState>;
     commit: (input?: Parameters<typeof import("../../index.js").commitSessionChanges>[2]) => Promise<import("../../index.js").CommitSessionResult>;
     publicShares: {
         list: () => Promise<{

package/dist/core/client/session-lifecycle-resources.d.ts

@@ -13,11 +13,20 @@ export declare function bindSessionLifecycleResources(ctx: SessionBindingContext
         keepalive?: boolean;
     }) => Promise<import("../../index.js").ApiResponse<{
         ok: boolean;
+        awake_until?: string | null;
+        awake_cap_at?: string | null;
     }>>;
     cost: () => Promise<P.SessionCostDetail>;
     update: (input: Parameters<typeof P.updateProjectSession>[2]) => Promise<P.ProjectSession>;
     delete: () => Promise<{
         ok: boolean;
+        restore_until?: string;
+    }>;
+    restore: () => Promise<{
+        ok: boolean;
+    }>;
+    recover: () => Promise<{
+        ok: true;
     }>;
     start: (options?: (number | {
         waitMs?: number;
@@ -60,6 +69,8 @@ export declare function bindSessionLifecycleResources(ctx: SessionBindingContext
     setWatch: (watching: boolean) => Promise<{
         watching: boolean;
     }>;
+    setPinned: (pinned: boolean) => Promise<P.SessionListState>;
+    setArchived: (archived: boolean) => Promise<P.SessionListState>;
     commit: (input?: Parameters<typeof P.commitSessionChanges>[2]) => Promise<P.CommitSessionResult>;
     publicShares: {
         list: () => Promise<{

package/dist/core/client/session-lifecycle-resources.js

@@ -10,6 +10,8 @@ export function bindSessionLifecycleResources(ctx) {
             ctx.forgetReady();
             return P.deleteProjectSession(ctx.projectId, ctx.sessionId);
         },
+        restore: () => P.restoreProjectSession(ctx.projectId, ctx.sessionId),
+        recover: () => P.recoverProjectSession(ctx.projectId, ctx.sessionId),
         start: (...a) => P.startProjectSession(ctx.projectId, ctx.sessionId, ...a),
         startOrThrow: (...a) => P.startProjectSessionOrThrow(ctx.projectId, ctx.sessionId, ...a),
         restart: () => {
@@ -34,6 +36,8 @@ export function bindSessionLifecycleResources(ctx) {
         participants: () => P.getSessionParticipants(ctx.projectId, ctx.sessionId),
         watch: () => P.getSessionWatch(ctx.projectId, ctx.sessionId),
         setWatch: (watching) => P.setSessionWatch(ctx.projectId, ctx.sessionId, watching),
+        setPinned: (pinned) => P.setSessionPinned(ctx.projectId, ctx.sessionId, pinned),
+        setArchived: (archived) => P.setSessionArchived(ctx.projectId, ctx.sessionId, archived),
         commit: (input) => P.commitSessionChanges(ctx.projectId, ctx.sessionId, input),
         publicShares: {
             list: () => P.listSessionPublicShares(ctx.projectId, ctx.sessionId),

package/dist/core/client/session-lifecycle-security.d.ts

@@ -20,6 +20,7 @@ export declare function bindSessionLifecycleSecurity(ctx: SessionBindingContext)
     messageAuthors: () => Promise<P.SessionMessageAuthors>;
     modelUsage: () => Promise<P.SessionModelUsage>;
     transcriptSync: (options?: Parameters<typeof P.getSessionTranscriptSync>[2]) => Promise<P.SessionTranscriptSyncEnvelope>;
+    log: (query?: Parameters<typeof P.getSessionLogPage>[2]) => Promise<import("../session-log/index.js").SessionLogPage | null>;
     turn: () => Promise<P.SessionTurnStatus>;
     prompts: {
         create: (input: P.CreateSessionPromptInput) => Promise<P.CreateSessionPromptResult>;
@@ -38,5 +39,6 @@ export declare function bindSessionLifecycleSecurity(ctx: SessionBindingContext)
     };
     ensureReady: (opts?: {
         readyTimeoutMs?: number;
+        session?: P.ProjectSession;
     }) => Promise<import("../../index.js").SessionRuntimeEntry>;
 };

package/dist/core/client/session-lifecycle-security.js

@@ -16,6 +16,7 @@ export function bindSessionLifecycleSecurity(ctx) {
         messageAuthors: () => P.getSessionMessageAuthors(ctx.projectId, ctx.sessionId),
         modelUsage: () => P.getSessionModelUsage(ctx.projectId, ctx.sessionId),
         transcriptSync: (options) => P.getSessionTranscriptSync(ctx.projectId, ctx.sessionId, options),
+        log: (query) => P.getSessionLogPage(ctx.projectId, ctx.sessionId, query),
         turn: () => P.getSessionTurn(ctx.projectId, ctx.sessionId),
         prompts: {
             create: (input) => P.createSessionPrompt(ctx.projectId, ctx.sessionId, input),