@opengeni/sdk 0.20.0 → 0.23.0

package/dist/index.js

@@ -319,6 +319,7 @@ var SESSION_EVENT_TYPES = [
   "agent.reasoning.delta",
   "agent.toolCall.created",
   "agent.toolCall.output",
+  "agent.model.request",
   "agent.model.usage",
   "tool.auth_needed",
   "credential.auth_needed",
@@ -370,6 +371,7 @@ var SESSION_EVENT_TYPES = [
   "terminal.pty.output.delta",
   "terminal.pty.exited",
   "session.title_set",
+  "session.mcp.approval_policy.updated",
   // Multi-account Codex (P1): the session's inference account changed.
   "codex.account.switched",
   // credential allocator metadata-only per-turn credential selection audit.
@@ -449,6 +451,8 @@ var KNOWN_PERMISSIONS = [
 ];
 var OPENGENI_API_CONTRACT_REVISION = "2026-07-turn-instructions-v1";
 var OPENGENI_API_CONTRACT_HEADER = "x-opengeni-api-contract";
+var RETAINED_OUTPUT_DEFAULT_PAGE_BYTES = 256 * 1024;
+var RETAINED_OUTPUT_MAX_PAGE_BYTES = 1024 * 1024;
 var KNOWN_USAGE_EVENT_TYPES = [
   "agent_run.created",
   "agent_run.completed",
@@ -495,6 +499,18 @@ var OpenGeniClient = class {
       request
     );
   }
+  /**
+   * Replace one attached MCP server's approval policy. The change is captured
+   * by the next claimed attempt; already-claimed work keeps its immutable
+   * policy snapshot.
+   */
+  async updateSessionMcpApprovalPolicy(workspaceId, sessionId, serverId, request) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/mcp-servers/${encodeURIComponent(serverId)}/approval-policy`,
+      request
+    );
+  }
   async listSessions(workspaceId, options = {}) {
     return await this.requestJson(
       "GET",
@@ -673,26 +689,30 @@ var OpenGeniClient = class {
   async listEvents(workspaceId, sessionId, options = {}) {
     return (await this.listEventPage(workspaceId, sessionId, options)).events;
   }
-  /** Bounded durable/monitoring page plus exact projection and cursor facts. */
   async listEventPage(workspaceId, sessionId, options = {}) {
     if (options.latest && ["includeTypes", "excludeTypes", "includeClasses", "excludeClasses"].some(
       (name) => Object.prototype.hasOwnProperty.call(options, name)
     )) {
       throw new TypeError("latest cannot be combined with event filters");
     }
+    if (options.resultMode === "compact" && !options.latest) {
+      throw new TypeError("resultMode=compact requires latest");
+    }
+    const listOptions = options.resultMode === "compact" ? null : options;
     const response = await this.fetchImpl(
       this.url(`/v1/workspaces/${workspaceId}/sessions/${sessionId}/events`, {
-        ...options.after !== void 0 ? { after: String(options.after) } : {},
-        ...options.before !== void 0 ? { before: String(options.before) } : {},
-        ...options.limit !== void 0 ? { limit: String(options.limit) } : {},
-        ...options.compact ? { compact: "1" } : {},
+        ...listOptions?.after !== void 0 ? { after: String(listOptions.after) } : {},
+        ...listOptions?.before !== void 0 ? { before: String(listOptions.before) } : {},
+        ...listOptions?.limit !== void 0 ? { limit: String(listOptions.limit) } : {},
+        ...listOptions?.compact ? { compact: "1" } : {},
         ...options.mode ? { mode: options.mode } : {},
-        ...options.direction ? { direction: options.direction } : {},
+        ...listOptions?.direction ? { direction: listOptions.direction } : {},
         ...options.payloadMode ? { payloadMode: options.payloadMode } : {},
-        ...options.includeTypes?.length ? { includeTypes: options.includeTypes.join(",") } : {},
-        ...options.excludeTypes?.length ? { excludeTypes: options.excludeTypes.join(",") } : {},
-        ...options.includeClasses?.length ? { includeClasses: options.includeClasses.join(",") } : {},
-        ...options.excludeClasses?.length ? { excludeClasses: options.excludeClasses.join(",") } : {},
+        ...options.resultMode ? { resultMode: options.resultMode } : {},
+        ...listOptions?.includeTypes?.length ? { includeTypes: listOptions.includeTypes.join(",") } : {},
+        ...listOptions?.excludeTypes?.length ? { excludeTypes: listOptions.excludeTypes.join(",") } : {},
+        ...listOptions?.includeClasses?.length ? { includeClasses: listOptions.includeClasses.join(",") } : {},
+        ...listOptions?.excludeClasses?.length ? { excludeClasses: listOptions.excludeClasses.join(",") } : {},
         ...options.latest ? { latest: options.latest } : {}
       }),
       {
@@ -702,7 +722,11 @@ var OpenGeniClient = class {
     );
     assertApiContractResponse(response);
     if (!response.ok) throw new OpenGeniApiError(response.status, await safeText(response));
-    const events = await response.json();
+    const body = await response.json();
+    if (options.resultMode === "compact") {
+      return body;
+    }
+    const events = body;
     const integerHeader = (name) => {
       const raw = response.headers.get(name);
       if (raw === null) return null;
@@ -735,6 +759,18 @@ var OpenGeniClient = class {
       forensicExact: response.headers.get("X-OpenGeni-Forensic-Exact") === "true"
     };
   }
+  /**
+   * Fetch the authoritative newest-sequence semantic result directly. This is
+   * the callback-loss recovery path: it reads one compact durable result and
+   * never creates a model turn. `latest: "receipt"` aliases `tool_receipt`;
+   * turn generation remains scoped retry metadata.
+   */
+  async getLatestEventResult(workspaceId, sessionId, options = { latest: "terminal" }) {
+    return await this.listEventPage(workspaceId, sessionId, {
+      ...options,
+      resultMode: "compact"
+    });
+  }
   /** POST a user/control event to the session. Returns the accepted event. */
   async sendEvent(workspaceId, sessionId, event) {
     return await this.requestJson(
@@ -1261,6 +1297,13 @@ var OpenGeniClient = class {
     }
     return config;
   }
+  /** Authenticated model definitions plus workspace-specific selectability. */
+  async getWorkspaceModelCatalog(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/model-catalog`
+    );
+  }
   /** The caller's access context: subject, account + workspace grants, defaults. */
   async getAccessContext() {
     return await this.requestJson("GET", "/v1/access/me");
@@ -1591,6 +1634,71 @@ var OpenGeniClient = class {
       `/v1/workspaces/${workspaceId}/files/${fileId}`
     );
   }
+  /** Read provider-neutral retained evidence metadata; never returns a storage location. */
+  async getRetainedArtifact(workspaceId, artifactId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/artifacts/${artifactId}`
+    );
+  }
+  /**
+   * Read at most one authenticated retained-evidence range from the API. This
+   * deliberately does not use the ordinary signed file-download URL.
+   */
+  async getRetainedArtifactContent(workspaceId, artifactId, options = {}) {
+    if (options.range && (options.range.length > 128 || /[^\x20-\x7e]/.test(options.range))) {
+      throw new RangeError("retained artifact range must be at most 128 printable ASCII bytes");
+    }
+    const response = await this.fetchImpl(
+      this.url(`/v1/workspaces/${workspaceId}/artifacts/${artifactId}/content`),
+      {
+        method: "GET",
+        headers: {
+          ...this.headers(),
+          Accept: "application/octet-stream",
+          ...options.range ? { Range: options.range } : {}
+        },
+        ...options.signal ? { signal: options.signal } : {}
+      }
+    );
+    try {
+      assertApiContractResponse(response);
+    } catch (error) {
+      await cancelResponseBody(response, "retained artifact API contract mismatch");
+      throw error;
+    }
+    if (!response.ok) {
+      throw new OpenGeniApiError(response.status, await safeBoundedText(response));
+    }
+    if (response.status !== 200 && response.status !== 206) {
+      await cancelResponseBody(response, "unexpected retained artifact response status");
+      throw new OpenGeniApiError(response.status, "unexpected retained artifact response status");
+    }
+    if (response.headers.get("accept-ranges") !== "bytes") {
+      await cancelResponseBody(response, "retained artifact response omitted byte-range support");
+      throw new OpenGeniApiError(502, "retained artifact response omitted byte-range support");
+    }
+    let declaredLength;
+    try {
+      declaredLength = parseBoundedContentLength(response.headers.get("content-length"));
+    } catch (error) {
+      await cancelResponseBody(response, "invalid retained artifact content-length");
+      throw error;
+    }
+    const bytes = await readBoundedResponseBytes(
+      response,
+      RETAINED_OUTPUT_MAX_PAGE_BYTES,
+      declaredLength
+    );
+    return {
+      bytes,
+      status: response.status,
+      contentType: response.headers.get("content-type") ?? "application/octet-stream",
+      contentLength: bytes.byteLength,
+      contentRange: response.headers.get("content-range"),
+      acceptRanges: "bytes"
+    };
+  }
   /** Mint a short-lived signed download URL for a ready file. */
   async createFileDownloadUrl(workspaceId, fileId) {
     return await this.requestJson(
@@ -1984,6 +2092,13 @@ var OpenGeniClient = class {
       `/v1/workspaces/${workspaceId}/codex/usage/refresh`
     );
   }
+  /** Live independently-settled quota + reset-credit overview for every account. */
+  async codexOverview(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/codex/overview`
+    );
+  }
   /** Disconnect ALL accounts (legacy workspace-wide). Prefer `disconnectCodexAccount`. */
   async codexDisconnect(workspaceId) {
     return await this.requestJson(
@@ -2013,6 +2128,14 @@ var OpenGeniClient = class {
       patch
     );
   }
+  /** Toggle only NEW automatic allocations under independent allocator OCC. */
+  async setCodexAccountAllocator(workspaceId, accountId, input) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/codex/accounts/${accountId}/allocator`,
+      input
+    );
+  }
   /** Disconnect ONE Codex account by id (re-picks active when the removed one was active). */
   async disconnectCodexAccount(workspaceId, accountId) {
     return await this.requestJson(
@@ -2083,6 +2206,62 @@ async function safeText(response) {
     return "";
   }
 }
+async function safeBoundedText(response) {
+  try {
+    return new TextDecoder().decode(await readBoundedResponseBytes(response, 64 * 1024, null));
+  } catch {
+    return "";
+  }
+}
+async function cancelResponseBody(response, reason) {
+  await response.body?.cancel(reason).catch(() => void 0);
+}
+function parseBoundedContentLength(value) {
+  if (value === null) return null;
+  if (!/^\d+$/.test(value)) {
+    throw new OpenGeniApiError(502, "invalid retained artifact content-length");
+  }
+  const length = Number(value);
+  if (!Number.isSafeInteger(length) || length > RETAINED_OUTPUT_MAX_PAGE_BYTES) {
+    throw new OpenGeniApiError(502, "retained artifact response exceeds the SDK byte limit");
+  }
+  return length;
+}
+async function readBoundedResponseBytes(response, maxBytes, expectedBytes) {
+  if (!response.body) {
+    if (expectedBytes !== null && expectedBytes !== 0) {
+      throw new OpenGeniApiError(502, "retained artifact response length mismatch");
+    }
+    return new Uint8Array();
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        await reader.cancel("retained artifact response exceeded the SDK byte limit").catch(() => void 0);
+        throw new OpenGeniApiError(502, "retained artifact response exceeds the SDK byte limit");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  if (expectedBytes !== null && totalBytes !== expectedBytes) {
+    throw new OpenGeniApiError(502, "retained artifact response length mismatch");
+  }
+  const bytes = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
 
 // src/proxy.ts
 function formatSseEvent(event) {
@@ -2489,6 +2668,8 @@ export {
   OpenGeniApiError,
   OpenGeniClient,
   OpenGeniStreamError,
+  RETAINED_OUTPUT_DEFAULT_PAGE_BYTES,
+  RETAINED_OUTPUT_MAX_PAGE_BYTES,
   SESSION_EVENT_TYPES,
   TTYD_SUBPROTOCOL,
   TtydClientCommand,