@opengeni/sdk 0.52.1 → 0.57.0

package/src/client.ts

@@ -12,15 +12,33 @@ import {
   streamWorkspaceControlEvents,
   type WorkspaceControlStreamTransport,
 } from "./workspace-control-stream";
+import {
+  streamWorkspaceInteractionRevisions,
+  type WorkspaceInteractionRevisionStreamTransport,
+} from "./interaction-revision-stream";
+import {
+  streamWorkspaceLiveEvents,
+  type WorkspaceLiveStreamOptions,
+  type WorkspaceLiveStreamTransport,
+} from "./workspace-live-stream";
 import {
   OpenGeniInteractionClient,
+  type AuthRun,
+  type AuthRunListOptions,
+  type AuthRunListResponse,
+  type AuthRunMutationResponse,
   type AttachedBrowserDevice,
   type AttachedBrowserDeviceListOptions,
   type AttachedBrowserDeviceListResponse,
   type BrowserActionReceipt,
   type BrowserActionRequest,
+  type BrowserClipboard,
   type BrowserDiagnosticBatch,
   type BrowserDiagnosticsOptions,
+  type BrowserDownload,
+  type BrowserDownloadListResponse,
+  type BrowserDownloadSaveRequest,
+  type BrowserDownloadSaveResponse,
   type BrowserIdentity,
   type BrowserIdentityListOptions,
   type BrowserIdentityListResponse,
@@ -34,11 +52,11 @@ import {
   type BrowserSessionLifecycleRequest,
   type BrowserSessionListResponse,
   type BrowserSessionMutationResponse,
-  type BrowserTarget,
   type BrowserTargetListResponse,
   type BrowserRevisionListResponse,
   type ComputerActionReceipt,
   type ComputerActionRequest,
+  type ComputerClipboard,
   type ComputerObservation,
   type ComputerSession,
   type ComputerSessionAttachment,
@@ -51,8 +69,37 @@ import {
   type CreateBrowserIdentityRequest,
   type CreateBrowserSessionRequest,
   type CreateComputerSessionRequest,
+  type CreateInteractionInterventionRequest,
+  type CreateNetworkRouteRequest,
+  type CreateSiteAuthConnectionRequest,
+  type ExternalAuthInteractiveRequest,
+  type ExternalAuthInteractiveResponse,
+  type ExternalAuthRunRequest,
+  type ExternalAuthRunResponse,
+  type InteractionIntervention,
+  type InteractionInterventionListOptions,
+  type InteractionInterventionListResponse,
+  type InteractionInterventionMutationResponse,
+  type NetworkRoute,
+  type NetworkRouteListOptions,
+  type NetworkRouteListResponse,
+  type NetworkRouteMutationResponse,
+  type ProtectedAuthFillRequest,
+  type ProtectedAuthFillResponse,
   type PublishBrowserRevisionRequest,
   type PublishBrowserRevisionResponse,
+  type ReportAuthRunRequest,
+  type ResolveInteractionInterventionRequest,
+  type SiteAuthConnection,
+  type SiteAuthConnectionListOptions,
+  type SiteAuthConnectionListResponse,
+  type SiteAuthConnectionMutationResponse,
+  type StartAuthRunRequest,
+  type UpdateNetworkRouteRequest,
+  type UpdateBrowserIdentityRequest,
+  type UpdateSiteAuthConnectionRequest,
+  type VerifyAuthRunRequest,
+  type WorkspaceInteractionRevisionEvent,
 } from "./interaction";
 import type {
   AccessContext,
@@ -75,6 +122,14 @@ import type {
   CodexConnectStart,
   CodexUsage,
   CodexUsageMap,
+  SuperGrokAccount,
+  SuperGrokAccountsResponse,
+  SuperGrokAccountScope,
+  SuperGrokAllocatorUpdate,
+  SuperGrokConnectionStatus,
+  SuperGrokConnectPoll,
+  SuperGrokConnectStart,
+  SuperGrokRotationSettings,
   BillingSummary,
   BillingUsageResponse,
   InsightsRange,
@@ -88,16 +143,16 @@ import type {
   ApiIntegrationUninstallPreview,
   InstallApiIntegrationRequest,
   InstalledApiIntegration,
-  IntegrationFeatureMutationResult,
-  IntegrationFeatureRemovalResult,
-  IntegrationInstanceFeaturesResponse,
-  ListApiIntegrationPresetsResponse,
+  IntegrationFacetMutationResult,
+  IntegrationFacetRemovalResult,
+  IntegrationInstanceFacetsResponse,
+  ListIntegrationDefinitionsResponse,
   ListApiIntegrationsResponse,
-  MutateIntegrationFeatureRequest,
+  MutateIntegrationFacetRequest,
   PreviewApiIntegrationRequest,
   UninstallApiIntegrationRequest,
   UninstallApiIntegrationResult,
-  UpsertIntegrationFeatureRequest,
+  UpsertIntegrationFacetRequest,
   PreviewPluginRequest,
   PluginPreview,
   InstallPluginRequest,
@@ -120,12 +175,17 @@ import type {
   CreateApiKeyResponse,
   CreateCapabilityCatalogItemRequest,
   InstallSkillRequest,
+  InstallLibrarySkillRequest,
   InstalledSkill,
+  ListInstalledSkillsResponse,
   CreateCheckoutRequest,
   CreateCheckoutResponse,
   OpenGeniSlackBotInstallRequest,
   OpenGeniSlackBotInstallStart,
   SlackReactionChannelListResponse,
+  FikenInstallRequest,
+  FikenOAuthStartRequest,
+  FikenOAuthStartResponse,
   CreateConnectionRequest,
   CreateDocumentBaseRequest,
   CreateFileUploadRequest,
@@ -165,6 +225,7 @@ import type {
   KnowledgeMemory,
   KnowledgeMemorySearchRequest,
   ListApiKeysResponse,
+  ListManagedOrganizationMembershipsResponse,
   ListPacksResponse,
   // Bring-your-own-compute: the Machines dashboard + per-machine metrics (M10).
   MachinesResponse,
@@ -209,6 +270,7 @@ import type {
   Session,
   SessionListResponse,
   AgentTopologyPageResponse,
+  UpdateSessionChannelRequest,
   UpdateSessionPinRequest,
   UninstallPackRequest,
   UninstallPackResult,
@@ -218,6 +280,7 @@ import type {
   SessionEventListOptions,
   SessionEventPage,
   SessionGoal,
+  SessionGoalRevision,
   SessionHumanInputRequest,
   SessionLineageResponse,
   SessionRealtimeMutationResponse,
@@ -295,6 +358,7 @@ import type {
   UpdateKnowledgeMemoryRequest,
   UpdateScheduledTaskRequest,
   UpdateSessionGoalRequest,
+  ApplySessionGoalRevisionRequest,
   UpdateSessionRequest,
   UpdateSessionToolPolicyRequest,
   UpdateVariableSetRequest,
@@ -307,6 +371,9 @@ import type {
   VariableSet,
   VariableSetSecret,
   VariableSetVariableMetadata,
+  Channel,
+  CreateChannelRequest,
+  UpdateChannelRequest,
   Rig,
   RigVersion,
   RigChange,
@@ -993,6 +1060,22 @@ export class OpenGeniClient {
     );
   }
 
+  /** Mint a short-lived browser token from a connected SuperGrok account. */
+  async negotiateXaiSubscriptionRealtime(
+    workspaceId: string,
+    sessionId: string,
+    request: GatewayRealtimeConnectRequest,
+    options: { signal?: AbortSignal | undefined } = {},
+  ): Promise<GatewayRealtimeConnectResponse> {
+    return await this.requestJson<GatewayRealtimeConnectResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/realtime/supergrok`,
+      request,
+      {},
+      { signal: options.signal },
+    );
+  }
+
   /** Promote a negotiated connection only after its browser data channel is ready. */
   async activateCodexRealtimeConnection(
     workspaceId: string,
@@ -1777,6 +1860,61 @@ export class OpenGeniClient {
     return streamWorkspaceControlEvents(this.workspaceControlStreamTransport(workspaceId), options);
   }
 
+  /**
+   * Multiplex workspace control and interaction invalidations over one HTTP
+   * connection while retaining an independent durable cursor for each domain.
+   */
+  streamWorkspaceLiveEvents(workspaceId: string, options: WorkspaceLiveStreamOptions = {}) {
+    return streamWorkspaceLiveEvents(this.workspaceLiveStreamTransport(workspaceId), options);
+  }
+
+  workspaceLiveStreamTransport(workspaceId: string): WorkspaceLiveStreamTransport {
+    return {
+      openStream: async (controlAfter, interactionAfter, signal) =>
+        await this.openWorkspaceLiveEventStream(workspaceId, {
+          controlAfter,
+          interactionAfter,
+          ...(signal ? { signal } : {}),
+        }),
+    };
+  }
+
+  async openWorkspaceLiveEventStream(
+    workspaceId: string,
+    options: {
+      controlAfter?: number;
+      interactionAfter?: number;
+      signal?: AbortSignal;
+    } = {},
+  ): Promise<ReadableStream<Uint8Array>> {
+    const correlationId = crypto.randomUUID();
+    const response = await this.fetchImpl(
+      this.url(`/v1/workspaces/${workspaceId}/live-events/stream`, {
+        controlAfter: String(options.controlAfter ?? 0),
+        interactionAfter: String(options.interactionAfter ?? 0),
+      }),
+      {
+        method: "GET",
+        headers: {
+          ...this.headers(correlationId),
+          Accept: "text/event-stream",
+        },
+        ...(options.signal ? { signal: options.signal } : {}),
+      },
+    );
+    assertApiContractResponse(response);
+    if (!response.ok) {
+      throw await apiErrorFromResponse(response, {
+        method: "GET",
+        correlationId,
+      });
+    }
+    if (!response.body) {
+      throw new OpenGeniApiError(response.status, "SSE response did not include a readable body");
+    }
+    return response.body;
+  }
+
   workspaceControlStreamTransport(workspaceId: string): WorkspaceControlStreamTransport {
     return {
       openStream: async (after, signal) =>
@@ -1855,6 +1993,26 @@ export class OpenGeniClient {
     );
   }
 
+  async listGoalRevisions(workspaceId: string, sessionId: string): Promise<SessionGoalRevision[]> {
+    return await this.requestJson<SessionGoalRevision[]>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/goal/revisions`,
+    );
+  }
+
+  async applyGoalRevision(
+    workspaceId: string,
+    sessionId: string,
+    revisionId: string,
+    request: ApplySessionGoalRevisionRequest,
+  ): Promise<SessionGoal> {
+    return await this.requestJson<SessionGoal>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/goal/revisions/${revisionId}/apply`,
+      request,
+    );
+  }
+
   async deleteGoal(workspaceId: string, sessionId: string): Promise<void> {
     await this.requestVoid("DELETE", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/goal`);
   }
@@ -2274,6 +2432,359 @@ export class OpenGeniClient {
 
   // --- Browser / Computer interaction resources --------------------------------
 
+  streamWorkspaceInteractionRevisions(
+    workspaceId: string,
+    options: StreamSessionEventsOptions = {},
+  ): AsyncGenerator<WorkspaceInteractionRevisionEvent, void, void> {
+    return streamWorkspaceInteractionRevisions(
+      this.workspaceInteractionRevisionStreamTransport(workspaceId),
+      options,
+    );
+  }
+
+  workspaceInteractionRevisionStreamTransport(
+    workspaceId: string,
+  ): WorkspaceInteractionRevisionStreamTransport {
+    return {
+      openStream: async (after, signal) =>
+        await this.openWorkspaceInteractionRevisionStream(workspaceId, {
+          after,
+          ...(signal ? { signal } : {}),
+        }),
+    };
+  }
+
+  async openWorkspaceInteractionRevisionStream(
+    workspaceId: string,
+    options: { after?: number; signal?: AbortSignal } = {},
+  ): Promise<ReadableStream<Uint8Array>> {
+    const correlationId = crypto.randomUUID();
+    const response = await this.fetchImpl(
+      this.url(`/v1/workspaces/${workspaceId}/interaction-events/stream`, {
+        after: String(options.after ?? 0),
+      }),
+      {
+        method: "GET",
+        headers: {
+          ...this.headers(correlationId),
+          Accept: "text/event-stream",
+        },
+        ...(options.signal ? { signal: options.signal } : {}),
+      },
+    );
+    assertApiContractResponse(response);
+    if (!response.ok) {
+      throw await apiErrorFromResponse(response, {
+        method: "GET",
+        correlationId,
+      });
+    }
+    if (!response.body) {
+      throw new OpenGeniApiError(response.status, "SSE response did not include a readable body");
+    }
+    return response.body;
+  }
+
+  async listNetworkRoutes(
+    workspaceId: string,
+    options: NetworkRouteListOptions = {},
+  ): Promise<NetworkRouteListResponse> {
+    return await this.requestJson<NetworkRouteListResponse>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/network-routes`,
+      undefined,
+      options.includeArchived ? { includeArchived: "true" } : {},
+      options,
+    );
+  }
+
+  async getNetworkRoute(
+    workspaceId: string,
+    networkRouteId: string,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<NetworkRoute> {
+    return await this.requestJson<NetworkRoute>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/network-routes/${encodeURIComponent(networkRouteId)}`,
+      undefined,
+      {},
+      options,
+    );
+  }
+
+  async createNetworkRoute(
+    workspaceId: string,
+    request: CreateNetworkRouteRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<NetworkRouteMutationResponse> {
+    return await this.requestJson<NetworkRouteMutationResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/network-routes`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async updateNetworkRoute(
+    workspaceId: string,
+    networkRouteId: string,
+    request: UpdateNetworkRouteRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<NetworkRouteMutationResponse> {
+    return await this.requestJson<NetworkRouteMutationResponse>(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/network-routes/${encodeURIComponent(networkRouteId)}`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async listSiteAuthConnections(
+    workspaceId: string,
+    options: SiteAuthConnectionListOptions = {},
+  ): Promise<SiteAuthConnectionListResponse> {
+    return await this.requestJson<SiteAuthConnectionListResponse>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/site-auth-connections`,
+      undefined,
+      options.includeArchived ? { includeArchived: "true" } : {},
+      options,
+    );
+  }
+
+  async getSiteAuthConnection(
+    workspaceId: string,
+    siteAuthConnectionId: string,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<SiteAuthConnection> {
+    return await this.requestJson<SiteAuthConnection>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/site-auth-connections/${encodeURIComponent(siteAuthConnectionId)}`,
+      undefined,
+      {},
+      options,
+    );
+  }
+
+  async createSiteAuthConnection(
+    workspaceId: string,
+    request: CreateSiteAuthConnectionRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<SiteAuthConnectionMutationResponse> {
+    return await this.requestJson<SiteAuthConnectionMutationResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/site-auth-connections`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async updateSiteAuthConnection(
+    workspaceId: string,
+    siteAuthConnectionId: string,
+    request: UpdateSiteAuthConnectionRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<SiteAuthConnectionMutationResponse> {
+    return await this.requestJson<SiteAuthConnectionMutationResponse>(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/site-auth-connections/${encodeURIComponent(siteAuthConnectionId)}`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async listAuthRuns(
+    workspaceId: string,
+    options: AuthRunListOptions = {},
+  ): Promise<AuthRunListResponse> {
+    return await this.requestJson<AuthRunListResponse>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/auth-runs`,
+      undefined,
+      {
+        ...(options.browserSessionId ? { browserSessionId: options.browserSessionId } : {}),
+        ...(options.siteAuthConnectionId
+          ? { siteAuthConnectionId: options.siteAuthConnectionId }
+          : {}),
+        ...(options.includeSettled ? { includeSettled: "true" } : {}),
+      },
+      options,
+    );
+  }
+
+  async getAuthRun(
+    workspaceId: string,
+    authRunId: string,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<AuthRun> {
+    return await this.requestJson<AuthRun>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/auth-runs/${encodeURIComponent(authRunId)}`,
+      undefined,
+      {},
+      options,
+    );
+  }
+
+  async startBrowserAuthRun(
+    workspaceId: string,
+    browserSessionId: string,
+    request: StartAuthRunRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<AuthRunMutationResponse> {
+    return await this.requestJson<AuthRunMutationResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async reportBrowserAuthRun(
+    workspaceId: string,
+    browserSessionId: string,
+    authRunId: string,
+    request: ReportAuthRunRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<AuthRunMutationResponse> {
+    return await this.requestJson<AuthRunMutationResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs/${encodeURIComponent(authRunId)}/report`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async protectedBrowserAuthFill(
+    workspaceId: string,
+    browserSessionId: string,
+    authRunId: string,
+    request: ProtectedAuthFillRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<ProtectedAuthFillResponse> {
+    return await this.requestJson<ProtectedAuthFillResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs/${encodeURIComponent(authRunId)}/protected-fill`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async advanceExternalBrowserAuthRun(
+    workspaceId: string,
+    browserSessionId: string,
+    authRunId: string,
+    request: ExternalAuthRunRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<ExternalAuthRunResponse> {
+    return await this.requestJson<ExternalAuthRunResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs/${encodeURIComponent(authRunId)}/external-auth`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async openExternalBrowserAuthFlow(
+    workspaceId: string,
+    browserSessionId: string,
+    authRunId: string,
+    request: ExternalAuthInteractiveRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<ExternalAuthInteractiveResponse> {
+    return await this.requestJson<ExternalAuthInteractiveResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs/${encodeURIComponent(authRunId)}/external-auth/interactive`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async verifyBrowserAuthRun(
+    workspaceId: string,
+    browserSessionId: string,
+    authRunId: string,
+    request: VerifyAuthRunRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<AuthRunMutationResponse> {
+    return await this.requestJson<AuthRunMutationResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs/${encodeURIComponent(authRunId)}/verify`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async listInteractionInterventions(
+    workspaceId: string,
+    options: InteractionInterventionListOptions = {},
+  ): Promise<InteractionInterventionListResponse> {
+    return await this.requestJson<InteractionInterventionListResponse>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/interaction-interventions`,
+      undefined,
+      {
+        ...(options.resourceKind ? { resourceKind: options.resourceKind } : {}),
+        ...(options.resourceId ? { resourceId: options.resourceId } : {}),
+        ...(options.includeSettled ? { includeSettled: "true" } : {}),
+      },
+      options,
+    );
+  }
+
+  async getInteractionIntervention(
+    workspaceId: string,
+    interventionId: string,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<InteractionIntervention> {
+    return await this.requestJson<InteractionIntervention>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/interaction-interventions/${encodeURIComponent(interventionId)}`,
+      undefined,
+      {},
+      options,
+    );
+  }
+
+  async createInteractionIntervention(
+    workspaceId: string,
+    request: CreateInteractionInterventionRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<InteractionInterventionMutationResponse> {
+    return await this.requestJson<InteractionInterventionMutationResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/interaction-interventions`,
+      request,
+      {},
+      options,
+    );
+  }
+
+  async resolveInteractionIntervention(
+    workspaceId: string,
+    interventionId: string,
+    request: ResolveInteractionInterventionRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<InteractionInterventionMutationResponse> {
+    return await this.requestJson<InteractionInterventionMutationResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/interaction-interventions/${encodeURIComponent(interventionId)}/resolve`,
+      request,
+      {},
+      options,
+    );
+  }
+
   async listAttachedBrowsers(
     workspaceId: string,
     options: AttachedBrowserDeviceListOptions = {},
@@ -2342,6 +2853,21 @@ export class OpenGeniClient {
     );
   }
 
+  async updateBrowserIdentity(
+    workspaceId: string,
+    identityId: string,
+    request: UpdateBrowserIdentityRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<BrowserIdentityMutationResponse> {
+    return await this.requestJson<BrowserIdentityMutationResponse>(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/browser-identities/${encodeURIComponent(identityId)}`,
+      request,
+      {},
+      options,
+    );
+  }
+
   async listBrowserRevisions(
     workspaceId: string,
     identityId: string,
@@ -2385,6 +2911,65 @@ export class OpenGeniClient {
     );
   }
 
+  async readBrowserClipboard(
+    workspaceId: string,
+    browserSessionId: string,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<BrowserClipboard> {
+    return await this.requestJson<BrowserClipboard>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/clipboard`,
+      undefined,
+      {},
+      options,
+    );
+  }
+
+  async listBrowserDownloads(
+    workspaceId: string,
+    browserSessionId: string,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<BrowserDownloadListResponse> {
+    return await this.requestJson<BrowserDownloadListResponse>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/downloads`,
+      undefined,
+      {},
+      options,
+    );
+  }
+
+  async getBrowserDownload(
+    workspaceId: string,
+    browserSessionId: string,
+    downloadId: string,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<BrowserDownload> {
+    return await this.requestJson<BrowserDownload>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/downloads/${encodeURIComponent(downloadId)}`,
+      undefined,
+      {},
+      options,
+    );
+  }
+
+  async saveBrowserDownload(
+    workspaceId: string,
+    browserSessionId: string,
+    downloadId: string,
+    request: BrowserDownloadSaveRequest,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<BrowserDownloadSaveResponse> {
+    return await this.requestJson<BrowserDownloadSaveResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/downloads/${encodeURIComponent(downloadId)}/save`,
+      request,
+      {},
+      options,
+    );
+  }
+
   async createBrowserSession(
     workspaceId: string,
     request: CreateBrowserSessionRequest,
@@ -2418,8 +3003,8 @@ export class OpenGeniClient {
     browserSessionId: string,
     request: BrowserOpenTargetRequest = {},
     options: OpenGeniRequestOptions = {},
-  ): Promise<BrowserTarget> {
-    return await this.requestJson<BrowserTarget>(
+  ): Promise<BrowserObservation> {
+    return await this.requestJson<BrowserObservation>(
       "POST",
       `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/targets`,
       request,
@@ -2433,8 +3018,8 @@ export class OpenGeniClient {
     browserSessionId: string,
     targetId: string,
     options: OpenGeniRequestOptions = {},
-  ): Promise<BrowserTarget> {
-    return await this.requestJson<BrowserTarget>(
+  ): Promise<BrowserObservation> {
+    return await this.requestJson<BrowserObservation>(
       "POST",
       `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/targets/${encodeURIComponent(targetId)}/select`,
       {},
@@ -2640,6 +3225,20 @@ export class OpenGeniClient {
     );
   }
 
+  async readComputerClipboard(
+    workspaceId: string,
+    computerSessionId: string,
+    options: OpenGeniRequestOptions = {},
+  ): Promise<ComputerClipboard> {
+    return await this.requestJson<ComputerClipboard>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}/clipboard`,
+      undefined,
+      {},
+      options,
+    );
+  }
+
   async createComputerSession(
     workspaceId: string,
     request: CreateComputerSessionRequest,
@@ -2800,6 +3399,14 @@ export class OpenGeniClient {
     return await this.requestJson<AccessContext>("GET", "/v1/access/me");
   }
 
+  /** Active organization memberships proven by the current managed-human session. */
+  async listOrganizationMemberships(): Promise<ListManagedOrganizationMembershipsResponse> {
+    return await this.requestJson<ListManagedOrganizationMembershipsResponse>(
+      "GET",
+      "/v1/organization-memberships",
+    );
+  }
+
   async listWorkspaces(): Promise<Workspace[]> {
     return await this.requestJson<Workspace[]>("GET", "/v1/workspaces");
   }
@@ -3456,6 +4063,55 @@ export class OpenGeniClient {
     );
   }
 
+  // --- Channels --------------------------------------------------------------
+  // Workspace-shared rail organization for root sessions. sessions:read gates
+  // list; sessions:create gates create / update / delete; sessions:control
+  // gates re-filing a session.
+
+  async listChannels(workspaceId: string): Promise<Channel[]> {
+    return await this.requestJson<Channel[]>("GET", `/v1/workspaces/${workspaceId}/channels`);
+  }
+
+  async createChannel(workspaceId: string, request: CreateChannelRequest): Promise<Channel> {
+    return await this.requestJson<Channel>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/channels`,
+      request,
+    );
+  }
+
+  async updateChannel(
+    workspaceId: string,
+    channelId: string,
+    request: UpdateChannelRequest,
+  ): Promise<Channel> {
+    return await this.requestJson<Channel>(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/channels/${channelId}`,
+      request,
+    );
+  }
+
+  async deleteChannel(workspaceId: string, channelId: string): Promise<void> {
+    await this.requestJson<unknown>(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/channels/${channelId}`,
+    );
+  }
+
+  /** Re-file a session into a channel (null = back to the unfiled inbox). */
+  async updateSessionChannel(
+    workspaceId: string,
+    sessionId: string,
+    request: UpdateSessionChannelRequest,
+  ): Promise<Session> {
+    return await this.requestJson<Session>(
+      "PUT",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/channel`,
+      request,
+    );
+  }
+
   // --- Rigs ------------------------------------------------------------------
   // Workspace-scoped, versioned sandbox machine definitions. rigs:use gates read
   // + proposeRigChange; rigs:manage gates create / update / delete / activate.
@@ -4413,11 +5069,13 @@ export class OpenGeniClient {
     );
   }
 
-  /** List curated provider presets without exposing deployment OAuth credentials. */
-  async listApiIntegrationPresets(workspaceId: string): Promise<ListApiIntegrationPresetsResponse> {
-    return await this.requestJson<ListApiIntegrationPresetsResponse>(
+  /** List curated provider definitions without exposing deployment OAuth credentials. */
+  async listIntegrationDefinitions(
+    workspaceId: string,
+  ): Promise<ListIntegrationDefinitionsResponse> {
+    return await this.requestJson<ListIntegrationDefinitionsResponse>(
       "GET",
-      `/v1/workspaces/${workspaceId}/integrations/presets`,
+      `/v1/workspaces/${workspaceId}/integrations/definitions`,
     );
   }
 
@@ -4433,7 +5091,7 @@ export class OpenGeniClient {
     );
   }
 
-  /** Start a signed PKCE OAuth flow for a built-in Google or Microsoft preset. */
+  /** Start a signed PKCE OAuth flow for a built-in Google or Microsoft definition. */
   async startApiIntegrationOAuth(
     workspaceId: string,
     request: ApiIntegrationOAuthStartRequest,
@@ -4483,39 +5141,42 @@ export class OpenGeniClient {
   }
 
   /** List immutable provider facets and their exact per-account bindings. */
-  async listIntegrationFeatures(
+  async listIntegrationFacets(
     workspaceId: string,
     capabilityId: string,
     instanceKey: string,
-  ): Promise<IntegrationInstanceFeaturesResponse> {
-    return await this.requestJson<IntegrationInstanceFeaturesResponse>(
+  ): Promise<IntegrationInstanceFacetsResponse> {
+    return await this.requestJson<IntegrationInstanceFacetsResponse>(
       "GET",
-      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/features`,
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets`,
     );
   }
 
-  /** Configure or OCC-update one adapter-owned feature on an Integration instance. */
-  async configureIntegrationFeature(
+  /** Configure or OCC-update one adapter-owned facet on an Integration instance. */
+  async configureIntegrationFacet(
     workspaceId: string,
     capabilityId: string,
     instanceKey: string,
-    featureKey: string,
-    request: UpsertIntegrationFeatureRequest,
-  ): Promise<IntegrationFeatureMutationResult> {
-    return await this.requestJson<IntegrationFeatureMutationResult>(
+    facetKey: string,
+    request: UpsertIntegrationFacetRequest,
+  ): Promise<IntegrationFacetMutationResult> {
+    return await this.requestJson<IntegrationFacetMutationResult>(
       "PUT",
-      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/features/${encodeURIComponent(featureKey)}`,
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets/${encodeURIComponent(facetKey)}`,
       request,
     );
   }
 
   /** Browse source metadata through one exact Google Drive Integration instance. */
-  async browseGoogleDriveIntegrationSource(
+  async browseGoogleDriveFacetSource(
     workspaceId: string,
     capabilityId: string,
     instanceKey: string,
-    featureKey: string,
-    options: { parentId?: string | undefined; pageToken?: string | undefined } = {},
+    facetKey: string,
+    options: {
+      parentId?: string | undefined;
+      pageToken?: string | undefined;
+    } = {},
   ): Promise<GoogleDriveBrowseResponse> {
     const query = new URLSearchParams();
     if (options.parentId) query.set("parentId", options.parentId);
@@ -4523,84 +5184,84 @@ export class OpenGeniClient {
     const suffix = query.size > 0 ? `?${query}` : "";
     return await this.requestJson<GoogleDriveBrowseResponse>(
       "GET",
-      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/features/${encodeURIComponent(featureKey)}/browse${suffix}`,
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets/${encodeURIComponent(facetKey)}/browse${suffix}`,
     );
   }
 
   /** Verify and bind document sources to one exact Google Drive Integration instance. */
-  async saveGoogleDriveIntegrationSource(
+  async saveGoogleDriveFacetSource(
     workspaceId: string,
     capabilityId: string,
     instanceKey: string,
-    featureKey: string,
+    facetKey: string,
     request: SaveGoogleDriveIntegrationSourceRequest,
-  ): Promise<IntegrationFeatureMutationResult> {
-    return await this.requestJson<IntegrationFeatureMutationResult>(
+  ): Promise<IntegrationFacetMutationResult> {
+    return await this.requestJson<IntegrationFacetMutationResult>(
       "PUT",
-      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/features/${encodeURIComponent(featureKey)}/source`,
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets/${encodeURIComponent(facetKey)}/source`,
       request,
     );
   }
 
-  async pauseIntegrationFeature(
+  async pauseIntegrationFacet(
     workspaceId: string,
     capabilityId: string,
     instanceKey: string,
-    featureKey: string,
-    request: MutateIntegrationFeatureRequest,
-  ): Promise<IntegrationFeatureMutationResult> {
-    return await this.mutateIntegrationFeatureLifecycle(
+    facetKey: string,
+    request: MutateIntegrationFacetRequest,
+  ): Promise<IntegrationFacetMutationResult> {
+    return await this.mutateIntegrationFacetLifecycle(
       workspaceId,
       capabilityId,
       instanceKey,
-      featureKey,
+      facetKey,
       "pause",
       request,
     );
   }
 
-  async resumeIntegrationFeature(
+  async resumeIntegrationFacet(
     workspaceId: string,
     capabilityId: string,
     instanceKey: string,
-    featureKey: string,
-    request: MutateIntegrationFeatureRequest,
-  ): Promise<IntegrationFeatureMutationResult> {
-    return await this.mutateIntegrationFeatureLifecycle(
+    facetKey: string,
+    request: MutateIntegrationFacetRequest,
+  ): Promise<IntegrationFacetMutationResult> {
+    return await this.mutateIntegrationFacetLifecycle(
       workspaceId,
       capabilityId,
       instanceKey,
-      featureKey,
+      facetKey,
       "resume",
       request,
     );
   }
 
-  async removeIntegrationFeature(
+  async removeIntegrationFacet(
     workspaceId: string,
     capabilityId: string,
     instanceKey: string,
-    featureKey: string,
-    request: MutateIntegrationFeatureRequest,
-  ): Promise<IntegrationFeatureRemovalResult> {
-    return await this.requestJson<IntegrationFeatureRemovalResult>(
+    facetKey: string,
+    request: MutateIntegrationFacetRequest,
+  ): Promise<IntegrationFacetRemovalResult> {
+    return await this.requestJson<IntegrationFacetRemovalResult>(
       "DELETE",
-      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/features/${encodeURIComponent(featureKey)}`,
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets/${encodeURIComponent(facetKey)}`,
       request,
     );
   }
 
-  private async mutateIntegrationFeatureLifecycle(
+  private async mutateIntegrationFacetLifecycle(
     workspaceId: string,
     capabilityId: string,
     instanceKey: string,
-    featureKey: string,
+    facetKey: string,
     action: "pause" | "resume",
-    request: MutateIntegrationFeatureRequest,
-  ): Promise<IntegrationFeatureMutationResult> {
-    return await this.requestJson<IntegrationFeatureMutationResult>(
+    request: MutateIntegrationFacetRequest,
+  ): Promise<IntegrationFacetMutationResult> {
+    return await this.requestJson<IntegrationFacetMutationResult>(
       "POST",
-      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/features/${encodeURIComponent(featureKey)}/${action}`,
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets/${encodeURIComponent(facetKey)}/${action}`,
       request,
     );
   }
@@ -4674,6 +5335,27 @@ export class OpenGeniClient {
     );
   }
 
+  /** List Skills from the authoritative Plugin/Skill-Facet installation ledger. */
+  async listInstalledSkills(workspaceId: string): Promise<ListInstalledSkillsResponse> {
+    return await this.requestJson<ListInstalledSkillsResponse>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/skills`,
+    );
+  }
+
+  /** Install one exact reviewed curated-library Skill through the Skill domain. */
+  async installLibrarySkill(
+    workspaceId: string,
+    libraryId: string,
+    request: InstallLibrarySkillRequest,
+  ): Promise<InstalledSkill> {
+    return await this.requestJson<InstalledSkill>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/skills/library/${encodeURIComponent(libraryId)}/install`,
+      request,
+    );
+  }
+
   async previewSkillUninstall(
     workspaceId: string,
     capabilityId: string,
@@ -4728,6 +5410,34 @@ export class OpenGeniClient {
     return response.connection;
   }
 
+  /**
+   * Verify a pasted Fiken personal API token and store it as the
+   * workspace-shared Fiken connection (or rewrite an existing one in place).
+   */
+  async installFikenConnection(
+    workspaceId: string,
+    request: FikenInstallRequest,
+  ): Promise<ConnectionMetadata> {
+    const response = await this.requestJson<ConnectionResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/connections/fiken/install`,
+      request,
+    );
+    return response.connection;
+  }
+
+  /** Start the Fiken OAuth flow for the workspace-shared Fiken connection. */
+  async startFikenOAuth(
+    workspaceId: string,
+    request: FikenOAuthStartRequest = {},
+  ): Promise<FikenOAuthStartResponse> {
+    return await this.requestJson<FikenOAuthStartResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/connections/fiken/oauth/start`,
+      request,
+    );
+  }
+
   /** Start the public Slack installation flow for the workspace-shared OpenGeni bot. */
   async startOpenGeniSlackBotInstall(
     workspaceId: string,
@@ -5187,6 +5897,97 @@ export class OpenGeniClient {
     );
   }
 
+  // --- SuperGrok/xAI connected subscriptions ------------------------------------------------------
+
+  async supergrokStatus(workspaceId: string): Promise<SuperGrokConnectionStatus> {
+    return await this.requestJson<SuperGrokConnectionStatus>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/supergrok/status`,
+    );
+  }
+
+  async supergrokConnectStart(
+    workspaceId: string,
+    scope: SuperGrokAccountScope = "workspace",
+  ): Promise<SuperGrokConnectStart> {
+    return await this.requestJson<SuperGrokConnectStart>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/supergrok/connect/start`,
+      { scope },
+    );
+  }
+
+  async supergrokConnectPoll(workspaceId: string, state: string): Promise<SuperGrokConnectPoll> {
+    return await this.requestJson<SuperGrokConnectPoll>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/supergrok/connect/poll`,
+      { state },
+    );
+  }
+
+  async listSuperGrokAccounts(workspaceId: string): Promise<SuperGrokAccountsResponse> {
+    return await this.requestJson<SuperGrokAccountsResponse>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/supergrok/accounts`,
+    );
+  }
+
+  async activateSuperGrokAccount(
+    workspaceId: string,
+    accountId: string,
+  ): Promise<{ activated: boolean; accountId: string }> {
+    return await this.requestJson<{ activated: boolean; accountId: string }>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/supergrok/accounts/${accountId}/activate`,
+      {},
+    );
+  }
+
+  async setSuperGrokRotationSettings(
+    workspaceId: string,
+    patch: { rotationEnabled: boolean },
+  ): Promise<SuperGrokRotationSettings> {
+    return await this.requestJson<SuperGrokRotationSettings>(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/supergrok/settings`,
+      patch,
+    );
+  }
+
+  async setSuperGrokAccountAllocator(
+    workspaceId: string,
+    accountId: string,
+    input: { enabled: boolean; expectedVersion: number },
+  ): Promise<SuperGrokAllocatorUpdate> {
+    return await this.requestJson<SuperGrokAllocatorUpdate>(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/supergrok/accounts/${accountId}/allocator`,
+      input,
+    );
+  }
+
+  async renameSuperGrokAccount(
+    workspaceId: string,
+    accountId: string,
+    label: string | null,
+  ): Promise<SuperGrokAccount> {
+    return await this.requestJson<SuperGrokAccount>(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/supergrok/accounts/${accountId}`,
+      { label },
+    );
+  }
+
+  async disconnectSuperGrokAccount(
+    workspaceId: string,
+    accountId: string,
+  ): Promise<{ disconnected: boolean; newActiveId: string | null }> {
+    return await this.requestJson<{
+      disconnected: boolean;
+      newActiveId: string | null;
+    }>("DELETE", `/v1/workspaces/${workspaceId}/supergrok/accounts/${accountId}`, {});
+  }
+
   /** Contract-checked JSON transport shared by opt-in typed SDK clients. */
   async requestJson<T>(
     method: string,