@opengeni/sdk 0.52.1 → 1.0.1

package/dist/{chunk-ILQZR5N6.js → chunk-YGH5P47G.js}

@@ -1,3 +1,11 @@
+import {
+  COMPUTER_SCREENSHOT_MAX_BYTES,
+  GENERATED_VIDEO_MAX_BYTES,
+  OPENGENI_API_CONTRACT_HEADER,
+  OPENGENI_API_CONTRACT_REVISION,
+  OPENGENI_CORRELATION_HEADER,
+  RETAINED_OUTPUT_MAX_PAGE_BYTES
+} from "./chunk-4DV37UUA.js";
 import {
   OpenGeniApiContractMismatchError,
   OpenGeniApiError,
@@ -5,18 +13,10 @@ import {
   OpenGeniStreamError,
   isAbortError,
   isRetryableStreamError
-} from "./chunk-V5F253OG.js";
+} from "./chunk-GU6JF75T.js";
 import {
   OpenGeniInteractionClient
-} from "./chunk-MZWTWOX6.js";
-import {
-  COMPUTER_SCREENSHOT_MAX_BYTES,
-  GENERATED_VIDEO_MAX_BYTES,
-  OPENGENI_API_CONTRACT_HEADER,
-  OPENGENI_API_CONTRACT_REVISION,
-  OPENGENI_CORRELATION_HEADER,
-  RETAINED_OUTPUT_MAX_PAGE_BYTES
-} from "./chunk-FRJFNDIR.js";
+} from "./chunk-ST5DDKJP.js";
 
 // src/sse.ts
 async function* parseSseStream(stream) {
@@ -353,6 +353,177 @@ async function sleep2(delayMs, signal) {
   });
 }
 
+// src/interaction-revision-stream.ts
+async function* streamWorkspaceInteractionRevisions(transport, options = {}) {
+  const signal = options.signal;
+  const reconnect = options.reconnect ?? true;
+  const baseDelayMs = options.reconnectDelayMs ?? 500;
+  const maxDelayMs = options.maxReconnectDelayMs ?? 1e4;
+  const jitterRatio = options.reconnectJitterRatio ?? 0.2;
+  const beforeLiveTimeoutMs = options.beforeLiveTimeoutMs ?? 15e3;
+  const heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? 45e3;
+  const maxAttempts = options.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;
+  let cursor = options.after ?? 0;
+  let failures = 0;
+  let delayMs = baseDelayMs;
+  let everConnected = false;
+  for (; ; ) {
+    if (signal?.aborted) return;
+    options.onStateChange?.(everConnected || failures > 0 ? "reconnecting" : "connecting");
+    const cursorAtOpen = cursor;
+    try {
+      const body = await transport.openStream(cursor, signal);
+      everConnected = true;
+      failures = 0;
+      delayMs = baseDelayMs;
+      await runBeforeLive(options.beforeLive, beforeLiveTimeoutMs, signal);
+      options.onStateChange?.("live");
+      for await (const message of parseSseStream(
+        withStreamInactivityTimeout(body, heartbeatTimeoutMs, signal)
+      )) {
+        if (signal?.aborted) return;
+        const event = parseWorkspaceInteractionRevision(message.data);
+        if (!event || event.sequence <= cursor) continue;
+        cursor = event.sequence;
+        yield event;
+      }
+      if (!reconnect) return;
+      if (cursor === cursorAtOpen) await sleep3(jitteredDelay(baseDelayMs, jitterRatio), signal);
+      continue;
+    } catch (error) {
+      if (signal?.aborted || isAbortError(error)) return;
+      if (!reconnect || !isRetryableStreamError(error)) throw error;
+      failures += 1;
+      if (failures > maxAttempts) {
+        throw new OpenGeniStreamError(
+          `workspace interaction stream gave up after ${maxAttempts} reconnect attempts: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    await sleep3(jitteredDelay(delayMs, jitterRatio), signal);
+    delayMs = Math.min(Math.max(delayMs * 2, baseDelayMs), maxDelayMs);
+  }
+}
+function parseWorkspaceInteractionRevision(data) {
+  let value;
+  try {
+    value = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if (!isRecord(value) || value.type !== "workspace.interaction.changed" || typeof value.workspaceId !== "string" || typeof value.sequence !== "number" || !Number.isSafeInteger(value.sequence) || value.sequence < 0 || value.revision !== value.sequence || typeof value.occurredAt !== "string") {
+    return null;
+  }
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function sleep3(delayMs, signal) {
+  if (signal?.aborted || delayMs <= 0) return;
+  await new Promise((resolve) => {
+    const timer = setTimeout(done, delayMs);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+
+// src/workspace-live-stream.ts
+async function* streamWorkspaceLiveEvents(transport, options = {}) {
+  const signal = options.signal;
+  const reconnect = options.reconnect ?? true;
+  const baseDelayMs = options.reconnectDelayMs ?? 500;
+  const maxDelayMs = options.maxReconnectDelayMs ?? 1e4;
+  const jitterRatio = options.reconnectJitterRatio ?? 0.2;
+  const beforeLiveTimeoutMs = options.beforeLiveTimeoutMs ?? 15e3;
+  const heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? 45e3;
+  const maxAttempts = options.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;
+  let controlCursor = options.controlAfter ?? 0;
+  let interactionCursor = options.interactionAfter ?? 0;
+  let failures = 0;
+  let delayMs = baseDelayMs;
+  let everConnected = false;
+  for (; ; ) {
+    if (signal?.aborted) return;
+    options.onStateChange?.(everConnected || failures > 0 ? "reconnecting" : "connecting");
+    const cursorsAtOpen = `${controlCursor}:${interactionCursor}`;
+    try {
+      const body = await transport.openStream(controlCursor, interactionCursor, signal);
+      everConnected = true;
+      failures = 0;
+      delayMs = baseDelayMs;
+      await runBeforeLive(options.beforeLive, beforeLiveTimeoutMs, signal);
+      options.onStateChange?.("live");
+      for await (const message of parseSseStream(
+        withStreamInactivityTimeout(body, heartbeatTimeoutMs, signal)
+      )) {
+        if (signal?.aborted) return;
+        const event = parseWorkspaceLiveEvent(message.data);
+        if (!event) continue;
+        if (event.type === "workspace.control.changed") {
+          if (event.sequence <= controlCursor) continue;
+          controlCursor = event.sequence;
+        } else {
+          if (event.sequence <= interactionCursor) continue;
+          interactionCursor = event.sequence;
+        }
+        yield event;
+      }
+      if (!reconnect) return;
+      if (`${controlCursor}:${interactionCursor}` === cursorsAtOpen) {
+        await sleep4(jitteredDelay(baseDelayMs, jitterRatio), signal);
+      }
+      continue;
+    } catch (error) {
+      if (signal?.aborted || isAbortError(error)) return;
+      if (!reconnect || !isRetryableStreamError(error)) throw error;
+      failures += 1;
+      if (failures > maxAttempts) {
+        throw new OpenGeniStreamError(
+          `workspace live stream gave up after ${maxAttempts} reconnect attempts: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    await sleep4(jitteredDelay(delayMs, jitterRatio), signal);
+    delayMs = Math.min(Math.max(delayMs * 2, baseDelayMs), maxDelayMs);
+  }
+}
+function parseWorkspaceLiveEvent(data) {
+  let value;
+  try {
+    value = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if (!isRecord2(value) || typeof value.sequence !== "number") return null;
+  if (value.type === "workspace.control.changed" && typeof value.id === "string" && Number.isSafeInteger(value.sequence)) {
+    return value;
+  }
+  if (value.type === "workspace.interaction.changed" && typeof value.workspaceId === "string" && Number.isSafeInteger(value.sequence) && value.sequence >= 0 && value.revision === value.sequence && typeof value.occurredAt === "string") {
+    return value;
+  }
+  return null;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function sleep4(delayMs, signal) {
+  if (signal?.aborted || delayMs <= 0) return;
+  await new Promise((resolve) => {
+    const timer = setTimeout(done, delayMs);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+
 // src/retained-artifacts.ts
 var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 var SHA256 = /^[0-9a-f]{64}$/;
@@ -900,6 +1071,16 @@ var OpenGeniClient = class {
       { signal: options.signal }
     );
   }
+  /** Mint a short-lived browser token from a connected SuperGrok account. */
+  async negotiateXaiSubscriptionRealtime(workspaceId, sessionId, request, options = {}) {
+    return await this.requestJson(
+      "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, sessionId, realtimeId, connectionId, request, options = {}) {
     return await this.requestJson(
@@ -1409,6 +1590,50 @@ var OpenGeniClient = class {
   streamWorkspaceControlEvents(workspaceId, options = {}) {
     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, options = {}) {
+    return streamWorkspaceLiveEvents(this.workspaceLiveStreamTransport(workspaceId), options);
+  }
+  workspaceLiveStreamTransport(workspaceId) {
+    return {
+      openStream: async (controlAfter, interactionAfter, signal) => await this.openWorkspaceLiveEventStream(workspaceId, {
+        controlAfter,
+        interactionAfter,
+        ...signal ? { signal } : {}
+      })
+    };
+  }
+  async openWorkspaceLiveEventStream(workspaceId, options = {}) {
+    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) {
     return {
       openStream: async (after, signal) => await this.openWorkspaceControlEventStream(workspaceId, {
@@ -1469,6 +1694,19 @@ var OpenGeniClient = class {
       request
     );
   }
+  async listGoalRevisions(workspaceId, sessionId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/goal/revisions`
+    );
+  }
+  async applyGoalRevision(workspaceId, sessionId, revisionId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/goal/revisions/${revisionId}/apply`,
+      request
+    );
+  }
   async deleteGoal(workspaceId, sessionId) {
     await this.requestVoid("DELETE", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/goal`);
   }
@@ -1747,6 +1985,235 @@ var OpenGeniClient = class {
     );
   }
   // --- Browser / Computer interaction resources --------------------------------
+  streamWorkspaceInteractionRevisions(workspaceId, options = {}) {
+    return streamWorkspaceInteractionRevisions(
+      this.workspaceInteractionRevisionStreamTransport(workspaceId),
+      options
+    );
+  }
+  workspaceInteractionRevisionStreamTransport(workspaceId) {
+    return {
+      openStream: async (after, signal) => await this.openWorkspaceInteractionRevisionStream(workspaceId, {
+        after,
+        ...signal ? { signal } : {}
+      })
+    };
+  }
+  async openWorkspaceInteractionRevisionStream(workspaceId, options = {}) {
+    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, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/network-routes`,
+      void 0,
+      options.includeArchived ? { includeArchived: "true" } : {},
+      options
+    );
+  }
+  async getNetworkRoute(workspaceId, networkRouteId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/network-routes/${encodeURIComponent(networkRouteId)}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async createNetworkRoute(workspaceId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/network-routes`,
+      request,
+      {},
+      options
+    );
+  }
+  async updateNetworkRoute(workspaceId, networkRouteId, request, options = {}) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/network-routes/${encodeURIComponent(networkRouteId)}`,
+      request,
+      {},
+      options
+    );
+  }
+  async listSiteAuthConnections(workspaceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/site-auth-connections`,
+      void 0,
+      options.includeArchived ? { includeArchived: "true" } : {},
+      options
+    );
+  }
+  async getSiteAuthConnection(workspaceId, siteAuthConnectionId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/site-auth-connections/${encodeURIComponent(siteAuthConnectionId)}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async createSiteAuthConnection(workspaceId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/site-auth-connections`,
+      request,
+      {},
+      options
+    );
+  }
+  async updateSiteAuthConnection(workspaceId, siteAuthConnectionId, request, options = {}) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/site-auth-connections/${encodeURIComponent(siteAuthConnectionId)}`,
+      request,
+      {},
+      options
+    );
+  }
+  async listAuthRuns(workspaceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/auth-runs`,
+      void 0,
+      {
+        ...options.browserSessionId ? { browserSessionId: options.browserSessionId } : {},
+        ...options.siteAuthConnectionId ? { siteAuthConnectionId: options.siteAuthConnectionId } : {},
+        ...options.includeSettled ? { includeSettled: "true" } : {}
+      },
+      options
+    );
+  }
+  async getAuthRun(workspaceId, authRunId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/auth-runs/${encodeURIComponent(authRunId)}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async startBrowserAuthRun(workspaceId, browserSessionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs`,
+      request,
+      {},
+      options
+    );
+  }
+  async reportBrowserAuthRun(workspaceId, browserSessionId, authRunId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs/${encodeURIComponent(authRunId)}/report`,
+      request,
+      {},
+      options
+    );
+  }
+  async protectedBrowserAuthFill(workspaceId, browserSessionId, authRunId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs/${encodeURIComponent(authRunId)}/protected-fill`,
+      request,
+      {},
+      options
+    );
+  }
+  async advanceExternalBrowserAuthRun(workspaceId, browserSessionId, authRunId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs/${encodeURIComponent(authRunId)}/external-auth`,
+      request,
+      {},
+      options
+    );
+  }
+  async openExternalBrowserAuthFlow(workspaceId, browserSessionId, authRunId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs/${encodeURIComponent(authRunId)}/external-auth/interactive`,
+      request,
+      {},
+      options
+    );
+  }
+  async verifyBrowserAuthRun(workspaceId, browserSessionId, authRunId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/auth-runs/${encodeURIComponent(authRunId)}/verify`,
+      request,
+      {},
+      options
+    );
+  }
+  async listInteractionInterventions(workspaceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/interaction-interventions`,
+      void 0,
+      {
+        ...options.resourceKind ? { resourceKind: options.resourceKind } : {},
+        ...options.resourceId ? { resourceId: options.resourceId } : {},
+        ...options.includeSettled ? { includeSettled: "true" } : {}
+      },
+      options
+    );
+  }
+  async getInteractionIntervention(workspaceId, interventionId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/interaction-interventions/${encodeURIComponent(interventionId)}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async createInteractionIntervention(workspaceId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/interaction-interventions`,
+      request,
+      {},
+      options
+    );
+  }
+  async resolveInteractionIntervention(workspaceId, interventionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/interaction-interventions/${encodeURIComponent(interventionId)}/resolve`,
+      request,
+      {},
+      options
+    );
+  }
   async listAttachedBrowsers(workspaceId, options = {}) {
     return await this.requestJson(
       "GET",
@@ -1792,6 +2259,15 @@ var OpenGeniClient = class {
       options
     );
   }
+  async updateBrowserIdentity(workspaceId, identityId, request, options = {}) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/browser-identities/${encodeURIComponent(identityId)}`,
+      request,
+      {},
+      options
+    );
+  }
   async listBrowserRevisions(workspaceId, identityId, options = {}) {
     return await this.requestJson(
       "GET",
@@ -1821,6 +2297,42 @@ var OpenGeniClient = class {
       options
     );
   }
+  async readBrowserClipboard(workspaceId, browserSessionId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/clipboard`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async listBrowserDownloads(workspaceId, browserSessionId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/downloads`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async getBrowserDownload(workspaceId, browserSessionId, downloadId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/downloads/${encodeURIComponent(downloadId)}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async saveBrowserDownload(workspaceId, browserSessionId, downloadId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/downloads/${encodeURIComponent(downloadId)}/save`,
+      request,
+      {},
+      options
+    );
+  }
   async createBrowserSession(workspaceId, request, options = {}) {
     return await this.requestJson(
       "POST",
@@ -1980,6 +2492,15 @@ var OpenGeniClient = class {
       options
     );
   }
+  async readComputerClipboard(workspaceId, computerSessionId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}/clipboard`,
+      void 0,
+      {},
+      options
+    );
+  }
   async createComputerSession(workspaceId, request, options = {}) {
     return await this.requestJson(
       "POST",
@@ -2088,6 +2609,13 @@ var OpenGeniClient = class {
   async getAccessContext() {
     return await this.requestJson("GET", "/v1/access/me");
   }
+  /** Active organization memberships proven by the current managed-human session. */
+  async listOrganizationMemberships() {
+    return await this.requestJson(
+      "GET",
+      "/v1/organization-memberships"
+    );
+  }
   async listWorkspaces() {
     return await this.requestJson("GET", "/v1/workspaces");
   }
@@ -2527,6 +3055,41 @@ var OpenGeniClient = class {
       `/v1/workspaces/${workspaceId}/variable-sets/${variableSetId}/variables/${encodeURIComponent(name)}`
     );
   }
+  // --- 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) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/channels`);
+  }
+  async createChannel(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/channels`,
+      request
+    );
+  }
+  async updateChannel(workspaceId, channelId, request) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/channels/${channelId}`,
+      request
+    );
+  }
+  async deleteChannel(workspaceId, channelId) {
+    await this.requestJson(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/channels/${channelId}`
+    );
+  }
+  /** Re-file a session into a channel (null = back to the unfiled inbox). */
+  async updateSessionChannel(workspaceId, sessionId, request) {
+    return await this.requestJson(
+      "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.
@@ -3202,11 +3765,11 @@ var OpenGeniClient = class {
       `/v1/workspaces/${workspaceId}/integrations`
     );
   }
-  /** List curated provider presets without exposing deployment OAuth credentials. */
-  async listApiIntegrationPresets(workspaceId) {
+  /** List curated provider definitions without exposing deployment OAuth credentials. */
+  async listIntegrationDefinitions(workspaceId) {
     return await this.requestJson(
       "GET",
-      `/v1/workspaces/${workspaceId}/integrations/presets`
+      `/v1/workspaces/${workspaceId}/integrations/definitions`
     );
   }
   /** Detect and compile an Integration without mutating workspace state. */
@@ -3217,7 +3780,7 @@ var OpenGeniClient = class {
       request
     );
   }
-  /** 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, request) {
     return await this.requestJson(
       "POST",
@@ -3248,70 +3811,70 @@ var OpenGeniClient = class {
     );
   }
   /** List immutable provider facets and their exact per-account bindings. */
-  async listIntegrationFeatures(workspaceId, capabilityId, instanceKey) {
+  async listIntegrationFacets(workspaceId, capabilityId, instanceKey) {
     return await this.requestJson(
       "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(workspaceId, capabilityId, instanceKey, featureKey, request) {
+  /** Configure or OCC-update one adapter-owned facet on an Integration instance. */
+  async configureIntegrationFacet(workspaceId, capabilityId, instanceKey, facetKey, request) {
     return await this.requestJson(
       "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(workspaceId, capabilityId, instanceKey, featureKey, options = {}) {
+  async browseGoogleDriveFacetSource(workspaceId, capabilityId, instanceKey, facetKey, options = {}) {
     const query = new URLSearchParams();
     if (options.parentId) query.set("parentId", options.parentId);
     if (options.pageToken) query.set("pageToken", options.pageToken);
     const suffix = query.size > 0 ? `?${query}` : "";
     return await this.requestJson(
       "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(workspaceId, capabilityId, instanceKey, featureKey, request) {
+  async saveGoogleDriveFacetSource(workspaceId, capabilityId, instanceKey, facetKey, request) {
     return await this.requestJson(
       "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(workspaceId, capabilityId, instanceKey, featureKey, request) {
-    return await this.mutateIntegrationFeatureLifecycle(
+  async pauseIntegrationFacet(workspaceId, capabilityId, instanceKey, facetKey, request) {
+    return await this.mutateIntegrationFacetLifecycle(
       workspaceId,
       capabilityId,
       instanceKey,
-      featureKey,
+      facetKey,
       "pause",
       request
     );
   }
-  async resumeIntegrationFeature(workspaceId, capabilityId, instanceKey, featureKey, request) {
-    return await this.mutateIntegrationFeatureLifecycle(
+  async resumeIntegrationFacet(workspaceId, capabilityId, instanceKey, facetKey, request) {
+    return await this.mutateIntegrationFacetLifecycle(
       workspaceId,
       capabilityId,
       instanceKey,
-      featureKey,
+      facetKey,
       "resume",
       request
     );
   }
-  async removeIntegrationFeature(workspaceId, capabilityId, instanceKey, featureKey, request) {
+  async removeIntegrationFacet(workspaceId, capabilityId, instanceKey, facetKey, request) {
     return await this.requestJson(
       "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
     );
   }
-  async mutateIntegrationFeatureLifecycle(workspaceId, capabilityId, instanceKey, featureKey, action, request) {
+  async mutateIntegrationFacetLifecycle(workspaceId, capabilityId, instanceKey, facetKey, action, request) {
     return await this.requestJson(
       "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
     );
   }
@@ -3364,6 +3927,21 @@ var OpenGeniClient = class {
       request
     );
   }
+  /** List Skills from the authoritative Plugin/Skill-Facet installation ledger. */
+  async listInstalledSkills(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/skills`
+    );
+  }
+  /** Install one exact reviewed curated-library Skill through the Skill domain. */
+  async installLibrarySkill(workspaceId, libraryId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/skills/library/${encodeURIComponent(libraryId)}/install`,
+      request
+    );
+  }
   async previewSkillUninstall(workspaceId, capabilityId) {
     return await this.requestJson(
       "GET",
@@ -3402,6 +3980,26 @@ var OpenGeniClient = class {
     );
     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, request) {
+    const response = await this.requestJson(
+      "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, request = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/connections/fiken/oauth/start`,
+      request
+    );
+  }
   /** Start the public Slack installation flow for the workspace-shared OpenGeni bot. */
   async startOpenGeniSlackBotInstall(workspaceId, request = {}) {
     return await this.requestJson(
@@ -3727,6 +4325,64 @@ var OpenGeniClient = class {
       { target }
     );
   }
+  // --- SuperGrok/xAI connected subscriptions ------------------------------------------------------
+  async supergrokStatus(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/supergrok/status`
+    );
+  }
+  async supergrokConnectStart(workspaceId, scope = "workspace") {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/supergrok/connect/start`,
+      { scope }
+    );
+  }
+  async supergrokConnectPoll(workspaceId, state) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/supergrok/connect/poll`,
+      { state }
+    );
+  }
+  async listSuperGrokAccounts(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/supergrok/accounts`
+    );
+  }
+  async activateSuperGrokAccount(workspaceId, accountId) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/supergrok/accounts/${accountId}/activate`,
+      {}
+    );
+  }
+  async setSuperGrokRotationSettings(workspaceId, patch) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/supergrok/settings`,
+      patch
+    );
+  }
+  async setSuperGrokAccountAllocator(workspaceId, accountId, input) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/supergrok/accounts/${accountId}/allocator`,
+      input
+    );
+  }
+  async renameSuperGrokAccount(workspaceId, accountId, label) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/supergrok/accounts/${accountId}`,
+      { label }
+    );
+  }
+  async disconnectSuperGrokAccount(workspaceId, accountId) {
+    return await this.requestJson("DELETE", `/v1/workspaces/${workspaceId}/supergrok/accounts/${accountId}`, {});
+  }
   /** Contract-checked JSON transport shared by opt-in typed SDK clients. */
   async requestJson(method, path, body, query = {}, options = {}) {
     const correlationId = crypto.randomUUID();
@@ -4016,6 +4672,9 @@ export {
   parseSseStream,
   streamSessionEvents,
   streamWorkspaceControlEvents,
+  streamWorkspaceInteractionRevisions,
+  streamWorkspaceLiveEvents,
+  parseWorkspaceLiveEvent,
   parseRetainedGeneratedImageReference,
   generatedImageSandboxPathMatches,
   parseGeneratedImageReceipt,
@@ -4024,4 +4683,4 @@ export {
   parseMediaGenerationResult,
   OpenGeniClient
 };
-//# sourceMappingURL=chunk-ILQZR5N6.js.map
+//# sourceMappingURL=chunk-YGH5P47G.js.map