@superlinked/sie-sdk 0.6.15 → 0.6.17

package/dist/index.cjs

@@ -87,6 +87,18 @@ var ModelLoadingError = class extends SIEError {
     this.model = model;
   }
 };
+var ResourceExhaustedError = class extends ServerError {
+  /** The model that was requested */
+  model;
+  /** Number of retry attempts made before giving up */
+  retries;
+  constructor(message, options) {
+    super(message, "RESOURCE_EXHAUSTED", 503);
+    this.name = "ResourceExhaustedError";
+    this.model = options?.model;
+    this.retries = options?.retries ?? 0;
+  }
+};
 var SIEStreamError = class extends SIEError {
   /** SIE-native error code (e.g. `context_exceeded`, `cancelled`). */
   code;
@@ -193,16 +205,24 @@ var HTTP_CLIENT_ERROR_MIN = 400;
 var HTTP_CLIENT_ERROR_MAX = 499;
 var HTTP_SERVER_ERROR_MIN = 500;
 var HTTP_SERVER_ERROR_MAX = 599;
+var HTTP_GATEWAY_TIMEOUT = 504;
 var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_LONG_RUNNING_TIMEOUT = 12e4;
 var DEFAULT_PROVISION_TIMEOUT = 3e5;
 var DEFAULT_RETRY_DELAY = 5e3;
 var DEFAULT_LEASE_RENEWAL_INTERVAL = 6e4;
+var DEFAULT_JOB_WAIT_TIMEOUT = 6e5;
+var DEFAULT_JOB_WAIT_POLL = 2e3;
 var LORA_LOADING_MAX_RETRIES = 10;
 var LORA_LOADING_DEFAULT_DELAY = 1e3;
 var LORA_LOADING_ERROR_CODE = "LORA_LOADING";
 var MODEL_LOADING_DEFAULT_DELAY = 5e3;
 var MODEL_LOADING_ERROR_CODE = "MODEL_LOADING";
 var PROVISIONING_ERROR_CODE = "PROVISIONING";
+var RESOURCE_EXHAUSTED_MAX_RETRIES = 3;
+var RESOURCE_EXHAUSTED_DEFAULT_DELAY = 5e3;
+var RESOURCE_EXHAUSTED_MAX_DELAY = 3e4;
+var RESOURCE_EXHAUSTED_ERROR_CODE = "RESOURCE_EXHAUSTED";
 var SDK_VERSION_HEADER = "X-SIE-SDK-Version";
 var SERVER_VERSION_HEADER = "X-SIE-Server-Version";
 var EXT_TYPE_NUMPY = 78;
@@ -392,9 +412,19 @@ function unpackMessage(data) {
 // src/internal/retry.ts
 var RETRY_JITTER_FRACTION = 0.25;
 function applyRetryJitter(delay) {
+  if (delay <= 0) return Math.max(delay, 0);
   const low = delay * (1 - RETRY_JITTER_FRACTION);
   return Math.max(0, low + Math.random() * (delay - low));
 }
+function computeOomBackoff(retryAfter, attempt, baseDelay = RESOURCE_EXHAUSTED_DEFAULT_DELAY, maxDelay = RESOURCE_EXHAUSTED_MAX_DELAY) {
+  const safeRetryAfter = retryAfter !== void 0 ? Math.max(retryAfter, 0) : void 0;
+  if (safeRetryAfter !== void 0 && attempt === 0) {
+    return Math.min(safeRetryAfter, maxDelay);
+  }
+  const base = safeRetryAfter !== void 0 ? Math.max(baseDelay, safeRetryAfter) : baseDelay;
+  const capped = Math.max(0, Math.min(base * 2 ** attempt, maxDelay));
+  return applyRetryJitter(capped);
+}
 function getRetryAfter(header) {
   if (!header) return void 0;
   const seconds = Number.parseInt(header, 10);
@@ -650,8 +680,12 @@ function parseCapacityInfo(data, gpuFilter) {
   const parsedWorkers = workers.map((w) => ({
     url: w.url,
     gpu: w.gpu,
+    gpuCount: w.gpu_count ?? 0,
+    readyGpuSlots: w.ready_gpu_slots ?? w.gpu_count ?? (w.healthy ? 1 : 0),
     healthy: w.healthy,
     queueDepth: w.queue_depth,
+    pendingCost: w.pending_cost ?? 0,
+    inflightBatches: w.inflight_batches ?? 0,
     loadedModels: w.loaded_models
   }));
   return {
@@ -669,8 +703,21 @@ function parseCapacityInfo(data, gpuFilter) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function nextOomRetryDelay(opts) {
+  const { retryAfter, oomRetries, maxOomRetries, elapsedMs, provisionTimeoutMs, model } = opts;
+  const message = `Server resource exhausted after ${oomRetries} retry attempt(s) for model '${model}'`;
+  if (oomRetries >= maxOomRetries || elapsedMs >= provisionTimeoutMs) {
+    throw new ResourceExhaustedError(message, { model, retries: oomRetries });
+  }
+  const delay = computeOomBackoff(retryAfter, oomRetries);
+  if (delay >= provisionTimeoutMs - elapsedMs) {
+    throw new ResourceExhaustedError(message, { model, retries: oomRetries });
+  }
+  return delay;
+}
 async function withProvisioningRetry(performFetch, opts) {
   const startTime = Date.now();
+  let oomRetries = 0;
   while (true) {
     const response = await performFetch();
     await throwIfModelLoadFailed(response, opts.model);
@@ -706,6 +753,26 @@ async function withProvisioningRetry(performFetch, opts) {
         await sleep(Math.min(delay, opts.provisionTimeoutMs - elapsed));
         continue;
       }
+      if (errorCode === RESOURCE_EXHAUSTED_ERROR_CODE) {
+        const delay = nextOomRetryDelay({
+          retryAfter: getRetryAfter2(response),
+          oomRetries,
+          maxOomRetries: RESOURCE_EXHAUSTED_MAX_RETRIES,
+          elapsedMs: Date.now() - startTime,
+          provisionTimeoutMs: opts.provisionTimeoutMs,
+          model: opts.model
+        });
+        oomRetries += 1;
+        await sleep(delay);
+        continue;
+      }
+    }
+    if (response.status === HTTP_GATEWAY_TIMEOUT) {
+      throw new ServerError(
+        "Gateway timed out (504) after the request was published to the queue; a worker may already be generating. Not retried because generation is non-idempotent (retrying could double-bill). Re-issue manually if needed.",
+        await getErrorCode(response.clone()),
+        HTTP_GATEWAY_TIMEOUT
+      );
     }
     if (!response.ok) {
       await handleError(response);
@@ -717,6 +784,255 @@ async function withProvisioningRetry(performFetch, opts) {
   }
 }
 
+// src/jobs.ts
+var TERMINAL_JOB_STATES = /* @__PURE__ */ new Set([
+  "succeeded",
+  "failed",
+  "suspended",
+  "cancelled"
+]);
+var SINK_RETURN = /* @__PURE__ */ new Set(["return", "default"]);
+var SINK_INPLACE = /* @__PURE__ */ new Set(["inplace", "in_place", "in place"]);
+var INTERNAL_SCHEMES = /* @__PURE__ */ new Set(["upload"]);
+var FIELD_MAP_KEYS = /* @__PURE__ */ new Set(["id_field", "input_field", "carry", "input_type"]);
+var INPUT_TYPES = /* @__PURE__ */ new Set(["text", "document"]);
+function isConnectorUri(value) {
+  return value.includes("://");
+}
+function isInternalUri(uri) {
+  return INTERNAL_SCHEMES.has(uri.split("://", 1)[0] ?? "");
+}
+function normItem(item, index) {
+  if (typeof item === "string") return { text: item };
+  if (item !== null && typeof item === "object") return item;
+  throw new RequestError(`item ${index} must be a string or an object`, "invalid_request", 400);
+}
+function connectionName(uri) {
+  const afterScheme = uri.split("://", 2)[1] ?? "";
+  const authority = afterScheme.split(/[/?#]/, 1)[0] ?? "";
+  const name = authority.trim();
+  if (!name) {
+    throw new RequestError(
+      `connector URI ${JSON.stringify(uri)} names no connection (expected 'scheme://<connection>/\u2026')`,
+      "invalid_request",
+      400
+    );
+  }
+  return name;
+}
+function resolveSource(source, connection) {
+  if (Array.isArray(source)) {
+    if (source.length === 0) {
+      throw new RequestError("inline source has no items", "invalid_request", 400);
+    }
+    return { items: source.map((item, i) => normItem(item, i)) };
+  }
+  if (isConnectorUri(source)) {
+    if (isInternalUri(source)) {
+      return connection ? { src: source, connection } : { src: source };
+    }
+    return { src: source, connection: connection ?? connectionName(source) };
+  }
+  if (typeof source === "string" && source.trim()) {
+    return { items: [{ text: source }] };
+  }
+  throw new RequestError(
+    "source must be inline items (a list/string) or a connector URI (scheme://<connection>/\u2026)",
+    "invalid_request",
+    400
+  );
+}
+function resolveSink(sink, sourceConnection, sinkConnection) {
+  if (sink === null || sink === void 0 || SINK_RETURN.has(sink.trim().toLowerCase())) {
+    return {};
+  }
+  if (SINK_INPLACE.has(sink.trim().toLowerCase())) {
+    return { sink: "inplace" };
+  }
+  if (isConnectorUri(sink)) {
+    const body = { sink };
+    if (isInternalUri(sink)) {
+      if (sinkConnection != null) body.sink_connection = sinkConnection;
+      return body;
+    }
+    const resolved = sinkConnection ?? connectionName(sink);
+    if (sinkConnection != null || resolved !== sourceConnection) {
+      body.sink_connection = resolved;
+    }
+    return body;
+  }
+  throw new RequestError(
+    `sink must be 'return', 'inplace', or a connector URI (got ${JSON.stringify(sink)})`,
+    "invalid_request",
+    400
+  );
+}
+function resolveFieldMap(fieldMap, outputField) {
+  const body = {};
+  if (fieldMap != null) {
+    const unknown = Object.keys(fieldMap).filter((key) => !FIELD_MAP_KEYS.has(key));
+    if (unknown.length > 0) {
+      throw new RequestError(
+        `unknown field_map key(s) ${JSON.stringify(unknown)} (known: ${[...FIELD_MAP_KEYS].join(", ")})`,
+        "invalid_request",
+        400
+      );
+    }
+    if (fieldMap.carry != null && (!Array.isArray(fieldMap.carry) || fieldMap.carry.some((c) => typeof c !== "string" || !c))) {
+      throw new RequestError(
+        `field_map.carry must be a list of field names (got ${JSON.stringify(fieldMap.carry)})`,
+        "invalid_request",
+        400
+      );
+    }
+    if (fieldMap.input_type != null && !INPUT_TYPES.has(fieldMap.input_type)) {
+      throw new RequestError(
+        `field_map.input_type must be one of ${[...INPUT_TYPES].join(", ")} (got ${JSON.stringify(fieldMap.input_type)})`,
+        "invalid_request",
+        400
+      );
+    }
+    const mapped = {};
+    if (fieldMap.id_field != null) mapped.id_field = fieldMap.id_field;
+    if (fieldMap.input_field != null) mapped.input_field = fieldMap.input_field;
+    if (fieldMap.input_type != null) mapped.input_type = fieldMap.input_type;
+    if (fieldMap.carry != null && fieldMap.carry.length > 0) mapped.carry = fieldMap.carry;
+    if (Object.keys(mapped).length > 0) body.field_map = mapped;
+  }
+  if (outputField != null) {
+    if (typeof outputField !== "string" || !outputField) {
+      throw new RequestError(
+        `output_field must be a non-empty string (got ${JSON.stringify(outputField)})`,
+        "invalid_request",
+        400
+      );
+    }
+    body.output_field = outputField;
+  }
+  return body;
+}
+function resolveWhen(when) {
+  if (when == null || when.trim() === "" || when.trim().toLowerCase() === "now") {
+    return {};
+  }
+  const text = when.trim();
+  if (text.toLowerCase().startsWith("schedule:")) {
+    return { when: "schedule", schedule: text.slice("schedule:".length).trim() };
+  }
+  if (text.toLowerCase().startsWith("watch:")) {
+    return { when: "watch", watch: text.slice("watch:".length).trim() };
+  }
+  if (text.toLowerCase() === "schedule") {
+    throw new RequestError(
+      "schedule trigger needs a cron expr: when='schedule:<cron>'",
+      "invalid_request",
+      400
+    );
+  }
+  if (text.split(/\s+/).length === 5) {
+    return { when: "schedule", schedule: text };
+  }
+  throw new RequestError(
+    `unrecognized when ${JSON.stringify(when)}: use 'now', 'schedule:<cron>', or 'watch:<source>'`,
+    "invalid_request",
+    400
+  );
+}
+function buildJobBody(options) {
+  const operation = options.operation ?? "encode";
+  const body = { operation, model: options.model };
+  const sourceFields = resolveSource(options.source, options.connection);
+  Object.assign(body, sourceFields);
+  Object.assign(
+    body,
+    resolveSink(
+      options.sink,
+      sourceFields.connection,
+      options.sinkConnection
+    )
+  );
+  const mappingFields = resolveFieldMap(options.fieldMap, options.outputField);
+  if (Object.keys(mappingFields).length > 0 && !("src" in body)) {
+    throw new RequestError(
+      "fieldMap/outputField apply to connector-src jobs; an inline items job maps nothing",
+      "invalid_request",
+      400
+    );
+  }
+  Object.assign(body, mappingFields);
+  Object.assign(body, resolveWhen(options.when));
+  if (options.outputTypes && options.outputTypes.length > 0) {
+    body.output_types = options.outputTypes;
+  }
+  if (options.options && Object.keys(options.options).length > 0) {
+    body.options = options.options;
+  }
+  return body;
+}
+function jobChunks(jobDoc) {
+  const raw = jobDoc.output?.chunks ?? [];
+  return raw.map((chunk) => ({
+    seq: chunk.seq,
+    items: chunk.items,
+    state: chunk.state,
+    ref: chunk.ref,
+    units: chunk.units,
+    credits: chunk.credits,
+    error: chunk.error ?? null
+  }));
+}
+function toNumberArrayLike(value) {
+  if (value == null) return null;
+  if (value instanceof Float32Array) return value;
+  if (Array.isArray(value)) return value;
+  if (ArrayBuffer.isView(value)) return value;
+  return null;
+}
+function denseInfo(dense) {
+  if (dense == null) return { dims: null, vector: null };
+  if (typeof dense === "object" && !Array.isArray(dense) && !ArrayBuffer.isView(dense)) {
+    const rec = dense;
+    let raw = null;
+    for (const key of ["values", "vector", "dense"]) {
+      if (rec[key] != null) {
+        raw = rec[key];
+        break;
+      }
+    }
+    const vector2 = toNumberArrayLike(raw);
+    let dims = typeof rec.dims === "number" ? rec.dims : null;
+    if (dims == null && vector2 != null) dims = vector2.length;
+    return { dims, vector: vector2 };
+  }
+  const vector = toNumberArrayLike(dense);
+  return { dims: vector != null ? vector.length : null, vector };
+}
+function decodeResultItem(result) {
+  const payload = result.result_msgpack;
+  let decoded = null;
+  if (payload instanceof Uint8Array) {
+    try {
+      decoded = unpackMessage(payload);
+    } catch {
+      decoded = null;
+    }
+  }
+  const dense = decoded && typeof decoded === "object" ? decoded.dense : null;
+  const { dims, vector } = denseInfo(dense);
+  return {
+    id: result.id ?? null,
+    success: result.success ?? null,
+    units: result.units ?? null,
+    dims,
+    dense: vector
+  };
+}
+function decodeChunkBytes(raw) {
+  const results = unpackMessage(raw);
+  if (!Array.isArray(results)) return [];
+  return results.map((r) => decodeResultItem(r));
+}
+
 // src/sse.ts
 var SSE_DONE = "[DONE]";
 var MAX_SSE_BUFFER_CHARS = 8 * 1024 * 1024;
@@ -856,12 +1172,20 @@ function extractDataPayload(block) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.6.15";
+var SDK_VERSION = "0.6.17";
 
 // src/client.ts
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function resolveUploadFilename(file, filename) {
+  if (filename) return filename;
+  const name = file.name;
+  if (typeof name === "string" && name.length > 0) {
+    return name.split(/[/\\]/).pop() || "upload.jsonl";
+  }
+  return "upload.jsonl";
+}
 function abortableSleep(ms, signal) {
   if (signal.aborted) return Promise.resolve(true);
   return new Promise((resolve) => {
@@ -915,6 +1239,16 @@ var SIEClient = class {
   apiKey;
   defaultWaitForCapacity;
   provisionTimeout;
+  controlPlaneUrl;
+  org;
+  /** Batch class — `POST/GET /v1/jobs` on the keyed gateway. */
+  jobs;
+  /** Org-scoped connections (connector auth by name) on the control plane. */
+  connections;
+  /** OpenAI-compatible Files API — `POST/GET /v1/files`. */
+  files;
+  /** OpenAI-compatible Batch API — `POST/GET /v1/batches`. */
+  batches;
   // Pool state: track created pools and their lease renewal scheduling
   pools = /* @__PURE__ */ new Map();
   // Version negotiation state
@@ -932,8 +1266,36 @@ var SIEClient = class {
     this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
     this.gpu = options.gpu;
     this.apiKey = options.apiKey;
-    this.defaultWaitForCapacity = options.waitForCapacity ?? false;
+    this.defaultWaitForCapacity = options.waitForCapacity ?? true;
     this.provisionTimeout = options.provisionTimeout ?? DEFAULT_PROVISION_TIMEOUT;
+    this.controlPlaneUrl = options.controlPlaneUrl?.replace(/\/$/, "");
+    this.org = options.org;
+    this.jobs = {
+      submit: (submitOptions) => this.jobSubmit(submitOptions),
+      get: (jobId) => this.jobGet(jobId),
+      list: () => this.jobList(),
+      cancel: (jobId) => this.jobCancel(jobId),
+      results: (jobId) => this.jobResults(jobId),
+      wait: (jobId, options2) => this.jobWait(jobId, options2)
+    };
+    this.connections = {
+      add: (name, type, secret) => this.connectionAdd(name, type, secret),
+      list: () => this.connectionList(),
+      revoke: (name) => this.connectionRevoke(name)
+    };
+    this.files = {
+      upload: (file, options2) => this.fileUpload(file, options2),
+      create: (options2) => this.fileUpload(options2.file, options2),
+      retrieve: (fileId) => this.fileRetrieve(fileId),
+      content: (fileId) => this.fileContent(fileId),
+      delete: (fileId) => this.fileDelete(fileId)
+    };
+    this.batches = {
+      create: (options2) => this.batchCreate(options2),
+      retrieve: (batchId) => this.batchRetrieve(batchId),
+      list: () => this.batchList(),
+      cancel: (batchId) => this.batchCancel(batchId)
+    };
   }
   /**
    * Get the base URL of the SIE server.
@@ -1396,8 +1758,10 @@ var SIEClient = class {
    * generator throws it instead of yielding the chunk.
    *
    * Retry policy mirrors {@link generate}: only explicit SAFE
-   * pre-execution capacity signals — `503 PROVISIONING` and
-   * `503 MODEL_LOADING` — are retried while the provision budget remains.
+   * pre-execution capacity signals — `503 PROVISIONING`,
+   * `503 MODEL_LOADING` and `503 RESOURCE_EXHAUSTED` (the latter only
+   * under `waitForCapacity`) — are retried while the provision budget
+   * remains; a `504` is post-publish and therefore terminal.
    * Once the body opens we never retry (the call is non-idempotent; a
    * mid-stream failure must not re-issue generation).
    *
@@ -1419,6 +1783,7 @@ var SIEClient = class {
     }
     try {
       const startTime = Date.now();
+      let oomRetries = 0;
       let response;
       while (true) {
         if (signal?.aborted) {
@@ -1490,6 +1855,34 @@ var SIEClient = class {
             }
             continue;
           }
+          if (errorCode === RESOURCE_EXHAUSTED_ERROR_CODE) {
+            if (!waitForCapacity) {
+              throw new ResourceExhaustedError(
+                `Server resource exhausted after ${oomRetries} retry attempt(s) for model '${model}'`,
+                { model, retries: oomRetries }
+              );
+            }
+            const delay = nextOomRetryDelay({
+              retryAfter: getRetryAfter2(attemptResponse),
+              oomRetries,
+              maxOomRetries: RESOURCE_EXHAUSTED_MAX_RETRIES,
+              elapsedMs: Date.now() - startTime,
+              provisionTimeoutMs: this.provisionTimeout,
+              model
+            });
+            oomRetries += 1;
+            if (await abortableSleep(delay, controller.signal)) {
+              throw new SIEConnectionError("Stream aborted while provisioning", "other");
+            }
+            continue;
+          }
+        }
+        if (attemptResponse.status === HTTP_GATEWAY_TIMEOUT) {
+          throw new ServerError(
+            "Gateway timed out (504) after the request was published to the queue; a worker may already be generating. Not retried because generation is non-idempotent (retrying could double-bill).",
+            await getErrorCode(attemptResponse.clone()),
+            HTTP_GATEWAY_TIMEOUT
+          );
         }
         if (attemptResponse.status !== 200) {
           await handleError(attemptResponse);
@@ -1642,12 +2035,21 @@ var SIEClient = class {
    * @param gpus - Optional machine profile requirements for pool readiness, e.g., { "l4": 2, "l4-spot": 1 }
    * @param gpuCaps - Optional maximum assigned workers per machine profile
    * @param queuePool - Optional Helm/NATS queue namespace backing this logical pool. Defaults to "default".
+   * @param options - Optional bundle filter, warm floor, and pinned models
+   *                  (Python SDK `create_pool` parity)
    *
    * @example
    * ```typescript
    * // Create or update a pool with 2 L4 GPUs
    * await client.createPool("eval-bench", { l4: 2 });
    *
+   * // With a bundle filter, warm floor, and pinned models
+   * await client.createPool("eval-bench", { l4: 2 }, undefined, undefined, {
+   *   bundle: "default",
+   *   minimumWorkerCount: 1,
+   *   pinnedModels: ["bge-m3"],
+   * });
+   *
    * // Use the pool for requests
    * await client.encode("bge-m3", { text: "Hello" }, { gpu: "eval-bench/l4" });
    *
@@ -1655,8 +2057,11 @@ var SIEClient = class {
    * await client.deletePool("eval-bench");
    * ```
    */
-  async createPool(name, gpus, gpuCaps, queuePool) {
+  async createPool(name, gpus, gpuCaps, queuePool, options = {}) {
     const alreadyTracking = this.pools.has(name);
+    if (options.minimumWorkerCount !== void 0 && options.minimumWorkerCount < 0) {
+      throw new RangeError("minimumWorkerCount must be >= 0");
+    }
     const requestBody = {
       name
     };
@@ -1669,6 +2074,15 @@ var SIEClient = class {
     if (queuePool) {
       requestBody.queue_pool = queuePool;
     }
+    if (options.bundle) {
+      requestBody.bundle = options.bundle;
+    }
+    if (options.minimumWorkerCount !== void 0) {
+      requestBody.minimum_worker_count = options.minimumWorkerCount;
+    }
+    if (options.pinnedModels !== void 0) {
+      requestBody.pinned_models = options.pinnedModels;
+    }
     const url = `${this.baseUrl}/v1/pools`;
     const headers = {
       "Content-Type": JSON_CONTENT_TYPE,
@@ -1976,6 +2390,11 @@ var SIEClient = class {
    * Retried (capped by `provisionTimeout`):
    *  - 503 `PROVISIONING` when `waitForCapacity: true`
    *  - 503 `MODEL_LOADING` / `LORA_LOADING`
+   *  - 503 `RESOURCE_EXHAUSTED` regardless of `waitForCapacity` (bounded
+   *    exponential backoff, at most `RESOURCE_EXHAUSTED_MAX_RETRIES`)
+   *  - 504 gateway timeout when `waitForCapacity: true` — encode/score/
+   *    extract are idempotent queue paths, so a post-publish retry is safe
+   *    (unlike generate/chat, where a 504 is terminal)
    *  - `SIEConnectionError` with `kind === "connect"` (issue #95)
    *
    * `kind === "timeout"` is NOT retried — would extend the user-visible
@@ -1984,6 +2403,7 @@ var SIEClient = class {
   async requestWithRetry(path, body, pool, gpu, waitForCapacity, model) {
     const startTime = Date.now();
     let loraRetries = 0;
+    let oomRetries = 0;
     while (true) {
       let response;
       try {
@@ -2058,6 +2478,27 @@ var SIEClient = class {
           await sleep2(actualDelay);
           continue;
         }
+        if (errorCode === RESOURCE_EXHAUSTED_ERROR_CODE) {
+          const delay = nextOomRetryDelay({
+            retryAfter: getRetryAfter2(response),
+            oomRetries,
+            maxOomRetries: RESOURCE_EXHAUSTED_MAX_RETRIES,
+            elapsedMs: Date.now() - startTime,
+            provisionTimeoutMs: this.provisionTimeout,
+            model
+          });
+          oomRetries += 1;
+          await sleep2(delay);
+          continue;
+        }
+      }
+      if (response.status === HTTP_GATEWAY_TIMEOUT && waitForCapacity) {
+        const elapsed = Date.now() - startTime;
+        if (elapsed < this.provisionTimeout) {
+          const delay = getRetryAfter2(response) ?? MODEL_LOADING_DEFAULT_DELAY;
+          await sleep2(Math.min(delay, this.provisionTimeout - elapsed));
+          continue;
+        }
       }
       if (!response.ok) {
         await handleError(response, gpu);
@@ -2146,6 +2587,291 @@ var SIEClient = class {
       clearTimeout(timeoutId);
     }
   }
+  // ---------------------------------------------------------------------------
+  // Jobs + connections namespaces. Jobs ride the keyed gateway
+  // (`/v1/jobs`); connections ride the control plane (`/internal/orgs/{org}/…`).
+  // ---------------------------------------------------------------------------
+  /** One JSON request over `fetch` (bearer auth reused; absolute or base-relative URL). */
+  async jsonRequest(target, method, body, timeoutMs = this.timeout) {
+    const url = target.startsWith("http") ? target : `${this.baseUrl}${target}`;
+    const headers = {
+      Accept: JSON_CONTENT_TYPE,
+      [SDK_VERSION_HEADER]: SDK_VERSION
+    };
+    if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
+    const init = { method, headers };
+    if (body !== void 0) {
+      headers["Content-Type"] = JSON_CONTENT_TYPE;
+      init.body = JSON.stringify(body);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    init.signal = controller.signal;
+    try {
+      const response = await fetch(url, init);
+      if (!response.ok) {
+        await handleError(response);
+      }
+      this.checkServerVersion(response);
+      const text = await response.text();
+      return text ? JSON.parse(text) : {};
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new SIEConnectionError(`Request timeout after ${timeoutMs}ms`, "timeout");
+      }
+      if (error instanceof TypeError) {
+        throw new SIEConnectionError(`Connection failed: ${error.message}`, "connect");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async jobSubmit(options) {
+    return this.jsonRequest(
+      "/v1/jobs",
+      "POST",
+      buildJobBody(options),
+      Math.max(this.timeout, DEFAULT_LONG_RUNNING_TIMEOUT)
+    );
+  }
+  async jobGet(jobId) {
+    return this.jsonRequest(`/v1/jobs/${encodeURIComponent(jobId)}`, "GET");
+  }
+  async jobList() {
+    const data = await this.jsonRequest("/v1/jobs", "GET");
+    return Array.isArray(data) ? data : data.data ?? [];
+  }
+  async jobCancel(jobId) {
+    return this.jsonRequest(`/v1/jobs/${encodeURIComponent(jobId)}/cancel`, "POST");
+  }
+  async jobResults(jobId) {
+    const job = await this.jobGet(jobId);
+    const chunks = jobChunks(job);
+    const items = [];
+    for (const chunk of chunks) {
+      if (chunk.state !== "succeeded" || !chunk.ref) continue;
+      const raw = await this.readRef(chunk.ref);
+      items.push(...decodeChunkBytes(raw));
+    }
+    const withDims = items.find((it) => it.dims != null);
+    return {
+      job_id: job.id ?? jobId,
+      state: job.state,
+      total_items: job.total_items,
+      settled_credits: job.settled_credits,
+      chunks,
+      retrieved: items.length,
+      dims: withDims ? withDims.dims : null,
+      items
+    };
+  }
+  async jobWait(jobId, options) {
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_JOB_WAIT_TIMEOUT;
+    const pollMs = options?.pollMs ?? DEFAULT_JOB_WAIT_POLL;
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const job = await this.jobGet(jobId);
+      if (job.state && TERMINAL_JOB_STATES.has(job.state)) {
+        return job;
+      }
+      if (Date.now() >= deadline) {
+        throw new RequestError(
+          `job ${jobId} still ${JSON.stringify(job.state)} after ${timeoutMs}ms`,
+          "job_wait_timeout",
+          504
+        );
+      }
+      await sleep2(pollMs);
+    }
+  }
+  /** Retrieve a chunk's payload-store ref (http(s) URL). */
+  async readRef(ref) {
+    if (!ref.startsWith("http://") && !ref.startsWith("https://")) {
+      throw new RequestError(
+        `cannot retrieve payload-store ref ${JSON.stringify(ref)} (the TS SDK reads http(s) refs)`,
+        "bad_ref",
+        400
+      );
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(ref, {
+        headers: { Accept: "application/octet-stream" },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        await handleError(response);
+      }
+      return new Uint8Array(await response.arrayBuffer());
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new SIEConnectionError(`Request timeout after ${this.timeout}ms`, "timeout");
+      }
+      if (error instanceof TypeError) {
+        throw new SIEConnectionError(`Connection failed: ${error.message}`, "connect");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  connectionsBase() {
+    if (!this.controlPlaneUrl) {
+      throw new RequestError(
+        "connections require controlPlaneUrl on the client: new SIEClient(url, { controlPlaneUrl, org })",
+        "missing_control_plane_url",
+        400
+      );
+    }
+    if (!this.org) {
+      throw new RequestError(
+        "connections require org on the client: new SIEClient(url, { controlPlaneUrl, org })",
+        "missing_org",
+        400
+      );
+    }
+    return `${this.controlPlaneUrl}/internal/orgs/${encodeURIComponent(this.org)}/connections`;
+  }
+  async connectionAdd(name, type, secret) {
+    return this.jsonRequest(this.connectionsBase(), "POST", {
+      type,
+      name,
+      secret
+    });
+  }
+  async connectionList() {
+    const data = await this.jsonRequest(
+      this.connectionsBase(),
+      "GET"
+    );
+    return Array.isArray(data) ? data : data.connections ?? [];
+  }
+  async connectionRevoke(name) {
+    return this.jsonRequest(
+      `${this.connectionsBase()}/${encodeURIComponent(name)}`,
+      "DELETE"
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Files + batches namespaces — the OpenAI-compatible file /
+  // batch surface on the keyed gateway. Method names/args mirror `openai.files`
+  // / `openai.batches` so switching an OpenAI-batch caller to the SDK is
+  // mechanical.
+  // ---------------------------------------------------------------------------
+  /** POST a raw body and parse the JSON response (bearer auth reused). */
+  async rawPostJson(path, body, contentType, timeoutMs = this.timeout) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Accept: JSON_CONTENT_TYPE,
+      "Content-Type": contentType,
+      [SDK_VERSION_HEADER]: SDK_VERSION
+    };
+    if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        await handleError(response);
+      }
+      this.checkServerVersion(response);
+      const text = await response.text();
+      return text ? JSON.parse(text) : {};
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new SIEConnectionError(`Request timeout after ${timeoutMs}ms`, "timeout");
+      }
+      if (error instanceof TypeError) {
+        throw new SIEConnectionError(`Connection failed: ${error.message}`, "connect");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /** GET raw bytes (bearer auth reused); used to download a file's content. */
+  async rawGetBytes(path) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Accept: "application/jsonl",
+      [SDK_VERSION_HEADER]: SDK_VERSION
+    };
+    if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, { method: "GET", headers, signal: controller.signal });
+      if (!response.ok) {
+        await handleError(response);
+      }
+      this.checkServerVersion(response);
+      return new Uint8Array(await response.arrayBuffer());
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new SIEConnectionError(`Request timeout after ${this.timeout}ms`, "timeout");
+      }
+      if (error instanceof TypeError) {
+        throw new SIEConnectionError(`Connection failed: ${error.message}`, "connect");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async fileUpload(file, options) {
+    const purpose = options?.purpose ?? "batch";
+    const filename = resolveUploadFilename(file, options?.filename);
+    const query = new URLSearchParams({ purpose, filename }).toString();
+    const body = file instanceof ArrayBuffer ? new Uint8Array(file) : file;
+    return this.rawPostJson(
+      `/v1/files?${query}`,
+      body,
+      "application/jsonl",
+      Math.max(this.timeout, DEFAULT_LONG_RUNNING_TIMEOUT)
+    );
+  }
+  async fileRetrieve(fileId) {
+    return this.jsonRequest(`/v1/files/${encodeURIComponent(fileId)}`, "GET");
+  }
+  async fileContent(fileId) {
+    return this.rawGetBytes(`/v1/files/${encodeURIComponent(fileId)}/content`);
+  }
+  async fileDelete(fileId) {
+    return this.jsonRequest(`/v1/files/${encodeURIComponent(fileId)}`, "DELETE");
+  }
+  async batchCreate(options) {
+    const body = {
+      input_file_id: options.input_file_id,
+      endpoint: options.endpoint ?? "/v1/embeddings",
+      completion_window: options.completion_window ?? "24h"
+    };
+    if (options.metadata !== void 0) {
+      body.metadata = options.metadata;
+    }
+    return this.jsonRequest(
+      "/v1/batches",
+      "POST",
+      body,
+      Math.max(this.timeout, DEFAULT_LONG_RUNNING_TIMEOUT)
+    );
+  }
+  async batchRetrieve(batchId) {
+    return this.jsonRequest(`/v1/batches/${encodeURIComponent(batchId)}`, "GET");
+  }
+  async batchList() {
+    const data = await this.jsonRequest("/v1/batches", "GET");
+    return Array.isArray(data) ? data : data.data ?? [];
+  }
+  async batchCancel(batchId) {
+    return this.jsonRequest(`/v1/batches/${encodeURIComponent(batchId)}/cancel`, "POST");
+  }
   buildWsUrl(path) {
     const url = new URL(this.baseUrl);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
@@ -2291,12 +3017,16 @@ exports.ModelLoadingError = ModelLoadingError;
 exports.PoolError = PoolError;
 exports.ProvisioningError = ProvisioningError;
 exports.RequestError = RequestError;
+exports.ResourceExhaustedError = ResourceExhaustedError;
 exports.SDK_VERSION = SDK_VERSION;
 exports.SIEClient = SIEClient;
 exports.SIEConnectionError = SIEConnectionError;
 exports.SIEError = SIEError;
 exports.SIEStreamError = SIEStreamError;
 exports.ServerError = ServerError;
+exports.TERMINAL_JOB_STATES = TERMINAL_JOB_STATES;
+exports.buildJobBody = buildJobBody;
+exports.connectionName = connectionName;
 exports.denseEmbedding = denseEmbedding;
 exports.detectImageFormat = detectImageFormat;
 exports.maxsim = maxsim;