@opengeni/sdk 3.1.0 → 3.3.2

package/dist/{chunk-VUQZAB3O.js → chunk-QT3KFVDP.js}

@@ -1,6 +1,6 @@
 import {
   OpenGeniDocumentAuthorityClient
-} from "./chunk-TX3EIENU.js";
+} from "./chunk-YXQX7RQT.js";
 
 // src/artifact-client.ts
 var OpenGeniClient = class extends OpenGeniDocumentAuthorityClient {
@@ -125,4 +125,4 @@ var OpenGeniClient = class extends OpenGeniDocumentAuthorityClient {
 export {
   OpenGeniClient
 };
-//# sourceMappingURL=chunk-VUQZAB3O.js.map
+//# sourceMappingURL=chunk-QT3KFVDP.js.map

package/dist/{chunk-7ZXBPJZP.js → chunk-TRNI7KEO.js}

@@ -5,10 +5,11 @@ import {
   OPENGENI_API_CONTRACT_REVISION,
   OPENGENI_CORRELATION_HEADER,
   RETAINED_OUTPUT_MAX_PAGE_BYTES
-} from "./chunk-YTAWBDO2.js";
+} from "./chunk-JUS2UYRP.js";
 import {
-  OpenGeniInteractionClient
-} from "./chunk-GW3EJ2GP.js";
+  OpenGeniInteractionClient,
+  decodeComputerFrameMetadataHeader
+} from "./chunk-KKRO2VCP.js";
 import {
   OpenGeniApiContractMismatchError,
   OpenGeniApiError,
@@ -772,6 +773,8 @@ function createSingleFlightReadEntry(generation, onRequestStart) {
     reject = entryReject;
   });
   return {
+    controller: new AbortController(),
+    consumers: 0,
     generation,
     promise,
     resolve,
@@ -787,6 +790,26 @@ function assertNoMessageTools(input) {
     );
   }
 }
+function normalizeScheduledTaskMachineTarget(request) {
+  if (!("agentConfig" in request) || !request.agentConfig?.machineTarget) {
+    return request;
+  }
+  const { workingDir, ...machineTarget } = request.agentConfig.machineTarget;
+  if (workingDir === void 0) {
+    return request;
+  }
+  const normalizedWorkingDir = workingDir.trim();
+  return {
+    ...request,
+    agentConfig: {
+      ...request.agentConfig,
+      machineTarget: {
+        ...machineTarget,
+        ...normalizedWorkingDir ? { workingDir: normalizedWorkingDir } : {}
+      }
+    }
+  };
+}
 var OpenGeniClient = class {
   baseUrl;
   options;
@@ -1007,7 +1030,11 @@ var OpenGeniClient = class {
   }
   async getSession(workspaceId, sessionId, options = {}) {
     const path = `/v1/workspaces/${workspaceId}/sessions/${sessionId}`;
-    return await this.sharedRead(path, () => this.requestJson("GET", path), options);
+    return await this.sharedRead(
+      path,
+      (signal) => this.requestJson("GET", path, void 0, {}, { signal }),
+      options
+    );
   }
   async updateSession(workspaceId, sessionId, request) {
     return await this.requestJson(
@@ -1107,7 +1134,8 @@ var OpenGeniClient = class {
           ...search ? { search } : {},
           ...options.pinsOnly ? { pinsOnly: "true" } : {},
           ...options.archivedOnly ? { archivedOnly: "true" } : {}
-        }
+        },
+        { signal: options.signal }
       );
     } catch (error) {
       if (error instanceof OpenGeniApiError && error.status === 410) {
@@ -1201,47 +1229,48 @@ var OpenGeniClient = class {
     const path = `/v1/workspaces/${workspaceId}/sessions/${sessionId}/lineage`;
     return await this.sharedRead(
       path,
-      () => this.requestJson("GET", path),
+      (signal) => this.requestJson("GET", path, void 0, {}, { signal }),
       options
     );
   }
   sharedRead(key, read, options = {}) {
+    if (options.signal?.aborted) {
+      return Promise.reject(
+        options.signal.reason ?? new DOMException("Request aborted", "AbortError")
+      );
+    }
     const existing = this.active.get(key);
     if (existing) {
       if (!options.fresh) {
         this.observeRead(existing, options.onRequestStart);
-        return existing.promise;
+        return this.consumeSharedRead(key, existing, options.signal);
       }
       const requiredGeneration = existing.generation + 1;
       const queued2 = this.queued.get(key);
       if (queued2 && queued2.generation >= requiredGeneration) {
         this.observeRead(queued2, options.onRequestStart);
-        return queued2.promise;
+        return this.consumeSharedRead(key, queued2, options.signal);
       }
       const predecessor = queued2?.promise ?? existing.promise;
-      return this.queueRead(key, predecessor, requiredGeneration, read, options.onRequestStart);
+      return this.queueRead(key, predecessor, requiredGeneration, read, options);
     }
     const queued = this.queued.get(key);
     if (queued && (!options.fresh || !queued.started)) {
       this.observeRead(queued, options.onRequestStart);
-      return queued.promise;
+      return this.consumeSharedRead(key, queued, options.signal);
     }
     if (queued) {
-      return this.queueRead(
-        key,
-        queued.promise,
-        queued.generation + 1,
-        read,
-        options.onRequestStart
-      );
+      return this.queueRead(key, queued.promise, queued.generation + 1, read, options);
     }
     const generation = (this.generations.get(key) ?? 0) + 1;
     const entry = createSingleFlightReadEntry(generation, options.onRequestStart);
+    const consumed = this.consumeSharedRead(key, entry, options.signal);
     this.launchRead(key, entry, read);
-    return entry.promise;
+    return consumed;
   }
-  queueRead(key, predecessor, generation, read, onRequestStart) {
-    const entry = createSingleFlightReadEntry(generation, onRequestStart);
+  queueRead(key, predecessor, generation, read, options) {
+    const entry = createSingleFlightReadEntry(generation, options.onRequestStart);
+    const consumed = this.consumeSharedRead(key, entry, options.signal);
     this.queued.set(key, entry);
     const launch = () => this.launchRead(key, entry, read);
     void predecessor.then(launch, launch);
@@ -1251,9 +1280,10 @@ var OpenGeniClient = class {
       if (!this.active.has(key)) this.generations.delete(key);
     };
     void entry.promise.then(clear, clear);
-    return entry.promise;
+    return consumed;
   }
   launchRead(key, entry, read) {
+    if (entry.controller.signal.aborted) return;
     entry.started = true;
     this.generations.set(key, entry.generation);
     this.active.set(key, entry);
@@ -1275,7 +1305,7 @@ var OpenGeniClient = class {
     };
     let request;
     try {
-      request = read();
+      request = read(entry.controller.signal);
     } catch (error) {
       settle();
       entry.reject(error);
@@ -1292,6 +1322,28 @@ var OpenGeniClient = class {
       }
     );
   }
+  consumeSharedRead(key, entry, signal) {
+    entry.consumers += 1;
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      entry.consumers -= 1;
+      if (!signal?.aborted || entry.consumers > 0) return;
+      const reason = signal.reason;
+      entry.controller.abort(reason);
+      if (this.active.get(key) === entry) this.active.delete(key);
+      if (this.queued.get(key) === entry) this.queued.delete(key);
+      if (!this.active.has(key) && !this.queued.has(key)) this.generations.delete(key);
+      entry.reject(reason);
+    };
+    signal?.addEventListener("abort", release, { once: true });
+    const consumed = awaitWithAbort(entry.promise, signal);
+    return consumed.finally(() => {
+      signal?.removeEventListener("abort", release);
+      release();
+    });
+  }
   observeRead(entry, listener) {
     if (!listener) return;
     if (!entry.started) {
@@ -1384,13 +1436,15 @@ var OpenGeniClient = class {
       {
         ...options.limit !== void 0 ? { limit: String(options.limit) } : {},
         ...options.latestStarted ? { latestStarted: "1" } : {}
-      }
+      },
+      { signal: options.signal }
     );
   }
   /** Newest turn that durably emitted `turn.started`, or null before any admission. */
-  async getLatestStartedTurn(workspaceId, sessionId) {
+  async getLatestStartedTurn(workspaceId, sessionId, options = {}) {
     const turns = await this.listTurns(workspaceId, sessionId, {
-      latestStarted: true
+      latestStarted: true,
+      signal: options.signal
     });
     return turns[0] ?? null;
   }
@@ -1777,10 +1831,12 @@ var OpenGeniClient = class {
       request
     );
   }
-  async getComposerDraft(workspaceId, sessionId) {
+  async getComposerDraft(workspaceId, sessionId, options = {}) {
     return await this.requestSessionCommand(
       "GET",
-      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/composer-draft`
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/composer-draft`,
+      void 0,
+      options
     );
   }
   async saveComposerDraft(workspaceId, sessionId, request) {
@@ -1965,9 +2021,13 @@ var OpenGeniClient = class {
   }
   // --- Goals -------------------------------------------------------------------
   /** The session's goal. 404s when the session never had one. */
-  async getGoal(workspaceId, sessionId) {
+  async getGoal(workspaceId, sessionId, options = {}) {
     const path = `/v1/workspaces/${workspaceId}/sessions/${sessionId}/goal`;
-    return await this.sharedRead(path, () => this.requestJson("GET", path));
+    return await this.sharedRead(
+      path,
+      (signal) => this.requestJson("GET", path, void 0, {}, { signal }),
+      options
+    );
   }
   async updateGoal(workspaceId, sessionId, request) {
     return await this.requestJson(
@@ -2844,6 +2904,42 @@ var OpenGeniClient = class {
       options
     );
   }
+  async captureComputerTarget(workspaceId, computerSessionId, targetId, options = {}) {
+    const response = await this.requestResponse(
+      "GET",
+      `/v1/workspaces/${workspaceId}/computer-sessions/${encodeURIComponent(computerSessionId)}/targets/${encodeURIComponent(targetId)}/screenshot`,
+      {},
+      options
+    );
+    const mediaType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+    if (mediaType !== "image/jpeg" && mediaType !== "image/png") {
+      await cancelResponseBody(response, "computer frame media type is invalid");
+      throw new OpenGeniApiError(502, "computer frame media type is invalid");
+    }
+    const metadataHeader = response.headers.get("x-opengeni-computer-frame");
+    if (!metadataHeader || metadataHeader.length > 32 * 1024) {
+      await cancelResponseBody(response, "computer frame metadata is invalid");
+      throw new OpenGeniApiError(502, "computer frame metadata is invalid");
+    }
+    let metadata;
+    try {
+      metadata = decodeComputerFrameMetadataHeader(metadataHeader);
+    } catch {
+      await cancelResponseBody(response, "computer frame metadata is invalid");
+      throw new OpenGeniApiError(502, "computer frame metadata is invalid");
+    }
+    const bytes = await readBoundedResponseBytes(response, 256 * 1024, null);
+    const mismatchReason = computerFrameEvidenceMismatchReason(metadata, {
+      computerSessionId,
+      targetId,
+      mediaType,
+      sha256: await sha256Hex(bytes)
+    });
+    if (mismatchReason) {
+      throw new OpenGeniApiError(502, "computer frame evidence does not match its request");
+    }
+    return { ...metadata, data: bytes };
+  }
   async actInComputer(workspaceId, computerSessionId, request, options = {}) {
     return await this.requestJson(
       "POST",
@@ -2897,8 +2993,14 @@ var OpenGeniClient = class {
    * 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");
+  async getClientConfig(options = {}) {
+    const config = await this.requestJson(
+      "GET",
+      "/v1/config/client",
+      void 0,
+      {},
+      options
+    );
     if (config.apiContractRevision !== OPENGENI_API_CONTRACT_REVISION) {
       throw new OpenGeniApiContractMismatchError(
         OPENGENI_API_CONTRACT_REVISION,
@@ -2908,10 +3010,13 @@ var OpenGeniClient = class {
     return config;
   }
   /** Authenticated model definitions plus workspace-specific selectability. */
-  async getWorkspaceModelCatalog(workspaceId) {
+  async getWorkspaceModelCatalog(workspaceId, options = {}) {
     return await this.requestJson(
       "GET",
-      `/v1/workspaces/${workspaceId}/model-catalog`
+      `/v1/workspaces/${workspaceId}/model-catalog`,
+      void 0,
+      {},
+      options
     );
   }
   /** Read the workspace's hard provider/model allowlist. */
@@ -2930,10 +3035,13 @@ var OpenGeniClient = class {
     );
   }
   /** Authenticated realtime voice models and credential readiness. */
-  async getWorkspaceRealtimeModelCatalog(workspaceId) {
+  async getWorkspaceRealtimeModelCatalog(workspaceId, options = {}) {
     return await this.requestJson(
       "GET",
-      `/v1/workspaces/${workspaceId}/realtime-model-catalog`
+      `/v1/workspaces/${workspaceId}/realtime-model-catalog`,
+      void 0,
+      {},
+      options
     );
   }
   /** The caller's access context: subject, account + workspace grants, defaults. */
@@ -3165,6 +3273,17 @@ var OpenGeniClient = class {
   async createWorkspace(request) {
     return await this.requestJson("POST", "/v1/workspaces", request);
   }
+  /**
+   * Create an organization workspace once for a stable external tenant
+   * identity, or return the existing workspace without overwriting it.
+   */
+  async ensureWorkspace(request) {
+    return await this.requestJson(
+      "PUT",
+      "/v1/workspaces/external",
+      request
+    );
+  }
   async getWorkspace(workspaceId) {
     return await this.requestJson("GET", `/v1/workspaces/${workspaceId}`);
   }
@@ -3346,6 +3465,19 @@ var OpenGeniClient = class {
       `/v1/workspaces/${workspaceId}/company-profile/revisions/${encodeURIComponent(revisionId)}`
     );
   }
+  async getCompanyProfileAgentPolicy(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/company-profile/agent-policy`
+    );
+  }
+  async updateCompanyProfileAgentPolicy(workspaceId, request) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/company-profile/agent-policy`,
+      request
+    );
+  }
   async updateCompanyProfile(workspaceId, request) {
     return await this.requestJson(
       "PUT",
@@ -3469,9 +3601,16 @@ var OpenGeniClient = class {
     );
     return response.members;
   }
+  /** Active organization members who can be added to this workspace. */
+  async listWorkspaceMemberCandidates(workspaceId) {
+    const response = await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/member-candidates`
+    );
+    return response.members;
+  }
   /**
-   * Add an already-registered user by email. 404s when no user with that email
-   * exists (email invites for unknown users are deferred).
+   * Add one active member selected from the workspace candidate inventory.
    */
   async addWorkspaceMember(workspaceId, request) {
     return await this.requestJson(
@@ -3551,14 +3690,14 @@ var OpenGeniClient = class {
     return await this.requestJson(
       "POST",
       `/v1/workspaces/${workspaceId}/scheduled-tasks`,
-      request
+      normalizeScheduledTaskMachineTarget(request)
     );
   }
   async updateScheduledTask(workspaceId, taskId, request) {
     return await this.requestJson(
       "PATCH",
       `/v1/workspaces/${workspaceId}/scheduled-tasks/${taskId}`,
-      request
+      normalizeScheduledTaskMachineTarget(request)
     );
   }
   async pauseScheduledTask(workspaceId, taskId) {
@@ -4867,6 +5006,28 @@ var OpenGeniClient = class {
       `/v1/workspaces/${workspaceId}/api-keys/${apiKeyId}`
     );
   }
+  async listOrganizationApiKeys(organizationId) {
+    const response = await this.requestJson(
+      "GET",
+      `/v1/organizations/${organizationId}/api-keys`
+    );
+    return response.apiKeys;
+  }
+  /** The returned `token` is shown once; only its prefix is stored. */
+  async createOrganizationApiKey(organizationId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/organizations/${organizationId}/api-keys`,
+      request
+    );
+  }
+  /** Revoke an organization-scoped API key. Returns the revoked key. */
+  async deleteOrganizationApiKey(organizationId, apiKeyId) {
+    return await this.requestJson(
+      "DELETE",
+      `/v1/organizations/${organizationId}/api-keys/${apiKeyId}`
+    );
+  }
   // --- Billing (account-scoped) --------------------------------------------------------------------
   async getBilling(options = {}) {
     return await this.requestJson("GET", "/v1/billing", void 0, {
@@ -5107,14 +5268,15 @@ var OpenGeniClient = class {
     return await this.requestJson("DELETE", `/v1/workspaces/${workspaceId}/supergrok/accounts/${accountId}`, {});
   }
   /** Contract-checked JSON transport shared by opt-in typed SDK clients. */
-  async requestSessionCommand(method, path, body) {
+  async requestSessionCommand(method, path, body, options = {}) {
     return await this.requestJson(
       method,
       path,
       body,
       {},
       {
-        timeoutMs: this.sessionCommandTimeoutMs
+        signal: options.signal,
+        timeoutMs: options.timeoutMs ?? this.sessionCommandTimeoutMs
       }
     );
   }
@@ -5386,6 +5548,15 @@ async function sha256Hex(bytes) {
   const digest = await globalThis.crypto.subtle.digest("SHA-256", owned.buffer);
   return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
+function computerFrameEvidenceMismatchReason(metadata, expected) {
+  if (metadata.computerSessionId !== expected.computerSessionId) {
+    return "frame_session_mismatch";
+  }
+  if (metadata.targetId !== expected.targetId) return "frame_target_mismatch";
+  if (metadata.mediaType !== expected.mediaType) return "frame_media_mismatch";
+  if (metadata.sha256 !== expected.sha256) return "frame_digest_mismatch";
+  return null;
+}
 async function cancelResponseBody(response, reason) {
   await response.body?.cancel(reason).catch(() => void 0);
 }
@@ -5478,4 +5649,4 @@ export {
   parseMediaGenerationResult,
   OpenGeniClient
 };
-//# sourceMappingURL=chunk-7ZXBPJZP.js.map
+//# sourceMappingURL=chunk-TRNI7KEO.js.map