@opengeni/sdk 2.2.0-canary.0 → 2.5.0-canary.0

package/dist/artifacts.d.ts

@@ -1,4 +1,4 @@
 /** Artifact-only API client entry; keeps unrelated SDK surfaces out of editor bundles. */
 export { OpenGeniClient } from "./artifact-client.js";
 export type { CreateEditableArtifactMaterializationRequest, CreateEditableArtifactResourceRequest, EditableArtifactListResource, EditableArtifactMaterializationFormat, EditableArtifactMaterializationJobResource, EditableArtifactMaterializationResultResource, EditableArtifactPinnedVersionResource, EditableArtifactResource, ListSessionEditableArtifactResourcesOptions, PinEditableArtifactVersionRequest, ReadEditableArtifactMaterializationOptions, ReadEditableArtifactResourceOptions, } from "./editable-artifact-resources.js";
-export type { FetchLike, OpenGeniClientOptions, OpenGeniRequestOptions } from "./client.js";
+export type { FetchLike, GetSessionOptions, OpenGeniClientOptions, OpenGeniRequestOptions, } from "./client.js";

package/dist/artifacts.js

@@ -1,8 +1,8 @@
 import {
   OpenGeniClient
-} from "./chunk-G6LBVWKT.js";
-import "./chunk-YBQTKNTL.js";
-import "./chunk-GLDV5QY7.js";
+} from "./chunk-UP2PIWU2.js";
+import "./chunk-7VERSV47.js";
+import "./chunk-ERPT45NP.js";
 import "./chunk-GW3EJ2GP.js";
 import "./chunk-C4DJPZRU.js";
 export {

package/dist/{chunk-YBQTKNTL.js → chunk-7VERSV47.js}

@@ -5,7 +5,7 @@ import {
   OPENGENI_API_CONTRACT_REVISION,
   OPENGENI_CORRELATION_HEADER,
   RETAINED_OUTPUT_MAX_PAGE_BYTES
-} from "./chunk-GLDV5QY7.js";
+} from "./chunk-ERPT45NP.js";
 import {
   OpenGeniInteractionClient
 } from "./chunk-GW3EJ2GP.js";
@@ -764,6 +764,22 @@ function sessionListQuery(options) {
     ...parentSessionId === void 0 ? {} : { parentSessionId: parentSessionId ?? "null" }
   };
 }
+function createSingleFlightReadEntry(generation, onRequestStart) {
+  let resolve;
+  let reject;
+  const promise = new Promise((entryResolve, entryReject) => {
+    resolve = entryResolve;
+    reject = entryReject;
+  });
+  return {
+    generation,
+    promise,
+    resolve,
+    reject,
+    started: false,
+    listeners: new Set(onRequestStart ? [onRequestStart] : [])
+  };
+}
 function assertNoMessageTools(input) {
   if (Object.prototype.hasOwnProperty.call(input, "tools")) {
     throw new TypeError(
@@ -776,8 +792,9 @@ var OpenGeniClient = class {
   options;
   fetchImpl;
   sessionCommandTimeoutMs;
-  readInFlight = /* @__PURE__ */ new Map();
-  readTrailing = /* @__PURE__ */ new Map();
+  active = /* @__PURE__ */ new Map();
+  generations = /* @__PURE__ */ new Map();
+  queued = /* @__PURE__ */ new Map();
   /** Resource-oriented Browser/Computer facade over this exact authenticated client. */
   interaction;
   constructor(options) {
@@ -987,7 +1004,7 @@ var OpenGeniClient = class {
   }
   async getSession(workspaceId, sessionId, options = {}) {
     const path = `/v1/workspaces/${workspaceId}/sessions/${sessionId}`;
-    return await this.singleFlightRead(path, () => this.requestJson("GET", path), options);
+    return await this.sharedRead(path, () => this.requestJson("GET", path), options);
   }
   async updateSession(workspaceId, sessionId, request) {
     return await this.requestJson(
@@ -996,6 +1013,14 @@ var OpenGeniClient = class {
       request
     );
   }
+  /** Replace the complete ordered Variable Set selection at a quiescent turn boundary. */
+  async updateSessionVariableSets(workspaceId, sessionId, request) {
+    return await this.requestJson(
+      "PUT",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/variable-sets`,
+      request
+    );
+  }
   /** Whether this exact authenticated principal may atomically create a private session. */
   async getSessionTenancyCreateCapabilities(workspaceId) {
     return await this.requestJson(
@@ -1156,35 +1181,112 @@ var OpenGeniClient = class {
       `/v1/workspaces/${workspaceId}/sessions/${sessionId}`
     );
   }
-  async getSessionLineage(workspaceId, sessionId) {
+  async getSessionLineage(workspaceId, sessionId, options = {}) {
     const path = `/v1/workspaces/${workspaceId}/sessions/${sessionId}/lineage`;
-    return await this.singleFlightRead(
+    return await this.sharedRead(
       path,
-      () => this.requestJson("GET", path)
+      () => this.requestJson("GET", path),
+      options
     );
   }
-  singleFlightRead(key, read, options = {}) {
-    const existing = this.readInFlight.get(key);
+  sharedRead(key, read, options = {}) {
+    const existing = this.active.get(key);
     if (existing) {
-      if (!options.fresh) return existing;
-      const queued = this.readTrailing.get(key);
-      if (queued) return queued;
-      const trailing = existing.then(
-        () => this.singleFlightRead(key, read),
-        () => this.singleFlightRead(key, read)
+      if (!options.fresh) {
+        this.observeRead(existing, options.onRequestStart);
+        return existing.promise;
+      }
+      const requiredGeneration = existing.generation + 1;
+      const queued2 = this.queued.get(key);
+      if (queued2 && queued2.generation >= requiredGeneration) {
+        this.observeRead(queued2, options.onRequestStart);
+        return queued2.promise;
+      }
+      const predecessor = queued2?.promise ?? existing.promise;
+      return this.queueRead(key, predecessor, requiredGeneration, read, options.onRequestStart);
+    }
+    const queued = this.queued.get(key);
+    if (queued && (!options.fresh || !queued.started)) {
+      this.observeRead(queued, options.onRequestStart);
+      return queued.promise;
+    }
+    if (queued) {
+      return this.queueRead(
+        key,
+        queued.promise,
+        queued.generation + 1,
+        read,
+        options.onRequestStart
       );
-      this.readTrailing.set(key, trailing);
-      const clear = () => {
-        if (this.readTrailing.get(key) === trailing) this.readTrailing.delete(key);
-      };
-      void trailing.then(clear, clear);
-      return trailing;
     }
-    const promise = read().finally(() => {
-      if (this.readInFlight.get(key) === promise) this.readInFlight.delete(key);
-    });
-    this.readInFlight.set(key, promise);
-    return promise;
+    const generation = (this.generations.get(key) ?? 0) + 1;
+    const entry = createSingleFlightReadEntry(generation, options.onRequestStart);
+    this.launchRead(key, entry, read);
+    return entry.promise;
+  }
+  queueRead(key, predecessor, generation, read, onRequestStart) {
+    const entry = createSingleFlightReadEntry(generation, onRequestStart);
+    this.queued.set(key, entry);
+    const launch = () => this.launchRead(key, entry, read);
+    void predecessor.then(launch, launch);
+    const clear = () => {
+      if (this.queued.get(key) !== entry) return;
+      this.queued.delete(key);
+      if (!this.active.has(key)) this.generations.delete(key);
+    };
+    void entry.promise.then(clear, clear);
+    return entry.promise;
+  }
+  launchRead(key, entry, read) {
+    entry.started = true;
+    this.generations.set(key, entry.generation);
+    this.active.set(key, entry);
+    try {
+      entry.stamp = this.options.beginSharedRead?.();
+    } catch {
+    }
+    for (const listener of entry.listeners) {
+      try {
+        listener(entry.stamp);
+      } catch {
+      }
+    }
+    entry.listeners.clear();
+    const settle = () => {
+      if (this.active.get(key) !== entry) return;
+      this.active.delete(key);
+      if (!this.queued.has(key)) this.generations.delete(key);
+    };
+    let request;
+    try {
+      request = read();
+    } catch (error) {
+      settle();
+      entry.reject(error);
+      return;
+    }
+    void request.then(
+      (value) => {
+        settle();
+        entry.resolve(value);
+      },
+      (error) => {
+        settle();
+        entry.reject(error);
+      }
+    );
+  }
+  observeRead(entry, listener) {
+    if (!listener) return;
+    if (!entry.started) {
+      entry.listeners.add(listener);
+      return;
+    }
+    if (entry.stamp === void 0) return;
+    try {
+      listener(entry.stamp);
+    } catch {
+    }
   }
   /** Negotiate one server-mediated connected-Codex GPT-Live V3 WebRTC call. */
   async negotiateCodexRealtimeWebrtc(workspaceId, sessionId, request, options = {}) {
@@ -1626,7 +1728,7 @@ var OpenGeniClient = class {
   // --- Turn queue ------------------------------------------------------------
   async getQueue(workspaceId, sessionId) {
     const path = `/v1/workspaces/${workspaceId}/sessions/${sessionId}/queue`;
-    return await this.singleFlightRead(
+    return await this.sharedRead(
       path,
       () => this.requestSessionCommand("GET", path)
     );
@@ -1849,7 +1951,7 @@ var OpenGeniClient = class {
   /** The session's goal. 404s when the session never had one. */
   async getGoal(workspaceId, sessionId) {
     const path = `/v1/workspaces/${workspaceId}/sessions/${sessionId}/goal`;
-    return await this.singleFlightRead(path, () => this.requestJson("GET", path));
+    return await this.sharedRead(path, () => this.requestJson("GET", path));
   }
   async updateGoal(workspaceId, sessionId, request) {
     return await this.requestJson(
@@ -2904,12 +3006,16 @@ var OpenGeniClient = class {
       request
     );
   }
-  async listOrganizationMembers(organizationId) {
+  async listOrganizationAdministrationMembers(organizationId) {
     return await this.requestJson(
       "GET",
       `/v1/organizations/${organizationId}/members`
     );
   }
+  /** @deprecated Use listOrganizationAdministrationMembers for its privacy-safe projection. */
+  async listOrganizationMembers(organizationId) {
+    return await this.listOrganizationAdministrationMembers(organizationId);
+  }
   /** Canonical organization identity and every non-personal workspace access roster. */
   async getOrganizationAdministrationOverview(organizationId) {
     return await this.requestJson(
@@ -2917,18 +3023,15 @@ var OpenGeniClient = class {
       `/v1/organizations/${organizationId}/overview`
     );
   }
-  /** Rename the organization under an exact optimistic-concurrency fence. */
-  async updateOrganizationName(organizationId, request) {
+  /** Create a shared workspace without implicitly granting the actor access. */
+  async createOrganizationWorkspace(organizationId, request) {
     return await this.requestJson(
-      "PATCH",
-      `/v1/organizations/${organizationId}`,
+      "POST",
+      `/v1/organizations/${organizationId}/workspaces`,
       request
     );
   }
-  /**
-   * Organization control-plane update for a shared workspace. This does not
-   * require or create operational workspace access for the organization admin.
-   */
+  /** Rename one shared workspace under an exact optimistic-concurrency fence. */
   async updateOrganizationWorkspace(organizationId, workspaceId, request) {
     return await this.requestJson(
       "PATCH",
@@ -2936,45 +3039,35 @@ var OpenGeniClient = class {
       request
     );
   }
-  /** Create a shared workspace without implicitly granting the actor access. */
-  async createOrganizationWorkspace(organizationId, request) {
+  async updateOrganizationWorkspaceSettings(organizationId, workspaceId, request) {
     return await this.requestJson(
-      "POST",
-      `/v1/organizations/${organizationId}/workspaces`,
+      "PATCH",
+      `/v1/organizations/${organizationId}/workspaces/${workspaceId}/settings`,
       request
     );
   }
-  async updateOrganizationWorkspaceSettings(organizationId, workspaceId, request) {
+  async putOrganizationWorkspaceMember(organizationId, workspaceId, membershipId, request) {
     return await this.requestJson(
-      "PATCH",
-      `/v1/organizations/${organizationId}/workspaces/${workspaceId}/settings`,
+      "PUT",
+      `/v1/organizations/${organizationId}/workspaces/${workspaceId}/members/${membershipId}`,
       request
     );
   }
-  async addOrganizationWorkspaceMember(organizationId, workspaceId, request) {
+  async revokeOrganizationWorkspaceMember(organizationId, workspaceId, membershipId, request) {
     return await this.requestJson(
       "POST",
-      `/v1/organizations/${organizationId}/workspaces/${workspaceId}/members`,
+      `/v1/organizations/${organizationId}/workspaces/${workspaceId}/members/${membershipId}/revoke`,
       request
     );
   }
-  async updateOrganizationWorkspaceMember(organizationId, workspaceId, subjectId, request) {
+  /** Rename the organization under an exact optimistic-concurrency fence. */
+  async updateOrganizationName(organizationId, request) {
     return await this.requestJson(
       "PATCH",
-      `/v1/organizations/${organizationId}/workspaces/${workspaceId}/members/${encodeURIComponent(
-        subjectId
-      )}`,
+      `/v1/organizations/${organizationId}`,
       request
     );
   }
-  async removeOrganizationWorkspaceMember(organizationId, workspaceId, subjectId) {
-    await this.requestVoid(
-      "DELETE",
-      `/v1/organizations/${organizationId}/workspaces/${workspaceId}/members/${encodeURIComponent(
-        subjectId
-      )}`
-    );
-  }
   async updateOrganizationMember(organizationId, membershipId, request) {
     return await this.requestJson(
       "PATCH",
@@ -4060,6 +4153,40 @@ var OpenGeniClient = class {
       request
     );
   }
+  /** List organization-scoped Default collection backfill runs (organization admin only). */
+  async listDocumentDefaultCollectionBackfillRuns(workspaceId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    if (options.cursor) params.set("cursor", options.cursor);
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/document-default-collection-backfills${query}`
+    );
+  }
+  /** Read bounded operation and workspace receipts for one Default-collection backfill run. */
+  async getDocumentDefaultCollectionBackfillAudit(workspaceId, runId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    if (options.operationCursor) params.set("operationCursor", options.operationCursor);
+    if (options.receiptCursor) params.set("receiptCursor", options.receiptCursor);
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/document-default-collection-backfills/${runId}${query}`
+    );
+  }
+  /** List organization-wide Document authority changes (organization admin only). */
+  async listOrganizationDocumentAuthorityReclassifications(workspaceId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    if (options.cursor) params.set("cursor", options.cursor);
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/document-authority-reclassifications${query}`
+    );
+  }
   /** Retry indexing for a failed document. */
   async reindexDocument(workspaceId, baseId, documentId) {
     return await this.requestJson(
@@ -4575,6 +4702,20 @@ var OpenGeniClient = class {
       `/v1/workspaces/${workspaceId}/integrations/slack/reaction-channels?${query}`
     );
   }
+  async listOpenGeniSlackChannelRoutes(workspaceId, connectionId) {
+    const query = new URLSearchParams({ connectionId });
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/integrations/slack/channel-routes?${query}`
+    );
+  }
+  async updateOpenGeniSlackChannelRoutes(workspaceId, request) {
+    await this.requestJson(
+      "PUT",
+      `/v1/workspaces/${workspaceId}/integrations/slack/channel-routes`,
+      request
+    );
+  }
   async updateConnection(workspaceId, connectionId, request) {
     const response = await this.requestJson(
       "PATCH",
@@ -5322,4 +5463,4 @@ export {
   parseMediaGenerationResult,
   OpenGeniClient
 };
-//# sourceMappingURL=chunk-YBQTKNTL.js.map
+//# sourceMappingURL=chunk-7VERSV47.js.map