@opengeni/sdk 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/sdk",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Framework-agnostic TypeScript SDK for the OpenGeni API: typed client, session lifecycle, SSE event streaming with reconnect + replay-by-sequence, and proxy re-streaming helpers.",
   "license": "Apache-2.0",
   "repository": {
@@ -36,6 +36,7 @@
   },
   "devDependencies": {
     "@opengeni/contracts": "workspace:*",
+    "@opengeni/deployment": "workspace:*",
     "tsup": "^8.5.0",
     "typescript": "^6.0.3",
     "zod": "^4.2.1"

package/src/client.ts

@@ -2,6 +2,7 @@ import { OpenGeniApiError } from "./errors";
 import { streamSessionEvents, type SessionEventStreamTransport, type StreamSessionEventsOptions } from "./stream";
 import type {
   AccessContext,
+  AddWorkspaceMemberRequest,
   ApiKey,
   BillingEntitlementsResponse,
   BillingSummary,
@@ -9,6 +10,7 @@ import type {
   CapabilityCatalogItem,
   CapabilityCatalogResponse,
   CapabilityInstallation,
+  ClientConfig,
   ClientSessionEventInput,
   CompactSessionContextResult,
   CompleteFileUploadResponse,
@@ -39,6 +41,7 @@ import type {
   GitHubRepositoriesResponse,
   ListApiKeysResponse,
   ListPacksResponse,
+  ListWorkspaceMembersResponse,
   PackInstallation,
   ReasoningEffort,
   RegisterCapabilityPackRequest,
@@ -49,15 +52,53 @@ import type {
   SessionEvent,
   SessionGoal,
   SessionTurn,
+  // Stream surfacing (Phase 5): capability negotiation + viewer lifecycle + config.
+  SessionCapabilities,
+  AttachViewerRequest,
+  AttachViewerResponse,
+  AcknowledgeStreamRequest,
+  AcknowledgeStreamResponse,
+  ViewerHeartbeatRequest,
+  ViewerHeartbeatResponse,
+  // Channel-A structured services (P4.4).
+  FsListRequest,
+  FsListResponse,
+  FsReadRequest,
+  FsReadResponse,
+  FsWriteRequest,
+  FsWriteResponse,
+  FsDeleteRequest,
+  FsDeleteResponse,
+  FsMoveRequest,
+  FsMoveResponse,
+  FsMkdirRequest,
+  FsMkdirResponse,
+  GitStatusRequest,
+  GitStatusResponse,
+  GitDiffRequest,
+  GitDiffResponse,
+  GitLogRequest,
+  GitLogResponse,
+  GitShowRequest,
+  GitShowResponse,
+  TerminalExecRequest,
+  TerminalExecResponse,
+  PtyOpenRequest,
+  PtyOpenResponse,
+  PtyWriteRequest,
+  PtyResizeRequest,
+  PtyCloseRequest,
   ToolRef,
   UpdateScheduledTaskRequest,
   UpdateSessionGoalRequest,
   UpdateSessionTurnRequest,
   UpdateWorkspaceEnvironmentRequest,
+  UpdateWorkspaceMemberRequest,
   UpdateWorkspaceRequest,
   UploadFileInput,
   WorkspaceEnvironment,
   WorkspaceEnvironmentVariableMetadata,
+  WorkspaceMember,
   WorkspaceRegisteredPack,
   Workspace,
 } from "./types";
@@ -398,8 +439,157 @@ export class OpenGeniClient {
     return await this.requestJson<CompactSessionContextResult>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/context/compact`, {});
   }
 
+  // --- Channel-A structured services (P4.4) ------------------------------------
+  // FileSystem (Pierre tree), Git (Pierre diff), Terminal (exec + PTY). Each is a
+  // synchronous API-direct point query; the fs.changed/git.changed/terminal.pty.*
+  // notifications + the PTY output stream arrive on the existing event SSE.
+
+  /** FileSystem: list a directory tree (feeds the Pierre file tree). */
+  async fsList(workspaceId: string, sessionId: string, request: FsListRequest = {}): Promise<FsListResponse> {
+    return await this.requestJson<FsListResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/fs/list`, request);
+  }
+
+  /** FileSystem: read a file (text or base64; binary-safe, size-capped). */
+  async fsRead(workspaceId: string, sessionId: string, request: FsReadRequest): Promise<FsReadResponse> {
+    return await this.requestJson<FsReadResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/fs/read`, request);
+  }
+
+  /** FileSystem: write a file (last-writer-wins; emits fs.changed). */
+  async fsWrite(workspaceId: string, sessionId: string, request: FsWriteRequest): Promise<FsWriteResponse> {
+    return await this.requestJson<FsWriteResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/fs/write`, request);
+  }
+
+  /** FileSystem: delete a path (emits fs.changed). */
+  async fsDelete(workspaceId: string, sessionId: string, request: FsDeleteRequest): Promise<FsDeleteResponse> {
+    return await this.requestJson<FsDeleteResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/fs/delete`, request);
+  }
+
+  /** FileSystem: move/rename a path (emits fs.changed; 409 if destination exists and overwrite is false). */
+  async fsMove(workspaceId: string, sessionId: string, request: FsMoveRequest): Promise<FsMoveResponse> {
+    return await this.requestJson<FsMoveResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/fs/move`, request);
+  }
+
+  /** FileSystem: create a directory (emits fs.changed; recursive defaults to true). */
+  async fsMkdir(workspaceId: string, sessionId: string, request: FsMkdirRequest): Promise<FsMkdirResponse> {
+    return await this.requestJson<FsMkdirResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/fs/mkdir`, request);
+  }
+
+  /** Git: working-tree/index status (the Pierre file-status feed). */
+  async gitStatus(workspaceId: string, sessionId: string, request: GitStatusRequest = {}): Promise<GitStatusResponse> {
+    return await this.requestJson<GitStatusResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/git/status`, request);
+  }
+
+  /** Git: structured diff hunks (the Pierre diff feed). */
+  async gitDiff(workspaceId: string, sessionId: string, request: GitDiffRequest = {}): Promise<GitDiffResponse> {
+    return await this.requestJson<GitDiffResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/git/diff`, request);
+  }
+
+  /** Git: commit log. */
+  async gitLog(workspaceId: string, sessionId: string, request: GitLogRequest = {}): Promise<GitLogResponse> {
+    return await this.requestJson<GitLogResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/git/log`, request);
+  }
+
+  /** Git: show a commit (diff vs first parent) or fetch a raw blob at a ref. */
+  async gitShow(workspaceId: string, sessionId: string, request: GitShowRequest): Promise<GitShowResponse> {
+    return await this.requestJson<GitShowResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/git/show`, request);
+  }
+
+  /** Terminal: run a bounded command, returning buffered stdout/stderr inline. */
+  async terminalExec(workspaceId: string, sessionId: string, request: TerminalExecRequest): Promise<TerminalExecResponse> {
+    return await this.requestJson<TerminalExecResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/terminal/exec`, request);
+  }
+
+  /** Terminal: open an interactive PTY. Output streams on the event SSE as
+   *  terminal.pty.output.delta; drive it with terminalPtyWrite. */
+  async terminalPtyOpen(workspaceId: string, sessionId: string, request: PtyOpenRequest = {}): Promise<PtyOpenResponse> {
+    return await this.requestJson<PtyOpenResponse>("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/terminal/pty`, request);
+  }
+
+  /** Terminal: send stdin to an open PTY (output rides A1). */
+  async terminalPtyWrite(workspaceId: string, sessionId: string, request: PtyWriteRequest): Promise<void> {
+    await this.requestVoid("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/terminal/pty/write`, request);
+  }
+
+  /** Terminal: resize an open PTY. */
+  async terminalPtyResize(workspaceId: string, sessionId: string, request: PtyResizeRequest): Promise<void> {
+    await this.requestVoid("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/terminal/pty/resize`, request);
+  }
+
+  /** Terminal: close an open PTY (idempotent). */
+  async terminalPtyClose(workspaceId: string, sessionId: string, request: PtyCloseRequest): Promise<void> {
+    await this.requestVoid("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/terminal/pty/close`, request);
+  }
+
+  // --- Stream surfacing: capability negotiation + viewer lifecycle (Phase 5) ---
+  // The capability doc is the single source of UI truth (degradation is always a
+  // value, never a crash). The desktop pixel plane (Channel B) is gated behind an
+  // un-redacted-acknowledgment + a viewer holder; the structured terminal/files/
+  // git surfaces (Channel A) ride the methods above and the event SSE.
+
+  /** Read the negotiated capability doc for a session WITHOUT acquiring a viewer
+   *  holder (no warm, no spawn). Drives capability-gated rendering: which
+   *  surfaces mount, the per-surface unavailability reasons, and the lease
+   *  liveness the client polls on while `cold`/`warming`. The desktop URL/token
+   *  are minted in-process only when the box is warm AND the principal has
+   *  acknowledged the un-redacted plane. */
+  async getStreamCapabilities(workspaceId: string, sessionId: string): Promise<SessionCapabilities> {
+    return await this.requestJson<SessionCapabilities>(
+      "GET", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/stream-capabilities`);
+  }
+
+  /** Record the calling principal's acknowledgment of the un-redacted desktop
+   *  pixel plane (and, when the box is shared, the shared-exposure disclosure).
+   *  The desktop viewer-attach path returns 409 until this is recorded. */
+  async acknowledgeStream(
+    workspaceId: string, sessionId: string, request: AcknowledgeStreamRequest = {},
+  ): Promise<AcknowledgeStreamResponse> {
+    return await this.requestJson<AcknowledgeStreamResponse>(
+      "POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/stream-capabilities/acknowledge`, request);
+  }
+
+  /** Attach a viewer holder (refcounted liveness — keeps the box warm while
+   *  watched/used), spinning the box up in-process when cold, and mint the scoped
+   *  direct-to-provider URLs for the requested plane(s). `request.desktop:true`
+   *  opts into the un-redacted pixel plane and mints the noVNC URL — that plane
+   *  alone throws `OpenGeniApiError(409)` when the un-redacted/shared
+   *  acknowledgment is missing (the consent gate). A terminal-only attach
+   *  (`desktop` omitted/false) warms the box + mints the pty-ws terminal cell with
+   *  NO consent gate. An omitted `viewerId` mints a fresh one. */
+  async attachViewer(
+    workspaceId: string, sessionId: string, request: AttachViewerRequest = {},
+  ): Promise<AttachViewerResponse> {
+    return await this.requestJson<AttachViewerResponse>(
+      "POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/viewers`, request);
+  }
+
+  /** Heartbeat a viewer holder (Channel-A app-level liveness). A closed laptop
+   *  stops sending these → the reaper drops the holder within ~90s. Echoes
+   *  `leaseEpoch` so a superseded epoch is rejected (`alive:false` → re-attach). */
+  async heartbeatViewer(
+    workspaceId: string, sessionId: string, viewerId: string, request: ViewerHeartbeatRequest,
+  ): Promise<ViewerHeartbeatResponse> {
+    return await this.requestJson<ViewerHeartbeatResponse>(
+      "POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/viewers/${viewerId}/heartbeat`, request);
+  }
+
+  /** Detach a viewer (delete this holder; idempotent delete-my-row). */
+  async detachViewer(workspaceId: string, sessionId: string, viewerId: string): Promise<void> {
+    await this.requestVoid("DELETE", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/viewers/${viewerId}`);
+  }
+
   // --- Access + workspaces -----------------------------------------------------
 
+  /**
+   * The deployment's public client bootstrap config: the host-exposed models
+   * (provider-grouped in `models`, flat in `allowedModels` for back-compat),
+   * reasoning efforts, MCP servers, file-upload limits, and how the client is
+   * expected to authenticate. Drives a composer's model picker without prior
+   * knowledge of the host setup; safe to call before any auth is established.
+   */
+  async getClientConfig(): Promise<ClientConfig> {
+    return await this.requestJson<ClientConfig>("GET", "/v1/config/client");
+  }
+
   /** The caller's access context: subject, account + workspace grants, defaults. */
   async getAccessContext(): Promise<AccessContext> {
     return await this.requestJson<AccessContext>("GET", "/v1/access/me");
@@ -421,6 +611,46 @@ export class OpenGeniClient {
     return await this.requestJson<Workspace>("PATCH", `/v1/workspaces/${workspaceId}`, request);
   }
 
+  /**
+   * Delete a workspace and everything in it. Refused (409) for the account's
+   * only workspace and while it still has a running session. Irreversible.
+   */
+  async deleteWorkspace(workspaceId: string): Promise<void> {
+    await this.requestVoid("DELETE", `/v1/workspaces/${workspaceId}`);
+  }
+
+  // --- Members ("People with access") -------------------------------------------
+
+  /** The workspace's members (user + api_key subjects). */
+  async listWorkspaceMembers(workspaceId: string): Promise<WorkspaceMember[]> {
+    const response = await this.requestJson<ListWorkspaceMembersResponse>("GET", `/v1/workspaces/${workspaceId}/members`);
+    return response.members;
+  }
+
+  /**
+   * Add an already-registered user by email. 404s when no user with that email
+   * exists (email invites for unknown users are deferred).
+   */
+  async addWorkspaceMember(workspaceId: string, request: AddWorkspaceMemberRequest): Promise<WorkspaceMember> {
+    return await this.requestJson<WorkspaceMember>("POST", `/v1/workspaces/${workspaceId}/members`, request);
+  }
+
+  async updateWorkspaceMember(workspaceId: string, subjectId: string, request: UpdateWorkspaceMemberRequest): Promise<WorkspaceMember> {
+    return await this.requestJson<WorkspaceMember>(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/members/${encodeURIComponent(subjectId)}`,
+      request,
+    );
+  }
+
+  /**
+   * Remove a member. Refused (409) for your own membership and for the last
+   * member who can still manage the workspace.
+   */
+  async removeWorkspaceMember(workspaceId: string, subjectId: string): Promise<void> {
+    await this.requestVoid("DELETE", `/v1/workspaces/${workspaceId}/members/${encodeURIComponent(subjectId)}`);
+  }
+
   // --- Scheduled tasks (write + runs) -------------------------------------------
 
   async createScheduledTask(workspaceId: string, request: CreateScheduledTaskRequest): Promise<ScheduledTask> {
@@ -614,6 +844,17 @@ export class OpenGeniClient {
     );
   }
 
+  /**
+   * Delete a document from a base. Removes the document row and its indexed
+   * chunks while leaving the uploaded file asset available for other uses.
+   */
+  async deleteDocument(workspaceId: string, baseId: string, documentId: string): Promise<void> {
+    await this.requestVoid(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/document-bases/${baseId}/documents/${documentId}`,
+    );
+  }
+
   async searchDocuments(
     workspaceId: string,
     baseId: string,

package/src/desktop.ts

@@ -0,0 +1,152 @@
+// Zero-dependency desktop (noVNC) transport contract.
+//
+// The actual `@novnc/novnc` RFB import is a browser-only DOM dependency and
+// lives in `@opengeni/react` (lazily imported, SSR-safe). The framework-agnostic
+// SDK ships only the transport CONTRACT: a URL assembler, the minimal RFB
+// surface the component drives, the connection state machine, and the
+// rotation/fence reducers — all pure and unit-testable, with no DOM and no deps.
+//
+// Channel A (terminal-as-events, files, git) needs NO new transport here: those
+// are event projections + the synchronous fs/git/terminal point queries on
+// `OpenGeniClient`. Only the desktop pixel plane (Channel B, direct-to-provider)
+// needs this.
+
+import type { DesktopStreamCapability, StreamUrlRotatedPayload } from "./types";
+
+/**
+ * Translate the negotiated desktop capability into the WebSocket URL the noVNC
+ * RFB client connects to. The scoped provider token is ALREADY embedded in the
+ * minted `url` (Modal tunnel host, Blaxel `bl_preview_token`, Daytona signed
+ * preview) by `session.resolveExposedPort(6080)` — we do NOT append `cap.token`
+ * as a query param (that double-auth was an adversarial-review bug: the box runs
+ * `-nopw` in v1, so the RFB password is meaningless and the real auth is the
+ * tunnel token in the host). We only normalize the scheme to `ws`/`wss` and, when
+ * the minted URL points at a `vnc.html` viewer page, rewrite it to the
+ * websockify socket path noVNC actually dials.
+ */
+export function desktopSocketUrl(cap: Pick<DesktopStreamCapability, "url">): string {
+  if (!cap.url) {
+    throw new Error("desktop capability has no url (transport is null)");
+  }
+  const u = new URL(cap.url);
+  // https → wss, http → ws (noVNC dials a WebSocket, not the HTTP viewer page).
+  if (u.protocol === "https:") {
+    u.protocol = "wss:";
+  } else if (u.protocol === "http:") {
+    u.protocol = "ws:";
+  }
+  // A minted `…/vnc.html` (or `…/vnc_lite.html`) viewer page → the websockify
+  // socket the page itself would open (`…/websockify`). A bare host/path with no
+  // viewer page is already the socket path; leave it untouched.
+  if (/\/vnc(_lite)?\.html$/.test(u.pathname)) {
+    u.pathname = u.pathname.replace(/\/vnc(_lite)?\.html$/, "/websockify");
+    u.search = "";
+    u.hash = "";
+  }
+  return u.toString();
+}
+
+/**
+ * The minimal RFB surface the React component drives. Lets tests (and 3rd
+ * parties swapping noVNC for a WebRTC client in v3) provide a fake without the
+ * DOM. Matches `@novnc/novnc`'s RFB constructor + lifecycle.
+ */
+export interface DesktopRfbLike {
+  viewOnly: boolean;
+  scaleViewport: boolean;
+  /**
+   * 1:1 viewport clipping. We always drive this FALSE: with clipping on, noVNC
+   * paints the framebuffer pixel-for-pixel and scrolls/crops to the container
+   * (the "zoomed in" look). FALSE lets `scaleViewport` shrink the 1280x800 frame
+   * to fit the panel (aspect-preserved). Declared so the hook can pin it instead
+   * of relying on noVNC's default — `scaleViewport=true` forces clip off
+   * internally, but a stale/partial state on reconnect could leave it on.
+   */
+  clipViewport: boolean;
+  addEventListener(
+    type: "connect" | "disconnect" | "securityfailure",
+    cb: (e?: unknown) => void,
+  ): void;
+  removeEventListener?: (
+    type: "connect" | "disconnect" | "securityfailure",
+    cb: (e?: unknown) => void,
+  ) => void;
+  disconnect(): void;
+}
+
+export type DesktopRfbFactory = (
+  target: HTMLElement,
+  url: string,
+  opts: { credentials?: { password?: string | undefined } | undefined },
+) => DesktopRfbLike;
+
+export type DesktopConnectionState =
+  | "idle"
+  | "negotiating"
+  | "connecting"
+  | "connected"
+  | "rotating"
+  | "reconnecting"
+  | "error"
+  | "ended";
+
+export type DesktopStreamEvent =
+  | { type: "negotiated" }
+  | { type: "connected" }
+  | { type: "disconnected" }
+  | { type: "rotate" }
+  | { type: "fail" }
+  | { type: "abort" };
+
+/**
+ * Pure reducer for the desktop connection lifecycle. The component owns the RFB
+ * object + DOM; this owns the transitions so they are unit-testable. Mirrors the
+ * Channel-A stream reducer discipline.
+ */
+export function nextDesktopState(
+  current: DesktopConnectionState,
+  ev: DesktopStreamEvent,
+): DesktopConnectionState {
+  switch (ev.type) {
+    case "negotiated":
+      return "connecting";
+    case "connected":
+      return "connected";
+    case "rotate":
+      return current === "connected" ? "rotating" : current;
+    case "disconnected":
+      // A deliberate teardown (ended) stays ended; everything else reconnects.
+      return current === "ended" ? "ended" : "reconnecting";
+    case "fail":
+      return "error";
+    case "abort":
+      return "ended";
+    default:
+      return current;
+  }
+}
+
+// `DesktopStreamCapability` is the desktop cell of `SessionCapabilities`; alias
+// it for the rotation reducer below without depending on the whole doc.
+export type DesktopStreamCapabilityLike = {
+  url: string | null;
+  token: string | null;
+  expiresAt: string | null;
+};
+
+/**
+ * Apply a `stream.url.rotated` event onto a desktop capability, fencing on
+ * leaseEpoch (split-brain). A rotation minted under an epoch the client has
+ * already advanced PAST is from a superseded owner and is dropped (returns
+ * null); otherwise the fresh url/token/expiresAt are folded in.
+ */
+export function applyUrlRotation<T extends DesktopStreamCapabilityLike>(
+  cap: T,
+  payload: StreamUrlRotatedPayload,
+  knownEpoch: number,
+): T | null {
+  if (payload.leaseEpoch < knownEpoch) {
+    return null;
+  }
+  return { ...cap, url: payload.url, token: payload.token, expiresAt: payload.expiresAt };
+}

package/src/index.ts

@@ -11,6 +11,27 @@ export {
 export type { ProxySessionEventStreamOptions, SseReStreamOptions } from "./proxy";
 export { parseSseStream } from "./sse";
 export type { SseMessage } from "./sse";
+// Desktop (noVNC) transport contract — pure, zero-dep (the RFB import lives in
+// @opengeni/react). URL assembler + connection state machine + rotation fence.
+export { desktopSocketUrl, nextDesktopState, applyUrlRotation } from "./desktop";
+export type {
+  DesktopRfbLike,
+  DesktopRfbFactory,
+  DesktopConnectionState,
+  DesktopStreamEvent,
+} from "./desktop";
+// Interactive terminal (ttyd PTY-over-websocket) transport contract — pure,
+// zero-dep (the WebSocket + xterm attach live in @opengeni/react). URL assembler
+// + the ttyd wire-protocol frame codec, symmetric with the desktop above.
+export {
+  terminalSocketUrl,
+  ttydAuthFrame,
+  ttydInputFrame,
+  ttydResizeFrame,
+  TTYD_SUBPROTOCOL,
+  TtydClientCommand,
+  TtydServerCommand,
+} from "./terminal";
 export { streamSessionEvents } from "./stream";
 export type {
   SessionEventStreamTransport,
@@ -23,6 +44,7 @@ export type {
   AccessGrant,
   AccountGrant,
   AccountRole,
+  AddWorkspaceMemberRequest,
   AgentMessageCompletedPayload,
   AgentTextDeltaPayload,
   AgentToolCallCreatedPayload,
@@ -48,6 +70,9 @@ export type {
   CapabilityPackSkillFile,
   CapabilityRuntime,
   CapabilitySource,
+  CapabilityUnavailableReason,
+  ClientConfig,
+  ClientModel,
   CompactSessionContextResult,
   ClientSessionEventInput,
   CompleteFileUploadResponse,
@@ -92,15 +117,25 @@ export type {
   KnownUsageEventType,
   ListApiKeysResponse,
   ListPacksResponse,
+  ListWorkspaceMembersResponse,
   PackInstallation,
   PackInstallationStatus,
   Permission,
   ProductAccessMode,
   ReasoningEffort,
+  RecordingAvailablePayload,
+  RecordingCodec,
+  RecordingContentType,
+  RecordingFailedPayload,
+  RecordingFailedReason,
+  RecordingMode,
+  RecordingStartedPayload,
   RegisterCapabilityPackRequest,
   RepositoryResourceRef,
   ResourceRef,
   SandboxBackend,
+  SandboxCapabilityName,
+  SandboxOs,
   ScheduledTask,
   ScheduledTaskAgentConfig,
   ScheduledTaskAgentConfigInput,
@@ -113,6 +148,27 @@ export type {
   ScheduledTaskStatus,
   ScheduledTaskTriggerType,
   Session,
+  SessionCapabilities,
+  // Per-surface capability cell aliases (views of SessionCapabilities).
+  FileSystemCapability,
+  TerminalCapability,
+  GitCapability,
+  DesktopStreamCapability,
+  RecordingCapability,
+  ComputerUseCapability,
+  // Stream-surfacing client surface (Phase 5).
+  ClientAuthConfig,
+  StreamUrlRotatedPayload,
+  StreamOpenedPayload,
+  StreamClosedPayload,
+  StreamRevokedPayload,
+  AttachViewerRequest,
+  AttachViewerResponse,
+  ViewerHolder,
+  AcknowledgeStreamRequest,
+  AcknowledgeStreamResponse,
+  ViewerHeartbeatRequest,
+  ViewerHeartbeatResponse,
   SessionEvent,
   SessionEventType,
   SessionGoal,
@@ -120,14 +176,61 @@ export type {
   SessionGoalStatus,
   SessionStatus,
   SessionStatusChangedPayload,
+  SessionStructuredCapabilities,
   SessionTurn,
   SessionTurnSource,
   SessionTurnStatus,
+  // Channel-A structured services (P4.4) — A1 payloads + A2 request/response.
+  SandboxCommandOutputDeltaPayload,
+  FsChangeKind,
+  FsChangedPayload,
+  GitChangedPayload,
+  TerminalPtyStartedPayload,
+  TerminalPtyOutputDeltaPayload,
+  TerminalPtyExitedPayload,
+  FsNodeType,
+  FsTreeNode,
+  FsEncoding,
+  FsListRequest,
+  FsListResponse,
+  FsReadRequest,
+  FsReadResponse,
+  FsWriteRequest,
+  FsWriteResponse,
+  FsDeleteRequest,
+  FsDeleteResponse,
+  FsMoveRequest,
+  FsMoveResponse,
+  FsMkdirRequest,
+  FsMkdirResponse,
+  GitFileStatusCode,
+  GitFileStatus,
+  GitStatusRequest,
+  GitStatusResponse,
+  GitDiffLineType,
+  GitDiffLine,
+  GitDiffHunk,
+  GitFileDiff,
+  GitDiffRequest,
+  GitDiffResponse,
+  GitLogRequest,
+  GitCommit,
+  GitLogResponse,
+  GitShowRequest,
+  GitShowResponse,
+  TerminalExecRequest,
+  TerminalExecResponse,
+  PtyOpenRequest,
+  PtyOpenResponse,
+  PtyWriteRequest,
+  PtyResizeRequest,
+  PtyCloseRequest,
   ToolRef,
   UpdateScheduledTaskRequest,
   UpdateSessionGoalRequest,
   UpdateSessionTurnRequest,
   UpdateWorkspaceEnvironmentRequest,
+  UpdateWorkspaceMemberRequest,
   UpdateWorkspaceRequest,
   UploadFileInput,
   UsageEvent,
@@ -138,5 +241,6 @@ export type {
   Workspace,
   WorkspaceEnvironment,
   WorkspaceEnvironmentVariableMetadata,
+  WorkspaceMember,
   WorkspaceRegisteredPack,
 } from "./types";