@opengeni/sdk 3.1.0 → 3.3.2-canary.1

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

@@ -5,18 +5,20 @@ import {
   OPENGENI_API_CONTRACT_REVISION,
   OPENGENI_CORRELATION_HEADER,
   RETAINED_OUTPUT_MAX_PAGE_BYTES
-} from "./chunk-YTAWBDO2.js";
+} from "./chunk-E5BNEG2D.js";
 import {
-  OpenGeniInteractionClient
-} from "./chunk-GW3EJ2GP.js";
+  OpenGeniInteractionClient,
+  decodeComputerFrameMetadataHeader
+} from "./chunk-QTBAMHEF.js";
 import {
   OpenGeniApiContractMismatchError,
   OpenGeniApiError,
+  OpenGeniSecureContextRequiredError,
   OpenGeniSessionListCursorError,
   OpenGeniStreamError,
   isAbortError,
   isRetryableStreamError
-} from "./chunk-C4DJPZRU.js";
+} from "./chunk-OO5LPTO7.js";
 
 // src/sse.ts
 async function* parseSseStream(stream) {
@@ -772,6 +774,8 @@ function createSingleFlightReadEntry(generation, onRequestStart) {
     reject = entryReject;
   });
   return {
+    controller: new AbortController(),
+    consumers: 0,
     generation,
     promise,
     resolve,
@@ -787,6 +791,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 +1031,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 +1135,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 +1230,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 +1281,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 +1306,7 @@ var OpenGeniClient = class {
     };
     let request;
     try {
-      request = read();
+      request = read(entry.controller.signal);
     } catch (error) {
       settle();
       entry.reject(error);
@@ -1292,6 +1323,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 +1437,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 +1832,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 +2022,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 +2905,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 +2994,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 +3011,69 @@ 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`,
+      void 0,
+      {},
+      options
+    );
+  }
+  /** List workspace-owned unpinned Vercel AI Gateway model slugs. */
+  async listWorkspaceGatewayCustomModels(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/gateway-custom-models`
+    );
+  }
+  /** Add one exact upstream Vercel AI Gateway slug. */
+  async createWorkspaceGatewayCustomModel(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/gateway-custom-models`,
+      request
+    );
+  }
+  /** Remove one workspace custom Gateway model by its stable row id. */
+  async deleteWorkspaceGatewayCustomModel(workspaceId, customModelId, request) {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(
+      customModelId
+    )) {
+      throw new TypeError("customModelId must be a UUID");
+    }
+    await this.requestVoid(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/gateway-custom-models/${encodeURIComponent(customModelId)}`,
+      request
+    );
+  }
+  /** List workspace-owned unpinned OpenRouter model slugs. */
+  async listWorkspaceOpenRouterCustomModels(workspaceId) {
     return await this.requestJson(
       "GET",
-      `/v1/workspaces/${workspaceId}/model-catalog`
+      `/v1/workspaces/${workspaceId}/openrouter-custom-models`
+    );
+  }
+  /** Add one exact upstream OpenRouter slug. */
+  async createWorkspaceOpenRouterCustomModel(workspaceId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/openrouter-custom-models`,
+      request
+    );
+  }
+  /** Remove one workspace custom OpenRouter model by its stable row id. */
+  async deleteWorkspaceOpenRouterCustomModel(workspaceId, customModelId, request) {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(
+      customModelId
+    )) {
+      throw new TypeError("customModelId must be a UUID");
+    }
+    await this.requestVoid(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/openrouter-custom-models/${encodeURIComponent(customModelId)}`,
+      request
     );
   }
   /** Read the workspace's hard provider/model allowlist. */
@@ -2930,10 +3092,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 +3330,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 +3522,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 +3658,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 +3747,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) {
@@ -3853,6 +4049,7 @@ var OpenGeniClient = class {
     if (input.timeoutMs !== void 0 && (!Number.isFinite(input.timeoutMs) || input.timeoutMs <= 0)) {
       throw new Error("File upload timeout must be a positive number");
     }
+    assertBrowserFileUploadSecureContext();
     const withTimeout = async (timeoutMs, operation) => {
       const controller = new AbortController();
       let timeout;
@@ -4867,6 +5064,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 +5326,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
       }
     );
   }
@@ -5376,6 +5596,16 @@ function mutationTransportError(correlationId) {
     displayMessage: "OpenGeni could not confirm the request \u2014 reconcile before retrying."
   });
 }
+function assertBrowserFileUploadSecureContext() {
+  const secureContext = typeof window !== "undefined" ? window.isSecureContext : typeof globalThis.isSecureContext === "boolean" ? globalThis.isSecureContext : void 0;
+  if (secureContext === void 0) return;
+  if (!secureContext) {
+    throw new OpenGeniSecureContextRequiredError("insecure_context");
+  }
+  if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.digest !== "function") {
+    throw new OpenGeniSecureContextRequiredError("web_crypto_unavailable");
+  }
+}
 async function sha256ForUpload(body) {
   const bytes = typeof body === "string" ? new TextEncoder().encode(body) : body instanceof Blob ? new Uint8Array(await body.arrayBuffer()) : new Uint8Array(body);
   const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
@@ -5386,6 +5616,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 +5717,4 @@ export {
   parseMediaGenerationResult,
   OpenGeniClient
 };
-//# sourceMappingURL=chunk-7ZXBPJZP.js.map
+//# sourceMappingURL=chunk-GY6RQPCG.js.map