@opengeni/sdk 0.48.0 → 0.57.0

package/dist/{chunk-MBGBLVUV.js → chunk-PKQ377ED.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-HJ3HHUT5.js";
 import {
   OpenGeniApiContractMismatchError,
   OpenGeniApiError,
@@ -5,7 +13,10 @@ import {
   OpenGeniStreamError,
   isAbortError,
   isRetryableStreamError
-} from "./chunk-V5F253OG.js";
+} from "./chunk-GU6JF75T.js";
+import {
+  OpenGeniInteractionClient
+} from "./chunk-ST5DDKJP.js";
 
 // src/sse.ts
 async function* parseSseStream(stream) {
@@ -342,203 +353,348 @@ async function sleep2(delayMs, signal) {
   });
 }
 
-// src/types.ts
-var DEFAULT_FILE_RESOURCE_MOUNT_ROOT = ".opengeni/files";
-var SESSION_EVENT_TYPES = [
-  "session.created",
-  // Defensive bounded projection for malformed/legacy oversized envelopes.
-  "session.event.envelope_omitted",
-  "session.status.changed",
-  "session.realtime.started",
-  "session.realtime.ended",
-  "session.requiresAction",
-  "session.humanInput.requested",
-  "session.context.compaction.requested",
-  "session.context.compaction.started",
-  "session.context.compacted",
-  "session.context.compaction.skipped",
-  "session.context.cleared",
-  "user.message",
-  "user.pause",
-  "user.approvalDecision",
-  "user.humanInputResponse",
-  "turn.queued",
-  "turn.started",
-  "turn.completed",
-  "turn.failed",
-  "turn.cancelled",
-  "turn.superseded",
-  "turn.recovery.requested",
-  "turn.capacity_waiting",
-  "agent.message.delta",
-  "agent.message.completed",
-  "agent.reasoning.delta",
-  "agent.toolCall.created",
-  "agent.toolCall.output",
-  "agent.model.request",
-  "agent.model.usage",
-  "tool.auth_needed",
-  "credential.auth_needed",
-  "agent.updated",
-  "rig.setup.started",
-  "rig.setup.completed",
-  "rig.setup.skipped",
-  "rig.setup.failed",
-  "sandbox.operation.started",
-  "sandbox.operation.completed",
-  "sandbox.operation.failed",
-  "sandbox.command.output.delta",
-  "artifact.created",
-  "goal.set",
-  "goal.updated",
-  "goal.completed",
-  "goal.paused",
-  "goal.resumed",
-  "goal.cleared",
-  "goal.continuation",
-  "system.update.pending",
-  "system.update.delivered",
-  "system.update.superseded",
-  "system.update.cancelled",
-  "system.update.settled",
-  "session.control.paused",
-  "session.control.resumed",
-  "session.control.steer_requested",
-  "workspace.inference.paused",
-  "workspace.inference.resumed",
-  "session.queue.changed",
-  "session.queue.prompt.cancelled",
-  "session.queue.history",
-  "turn.event.rejected_late",
-  "memory.saved",
-  "memory.corrected",
-  // Channel-B desktop pixel-plane signals (mirror of contracts SessionEventType;
-  // the contract-parity test asserts sorted equality).
-  "stream.url.rotated",
-  "stream.opened",
-  "stream.closed",
-  "stream.revoked",
-  // Channel-B recording signals (P4.3 — "agent films itself proving the fix").
-  "recording.started",
-  "recording.available",
-  "recording.failed",
-  // Channel-A structured-service notifications (P4.4; mirror of contracts
-  // SessionEventType — the contract-parity test asserts sorted equality).
-  "fs.changed",
-  "git.changed",
-  "terminal.pty.started",
-  "terminal.pty.output.delta",
-  "terminal.pty.exited",
-  "session.title_set",
-  "session.mcp.approval_policy.updated",
-  "session.tool_policy.updated",
-  // Multi-account Codex (P1): the session's inference account changed.
-  "codex.account.switched",
-  // credential allocator metadata-only per-turn credential selection audit.
-  "codex.credential.selected",
-  // Bounded, identity-free deterministic shadow/replay decision.
-  "codex.fleet.decision",
-  // credential allocator durable zero-capacity wait lifecycle. These are system/runtime
-  // events, never synthetic user messages.
-  "codex.capacity.waiting",
-  "codex.capacity.resumed",
-  "codex.capacity.superseded",
-  // Sandbox durability observability (mirror of contracts SessionEventType):
-  // box lifecycle + manifest-env drift, attributable from the DB alone.
-  "sandbox.box.created",
-  "sandbox.box.lost",
-  "sandbox.box.terminated",
-  "sandbox.box.snapshot",
-  "sandbox.env.drift",
-  // Active-sandbox pointer reconcile (issue #341; announce-only; mirror of contracts
-  // SessionEventType — the contract-parity test asserts sorted equality).
-  "session.route.reconciled",
-  // Workbench v2 turn-end workspace capture (announce-only; mirror of contracts
-  // SessionEventType — the contract-parity test asserts sorted equality).
-  "workspace.revision.captured",
-  "workspace.revision.degraded",
-  // Connected Machine op-outcome observability (announce-only, quiet; mirror of
-  // contracts SessionEventType — the contract-parity test asserts sorted equality).
-  "machine.op.failed",
-  "machine.op.recovered",
-  // Connected Machine link-plane observability (announce-only, quiet; mirror of
-  // contracts SessionEventType — the contract-parity test asserts sorted equality).
-  "machine.link.lost",
-  "machine.link.restored",
-  "machine.runner.restarted"
-];
-var KNOWN_PERMISSIONS = [
-  "account:read",
-  "account:admin",
-  "members:manage",
-  "workspace:create",
-  "billing:read",
-  "billing:manage",
-  "workspace:read",
-  "workspace:admin",
-  "sessions:create",
-  "sessions:read",
-  "sessions:control",
-  // sandbox workspace (mirror of @opengeni/contracts Permission). stream:view is
-  // strictly broader than sessions:read (un-redacted pixels); stream:control is
-  // the never-granted-v1 raw-input plane; stream:acknowledge is the secret-leak
-  // consent gate.
-  "stream:view",
-  "stream:control",
-  "stream:acknowledge",
-  "files:upload",
-  "files:read",
-  "files:write",
-  "terminal:attach",
-  "documents:manage",
-  "documents:search",
-  "scheduled_tasks:manage",
-  "scheduled_tasks:run",
-  "github:manage",
-  "github:use",
-  "api_keys:manage",
-  "connections:read",
-  "connections:write",
-  "environments:manage",
-  "environments:use",
-  "variable-sets:list",
-  "variable-sets:read",
-  "variable-sets:write",
-  "variable-sets:manage",
-  "variable-sets:use",
-  "secrets:list",
-  "secrets:read",
-  "secrets:write",
-  "mcp_servers:attach",
-  "toolspace:call",
-  "goals:manage",
-  "enrollments:read",
-  "enrollments:manage",
-  "rigs:use",
-  "rigs:manage",
-  "artifacts:read",
-  "artifacts:publish"
-];
-var OPENGENI_API_CONTRACT_REVISION = "2026-07-workspace-artifacts-v1";
-var OPENGENI_API_CONTRACT_HEADER = "x-opengeni-api-contract";
-var OPENGENI_CORRELATION_HEADER = "x-opengeni-correlation-id";
-var RETAINED_OUTPUT_DEFAULT_PAGE_BYTES = 256 * 1024;
-var RETAINED_OUTPUT_MAX_PAGE_BYTES = 1024 * 1024;
-var COMPUTER_SCREENSHOT_MAX_BYTES = 32 * 1024 * 1024;
-var KNOWN_USAGE_EVENT_TYPES = [
-  "agent_run.created",
-  "agent_run.completed",
-  "model.tokens",
-  "model.cost",
-  "file.uploaded",
-  "file.deleted",
-  "document.indexed",
-  "scheduled_task.fired",
-  "api_key.request",
-  // sandbox warm-time metering (P2.1) — mirrors contracts UsageEventType.
-  "sandbox.warm_seconds",
-  "sandbox.warm_cost"
-];
+// 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}$/;
+var ISO_DATETIME_WITH_OFFSET = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+var WORKSPACE_PATH = /^\/v1\/workspaces\/([0-9a-f-]+)\/artifacts\/([0-9a-f-]+)\/content$/;
+var MAX_BYTES = 64 * 1024 * 1024;
+var MAX_VIDEO_BYTES = 512 * 1024 * 1024;
+var MAX_DIMENSION = 16384;
+var MAX_PIXELS = 67108864;
+var MAX_RANGE_BYTES = 1024 * 1024;
+function parseRetainedGeneratedImageReference(value, expectedWorkspaceId) {
+  if (!recordWithKeys(value, GENERATED_IMAGE_REFERENCE_KEYS)) return null;
+  const artifact = value;
+  if (artifact.available !== true || artifact.kind !== "generated_image" || typeof artifact.artifactId !== "string" || !UUID.test(artifact.artifactId) || !["image/png", "image/jpeg", "image/webp"].includes(String(artifact.contentType)) || !safeIntegerBetween(artifact.originalBytes, 1, MAX_BYTES) || typeof artifact.sha256 !== "string" || !SHA256.test(artifact.sha256) || typeof artifact.retainedAt !== "string" || artifact.retainedAt.length > 64 || !ISO_DATETIME_WITH_OFFSET.test(artifact.retainedAt) || !Number.isFinite(Date.parse(artifact.retainedAt)) || !recordWithKeys(artifact.dimensions, DIMENSION_KEYS) || !recordWithKeys(artifact.retention, RETENTION_KEYS) || !recordWithKeys(artifact.retrieval, RETRIEVAL_KEYS)) {
+    return null;
+  }
+  const dimensions = artifact.dimensions;
+  if (!safeIntegerBetween(dimensions.width, 1, MAX_DIMENSION) || !safeIntegerBetween(dimensions.height, 1, MAX_DIMENSION) || Number(dimensions.width) * Number(dimensions.height) > MAX_PIXELS) {
+    return null;
+  }
+  const retention = artifact.retention;
+  if (retention.policy !== "workspace_file" || retention.expiresAt !== null) return null;
+  const retrieval = artifact.retrieval;
+  if (retrieval.method !== "GET" || retrieval.acceptRanges !== "bytes" || retrieval.maxRangeBytes !== MAX_RANGE_BYTES || typeof retrieval.path !== "string" || retrieval.path.length > 256) {
+    return null;
+  }
+  const match = WORKSPACE_PATH.exec(retrieval.path);
+  if (!match || !UUID.test(match[1] ?? "") || match[2] !== artifact.artifactId || expectedWorkspaceId !== void 0 && match[1] !== expectedWorkspaceId) {
+    return null;
+  }
+  return value;
+}
+function generatedImageSandboxPathMatches(artifact, sandboxPath) {
+  if (typeof sandboxPath !== "string") return false;
+  const extension = artifact.contentType === "image/png" ? "png" : artifact.contentType === "image/jpeg" ? "jpg" : artifact.contentType === "image/webp" ? "webp" : null;
+  return extension !== null && sandboxPath === `/workspace/generated-images/generated-image-${artifact.artifactId}.${extension}`;
+}
+function parseGeneratedImageReceipt(value, expectedWorkspaceId) {
+  if (typeof value === "string" && value.length <= 4096) {
+    try {
+      return parseGeneratedImageReceipt(JSON.parse(value), expectedWorkspaceId);
+    } catch {
+      return null;
+    }
+  }
+  if (!recordWithKeys(value, GENERATED_IMAGE_RECEIPT_KEYS)) return null;
+  if (value.type !== "generated_image") return null;
+  const artifact = parseRetainedGeneratedImageReference(value.artifact, expectedWorkspaceId);
+  if (!artifact || !generatedImageSandboxPathMatches(artifact, value.sandboxPath)) return null;
+  return { type: "generated_image", artifact, sandboxPath: value.sandboxPath };
+}
+function parseRetainedGeneratedVideoReference(value, expectedWorkspaceId) {
+  if (!recordWithKeys(value, GENERATED_IMAGE_REFERENCE_KEYS)) return null;
+  const artifact = value;
+  if (artifact.available !== true || artifact.kind !== "generated_video" || typeof artifact.artifactId !== "string" || !UUID.test(artifact.artifactId) || artifact.contentType !== "video/mp4" || !safeIntegerBetween(artifact.originalBytes, 1, MAX_VIDEO_BYTES) || typeof artifact.sha256 !== "string" || !SHA256.test(artifact.sha256) || typeof artifact.retainedAt !== "string" || artifact.retainedAt.length > 64 || !ISO_DATETIME_WITH_OFFSET.test(artifact.retainedAt) || !Number.isFinite(Date.parse(artifact.retainedAt)) || !recordWithKeys(artifact.dimensions, DIMENSION_KEYS) || !recordWithKeys(artifact.retention, RETENTION_KEYS) || !recordWithKeys(artifact.retrieval, RETRIEVAL_KEYS)) {
+    return null;
+  }
+  const dimensions = artifact.dimensions;
+  if (!safeIntegerBetween(dimensions.width, 1, 8192) || !safeIntegerBetween(dimensions.height, 1, 8192)) {
+    return null;
+  }
+  const retention = artifact.retention;
+  if (retention.policy !== "workspace_file" || retention.expiresAt !== null) return null;
+  const retrieval = artifact.retrieval;
+  if (retrieval.method !== "GET" || retrieval.acceptRanges !== "bytes" || retrieval.maxRangeBytes !== MAX_RANGE_BYTES || typeof retrieval.path !== "string" || retrieval.path.length > 256) {
+    return null;
+  }
+  const match = WORKSPACE_PATH.exec(retrieval.path);
+  if (!match || !UUID.test(match[1] ?? "") || match[2] !== artifact.artifactId || expectedWorkspaceId !== void 0 && match[1] !== expectedWorkspaceId) {
+    return null;
+  }
+  return value;
+}
+function parseGeneratedVideoReceipt(value, expectedWorkspaceId) {
+  if (typeof value === "string" && value.length <= 8192) {
+    try {
+      return parseGeneratedVideoReceipt(JSON.parse(value), expectedWorkspaceId);
+    } catch {
+      return null;
+    }
+  }
+  if (!recordWithKeys(value, GENERATED_VIDEO_RECEIPT_KEYS)) return null;
+  if (value.type !== "generated_video" || value.schemaVersion !== 1 || typeof value.operationId !== "string" || !UUID.test(value.operationId) || !recordWithKeys(value.video, GENERATED_VIDEO_FACT_KEYS)) {
+    return null;
+  }
+  const artifact = parseRetainedGeneratedVideoReference(value.artifact, expectedWorkspaceId);
+  const video = value.video;
+  if (!artifact || typeof value.sandboxPath !== "string" || value.sandboxPath !== `/workspace/generated-videos/generated-video-${artifact.artifactId}.mp4` || typeof video.durationSeconds !== "number" || !Number.isFinite(video.durationSeconds) || video.durationSeconds <= 0 || video.durationSeconds > 120 || video.width !== artifact.dimensions?.width || video.height !== artifact.dimensions?.height || typeof video.fps !== "number" || !Number.isFinite(video.fps) || video.fps <= 0 || video.fps > 120 || typeof video.hasAudio !== "boolean" || video.videoCodec !== "h264" || video.audioCodec !== null && video.audioCodec !== "aac") {
+    return null;
+  }
+  return value;
+}
+function parseMediaGenerationResult(value, expectedWorkspaceId) {
+  if (typeof value === "string" && value.length <= 12e3) {
+    try {
+      return parseMediaGenerationResult(JSON.parse(value), expectedWorkspaceId);
+    } catch {
+      return null;
+    }
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const result = value;
+  if (result.type !== "media_generation_result" || result.schemaVersion !== 1 || typeof result.operationId !== "string" || !UUID.test(result.operationId)) {
+    return null;
+  }
+  if (result.status === "ready") {
+    if (!recordWithKeys(result, MEDIA_RESULT_READY_KEYS)) return null;
+    const receipt = parseGeneratedVideoReceipt(result.receipt, expectedWorkspaceId);
+    if (!receipt || receipt.operationId !== result.operationId) return null;
+    return value;
+  }
+  if (!["provider_failed", "retention_failed", "cancelled_before_submit", "outcome_unknown"].includes(
+    String(result.status)
+  ) || !recordWithKeys(result, MEDIA_RESULT_FAILURE_KEYS) || typeof result.boundedPublicReason !== "string" || result.boundedPublicReason.length < 1 || result.boundedPublicReason.length > 1e3) {
+    return null;
+  }
+  return value;
+}
+var GENERATED_IMAGE_REFERENCE_KEYS = /* @__PURE__ */ new Set([
+  "available",
+  "artifactId",
+  "kind",
+  "contentType",
+  "originalBytes",
+  "sha256",
+  "retainedAt",
+  "dimensions",
+  "retention",
+  "retrieval"
+]);
+var DIMENSION_KEYS = /* @__PURE__ */ new Set(["width", "height"]);
+var RETENTION_KEYS = /* @__PURE__ */ new Set(["policy", "expiresAt"]);
+var RETRIEVAL_KEYS = /* @__PURE__ */ new Set(["method", "path", "acceptRanges", "maxRangeBytes"]);
+var GENERATED_IMAGE_RECEIPT_KEYS = /* @__PURE__ */ new Set(["type", "artifact", "sandboxPath"]);
+var GENERATED_VIDEO_RECEIPT_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "schemaVersion",
+  "operationId",
+  "artifact",
+  "video",
+  "sandboxPath"
+]);
+var GENERATED_VIDEO_FACT_KEYS = /* @__PURE__ */ new Set([
+  "durationSeconds",
+  "width",
+  "height",
+  "fps",
+  "hasAudio",
+  "videoCodec",
+  "audioCodec"
+]);
+var MEDIA_RESULT_READY_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "schemaVersion",
+  "status",
+  "operationId",
+  "receipt"
+]);
+var MEDIA_RESULT_FAILURE_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "schemaVersion",
+  "status",
+  "operationId",
+  "boundedPublicReason"
+]);
+function recordWithKeys(value, allowed) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === allowed.size && Object.keys(value).every((key) => allowed.has(key));
+}
+function safeIntegerBetween(value, min, max) {
+  return Number.isSafeInteger(value) && Number(value) >= min && Number(value) <= max;
+}
 
 // src/client.ts
 function sessionListQuery(options) {
@@ -554,10 +710,13 @@ var OpenGeniClient = class {
   fetchImpl;
   readInFlight = /* @__PURE__ */ new Map();
   readTrailing = /* @__PURE__ */ new Map();
+  /** Resource-oriented Browser/Computer facade over this exact authenticated client. */
+  interaction;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.options = options;
     this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+    this.interaction = new OpenGeniInteractionClient(this);
   }
   // --- Session lifecycle ---------------------------------------------------
   /** Make one finalization attempt for a recording; callers may retry retained audio. */
@@ -839,6 +998,21 @@ var OpenGeniClient = class {
     }
     return response;
   }
+  /** Compact, bounded workspace agent hierarchy page. */
+  async listAgentTopology(workspaceId, options = {}) {
+    const search = options.search?.trim();
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/agent-topology`,
+      void 0,
+      {
+        ...options.limit !== void 0 ? { limit: String(options.limit) } : {},
+        ...options.parentSessionId === void 0 ? {} : { parentSessionId: options.parentSessionId ?? "null" },
+        ...options.cursor ? { cursor: options.cursor } : {},
+        ...search ? { search } : {}
+      }
+    );
+  }
   /** Set this authenticated member's personal workspace pin for a session. */
   async updateSessionPin(workspaceId, sessionId, request) {
     return await this.requestJson(
@@ -897,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(
@@ -1406,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, {
@@ -1466,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`);
   }
@@ -1714,13 +1955,11 @@ var OpenGeniClient = class {
     );
   }
   /** 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. */
+   *  watched/used), spinning the box up in-process when cold. Exact plane flags
+   *  mint only the requested short-lived credentials and enforce that plane's
+   *  permission. `desktop:true` alone carries the un-redacted/shared consent
+   *  gate. An entirely omitted plane set retains the legacy terminal-only
+   *  meaning; current clients should send all three flags. */
   async attachViewer(workspaceId, sessionId, request = {}) {
     return await this.requestJson(
       "POST",
@@ -1745,15 +1984,604 @@ var OpenGeniClient = class {
       `/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() {
+  // --- 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",
+      `/v1/workspaces/${workspaceId}/attached-browsers`,
+      void 0,
+      options.includeDisconnected ? { includeDisconnected: "true" } : {},
+      options
+    );
+  }
+  async getAttachedBrowser(workspaceId, deviceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/attached-browsers/${encodeURIComponent(deviceId)}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async listBrowserIdentities(workspaceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-identities`,
+      void 0,
+      options.includeArchived ? { includeArchived: "true" } : {},
+      options
+    );
+  }
+  async getBrowserIdentity(workspaceId, identityId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-identities/${encodeURIComponent(identityId)}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async createBrowserIdentity(workspaceId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-identities`,
+      request,
+      {},
+      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",
+      `/v1/workspaces/${workspaceId}/browser-identities/${encodeURIComponent(identityId)}/revisions`,
+      void 0,
+      {},
+      options
+    );
+  }
+  /** Workspace-wide BrowserSession inventory. Associations express relevance,
+   *  not access: peers and child agents intentionally remain discoverable. */
+  async listBrowserSessions(workspaceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async getBrowserSession(workspaceId, browserSessionId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}`,
+      void 0,
+      {},
+      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",
+      `/v1/workspaces/${workspaceId}/browser-sessions`,
+      request,
+      {},
+      options
+    );
+  }
+  async listBrowserTargets(workspaceId, browserSessionId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/targets`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async openBrowserTarget(workspaceId, browserSessionId, request = {}, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/targets`,
+      request,
+      {},
+      options
+    );
+  }
+  async selectBrowserTarget(workspaceId, browserSessionId, targetId, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/targets/${encodeURIComponent(targetId)}/select`,
+      {},
+      {},
+      options
+    );
+  }
+  async closeBrowserTarget(workspaceId, browserSessionId, targetId, options = {}) {
+    return await this.requestJson(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/targets/${encodeURIComponent(targetId)}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async observeBrowserTarget(workspaceId, browserSessionId, targetId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/targets/${encodeURIComponent(targetId)}/observation`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async actInBrowser(workspaceId, browserSessionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/actions`,
+      request,
+      {},
+      options
+    );
+  }
+  async getBrowserActionReceipt(workspaceId, browserSessionId, operationId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/operations/${encodeURIComponent(operationId)}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async listBrowserDiagnostics(workspaceId, browserSessionId, targetId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/targets/${encodeURIComponent(targetId)}/diagnostics`,
+      void 0,
+      {
+        ...options.kinds?.length ? { kinds: options.kinds.join(",") } : {},
+        ...options.after !== void 0 ? { after: String(options.after) } : {},
+        ...options.limit !== void 0 ? { limit: String(options.limit) } : {}
+      },
+      options.signal ? { signal: options.signal } : {}
+    );
+  }
+  async attachBrowserSession(workspaceId, browserSessionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/attachments`,
+      request,
+      {},
+      options
+    );
+  }
+  async heartbeatBrowserSession(workspaceId, browserSessionId, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/heartbeat`,
+      {},
+      {},
+      options
+    );
+  }
+  async publishBrowserRevision(workspaceId, browserSessionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/revisions`,
+      request,
+      {},
+      options
+    );
+  }
+  async suspendBrowserSession(workspaceId, browserSessionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/suspend`,
+      request,
+      {},
+      options
+    );
+  }
+  async resumeBrowserSession(workspaceId, browserSessionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/resume`,
+      request,
+      {},
+      options
+    );
+  }
+  async endBrowserSession(workspaceId, browserSessionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/browser-sessions/${encodeURIComponent(browserSessionId)}/end`,
+      request,
+      {},
+      options
+    );
+  }
+  /** Workspace-wide ComputerSession inventory. Associations express
+   * relevance, not access; peer sessions intentionally remain discoverable. */
+  async listComputerSessions(workspaceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/computer-sessions`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async getComputerSession(workspaceId, computerSessionId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}`,
+      void 0,
+      {},
+      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",
+      `/v1/workspaces/${workspaceId}/computer-sessions`,
+      request,
+      {},
+      options
+    );
+  }
+  async listComputerTargets(workspaceId, computerSessionId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}/targets`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async observeComputerTarget(workspaceId, computerSessionId, targetId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}/targets/${encodeURIComponent(targetId)}/observation`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async actInComputer(workspaceId, computerSessionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}/actions`,
+      request,
+      {},
+      options
+    );
+  }
+  async getComputerActionReceipt(workspaceId, computerSessionId, operationId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}/operations/${encodeURIComponent(operationId)}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  async attachComputerSession(workspaceId, computerSessionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}/attachments`,
+      request,
+      {},
+      options
+    );
+  }
+  async heartbeatComputerSession(workspaceId, computerSessionId, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}/heartbeat`,
+      {},
+      {},
+      options
+    );
+  }
+  async endComputerSession(workspaceId, computerSessionId, request, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}/end`,
+      request,
+      {},
+      options
+    );
+  }
+  // --- 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() {
     const config = await this.requestJson("GET", "/v1/config/client");
     if (config.apiContractRevision !== OPENGENI_API_CONTRACT_REVISION) {
       throw new OpenGeniApiContractMismatchError(
@@ -1781,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");
   }
@@ -1892,6 +2727,52 @@ var OpenGeniClient = class {
       request
     );
   }
+  /** Read the current organization profile plus immutable revision and activation history. */
+  async listCompanyProfile(workspaceId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.afterRevision !== void 0)
+      params.set("afterRevision", String(options.afterRevision));
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    const query = params.toString();
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/company-profile${query ? `?${query}` : ""}`
+    );
+  }
+  async getCompanyProfileRevision(workspaceId, revisionId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/company-profile/revisions/${encodeURIComponent(revisionId)}`
+    );
+  }
+  async updateCompanyProfile(workspaceId, request) {
+    return await this.requestJson(
+      "PUT",
+      `/v1/workspaces/${workspaceId}/company-profile`,
+      request
+    );
+  }
+  async diffCompanyProfileRevisions(workspaceId, request) {
+    const params = new URLSearchParams(request);
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/company-profile/diff?${params}`
+    );
+  }
+  async activateCompanyProfileRevision(workspaceId, revisionId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/company-profile/revisions/${encodeURIComponent(revisionId)}/activate`,
+      request
+    );
+  }
+  async rollbackCompanyProfile(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/company-profile/rollback`,
+      request
+    );
+  }
   async listPreferenceRegistry(workspaceId, options = {}) {
     const params = new URLSearchParams();
     if (options.scope) params.set("scope", options.scope);
@@ -1998,21 +2879,70 @@ var OpenGeniClient = class {
       request
     );
   }
-  async updateWorkspaceMember(workspaceId, subjectId, request) {
+  async updateWorkspaceMember(workspaceId, subjectId, request) {
+    return await this.requestJson(
+      "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, subjectId) {
+    await this.requestVoid(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/members/${encodeURIComponent(subjectId)}`
+    );
+  }
+  /** Exchange one signed Slack bearer for durable, token-free continuation state. */
+  async prepareSlackUserLinkAccess(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/integrations/slack/user-link-intents`,
+      request
+    );
+  }
+  async getSlackUserLinkAccess(workspaceId, requestId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/integrations/slack/user-link-intents/${requestId}`
+    );
+  }
+  async requestSlackUserLinkWorkspaceAccess(workspaceId, requestId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/integrations/slack/user-link-intents/${requestId}/request-access`,
+      request
+    );
+  }
+  async cancelSlackUserLinkAccess(workspaceId, requestId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/integrations/slack/user-link-intents/${requestId}/cancel`,
+      request
+    );
+  }
+  async listSlackUserLinkAccessRequests(workspaceId) {
+    const response = await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/members/access-requests/slack`
+    );
+    return response.requests;
+  }
+  async approveSlackUserLinkAccessRequest(workspaceId, requestId, request) {
     return await this.requestJson(
-      "PATCH",
-      `/v1/workspaces/${workspaceId}/members/${encodeURIComponent(subjectId)}`,
+      "POST",
+      `/v1/workspaces/${workspaceId}/members/access-requests/slack/${requestId}/approve`,
       request
     );
   }
-  /**
-   * Remove a member. Refused (409) for your own membership and for the last
-   * member who can still manage the workspace.
-   */
-  async removeWorkspaceMember(workspaceId, subjectId) {
-    await this.requestVoid(
-      "DELETE",
-      `/v1/workspaces/${workspaceId}/members/${encodeURIComponent(subjectId)}`
+  async denySlackUserLinkAccessRequest(workspaceId, requestId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/members/access-requests/slack/${requestId}/deny`,
+      request
     );
   }
   // --- Scheduled tasks (write + runs) -------------------------------------------
@@ -2125,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.
@@ -2367,21 +3332,38 @@ var OpenGeniClient = class {
       options
     );
   }
+  /** Assemble one permanent generated-image receipt from bounded authenticated ranges. */
+  async downloadRetainedArtifact(workspaceId, artifact, options = {}) {
+    assertRetainedGeneratedImageReceipt(workspaceId, artifact);
+    const bytes = await this.downloadRetainedArtifactBytes(artifact, options);
+    return { artifact, bytes };
+  }
+  /** Mint a short-lived, zero-copy browser source for a validated generated image. */
+  async createRetainedArtifactDownloadUrl(workspaceId, artifact, options = {}) {
+    assertRetainedGeneratedImageReceipt(workspaceId, artifact);
+    const download = await this.createFileDownloadUrl(workspaceId, artifact.artifactId, options);
+    assertSafeArtifactDownloadUrl(download);
+    return download;
+  }
   /** Assemble one retained screenshot from bounded authenticated API ranges. */
   async downloadRetainedScreenshot(workspaceId, sessionId, artifactId, options = {}) {
-    const maxRetries = options.maxRetries ?? 2;
-    if (!Number.isInteger(maxRetries) || maxRetries < 0 || maxRetries > 3) {
-      throw new RangeError("retained screenshot maxRetries must be an integer from 0 to 3");
-    }
     const metadata = await this.getSessionRetainedArtifact(workspaceId, sessionId, artifactId);
     if (!metadata.available) return { metadata, bytes: null };
     if (metadata.kind !== "computer_screenshot" || metadata.contentType !== "image/png" || !metadata.dimensions || metadata.originalBytes <= 0 || metadata.originalBytes > COMPUTER_SCREENSHOT_MAX_BYTES) {
       throw new OpenGeniApiError(502, "retained screenshot metadata is invalid");
     }
-    const bytes = new Uint8Array(metadata.originalBytes);
-    const pageBytes = Math.min(metadata.retrieval.maxRangeBytes, RETAINED_OUTPUT_MAX_PAGE_BYTES);
+    const bytes = await this.downloadRetainedArtifactBytes(metadata, options);
+    return { metadata, bytes };
+  }
+  async downloadRetainedArtifactBytes(artifact, options) {
+    const maxRetries = options.maxRetries ?? 2;
+    if (!Number.isInteger(maxRetries) || maxRetries < 0 || maxRetries > 3) {
+      throw new RangeError("retained artifact maxRetries must be an integer from 0 to 3");
+    }
+    const bytes = new Uint8Array(artifact.originalBytes);
+    const pageBytes = Math.min(artifact.retrieval.maxRangeBytes, RETAINED_OUTPUT_MAX_PAGE_BYTES);
     if (!Number.isSafeInteger(pageBytes) || pageBytes <= 0) {
-      throw new OpenGeniApiError(502, "retained screenshot range metadata is invalid");
+      throw new OpenGeniApiError(502, "retained artifact range metadata is invalid");
     }
     for (let start = 0; start < bytes.byteLength; start += pageBytes) {
       options.signal?.throwIfAborted();
@@ -2389,7 +3371,7 @@ var OpenGeniClient = class {
       let page = null;
       for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
         try {
-          page = await this.getSessionRetainedArtifactContent(workspaceId, sessionId, artifactId, {
+          page = await this.getRetainedArtifactContentAtPath(artifact.retrieval.path, {
             range: `bytes=${start}-${end}`,
             ...options.signal ? { signal: options.signal } : {}
           });
@@ -2401,17 +3383,17 @@ var OpenGeniClient = class {
           }
         }
       }
-      if (!page) throw new OpenGeniApiError(502, "retained screenshot range retry exhausted");
+      if (!page) throw new OpenGeniApiError(502, "retained artifact range retry exhausted");
       const expectedLength = end - start + 1;
-      if (page.status !== 206 || page.contentType !== metadata.contentType || page.contentLength !== expectedLength || page.contentRange !== `bytes ${start}-${end}/${metadata.originalBytes}`) {
-        throw new OpenGeniApiError(502, "retained screenshot range response is invalid");
+      if (page.status !== 206 || page.contentType !== artifact.contentType || page.contentLength !== expectedLength || page.contentRange !== `bytes ${start}-${end}/${artifact.originalBytes}`) {
+        throw new OpenGeniApiError(502, "retained artifact range response is invalid");
       }
       bytes.set(page.bytes, start);
     }
-    if (await sha256Hex(bytes) !== metadata.sha256) {
-      throw new OpenGeniApiError(502, "retained screenshot checksum mismatch");
+    if (await sha256Hex(bytes) !== artifact.sha256) {
+      throw new OpenGeniApiError(502, "retained artifact checksum mismatch");
     }
-    return { metadata, bytes };
+    return bytes;
   }
   async getRetainedArtifactContentAtPath(path, options) {
     if (options.range && (options.range.length > 128 || /[^\x20-\x7e]/.test(options.range))) {
@@ -2469,11 +3451,57 @@ var OpenGeniClient = class {
     };
   }
   /** Mint a short-lived signed download URL for a ready file. */
-  async createFileDownloadUrl(workspaceId, fileId) {
+  async createFileDownloadUrl(workspaceId, fileId, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/files/${fileId}/download-url`,
+      void 0,
+      {},
+      options
+    );
+  }
+  // --- Video generation ---------------------------------------------------------------
+  /** Read the effective workspace policy and executable Seedance capabilities. */
+  async getVideoGenerationSettings(workspaceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/video-generation`,
+      void 0,
+      {},
+      options
+    );
+  }
+  /** Replace the enabled video models/default under optimistic policy revision control. */
+  async updateVideoGenerationPolicy(workspaceId, request, options = {}) {
     return await this.requestJson(
+      "PUT",
+      `/v1/workspaces/${workspaceId}/video-generation/policy`,
+      request,
+      {},
+      options
+    );
+  }
+  /** Read durable progress for one accepted video generation operation. */
+  async getVideoGenerationOperation(workspaceId, operationId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/video-generation/operations/${operationId}`,
+      void 0,
+      {},
+      options
+    );
+  }
+  /** Mint a short-lived zero-copy URL for native Range-based video playback. */
+  async createVideoArtifactPlaybackSource(workspaceId, artifactId, options = {}) {
+    const source = await this.requestJson(
       "POST",
-      `/v1/workspaces/${workspaceId}/files/${fileId}/download-url`
+      `/v1/workspaces/${workspaceId}/artifacts/${artifactId}/playback-source`,
+      void 0,
+      {},
+      options
     );
+    assertSafeVideoArtifactPlaybackSource(source, artifactId);
+    return source;
   }
   // --- Documents ----------------------------------------------------------------------
   async createDocumentBase(workspaceId, request) {
@@ -2550,153 +3578,382 @@ var OpenGeniClient = class {
       `/v1/workspaces/${workspaceId}/document-bases/${baseId}/documents/${documentId}`
     );
   }
-  async searchDocuments(workspaceId, baseId, request) {
+  async searchDocuments(workspaceId, baseId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/document-bases/${baseId}/search`,
+      request
+    );
+  }
+  async searchKnowledge(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/knowledge/search`,
+      request
+    );
+  }
+  async listKnowledgeMemories(workspaceId, request = {}) {
+    const params = new URLSearchParams();
+    if (request.query) params.set("query", request.query);
+    if (request.status) params.set("status", request.status);
+    if (request.kind) params.set("kind", request.kind);
+    if (request.scope) params.set("scope", request.scope);
+    if (request.limit) params.set("limit", String(request.limit));
+    const query = params.toString();
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/knowledge/memories${query ? `?${query}` : ""}`
+    );
+  }
+  async getKnowledgeMemory(workspaceId, memoryId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/knowledge/memories/${memoryId}`
+    );
+  }
+  async createKnowledgeMemory(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/knowledge/memories`,
+      request
+    );
+  }
+  async updateKnowledgeMemory(workspaceId, memoryId, request) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/knowledge/memories/${memoryId}`,
+      request
+    );
+  }
+  /** Hybrid (semantic + keyword) search over the workspace's agent-visible memory. */
+  async searchWorkspaceMemories(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/knowledge/memories/search`,
+      request
+    );
+  }
+  /** Deep-merge a settings patch into the workspace (preserves unknown keys). */
+  async updateWorkspaceSettings(workspaceId, request) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/settings`,
+      request
+    );
+  }
+  async setWorkspaceDefaultRig(workspaceId, request) {
+    return await this.requestJson(
+      "PUT",
+      `/v1/workspaces/${workspaceId}/default-rig`,
+      request
+    );
+  }
+  // --- Capability packs ------------------------------------------------------------------
+  /** Built-in + registered packs, with the workspace's installations. */
+  async listPacks(workspaceId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/packs`);
+  }
+  /** Register (or replace) a workspace-scoped pack from a manifest. */
+  async registerPack(workspaceId, manifest) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/packs`,
+      manifest
+    );
+  }
+  async getPack(workspaceId, packId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}`
+    );
+  }
+  async enablePack(workspaceId, packId, request = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}/enable`,
+      request
+    );
+  }
+  /** Resolve pinned components, Variable Set, and Rig requirements before installation. */
+  async previewPackInstallation(workspaceId, packId, request = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}/installation-preview`,
+      request
+    );
+  }
+  /** Install, update, or repair a Pack from an exact previewed manifest. */
+  async installPack(workspaceId, packId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}/install`,
+      request
+    );
+  }
+  /** Preview which Pack-owned components will be retained by other owners. */
+  async previewPackUninstall(workspaceId, packId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}/uninstall-preview`
+    );
+  }
+  /** Safely release Pack ownership and disable only now-ownerless components. */
+  async uninstallPack(workspaceId, packId, request) {
+    return await this.requestJson(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}/installation`,
+      request
+    );
+  }
+  /** Unregister a workspace-scoped pack (built-in packs cannot be deleted). */
+  async deletePack(workspaceId, packId) {
+    await this.requestVoid(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}`
+    );
+  }
+  async listPackInstallations(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/packs/installations`
+    );
+  }
+  // --- Capabilities -------------------------------------------------------------------------
+  async listCapabilities(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/capabilities`
+    );
+  }
+  /** Add a manual capability catalog item (e.g. a remote MCP server). */
+  async createCapability(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/capabilities`,
+      request
+    );
+  }
+  async enableCapability(workspaceId, capabilityId, request = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/capabilities/${encodeURIComponent(capabilityId)}/enable`,
+      request
+    );
+  }
+  async disableCapability(workspaceId, capabilityId) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/capabilities/${encodeURIComponent(capabilityId)}/disable`
+    );
+  }
+  /** Search the official MCP registry for installable capabilities. */
+  async discoverMcpCapabilities(workspaceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/capabilities/discovery/mcp-registry`,
+      void 0,
+      {
+        ...options.query !== void 0 ? { query: options.query } : {},
+        ...options.limit !== void 0 ? { limit: String(options.limit) } : {}
+      }
+    );
+  }
+  /** List installed protocol-neutral OpenAPI and GraphQL Integrations. */
+  async listApiIntegrations(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/integrations`
+    );
+  }
+  /** List curated provider definitions without exposing deployment OAuth credentials. */
+  async listIntegrationDefinitions(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/integrations/definitions`
+    );
+  }
+  /** Detect and compile an Integration without mutating workspace state. */
+  async previewApiIntegration(workspaceId, request) {
     return await this.requestJson(
       "POST",
-      `/v1/workspaces/${workspaceId}/document-bases/${baseId}/search`,
+      `/v1/workspaces/${workspaceId}/integrations/preview`,
       request
     );
   }
-  async searchKnowledge(workspaceId, request) {
+  /** Start a signed PKCE OAuth flow for a built-in Google or Microsoft definition. */
+  async startApiIntegrationOAuth(workspaceId, request) {
     return await this.requestJson(
       "POST",
-      `/v1/workspaces/${workspaceId}/knowledge/search`,
+      `/v1/workspaces/${workspaceId}/integrations/oauth/start`,
       request
     );
   }
-  async listKnowledgeMemories(workspaceId, request = {}) {
-    const params = new URLSearchParams();
-    if (request.query) params.set("query", request.query);
-    if (request.status) params.set("status", request.status);
-    if (request.kind) params.set("kind", request.kind);
-    if (request.scope) params.set("scope", request.scope);
-    if (request.limit) params.set("limit", String(request.limit));
-    const query = params.toString();
+  /** Install only the exact immutable revision and digest accepted in preview. */
+  async installApiIntegration(workspaceId, request) {
     return await this.requestJson(
-      "GET",
-      `/v1/workspaces/${workspaceId}/knowledge/memories${query ? `?${query}` : ""}`
+      "POST",
+      `/v1/workspaces/${workspaceId}/integrations/install`,
+      request
     );
   }
-  async getKnowledgeMemory(workspaceId, memoryId) {
+  async previewApiIntegrationUninstall(workspaceId, capabilityId, instanceKey) {
     return await this.requestJson(
       "GET",
-      `/v1/workspaces/${workspaceId}/knowledge/memories/${memoryId}`
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/uninstall-preview`
     );
   }
-  async createKnowledgeMemory(workspaceId, request) {
+  /** Remove one Integration instance without deleting its Connection or sibling instances. */
+  async uninstallApiIntegration(workspaceId, capabilityId, instanceKey, request) {
     return await this.requestJson(
-      "POST",
-      `/v1/workspaces/${workspaceId}/knowledge/memories`,
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}`,
       request
     );
   }
-  async updateKnowledgeMemory(workspaceId, memoryId, request) {
+  /** List immutable provider facets and their exact per-account bindings. */
+  async listIntegrationFacets(workspaceId, capabilityId, instanceKey) {
     return await this.requestJson(
-      "PATCH",
-      `/v1/workspaces/${workspaceId}/knowledge/memories/${memoryId}`,
-      request
+      "GET",
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets`
     );
   }
-  /** Hybrid (semantic + keyword) search over the workspace's agent-visible memory. */
-  async searchWorkspaceMemories(workspaceId, request) {
+  /** Configure or OCC-update one adapter-owned facet on an Integration instance. */
+  async configureIntegrationFacet(workspaceId, capabilityId, instanceKey, facetKey, request) {
     return await this.requestJson(
-      "POST",
-      `/v1/workspaces/${workspaceId}/knowledge/memories/search`,
+      "PUT",
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets/${encodeURIComponent(facetKey)}`,
       request
     );
   }
-  /** Deep-merge a settings patch into the workspace (preserves unknown keys). */
-  async updateWorkspaceSettings(workspaceId, request) {
+  /** Browse source metadata through one exact Google Drive Integration instance. */
+  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(
-      "PATCH",
-      `/v1/workspaces/${workspaceId}/settings`,
-      request
+      "GET",
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets/${encodeURIComponent(facetKey)}/browse${suffix}`
     );
   }
-  async setWorkspaceDefaultRig(workspaceId, request) {
+  /** Verify and bind document sources to one exact Google Drive Integration instance. */
+  async saveGoogleDriveFacetSource(workspaceId, capabilityId, instanceKey, facetKey, request) {
     return await this.requestJson(
       "PUT",
-      `/v1/workspaces/${workspaceId}/default-rig`,
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets/${encodeURIComponent(facetKey)}/source`,
       request
     );
   }
-  // --- Capability packs ------------------------------------------------------------------
-  /** Built-in + registered packs, with the workspace's installations. */
-  async listPacks(workspaceId) {
-    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/packs`);
+  async pauseIntegrationFacet(workspaceId, capabilityId, instanceKey, facetKey, request) {
+    return await this.mutateIntegrationFacetLifecycle(
+      workspaceId,
+      capabilityId,
+      instanceKey,
+      facetKey,
+      "pause",
+      request
+    );
   }
-  /** Register (or replace) a workspace-scoped pack from a manifest. */
-  async registerPack(workspaceId, manifest) {
-    return await this.requestJson(
-      "POST",
-      `/v1/workspaces/${workspaceId}/packs`,
-      manifest
+  async resumeIntegrationFacet(workspaceId, capabilityId, instanceKey, facetKey, request) {
+    return await this.mutateIntegrationFacetLifecycle(
+      workspaceId,
+      capabilityId,
+      instanceKey,
+      facetKey,
+      "resume",
+      request
     );
   }
-  async getPack(workspaceId, packId) {
+  async removeIntegrationFacet(workspaceId, capabilityId, instanceKey, facetKey, request) {
     return await this.requestJson(
-      "GET",
-      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}`
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets/${encodeURIComponent(facetKey)}`,
+      request
     );
   }
-  async enablePack(workspaceId, packId, request = {}) {
+  async mutateIntegrationFacetLifecycle(workspaceId, capabilityId, instanceKey, facetKey, action, request) {
     return await this.requestJson(
       "POST",
-      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}/enable`,
+      `/v1/workspaces/${workspaceId}/integrations/${encodeURIComponent(capabilityId)}/instances/${encodeURIComponent(instanceKey)}/facets/${encodeURIComponent(facetKey)}/${action}`,
       request
     );
   }
-  /** Unregister a workspace-scoped pack (built-in packs cannot be deleted). */
-  async deletePack(workspaceId, packId) {
-    await this.requestVoid(
-      "DELETE",
-      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}`
+  async previewPlugin(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/plugins/preview`,
+      request
     );
   }
-  async listPackInstallations(workspaceId) {
+  async listInstalledPlugins(workspaceId) {
     return await this.requestJson(
       "GET",
-      `/v1/workspaces/${workspaceId}/packs/installations`
+      `/v1/workspaces/${workspaceId}/plugins`
     );
   }
-  // --- Capabilities -------------------------------------------------------------------------
-  async listCapabilities(workspaceId) {
+  async installPlugin(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/plugins/install`,
+      request
+    );
+  }
+  async previewPluginUninstall(workspaceId, pluginKey) {
     return await this.requestJson(
       "GET",
-      `/v1/workspaces/${workspaceId}/capabilities`
+      `/v1/workspaces/${workspaceId}/plugins/${encodeURIComponent(pluginKey)}/uninstall-preview`
     );
   }
-  /** Add a manual capability catalog item (e.g. a remote MCP server). */
-  async createCapability(workspaceId, request) {
+  async uninstallPlugin(workspaceId, pluginKey, request) {
+    return await this.requestJson(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/plugins/${encodeURIComponent(pluginKey)}`,
+      request
+    );
+  }
+  /** Resolve one public skills.sh or GitHub Skill folder to an immutable review preview. */
+  async previewSkillImport(workspaceId, request) {
     return await this.requestJson(
       "POST",
-      `/v1/workspaces/${workspaceId}/capabilities`,
+      `/v1/workspaces/${workspaceId}/skills/preview`,
       request
     );
   }
-  async enableCapability(workspaceId, capabilityId, request = {}) {
+  /** Install only the exact commit and full-content digest accepted during preview. */
+  async installSkill(workspaceId, request) {
     return await this.requestJson(
       "POST",
-      `/v1/workspaces/${workspaceId}/capabilities/${encodeURIComponent(capabilityId)}/enable`,
+      `/v1/workspaces/${workspaceId}/skills/install`,
       request
     );
   }
-  async disableCapability(workspaceId, capabilityId) {
+  /** 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}/capabilities/${encodeURIComponent(capabilityId)}/disable`
+      `/v1/workspaces/${workspaceId}/skills/library/${encodeURIComponent(libraryId)}/install`,
+      request
     );
   }
-  /** Search the official MCP registry for installable capabilities. */
-  async discoverMcpCapabilities(workspaceId, options = {}) {
+  async previewSkillUninstall(workspaceId, capabilityId) {
     return await this.requestJson(
       "GET",
-      `/v1/workspaces/${workspaceId}/capabilities/discovery/mcp-registry`,
-      void 0,
-      {
-        ...options.query !== void 0 ? { query: options.query } : {},
-        ...options.limit !== void 0 ? { limit: String(options.limit) } : {}
-      }
+      `/v1/workspaces/${workspaceId}/skills/${encodeURIComponent(capabilityId)}/uninstall-preview`
+    );
+  }
+  /** Remove the direct owner under an optimistic installation-version fence. */
+  async uninstallSkill(workspaceId, capabilityId, request) {
+    return await this.requestJson(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/skills/${encodeURIComponent(capabilityId)}`,
+      request
     );
   }
   // --- Connections -------------------------------------------------------------------------------
@@ -2707,6 +3964,14 @@ var OpenGeniClient = class {
     );
     return response.connections;
   }
+  /** List the secret-free Slack team -> OpenGeni tenant routing authority. */
+  async listSlackInstallationBindings(workspaceId) {
+    const response = await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/connections/slack-bot/bindings`
+    );
+    return response.bindings;
+  }
   async createConnection(workspaceId, request) {
     const response = await this.requestJson(
       "POST",
@@ -2715,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(
@@ -2804,8 +4089,13 @@ var OpenGeniClient = class {
   }
   // --- GitHub ----------------------------------------------------------------------------------
   /** GitHub App server configuration plus truthful workspace binding status. */
-  async getGitHubApp(workspaceId) {
-    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/github/app`);
+  async getGitHubApp(workspaceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/github/app`,
+      void 0,
+      options.returnPath ? { returnPath: options.returnPath } : void 0
+    );
   }
   /** Build the GitHub owner-consent entry URL for fresh workspace-bound state. */
   githubConnectUrl(workspaceId, state) {
@@ -3035,6 +4325,65 @@ 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();
     let response;
@@ -3069,6 +4418,29 @@ var OpenGeniClient = class {
       throw error;
     }
   }
+  /** Authenticated, contract-checked response for bounded streaming downloads. */
+  async requestResponse(method, path, query = {}, options = {}) {
+    const correlationId = crypto.randomUUID();
+    let response;
+    try {
+      response = await this.fetchImpl(this.url(path, query), {
+        method,
+        headers: {
+          ...this.headers(correlationId),
+          Accept: "application/octet-stream"
+        },
+        ...options.signal ? { signal: options.signal } : {}
+      });
+    } catch (error) {
+      if (isMutationMethod(method)) throw mutationTransportError(correlationId);
+      throw error;
+    }
+    assertApiContractResponse(response);
+    if (!response.ok) {
+      throw await apiErrorFromResponse(response, { method, correlationId });
+    }
+    return response;
+  }
   /** Like `requestJson` for endpoints that respond with no body (204). */
   async requestVoid(method, path, body) {
     const correlationId = crypto.randomUUID();
@@ -3224,6 +4596,31 @@ async function sha256Hex(bytes) {
 async function cancelResponseBody(response, reason) {
   await response.body?.cancel(reason).catch(() => void 0);
 }
+function assertRetainedGeneratedImageReceipt(workspaceId, artifact) {
+  if (!parseRetainedGeneratedImageReference(artifact, workspaceId)) {
+    throw new OpenGeniApiError(502, "retained generated image receipt is invalid");
+  }
+}
+function assertSafeArtifactDownloadUrl(value) {
+  if (!value || typeof value.url !== "string" || typeof value.expiresAt !== "string" || !Number.isFinite(Date.parse(value.expiresAt))) {
+    throw new OpenGeniApiError(502, "retained artifact download URL is invalid");
+  }
+  let parsed;
+  try {
+    parsed = new URL(value.url);
+  } catch {
+    throw new OpenGeniApiError(502, "retained artifact download URL is invalid");
+  }
+  if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password) {
+    throw new OpenGeniApiError(502, "retained artifact download URL is unsafe");
+  }
+}
+function assertSafeVideoArtifactPlaybackSource(value, expectedArtifactId) {
+  if (!value || value.schemaVersion !== 1 || value.artifactId !== expectedArtifactId || value.contentType !== "video/mp4" || value.acceptRanges !== "bytes" || !Number.isSafeInteger(value.sizeBytes) || value.sizeBytes <= 0 || value.sizeBytes > GENERATED_VIDEO_MAX_BYTES || !/^[0-9a-f]{64}$/.test(value.sha256)) {
+    throw new OpenGeniApiError(502, "generated-video playback source is invalid");
+  }
+  assertSafeArtifactDownloadUrl({ url: value.url, expiresAt: value.expiresAt });
+}
 function parseBoundedContentLength(value) {
   if (value === null) return null;
   if (!/^\d+$/.test(value)) {
@@ -3271,246 +4668,19 @@ async function readBoundedResponseBytes(response, maxBytes, expectedBytes) {
   return bytes;
 }
 
-// src/transcription.ts
-var DEFAULT_WORKSPACE_TRANSCRIPTION_POLICY = {
-  enabled: false,
-  acceptanceId: null,
-  primary: null,
-  language: null,
-  autoDetectLanguage: false,
-  diarization: { enabled: false, maxSpeakers: null },
-  retention: { mode: "none", maxDays: null },
-  privacy: { allowProviderLogging: false, allowProviderTraining: false },
-  fallback: { mode: "disabled", targets: [] },
-  cost: { currency: "USD", maxPerHour: null, maxPerMonth: null }
-};
-function resolveWorkspaceVoiceInputEnabled(settings) {
-  if (!isRecord(settings)) return null;
-  const voiceInput = settings.voiceInput;
-  if (isRecord(voiceInput) && typeof voiceInput.enabled === "boolean") {
-    return voiceInput.enabled;
-  }
-  const legacy = settings.transcription;
-  return isRecord(legacy) && typeof legacy.enabled === "boolean" ? legacy.enabled : null;
-}
-function resolveWorkspaceTranscriptionPolicy(settings) {
-  if (!isRecord(settings)) return cloneDefaultPolicy();
-  const candidate = settings.transcription;
-  if (!isWorkspaceTranscriptionPolicy(candidate)) return cloneDefaultPolicy();
-  return {
-    ...candidate,
-    primary: candidate.primary ? normalizeTarget(candidate.primary) : null,
-    language: candidate.language?.trim() ?? null,
-    diarization: { ...candidate.diarization },
-    retention: { ...candidate.retention },
-    privacy: { ...candidate.privacy },
-    fallback: {
-      mode: candidate.fallback.mode,
-      targets: candidate.fallback.targets.map(normalizeTarget)
-    },
-    cost: { ...candidate.cost }
-  };
-}
-function authorizeTranscriptionAdapter(policy, descriptor, selection = { kind: "primary" }) {
-  if (!isWorkspaceTranscriptionPolicy(policy)) {
-    return { authorized: false, reason: "unaccepted" };
-  }
-  if (!policy.enabled) return { authorized: false, reason: "disabled" };
-  if (!policy.acceptanceId) return { authorized: false, reason: "unaccepted" };
-  let target;
-  if (selection.kind === "primary") {
-    target = policy.primary;
-  } else {
-    if (policy.fallback.mode !== "explicit") {
-      return { authorized: false, reason: "fallback_disabled" };
-    }
-    target = policy.fallback.targets[selection.index];
-    if (!target) return { authorized: false, reason: "fallback_unaccepted" };
-  }
-  if (!target) return { authorized: false, reason: "target_missing" };
-  const acceptedTarget = normalizeTarget(target);
-  if (acceptedTarget.provider !== descriptor.provider) {
-    return { authorized: false, reason: "provider_mismatch" };
-  }
-  if (acceptedTarget.model !== descriptor.model) {
-    return { authorized: false, reason: "model_mismatch" };
-  }
-  if (acceptedTarget.credentialMode !== descriptor.credentialMode) {
-    return { authorized: false, reason: "credential_mode_mismatch" };
-  }
-  if (acceptedTarget.region !== descriptor.region) {
-    return { authorized: false, reason: "region_mismatch" };
-  }
-  return {
-    authorized: true,
-    acceptanceId: policy.acceptanceId,
-    target: acceptedTarget,
-    selection
-  };
-}
-function createTranscriptionSessionRequest(input) {
-  const sequenceFloor = input.sequenceFloor ?? 0;
-  if (!Number.isSafeInteger(sequenceFloor) || sequenceFloor < 0) return null;
-  const authorization = authorizeTranscriptionAdapter(
-    input.policy,
-    input.adapter.descriptor,
-    input.selection
-  );
-  if (!authorization.authorized) return null;
-  return {
-    localSessionId: input.localSessionId,
-    policyAcceptanceId: authorization.acceptanceId,
-    selection: authorization.selection,
-    target: { ...authorization.target },
-    language: input.policy.language?.trim() ?? null,
-    autoDetectLanguage: input.policy.autoDetectLanguage,
-    diarization: { ...input.policy.diarization },
-    retention: { ...input.policy.retention },
-    privacy: { ...input.policy.privacy },
-    cost: { ...input.policy.cost },
-    sequenceFloor
-  };
-}
-function cloneDefaultPolicy() {
-  return {
-    ...DEFAULT_WORKSPACE_TRANSCRIPTION_POLICY,
-    diarization: { ...DEFAULT_WORKSPACE_TRANSCRIPTION_POLICY.diarization },
-    retention: { ...DEFAULT_WORKSPACE_TRANSCRIPTION_POLICY.retention },
-    privacy: { ...DEFAULT_WORKSPACE_TRANSCRIPTION_POLICY.privacy },
-    fallback: { mode: "disabled", targets: [] },
-    cost: { ...DEFAULT_WORKSPACE_TRANSCRIPTION_POLICY.cost }
-  };
-}
-function isWorkspaceTranscriptionPolicy(value) {
-  if (!isRecord(value) || typeof value.enabled !== "boolean") return false;
-  if (!hasOnlyKeys(value, [
-    "enabled",
-    "acceptanceId",
-    "primary",
-    "language",
-    "autoDetectLanguage",
-    "diarization",
-    "retention",
-    "privacy",
-    "fallback",
-    "cost"
-  ])) {
-    return false;
-  }
-  if (!(value.acceptanceId === null || isUuid(value.acceptanceId))) return false;
-  if (!(value.primary === null || isTarget(value.primary))) return false;
-  if (!(value.language === null || isBoundedString(value.language, 64))) return false;
-  if (typeof value.autoDetectLanguage !== "boolean") return false;
-  if (!isRecord(value.diarization) || !hasOnlyKeys(value.diarization, ["enabled", "maxSpeakers"]) || typeof value.diarization.enabled !== "boolean" || !(value.diarization.maxSpeakers === null || isBoundedInteger(value.diarization.maxSpeakers, 100) && value.diarization.maxSpeakers >= 2)) {
-    return false;
-  }
-  if (!value.diarization.enabled && value.diarization.maxSpeakers !== null) return false;
-  if (!isRecord(value.retention) || !hasOnlyKeys(value.retention, ["mode", "maxDays"])) {
-    return false;
-  }
-  if (value.retention.mode !== "none" && value.retention.mode !== "provider-policy") return false;
-  if (!(value.retention.maxDays === null || isBoundedInteger(value.retention.maxDays, 3650))) {
-    return false;
-  }
-  if (!isRecord(value.privacy) || !hasOnlyKeys(value.privacy, ["allowProviderLogging", "allowProviderTraining"]) || typeof value.privacy.allowProviderLogging !== "boolean" || typeof value.privacy.allowProviderTraining !== "boolean") {
-    return false;
-  }
-  if (!isRecord(value.fallback) || !hasOnlyKeys(value.fallback, ["mode", "targets"])) {
-    return false;
-  }
-  if (value.fallback.mode !== "disabled" && value.fallback.mode !== "explicit") return false;
-  if (!Array.isArray(value.fallback.targets) || value.fallback.targets.length > 8 || !value.fallback.targets.every(isTarget)) {
-    return false;
-  }
-  if (value.fallback.mode === "disabled" && value.fallback.targets.length !== 0) return false;
-  if (value.fallback.mode === "explicit" && value.fallback.targets.length === 0) return false;
-  if (!isRecord(value.cost) || !hasOnlyKeys(value.cost, ["currency", "maxPerHour", "maxPerMonth"]) || value.cost.currency !== "USD") {
-    return false;
-  }
-  if (!isNullableBoundedNumber(value.cost.maxPerHour, 1e4)) return false;
-  if (!isNullableBoundedNumber(value.cost.maxPerMonth, 1e6)) return false;
-  if (value.enabled && (!value.acceptanceId || !value.primary)) return false;
-  if (value.enabled && !value.autoDetectLanguage && value.language === null) return false;
-  if (value.autoDetectLanguage && value.language !== null) return false;
-  const targets = [value.primary, ...value.fallback.targets].filter(
-    (target) => target !== null
-  );
-  if (new Set(targets.map(targetKey)).size !== targets.length) return false;
-  return true;
-}
-function targetKey(target) {
-  return [
-    target.provider.trim(),
-    target.model?.trim() ?? "",
-    target.credentialMode,
-    target.credentialConnectionId ?? "",
-    target.region?.trim() ?? ""
-  ].join("\0");
-}
-function isTarget(value) {
-  if (!isRecord(value)) return false;
-  if (!hasOnlyKeys(value, ["provider", "model", "credentialMode", "credentialConnectionId", "region"])) {
-    return false;
-  }
-  if (!isBoundedString(value.provider, 128)) return false;
-  if (!(value.model === null || isBoundedString(value.model, 256))) return false;
-  if (value.credentialMode !== "managed" && value.credentialMode !== "byok") return false;
-  if (value.provider.trim() === "azure-speech" && value.credentialMode !== "byok") return false;
-  if (!(value.credentialConnectionId === null || isUuid(value.credentialConnectionId))) {
-    return false;
-  }
-  if (!(value.region === null || isBoundedString(value.region, 128))) return false;
-  if (value.credentialMode === "byok" && value.credentialConnectionId === null) return false;
-  if (value.credentialMode === "managed" && value.credentialConnectionId !== null) return false;
-  return true;
-}
-function normalizeTarget(target) {
-  return {
-    provider: target.provider.trim(),
-    model: target.model?.trim() ?? null,
-    credentialMode: target.credentialMode,
-    credentialConnectionId: target.credentialConnectionId,
-    region: target.region?.trim() ?? null
-  };
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function hasOnlyKeys(value, keys) {
-  const accepted = new Set(keys);
-  return Object.keys(value).every((key) => accepted.has(key));
-}
-function isBoundedString(value, maximum) {
-  return typeof value === "string" && value.trim().length > 0 && value.length <= maximum;
-}
-function isUuid(value) {
-  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
-}
-function isBoundedInteger(value, maximum) {
-  return Number.isInteger(value) && value >= 0 && value <= maximum;
-}
-function isNullableBoundedNumber(value, maximum) {
-  return value === null || typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= maximum;
-}
-
 export {
   parseSseStream,
   streamSessionEvents,
   streamWorkspaceControlEvents,
-  DEFAULT_FILE_RESOURCE_MOUNT_ROOT,
-  SESSION_EVENT_TYPES,
-  KNOWN_PERMISSIONS,
-  OPENGENI_API_CONTRACT_REVISION,
-  OPENGENI_API_CONTRACT_HEADER,
-  OPENGENI_CORRELATION_HEADER,
-  RETAINED_OUTPUT_DEFAULT_PAGE_BYTES,
-  RETAINED_OUTPUT_MAX_PAGE_BYTES,
-  KNOWN_USAGE_EVENT_TYPES,
-  OpenGeniClient,
-  DEFAULT_WORKSPACE_TRANSCRIPTION_POLICY,
-  resolveWorkspaceVoiceInputEnabled,
-  resolveWorkspaceTranscriptionPolicy,
-  authorizeTranscriptionAdapter,
-  createTranscriptionSessionRequest
+  streamWorkspaceInteractionRevisions,
+  streamWorkspaceLiveEvents,
+  parseWorkspaceLiveEvent,
+  parseRetainedGeneratedImageReference,
+  generatedImageSandboxPathMatches,
+  parseGeneratedImageReceipt,
+  parseRetainedGeneratedVideoReference,
+  parseGeneratedVideoReceipt,
+  parseMediaGenerationResult,
+  OpenGeniClient
 };
-//# sourceMappingURL=chunk-MBGBLVUV.js.map
+//# sourceMappingURL=chunk-PKQ377ED.js.map