@opengeni/sdk 0.20.0 → 0.25.0

package/dist/index.js

@@ -1,14 +1,33 @@
 // src/errors.ts
 var OpenGeniApiError = class extends Error {
   status;
+  code;
   body;
   constructor(status, body) {
-    super(`OpenGeni API ${status}: ${body || "(empty body)"}`);
+    const decoded = decodeApiErrorBody(body);
+    super(`OpenGeni API ${status}: ${decoded.message ?? (body || "(empty body)")}`);
     this.name = "OpenGeniApiError";
     this.status = status;
+    this.code = decoded.code;
     this.body = body;
   }
 };
+function decodeApiErrorBody(body) {
+  if (!body) return {};
+  try {
+    const decoded = JSON.parse(body);
+    if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) return {};
+    const record = decoded;
+    return {
+      ...typeof record.code === "string" && record.code ? { code: record.code } : {},
+      ...typeof record.message === "string" && record.message ? { message: record.message } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+var OpenGeniSessionListCursorError = class extends OpenGeniApiError {
+};
 var OpenGeniApiContractMismatchError = class extends Error {
   expected;
   actual;
@@ -319,6 +338,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,10 +390,13 @@ 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.
   "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",
@@ -449,6 +472,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",
@@ -465,6 +490,13 @@ var KNOWN_USAGE_EVENT_TYPES = [
 ];
 
 // src/client.ts
+function sessionListQuery(options) {
+  const { limit, parentSessionId } = options;
+  return {
+    ...limit === void 0 ? {} : { limit: String(limit) },
+    ...parentSessionId === void 0 ? {} : { parentSessionId: parentSessionId ?? "null" }
+  };
+}
 var OpenGeniClient = class {
   baseUrl;
   options;
@@ -482,6 +514,19 @@ var OpenGeniClient = class {
       request
     );
   }
+  async getNewSessionDraft(workspaceId) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/new-session-draft`
+    );
+  }
+  async saveNewSessionDraft(workspaceId, request) {
+    return await this.requestJson(
+      "PUT",
+      `/v1/workspaces/${workspaceId}/new-session-draft`,
+      request
+    );
+  }
   async getSession(workspaceId, sessionId) {
     return await this.requestJson(
       "GET",
@@ -495,36 +540,66 @@ 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 = {}) {
+    if (options.search?.trim()) {
+      const page = await this.listSessionPage(workspaceId, options);
+      return [...page.pinned, ...page.sessions];
+    }
     return await this.requestJson(
       "GET",
       `/v1/workspaces/${workspaceId}/sessions`,
       void 0,
-      {
-        ...options.limit !== void 0 ? { limit: String(options.limit) } : {},
-        ...options.search?.trim() ? { search: options.search.trim() } : {},
-        ...Object.prototype.hasOwnProperty.call(options, "parentSessionId") && options.parentSessionId !== void 0 ? {
-          parentSessionId: options.parentSessionId === null ? "null" : String(options.parentSessionId)
-        } : {}
-      }
+      sessionListQuery(options)
     );
   }
   /** Pin-aware ordinary-session page with a stable keyset cursor. */
   async listSessionPage(workspaceId, options = {}) {
-    return await this.requestJson(
-      "GET",
-      `/v1/workspaces/${workspaceId}/sessions`,
-      void 0,
-      {
-        view: "page",
-        ...options.limit !== void 0 ? { limit: String(options.limit) } : {},
-        ...options.cursor !== void 0 ? { cursor: options.cursor } : {},
-        ...options.search?.trim() ? { search: options.search.trim() } : {},
-        ...Object.prototype.hasOwnProperty.call(options, "parentSessionId") && options.parentSessionId !== void 0 ? {
-          parentSessionId: options.parentSessionId === null ? "null" : String(options.parentSessionId)
-        } : {}
+    const search = options.search?.trim();
+    let response;
+    try {
+      response = await this.requestJson(
+        "GET",
+        `/v1/workspaces/${workspaceId}/sessions`,
+        void 0,
+        {
+          view: "page",
+          ...sessionListQuery(options),
+          ...options.cursor !== void 0 ? { cursor: options.cursor } : {},
+          ...search ? { search } : {},
+          ...options.pinsOnly ? { pinsOnly: "true" } : {}
+        }
+      );
+    } catch (error) {
+      if (error instanceof OpenGeniApiError && error.status === 410) {
+        throw new OpenGeniSessionListCursorError(error.status, error.body);
       }
-    );
+      throw error;
+    }
+    if (Array.isArray(response)) {
+      if (options.cursor) {
+        throw new Error("The connected OpenGeni API does not support stable session-page cursors");
+      }
+      if (search) {
+        throw new Error("The connected OpenGeni API does not support session search");
+      }
+      if (options.pinsOnly) {
+        throw new Error("The connected OpenGeni API does not support pins-only session lists");
+      }
+      return { pinned: [], sessions: response, nextCursor: null };
+    }
+    return response;
   }
   /** Set this authenticated member's personal workspace pin for a session. */
   async updateSessionPin(workspaceId, sessionId, request) {
@@ -673,26 +748,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 +781,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 +818,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 +1356,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");
@@ -1561,13 +1663,14 @@ var OpenGeniClient = class {
    * -> complete. Returns the ready `FileAsset`.
    */
   async uploadFile(workspaceId, input) {
-    const body = input.data instanceof Uint8Array ? new Blob([input.data.slice()]) : input.data;
+    const body = input.data instanceof Uint8Array ? new Blob([input.data.slice()]) : input.data instanceof ArrayBuffer ? input.data.slice(0) : input.data;
     const sizeBytes = typeof body === "string" ? new TextEncoder().encode(body).byteLength : body instanceof Blob ? body.size : body.byteLength;
+    const sha256 = input.sha256 ?? await sha256ForUpload(body);
     const upload = await this.beginFileUpload(workspaceId, {
       filename: input.filename,
       contentType: input.contentType,
       sizeBytes,
-      ...input.sha256 !== void 0 ? { sha256: input.sha256 } : {}
+      sha256
     });
     const putResponse = await this.fetchImpl(upload.putUrl, {
       method: "PUT",
@@ -1591,6 +1694,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 +2152,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 +2188,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(
@@ -2076,6 +2259,11 @@ function assertApiContractResponse(response) {
     throw new OpenGeniApiContractMismatchError(OPENGENI_API_CONTRACT_REVISION, actual);
   }
 }
+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);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
 async function safeText(response) {
   try {
     return await response.text();
@@ -2083,6 +2271,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) {
@@ -2488,7 +2732,10 @@ export {
   OpenGeniApiContractMismatchError,
   OpenGeniApiError,
   OpenGeniClient,
+  OpenGeniSessionListCursorError,
   OpenGeniStreamError,
+  RETAINED_OUTPUT_DEFAULT_PAGE_BYTES,
+  RETAINED_OUTPUT_MAX_PAGE_BYTES,
   SESSION_EVENT_TYPES,
   TTYD_SUBPROTOCOL,
   TtydClientCommand,