@superlinked/sie-sdk 0.6.15 → 0.6.17

package/dist/index.d.cts

@@ -1,5 +1,153 @@
 export { maxsim, maxsimBatch, maxsimDocuments } from './scoring.cjs';
 
+/**
+ * Jobs surface (`client.jobs`) — pure helpers + wire types.
+ *
+ * The jobs API is the gateway's batch class. `client.jobs.submit(...)` binds to
+ * `POST /v1/jobs`; this module owns the transport-free pieces (the
+ * `source → operation → sink / when` slot mapping and result decoding) so they
+ * mirror the Python SDK's `sie_sdk.jobs`.
+ */
+/** Job lifecycle state (queued → running → terminal). */
+type JobState = "queued" | "running" | "succeeded" | "failed" | "suspended" | "cancelled";
+/** Terminal states with no further transitions (job lifecycle). */
+declare const TERMINAL_JOB_STATES: ReadonlySet<JobState>;
+/** One inline input item (the `/v1/encode` item contract: `{text}` / `{id,text}`). */
+type JobItem = {
+    text?: string;
+    id?: string;
+} & Record<string, unknown>;
+/**
+ * A job source: inline items (a list, or a bare string = one text item) or a
+ * connector `scheme://<connection>/…` URI.
+ */
+type JobSource = string | Array<string | JobItem>;
+/**
+ * The uniform source-mapping slots (wire-shaped, mirroring the Python
+ * SDK's dict): `id_field` ≈ `custom_id`, `input_field` ≈ `body.input`,
+ * `carry` = source fields echoed to the sink keyed by id, `input_type` pins
+ * the item shape. The sink slot rides separately as `outputField`. All
+ * optional — per-connector URI params stay as aliases.
+ */
+interface JobFieldMap {
+    id_field?: string;
+    input_field?: string;
+    carry?: string[];
+    input_type?: "text" | "document";
+}
+/** Options for `client.jobs.submit`. */
+interface SubmitJobOptions {
+    /** Inline items or a connector URI (incl. `upload://<file-id>`). */
+    source: JobSource;
+    /** Model id (e.g. "BAAI/bge-m3"). */
+    model: string;
+    /** Job operation: encode | score | extract | parse | generate (default "encode"). */
+    operation?: string;
+    /** Sink: "return" (default), "inplace", or a connector URI. */
+    sink?: string | null;
+    /** Override the source connection name (default: derived from the URI). */
+    connection?: string | null;
+    /** Distinct connection name for the sink. */
+    sinkConnection?: string | null;
+    /** Uniform source mapping (connector jobs only). */
+    fieldMap?: JobFieldMap | null;
+    /** Sink target (≈ `response.body`; aliases PG `column` / object-store `suffix`). */
+    outputField?: string | null;
+    /** Trigger: "now" (default), "schedule:<cron>", or "watch:<source>". */
+    when?: string | null;
+    /** Encode output types (default: dense). */
+    outputTypes?: string[];
+    /**
+     * Per-item options plus the op inputs, forwarded as-is (operation
+     * matrix): score → `options.query`, extract → `options.labels` /
+     * `options.output_schema`, generate → sampling (e.g. `max_new_tokens`).
+     */
+    options?: Record<string, unknown> | null;
+}
+/** The preflight reservation echoed on submit / status. */
+interface JobPreflight {
+    estimated_credits?: number;
+    estimate_basis?: string;
+}
+/** One spawned chunk's settle metadata (`output.chunks[]`; results-as-refs). */
+interface JobChunk {
+    seq?: number;
+    items?: number;
+    state?: string;
+    ref?: string | null;
+    units?: number | null;
+    credits?: number | null;
+    error?: unknown;
+}
+/** The `201` envelope from `POST /v1/jobs` (inline or connector job). */
+interface JobSubmitResult {
+    id: string;
+    object: string;
+    operation: string;
+    model: string;
+    state: JobState;
+    total_items?: number;
+    chunks?: number;
+    preflight?: JobPreflight;
+    input_source?: string;
+    source?: string;
+    sink?: string;
+}
+/** A job's public status doc from `GET /v1/jobs/{id}` (refs, never payloads). */
+interface JobStatus {
+    id: string;
+    object: string;
+    operation: string;
+    model: string;
+    state: JobState;
+    total_items?: number;
+    completed_items?: number;
+    preflight?: JobPreflight;
+    settled_credits?: number;
+    created_at?: number;
+    finished_at?: number | null;
+    output?: {
+        kind?: string;
+        chunks?: JobChunk[];
+    };
+}
+/** One decoded per-item result retrieved from a finished job's chunk refs. */
+interface JobResultItem {
+    id: string | null;
+    success: boolean | null;
+    units: unknown;
+    dims: number | null;
+    dense: number[] | Float32Array | null;
+}
+/** A finished job's decoded results — the chunk refs read and unpacked. */
+interface JobResults {
+    job_id: string;
+    state: JobState | undefined;
+    total_items: number | undefined;
+    settled_credits: number | undefined;
+    chunks: JobChunk[];
+    retrieved: number;
+    dims: number | null;
+    items: JobResultItem[];
+}
+/**
+ * Derive a connection name from a connector URI's authority.
+ *
+ * `postgres://warehouse?query=…` → `warehouse`; `s3://customer-bucket/in/` →
+ * `customer-bucket`. Credentials never appear in the call — the job only names
+ * the connection; the runner resolves it org-scoped.
+ */
+declare function connectionName(uri: string): string;
+/**
+ * Compose the `POST /v1/jobs` body from the source/op/sink/when slots.
+ *
+ * A thin, pure mapping: inline `items` or connector `src`/`sink` +
+ * connection name, plus an optional trigger. Only the fields that are set ride
+ * the wire, so an inline submit is byte-for-byte the realtime POC body and the
+ * connector body is additive (`/v1` additive-only rule).
+ */
+declare function buildJobBody(options: SubmitJobOptions): Record<string, unknown>;
+
 /**
  * Image handling utilities for the SIE TypeScript SDK.
  *
@@ -333,10 +481,18 @@ interface WorkerInfo {
     url: string;
     /** GPU type (e.g., "l4", "a100-80gb") */
     gpu: string;
+    /** Number of GPUs on this worker */
+    gpuCount: number;
+    /** Number of worker GPU slots ready to receive work */
+    readyGpuSlots: number;
     /** Whether the worker is healthy */
     healthy: boolean;
     /** Number of items in the worker's queue */
     queueDepth: number;
+    /** Worker-local scheduler pending cost */
+    pendingCost: number;
+    /** Number of batches currently executing on the worker */
+    inflightBatches: number;
     /** List of model names loaded on this worker */
     loadedModels: string[];
 }
@@ -359,6 +515,26 @@ interface CapacityInfo {
     /** List of worker details */
     workers: WorkerInfo[];
 }
+/**
+ * Optional arguments for `SIEClient.createPool`, mirroring the Python SDK's
+ * `create_pool` keyword arguments (`bundle`, `minimum_worker_count`,
+ * `pinned_models`).
+ */
+interface CreatePoolOptions {
+    /** Optional bundle filter. When set, only workers running this bundle will be assigned to the pool. */
+    bundle?: string;
+    /**
+     * Per-pool warm floor (minimum machines kept warm). The gateway publishes
+     * it as `sie_gateway_pool_warm_floor` for KEDA. Defaults to 0 (scale to zero).
+     */
+    minimumWorkerCount?: number;
+    /**
+     * Model ids to keep loaded so the first request to them pays no cold
+     * model-load. Each id must be a model the gateway already tracks and may be
+     * profile-qualified ("model-name:profile_name"); unknown ids are rejected.
+     */
+    pinnedModels?: string[];
+}
 /**
  * Pool specification returned by the gateway.
  */
@@ -408,7 +584,15 @@ interface PoolInfo {
     /** Pool status */
     status: PoolStatus;
 }
-type ModelState = "available" | "loading" | "loaded" | "unloading";
+/**
+ * Canonical model residency states. The runtime `MODEL_STATES` array is the
+ * single source the `ModelState` type is derived from, so it can be checked
+ * against the shared golden fixture (`packages/wire-fixtures/model_state.json`)
+ * in CI. Includes `"failed"` (a terminal load-failure state) to stay in parity
+ * with the Python SDK and server, which already carry it.
+ */
+declare const MODEL_STATES: readonly ["available", "loading", "loaded", "unloading", "failed"];
+type ModelState = (typeof MODEL_STATES)[number];
 interface ClusterSummary {
     worker_count: number;
     gpu_count: number;
@@ -497,10 +681,110 @@ interface SIEClientOptions {
     gpu?: string;
     /** API key for authentication (sent as Bearer token) */
     apiKey?: string;
-    /** Whether to auto-retry on 503 PROVISIONING responses */
+    /**
+     * Whether to auto-retry retryable capacity signals (503 PROVISIONING,
+     * idempotent 504 gateway timeouts, transient connect errors).
+     * Default: `true`, matching the Python SDK's `wait_for_capacity=True`.
+     * BREAKING (0.7): the default was previously `false` — pass `false`
+     * explicitly to fail fast.
+     */
     waitForCapacity?: boolean;
     /** Maximum time to wait for provisioning in milliseconds (default: 300000) */
     provisionTimeout?: number;
+    /**
+     * Control-plane base URL for the `connections` namespace (connector
+     * auth lives on the control plane, not the keyed gateway). Required to call
+     * `client.connections.*`.
+     */
+    controlPlaneUrl?: string;
+    /** Org the `connections` namespace operates on (org-scoped by path in the POC). */
+    org?: string;
+}
+/**
+ * An org-scoped connection (connector auth by name). The secret is never
+ * returned by the list endpoint (only the job-runner resolve path sees it).
+ */
+interface Connection {
+    id?: number;
+    type?: string;
+    name?: string;
+    created_at?: number;
+}
+/** The `201` envelope from creating a connection (org + connection, no secret). */
+interface ConnectionCreated extends Connection {
+    org?: string;
+    account_id?: number;
+}
+/** The envelope from revoking (soft-deleting) a connection. */
+interface ConnectionRevoked {
+    org?: string;
+    account_id?: number;
+    name?: string;
+    state?: string;
+}
+/**
+ * An OpenAI-shaped file object (`POST/GET /v1/files`). The
+ * gateway emits `{id, object:"file", bytes, created_at, filename, purpose}`;
+ * `status` / `expires_at` are the optional OpenAI fields surfaced
+ * when the TTL-GC lands. Byte-for-byte OpenAI's `FileObject`.
+ */
+interface File {
+    id?: string;
+    object?: string;
+    bytes?: number;
+    created_at?: number;
+    filename?: string;
+    purpose?: string;
+    status?: string;
+    expires_at?: number;
+}
+/** The envelope from deleting a file (OpenAI `FileDeleted`). */
+interface FileDeleted {
+    id?: string;
+    object?: string;
+    deleted?: boolean;
+}
+/** Per-batch request tally (OpenAI `request_counts`). */
+interface BatchRequestCounts {
+    total?: number;
+    completed?: number;
+    failed?: number;
+}
+/**
+ * An OpenAI-shaped batch object (`POST/GET /v1/batches`).
+ * The gateway emits `{id, object:"batch", endpoint, input_file_id,
+ * completion_window, status, output_file_id, error_file_id, created_at,
+ * finished_at, request_counts, errors}`. The granular OpenAI
+ * timestamps (`completed_at` etc.) are optional — a strict OpenAI SDK reads them
+ * when the gateway surfaces them.
+ */
+interface Batch {
+    id?: string;
+    object?: string;
+    endpoint?: string;
+    input_file_id?: string;
+    completion_window?: string;
+    status?: string;
+    output_file_id?: string | null;
+    error_file_id?: string | null;
+    created_at?: number;
+    finished_at?: number | null;
+    in_progress_at?: number | null;
+    completed_at?: number | null;
+    failed_at?: number | null;
+    expired_at?: number | null;
+    cancelled_at?: number | null;
+    request_counts?: BatchRequestCounts;
+    errors?: unknown;
+    metadata?: Record<string, unknown> | null;
+}
+/** The listing envelope from `GET /v1/batches` (OpenAI cursor page). */
+interface BatchList {
+    object?: string;
+    data?: Batch[];
+    first_id?: string;
+    last_id?: string;
+    has_more?: boolean;
 }
 /**
  * Options for encode operation.
@@ -821,11 +1105,11 @@ interface ChatCompletionChunk {
 interface ChatCompletionOptions {
     /**
      * When `true`, retry the SAFE pre-execution capacity signals
-     * (`503 PROVISIONING`, `503 MODEL_LOADING`) until
-     * `provisionTimeoutMs` elapses. When `false`, the first such signal
-     * throws (`ProvisioningError` / `ModelLoadingError` / `ServerError`).
-     * Defaults to the client's `waitForCapacity` (false unless the
-     * constructor opted in).
+     * (`503 PROVISIONING`, `503 MODEL_LOADING`, `503 RESOURCE_EXHAUSTED`)
+     * until `provisionTimeoutMs` elapses. When `false`, the first
+     * provisioning signal throws (`ProvisioningError` / `ModelLoadingError`
+     * / `ServerError`). Defaults to the client's `waitForCapacity`
+     * (true unless the constructor opted out).
      */
     waitForCapacity?: boolean;
     /**
@@ -919,6 +1203,84 @@ declare function toFloat32Array(arr: number[]): Float32Array;
  * ```
  */
 
+/** The `client.jobs` batch namespace. */
+interface JobsNamespace {
+    /** Submit a batch job (`POST /v1/jobs`); returns the created-job envelope. */
+    submit(options: SubmitJobOptions): Promise<JobSubmitResult>;
+    /** Fetch a job's public status doc (`GET /v1/jobs/{id}`). */
+    get(jobId: string): Promise<JobStatus>;
+    /** List the org's jobs (`GET /v1/jobs`; scoped to the key's org). */
+    list(): Promise<JobStatus[]>;
+    /** Cancel a job (`POST /v1/jobs/{id}/cancel`); the hold's remainder releases. */
+    cancel(jobId: string): Promise<JobStatus>;
+    /** Retrieve a finished job's chunk refs and decode the per-item results. */
+    results(jobId: string): Promise<JobResults>;
+    /**
+     * Poll `get` until the job reaches a terminal state, then return its status.
+     * Throws a `job_wait_timeout` `RequestError` if `timeoutMs` elapses first.
+     * Mirrors the Python SDK's `jobs.wait` (default 600s timeout, 2s poll).
+     */
+    wait(jobId: string, options?: {
+        timeoutMs?: number;
+        pollMs?: number;
+    }): Promise<JobStatus>;
+}
+/** The `client.connections` namespace (org-scoped connector auth). */
+interface ConnectionsNamespace {
+    /** Create an org-scoped connection (connector auth by name). */
+    add(name: string, type: string, secret: string): Promise<ConnectionCreated>;
+    /** List the org's active connections (secrets redacted). */
+    list(): Promise<Connection[]>;
+    /** Revoke (soft-delete) a connection; frees the name for reuse. */
+    revoke(name: string): Promise<ConnectionRevoked>;
+}
+/** Accepted upload payloads — the same shapes `fetch` sends as a body. */
+type FileUploadInput = Uint8Array | ArrayBuffer | string | Blob;
+/**
+ * The `client.files` OpenAI-compatible Files namespace. Method
+ * names/args mirror `openai.files` so an `openai` → `sie-sdk` swap is mechanical.
+ */
+interface FilesNamespace {
+    /** Upload a file (`POST /v1/files`); `purpose` defaults to `"batch"`. */
+    upload(file: FileUploadInput, options?: {
+        purpose?: string;
+        filename?: string;
+    }): Promise<File>;
+    /** OpenAI-exact alias for {@link upload} (`files.create({ file, purpose })`). */
+    create(options: {
+        file: FileUploadInput;
+        purpose?: string;
+        filename?: string;
+    }): Promise<File>;
+    /** Fetch a file's metadata (`GET /v1/files/{id}`). */
+    retrieve(fileId: string): Promise<File>;
+    /** Download a file's raw bytes (`GET /v1/files/{id}/content`). */
+    content(fileId: string): Promise<Uint8Array>;
+    /** Delete a file (`DELETE /v1/files/{id}`; additive OpenAI-parity surface). */
+    delete(fileId: string): Promise<FileDeleted>;
+}
+/**
+ * The `client.batches` OpenAI-compatible Batch namespace. A
+ * batch is a job over an uploaded file's JSONL lines;
+ * `list` / `cancel` are the additive OpenAI-parity completion of the surface.
+ * Args are OpenAI's exact snake_case body keys, so an `openai` → `sie-sdk` swap
+ * is mechanical.
+ */
+interface BatchesNamespace {
+    /** Create a batch (`POST /v1/batches`); returns the Batch object. */
+    create(options: {
+        input_file_id: string;
+        endpoint?: string;
+        completion_window?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Batch>;
+    /** Fetch a batch's status (`GET /v1/batches/{id}`). */
+    retrieve(batchId: string): Promise<Batch>;
+    /** List the org's batches (`GET /v1/batches`; additive OpenAI-parity). */
+    list(): Promise<Batch[]>;
+    /** Cancel a batch (`POST /v1/batches/{id}/cancel`; additive OpenAI-parity). */
+    cancel(batchId: string): Promise<Batch>;
+}
 /**
  * SIE Client for embedding, scoring, and extraction.
  *
@@ -951,6 +1313,16 @@ declare class SIEClient {
     private readonly apiKey?;
     private readonly defaultWaitForCapacity;
     private readonly provisionTimeout;
+    private readonly controlPlaneUrl?;
+    private readonly org?;
+    /** Batch class — `POST/GET /v1/jobs` on the keyed gateway. */
+    readonly jobs: JobsNamespace;
+    /** Org-scoped connections (connector auth by name) on the control plane. */
+    readonly connections: ConnectionsNamespace;
+    /** OpenAI-compatible Files API — `POST/GET /v1/files`. */
+    readonly files: FilesNamespace;
+    /** OpenAI-compatible Batch API — `POST/GET /v1/batches`. */
+    readonly batches: BatchesNamespace;
     private readonly pools;
     private versionWarningLogged;
     /**
@@ -1189,8 +1561,10 @@ declare class SIEClient {
      * 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).
      *
@@ -1242,12 +1616,21 @@ declare class SIEClient {
      * @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" });
      *
@@ -1255,7 +1638,7 @@ declare class SIEClient {
      * await client.deletePool("eval-bench");
      * ```
      */
-    createPool(name: string, gpus?: Record<string, number>, gpuCaps?: Record<string, number>, queuePool?: string): Promise<void>;
+    createPool(name: string, gpus?: Record<string, number>, gpuCaps?: Record<string, number>, queuePool?: string, options?: CreatePoolOptions): Promise<void>;
     /**
      * Get information about a pool.
      *
@@ -1348,6 +1731,11 @@ declare class SIEClient {
      * 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
@@ -1363,12 +1751,38 @@ declare class SIEClient {
      * Used for endpoints that return JSON (e.g., /v1/models, /health).
      */
     private requestJson;
+    /** One JSON request over `fetch` (bearer auth reused; absolute or base-relative URL). */
+    private jsonRequest;
+    private jobSubmit;
+    private jobGet;
+    private jobList;
+    private jobCancel;
+    private jobResults;
+    private jobWait;
+    /** Retrieve a chunk's payload-store ref (http(s) URL). */
+    private readRef;
+    private connectionsBase;
+    private connectionAdd;
+    private connectionList;
+    private connectionRevoke;
+    /** POST a raw body and parse the JSON response (bearer auth reused). */
+    private rawPostJson;
+    /** GET raw bytes (bearer auth reused); used to download a file's content. */
+    private rawGetBytes;
+    private fileUpload;
+    private fileRetrieve;
+    private fileContent;
+    private fileDelete;
+    private batchCreate;
+    private batchRetrieve;
+    private batchList;
+    private batchCancel;
     private buildWsUrl;
     private createWebSocket;
     private detectEndpointType;
 }
 
-declare const SDK_VERSION = "0.6.15";
+declare const SDK_VERSION = "0.6.17";
 
 /**
  * Helpers for converting SIE encode results to plain JavaScript types.
@@ -1584,6 +1998,30 @@ declare class ModelLoadingError extends SIEError {
     readonly model: string | undefined;
     constructor(message: string, model?: string);
 }
+/**
+ * Error when the server has exhausted its OOM-recovery strategies.
+ *
+ * Raised when:
+ * - Server returns 503 with RESOURCE_EXHAUSTED code
+ * - SDK retry limit is exceeded (or the next backoff would exhaust the
+ *   provision-timeout budget)
+ *
+ * Subclass of {@link ServerError} so callers that already catch
+ * `ServerError` continue to behave correctly; new code can catch
+ * `ResourceExhaustedError` specifically to react to sustained GPU
+ * pressure (e.g., back off, route elsewhere, scale up). Mirrors the
+ * Python SDK's `ResourceExhaustedError`.
+ */
+declare class ResourceExhaustedError extends ServerError {
+    /** The model that was requested */
+    readonly model: string | undefined;
+    /** Number of retry attempts made before giving up */
+    readonly retries: number;
+    constructor(message: string, options?: {
+        model?: string;
+        retries?: number;
+    });
+}
 /**
  * Error surfaced mid-stream from `streamChatCompletions` / `streamGenerate`.
  *
@@ -1689,4 +2127,4 @@ declare function packMessage(data: unknown): Uint8Array;
  */
 declare function unpackMessage<T = unknown>(data: Uint8Array): T;
 
-export { type CapacityInfo, type ChatChoice, type ChatChunkChoice, type ChatCompletion, type ChatCompletionChunk, type ChatCompletionRequest, type ChatDelta, type ChatFinishReason, type ChatMessage, type ChatUsage, type Classification, type ClusterStatusMessage, type ClusterSummary, type ClusterWorkerInfo, type DType, type DetectedObject, type EncodeOptions, type EncodeResult, type Entity, type ExtractOptions, type ExtractResult, type FinishReason, type GPUMetrics, type GenerateChunk, type GenerateOptions, type GenerateResult, type GenerationUsage, type ImageInput, type ImageWireFormat, InputTooLongError, type Item, LoraLoadingError, type ModelCapabilities, type ModelConfig, type ModelDims, type ModelInfo, ModelLoadFailedError, ModelLoadingError, type ModelState, type ModelStatus, type ModelSummary, type OutputType, PoolError, type PoolInfo, type PoolSpec, type PoolStatus, ProvisioningError, type Relation, RequestError, type ResponseFormat, SDK_VERSION, SIEClient, type SIEClientOptions, SIEConnectionError, SIEError, SIEStreamError, type ScoreEntry, type ScoreOptions, type ScoreResult, ServerError, type ServerInfo, type SparseResult, type SparseVector, type StatusMessage, type TimingInfo, type ToolCall, type ToolCallDelta, type ToolChoice, type ToolSpec, type WorkerInfo, type WorkerStatusMessage, denseEmbedding, detectImageFormat, multivectorEmbedding, normalizeSparseVector, packMessage, sparseEmbedding, sparseEmbeddingMap, toFloat32Array, toImageBytes, toImageWireFormat, toNumberArray, unpackMessage };
+export { type Batch, type BatchList, type BatchRequestCounts, type BatchesNamespace, type CapacityInfo, type ChatChoice, type ChatChunkChoice, type ChatCompletion, type ChatCompletionChunk, type ChatCompletionRequest, type ChatDelta, type ChatFinishReason, type ChatMessage, type ChatUsage, type Classification, type ClusterStatusMessage, type ClusterSummary, type ClusterWorkerInfo, type Connection, type ConnectionCreated, type ConnectionRevoked, type ConnectionsNamespace, type CreatePoolOptions, type DType, type DetectedObject, type EncodeOptions, type EncodeResult, type Entity, type ExtractOptions, type ExtractResult, type FileDeleted, type FileUploadInput, type FilesNamespace, type FinishReason, type GPUMetrics, type GenerateChunk, type GenerateOptions, type GenerateResult, type GenerationUsage, type ImageInput, type ImageWireFormat, InputTooLongError, type Item, type JobChunk, type JobFieldMap, type JobItem, type JobPreflight, type JobResultItem, type JobResults, type JobSource, type JobState, type JobStatus, type JobSubmitResult, type JobsNamespace, LoraLoadingError, type ModelCapabilities, type ModelConfig, type ModelDims, type ModelInfo, ModelLoadFailedError, ModelLoadingError, type ModelState, type ModelStatus, type ModelSummary, type OutputType, PoolError, type PoolInfo, type PoolSpec, type PoolStatus, ProvisioningError, type Relation, RequestError, ResourceExhaustedError, type ResponseFormat, SDK_VERSION, SIEClient, type SIEClientOptions, SIEConnectionError, SIEError, type File as SIEFile, SIEStreamError, type ScoreEntry, type ScoreOptions, type ScoreResult, ServerError, type ServerInfo, type SparseResult, type SparseVector, type StatusMessage, type SubmitJobOptions, TERMINAL_JOB_STATES, type TimingInfo, type ToolCall, type ToolCallDelta, type ToolChoice, type ToolSpec, type WorkerInfo, type WorkerStatusMessage, buildJobBody, connectionName, denseEmbedding, detectImageFormat, multivectorEmbedding, normalizeSparseVector, packMessage, sparseEmbedding, sparseEmbeddingMap, toFloat32Array, toImageBytes, toImageWireFormat, toNumberArray, unpackMessage };