@itsoltech/basal-client 0.2.0 → 0.4.0

package/dist/cjs/tasks.d.cts

@@ -0,0 +1,108 @@
+import { QuestionSpec } from './questions.cjs';
+import type { DecisionResponse, JsonValue, Question, MultiObjective } from './index.cjs';
+/** Task automation is unknown (null) without a threshold certified for that task/error target. */
+export type Automation = Record<string, boolean | null>;
+export interface ClassifyAnswer<K extends string = string> {
+    type: 'classify';
+    experimental: true;
+    scores: Record<K, number>;
+    label?: K;
+    top_label?: K;
+    confidence?: number;
+    automated?: Automation;
+    labels?: K[];
+    set_confidence?: number;
+}
+export interface ClaimResult {
+    verdict: 'supported' | 'contradicted' | 'not_stated' | 'not_supported';
+    probabilities: Record<string, number>;
+    confidence: number;
+    automated: Automation;
+}
+export interface VerifyAnswer {
+    type: 'verify';
+    experimental: true;
+    claims: Record<string, ClaimResult>;
+    all_supported: boolean;
+    not_supported: string[];
+}
+/** Inclusive start/exclusive end count Unicode code points, not JavaScript UTF-16 units. */
+export interface CompressionUnit {
+    start: number;
+    end: number;
+    probability: number;
+}
+export interface CompressAnswer {
+    type: 'compress';
+    experimental: true;
+    compressed: string;
+    kept: number[];
+    units: CompressionUnit[];
+    unit: 'sentence' | 'line' | 'paragraph';
+    original_chars: number;
+    compressed_chars: number;
+    ratio: number;
+}
+export interface ExtractField {
+    value: JsonValue;
+    confidence: number;
+    source: 'choice' | 'span';
+    calibration: 'validated' | 'per decision';
+    probabilities?: Record<string, number>;
+    present_probability?: number;
+    text?: string;
+    start?: number;
+    end?: number;
+    line_probability?: number;
+    span_probability?: number;
+    error?: string;
+}
+export interface ExtractAnswer {
+    type: 'extract';
+    experimental: true;
+    data: Record<string, JsonValue>;
+    fields: Record<string, ExtractField>;
+}
+export type TaskAnswer = ClassifyAnswer | VerifyAnswer | CompressAnswer | ExtractAnswer;
+export interface ClassifyOptions {
+    multi_label?: boolean;
+    none?: boolean;
+    max_error?: number | readonly number[];
+    option_keys?: 'show' | 'hide';
+    threshold?: number;
+    min?: number;
+    max?: number;
+    objective?: MultiObjective;
+}
+export interface VerifyOptions {
+    binary?: boolean;
+    max_error?: number | readonly number[];
+}
+export interface CompressOptions {
+    unit?: 'sentence' | 'line' | 'paragraph';
+    keep_ratio?: number;
+    threshold?: number;
+    min_keep?: number;
+}
+declare abstract class TaskQuestion<A extends TaskAnswer> extends QuestionSpec<A> {
+    protected constructor(kind: A['type'], text: string, fields: Question);
+    read(response: DecisionResponse, id: string): A;
+}
+export declare class ClassifyQuestion<K extends string = string> extends TaskQuestion<ClassifyAnswer<K>> {
+    constructor(text: string, labels: Record<K, JsonValue> | readonly JsonValue[], options?: ClassifyOptions);
+}
+export declare class VerifyQuestion extends TaskQuestion<VerifyAnswer> {
+    constructor(text: string, claims: Record<string, JsonValue> | readonly JsonValue[], options?: VerifyOptions);
+}
+export declare class CompressQuestion extends TaskQuestion<CompressAnswer> {
+    constructor(text?: string, options?: CompressOptions);
+}
+export declare class ExtractQuestion extends TaskQuestion<ExtractAnswer> {
+    constructor(text: string, schema: Record<string, JsonValue>);
+}
+export declare function classify<const K extends string>(text: string, labels: Record<K, JsonValue>, options?: ClassifyOptions): ClassifyQuestion<K>;
+export declare function classify(text: string, labels: readonly JsonValue[], options?: ClassifyOptions): ClassifyQuestion;
+export declare function verify(text: string, claims: Record<string, JsonValue> | readonly JsonValue[], options?: VerifyOptions): VerifyQuestion;
+export declare function compress(text?: string, options?: CompressOptions): CompressQuestion;
+export declare function extract(text: string, schema: Record<string, JsonValue>): ExtractQuestion;
+export {};

package/dist/esm/batches.d.ts

@@ -0,0 +1,166 @@
+import type { DecisionRequest, JsonValue } from "./index.js";
+/** Batch and Files wire types (`contracts/batches/openapi.json`). Times are Unix seconds.
+ * Unknown response fields are preserved at runtime; `(string & {})` keeps enums open to future server values.
+ */
+export type FilePurpose = "batch" | "batch_output";
+export interface FileObject {
+    id: string;
+    object: "file";
+    bytes: number;
+    created_at: number;
+    expires_at: number | null;
+    /** As uploaded, or `batch_<id>_output.jsonl` / `batch_<id>_error.jsonl` for results; never a server path. */
+    filename: string;
+    purpose: FilePurpose | (string & {});
+    /** Always `processed` (OpenAI compatibility). */
+    status: "processed" | (string & {});
+    status_details: string | null;
+}
+export interface DeletedFile {
+    id: string;
+    object: "file";
+    deleted: boolean;
+}
+export interface ListPage<T> {
+    object: "list";
+    data: T[];
+    first_id: string | null;
+    last_id: string | null;
+    has_more: boolean;
+}
+export type FileList = ListPage<FileObject>;
+export type BatchList = ListPage<Batch>;
+/** At most 16 pairs, keys of 1–64 and values of up to 512 characters, in insertion order (checked by the server).
+ * JavaScript enumerates integer-like keys first; use textual keys when order matters.
+ */
+export type Metadata = Record<string, string>;
+export interface ExpiresAfter {
+    anchor: "created_at";
+    seconds: number;
+}
+export type BatchStatus = "validating" | "failed" | "in_progress" | "finalizing" | "completed" | "expired" | "cancelling" | "cancelled";
+export type BatchErrorCode = "empty_file" | "empty_line" | "invalid_json_line" | "line_too_large" | "too_many_records" | "invalid_custom_id" | "duplicate_custom_id" | "invalid_method" | "invalid_url" | "stream_unsupported" | "invalid_body" | "model_not_found" | "mixed_models" | "budget_exceeded" | "host_budget_exceeded" | "unbounded_feature" | "input_changed" | "batch_expired" | "errors_truncated";
+export interface RequestCounts {
+    total: number;
+    completed: number;
+    failed: number;
+}
+export interface BatchErrorEntry {
+    code: BatchErrorCode | (string & {});
+    message: string;
+    param: string | null;
+    line: number | null;
+}
+export interface BatchErrors {
+    object: "list";
+    data: BatchErrorEntry[];
+}
+export interface Batch {
+    id: string;
+    object: "batch";
+    endpoint: "/v1/basal" | (string & {});
+    model: string | null;
+    errors: BatchErrors | null;
+    input_file_id: string;
+    completion_window: "24h" | (string & {});
+    status: BatchStatus | (string & {});
+    output_file_id: string | null;
+    error_file_id: string | null;
+    created_at: number;
+    in_progress_at: number | null;
+    /** End of the 24h inference window; export may finish later. */
+    expires_at: number;
+    finalizing_at: number | null;
+    completed_at: number | null;
+    failed_at: number | null;
+    expired_at: number | null;
+    cancelling_at: number | null;
+    cancelled_at: number | null;
+    request_counts: RequestCounts;
+    metadata: Metadata | null;
+}
+/** `POST /v1/batches` body. `endpoint` and `completion_window` default to their only accepted values. */
+export interface CreateBatchRequest {
+    input_file_id: string;
+    endpoint?: "/v1/basal";
+    completion_window?: "24h";
+    metadata?: Metadata | null;
+    /** Lifetime of each result file, anchored at its creation. */
+    output_expires_after?: ExpiresAfter | null;
+}
+/** One line of an input file; `body` is the native `/v1/basal` request (see `buildRequest`). */
+export interface BatchInputLine {
+    custom_id: string;
+    method?: "POST";
+    url?: "/v1/basal";
+    body: DecisionRequest;
+}
+/** One line of a result file. `response.body` is the native answer: a `DecisionResponse` for status 200, otherwise
+ * the native error body. `error` is set when the record has no response (e.g. `batch_expired`, `result_too_large`).
+ */
+export interface BatchResultLine {
+    id: string;
+    custom_id: string;
+    response: {
+        status_code: number;
+        request_id: string;
+        body: {
+            [key: string]: JsonValue;
+        };
+    } | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+}
+/** Common options of Batch and Files calls. */
+export interface RequestOptions {
+    signal?: AbortSignal;
+}
+/** Upload and download options; `timeoutMs` replaces the client deadline for this call only. */
+export interface TransferOptions extends RequestOptions {
+    timeoutMs?: number;
+}
+export interface DownloadOptions extends TransferOptions {
+    /** Byte cap of this download; defaults to the client's `maxResponseBytes`. The body is buffered in memory. */
+    maxBytes?: number;
+}
+export interface CreateBatchOptions extends RequestOptions {
+    /** 1–128 visible ASCII characters; a replay with the same request data returns the existing batch. */
+    idempotencyKey?: string;
+}
+export interface ListOptions extends RequestOptions {
+    after?: string;
+    limit?: number;
+}
+export interface ListFilesOptions extends ListOptions {
+    purpose?: FilePurpose;
+}
+/** Caller-owned upload content. The SDK never fetches URLs or reads paths; a stream is consumed and locked. */
+export type UploadContent = Uint8Array | ArrayBuffer | Blob | ReadableStream<Uint8Array>;
+export interface UploadFileRequest {
+    file: UploadContent;
+    /** 1–255 UTF-8 bytes without control characters or backslashes; stored as given, never used as a path. */
+    filename: string;
+    purpose?: "batch";
+    /** File lifetime (server default 30 days). */
+    expires_after?: ExpiresAfter;
+}
+/** Path segment of a resource id. `.` and `..` would be resolved as dot segments by URL parsing. */
+export declare function resourcePath(prefix: string, id: string, suffix?: string): string;
+export declare function listPath(path: string, options: ListFilesOptions): string;
+export declare function idempotencyHeader(key: string | undefined): Record<string, string>;
+export declare function createBody(request: CreateBatchRequest): CreateBatchRequest;
+/** A multipart body; a stream body is created per request and stops its source when `signal` aborts. */
+export interface Multipart {
+    contentType: string;
+    body: Blob | ((signal: AbortSignal) => ReadableStream<Uint8Array>);
+}
+/** Multipart form of an upload: `expires_after[...]`, then `purpose`, then the file part last (the server reserves the
+ * upload session at the file part, so expiry fields must precede it).
+ */
+export declare function uploadForm(request: UploadFileRequest): Multipart;
+/** JSONL input file of native records (`method` POST and `url` /v1/basal are filled in). Never sends anything. */
+export declare function batchInput(lines: Iterable<BatchInputLine>): Uint8Array;
+/** Parse downloaded result bytes (output or error file) into lines. Never fetches anything. */
+export declare function parseBatchResults(content: Uint8Array): BatchResultLine[];

package/dist/esm/batches.js

@@ -0,0 +1,182 @@
+import { BasalProtocolError } from "./errors.js";
+const encoder = new TextEncoder();
+/** Path segment of a resource id. `.` and `..` would be resolved as dot segments by URL parsing. */
+export function resourcePath(prefix, id, suffix = "") {
+    if (typeof id !== "string" || !id || id === "." || id === "..")
+        throw new TypeError("resource id must be a nonempty string");
+    return `${prefix}/${encodeURIComponent(id)}${suffix}`;
+}
+export function listPath(path, options) {
+    const query = new URLSearchParams();
+    if (options.after !== undefined) {
+        if (typeof options.after !== "string" || !options.after)
+            throw new TypeError("after must be a nonempty id");
+        query.set("after", options.after);
+    }
+    if (options.limit !== undefined) {
+        if (!Number.isSafeInteger(options.limit) || options.limit < 1)
+            throw new TypeError("limit must be a positive integer");
+        query.set("limit", String(options.limit));
+    }
+    if (options.purpose !== undefined) {
+        if (typeof options.purpose !== "string" || !options.purpose)
+            throw new TypeError("purpose must be a nonempty string");
+        query.set("purpose", options.purpose);
+    }
+    const encoded = query.toString();
+    return encoded ? `${path}?${encoded}` : path;
+}
+export function idempotencyHeader(key) {
+    if (key === undefined)
+        return {};
+    if (typeof key !== "string" || !/^[!-~]{1,128}$/.test(key)) {
+        throw new TypeError("idempotencyKey must have 1-128 visible ASCII characters");
+    }
+    return { "Idempotency-Key": key };
+}
+export function createBody(request) {
+    if (!request || typeof request !== "object" || typeof request.input_file_id !== "string" || !request.input_file_id) {
+        throw new TypeError("input_file_id must be a nonempty string");
+    }
+    // Extra caller fields are forwarded; the server refuses fields it does not know.
+    return { endpoint: "/v1/basal", completion_window: "24h", ...request };
+}
+function expiresFields(expires) {
+    if (expires === undefined)
+        return [];
+    if (!expires || expires.anchor !== "created_at" || !Number.isSafeInteger(expires.seconds) || expires.seconds < 0) {
+        throw new TypeError("expires_after needs anchor created_at and whole seconds");
+    }
+    return [["expires_after[anchor]", expires.anchor], ["expires_after[seconds]", String(expires.seconds)]];
+}
+/** Multipart form of an upload: `expires_after[...]`, then `purpose`, then the file part last (the server reserves the
+ * upload session at the file part, so expiry fields must precede it).
+ */
+export function uploadForm(request) {
+    if (!request || typeof request !== "object")
+        throw new TypeError("upload request must be an object");
+    const { file, filename } = request;
+    if (request.purpose !== undefined && request.purpose !== "batch")
+        throw new TypeError("purpose must be batch");
+    // Control characters (CR/LF) would split the part header; a backslash is ambiguous in a quoted filename.
+    if (typeof filename !== "string" || !filename || encoder.encode(filename).length > 255 || /[\p{Cc}\\]/u.test(filename)) {
+        throw new TypeError("filename must have 1-255 UTF-8 bytes without control characters or backslashes");
+    }
+    const random = new Uint8Array(16);
+    globalThis.crypto.getRandomValues(random);
+    const boundary = `basal-${Array.from(random, b => b.toString(16).padStart(2, "0")).join("")}`;
+    let head = "";
+    for (const [name, value] of [...expiresFields(request.expires_after), ["purpose", "batch"]]) {
+        head += `--${boundary}\r\nContent-Disposition: form-data; name="${name}"\r\n\r\n${value}\r\n`;
+    }
+    head += `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${filename.replaceAll('"', '\\"')}"\r\n`
+        + "Content-Type: application/jsonl\r\n\r\n";
+    const prefix = encoder.encode(head);
+    const suffix = encoder.encode(`\r\n--${boundary}--\r\n`);
+    const contentType = `multipart/form-data; boundary=${boundary}`;
+    if (file instanceof ReadableStream) {
+        if (file.locked)
+            throw new TypeError("upload stream is locked");
+        return { contentType, body: signal => framedStream(prefix, file, suffix, signal) };
+    }
+    let content;
+    if (file instanceof Blob || file instanceof ArrayBuffer)
+        content = file;
+    else if (file instanceof Uint8Array)
+        content = file.buffer instanceof ArrayBuffer ? file : new Uint8Array(file);
+    else
+        throw new TypeError("file must be a Uint8Array, ArrayBuffer, Blob or ReadableStream");
+    return { contentType, body: new Blob([prefix, content, suffix]) };
+}
+/** Streams the multipart prefix, the caller's chunks and the suffix without buffering the file.
+ * Fetch implementations may keep pulling a request body after abort, so `signal` cancels the source here.
+ */
+function framedStream(prefix, source, suffix, signal) {
+    let reader;
+    let stage = "prefix";
+    const stop = (reason) => {
+        signal.removeEventListener("abort", onAbort);
+        if (stage === "finished" || stage === "stopped")
+            return Promise.resolve();
+        stage = "stopped";
+        return (reader ? reader.cancel(reason) : source.cancel(reason)).catch(() => { });
+    };
+    const onAbort = () => { void stop(signal.reason); };
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted)
+        onAbort();
+    return new ReadableStream({
+        async pull(controller) {
+            if (stage === "stopped")
+                throw signal.reason ?? new Error("upload stopped");
+            if (stage === "prefix") {
+                stage = "file";
+                controller.enqueue(prefix);
+                return;
+            }
+            if (stage === "finished") {
+                controller.close();
+                return;
+            }
+            reader ??= source.getReader();
+            const { done, value } = await reader.read();
+            // A read cancelled by `stop` ends as done; it must not be framed as a complete file.
+            if (stage !== "file")
+                throw signal.reason ?? new Error("upload stopped");
+            if (!done) {
+                if (!(value instanceof Uint8Array)) {
+                    const error = new TypeError("upload stream chunks must be Uint8Array");
+                    await stop(error);
+                    throw error;
+                }
+                controller.enqueue(value);
+                return;
+            }
+            reader.releaseLock();
+            reader = undefined;
+            stage = "finished";
+            signal.removeEventListener("abort", onAbort);
+            controller.enqueue(suffix);
+        },
+        cancel(reason) { return stop(reason); },
+    });
+}
+/** JSONL input file of native records (`method` POST and `url` /v1/basal are filled in). Never sends anything. */
+export function batchInput(lines) {
+    const out = [];
+    for (const line of lines) {
+        if (!line || typeof line.custom_id !== "string" || !line.custom_id || !line.body || typeof line.body !== "object") {
+            throw new TypeError("each batch line needs a custom_id and a native request body");
+        }
+        out.push(JSON.stringify({ custom_id: line.custom_id, method: line.method ?? "POST", url: line.url ?? "/v1/basal", body: line.body }));
+    }
+    if (!out.length)
+        throw new TypeError("a batch input needs at least one line");
+    return encoder.encode(out.join("\n") + "\n");
+}
+/** Parse downloaded result bytes (output or error file) into lines. Never fetches anything. */
+export function parseBatchResults(content) {
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(content);
+    }
+    catch (cause) {
+        throw new BasalProtocolError("Batch result file is not UTF-8", { cause });
+    }
+    const lines = text.split("\n");
+    if (lines[lines.length - 1] === "")
+        lines.pop();
+    return lines.map((line, index) => {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch (cause) {
+            throw new BasalProtocolError(`Batch result line ${index + 1} is not JSON`, { cause });
+        }
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            throw new BasalProtocolError(`Batch result line ${index + 1} is not a JSON object`);
+        }
+        return value;
+    });
+}

package/dist/esm/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class BasalError extends Error {
+}
+/** Non-2xx response. Server body and Retry-After are available without logging them. */
+export declare class BasalHTTPError extends BasalError {
+    readonly statusCode: number;
+    readonly body: unknown;
+    readonly retryAfter: string | null;
+    constructor(statusCode: number, body: unknown, retryAfter: string | null);
+}
+export declare class BasalTransportError extends BasalError {
+}
+export declare class BasalProtocolError extends BasalError {
+}
+export declare class BasalResponseTooLargeError extends BasalError {
+}

package/dist/esm/errors.js

@@ -0,0 +1,23 @@
+export class BasalError extends Error {
+}
+/** Non-2xx response. Server body and Retry-After are available without logging them. */
+export class BasalHTTPError extends BasalError {
+    statusCode;
+    body;
+    retryAfter;
+    constructor(statusCode, body, retryAfter) {
+        super(`Basal HTTP ${statusCode}`);
+        this.statusCode = statusCode;
+        this.body = body;
+        this.retryAfter = retryAfter;
+        this.name = "BasalHTTPError";
+        // Node's default inspection and JSON.stringify must not print reflected state or credentials.
+        Object.defineProperty(this, "body", { enumerable: false });
+    }
+}
+export class BasalTransportError extends BasalError {
+}
+export class BasalProtocolError extends BasalError {
+}
+export class BasalResponseTooLargeError extends BasalError {
+}

package/dist/esm/index.d.ts

@@ -1,6 +1,12 @@
 import { type QuestionSet, type TypedDecisionResponse, type DecisionOptions } from "./questions.js";
+import { type Batch, type BatchList, type CreateBatchOptions, type CreateBatchRequest, type DeletedFile, type DownloadOptions, type FileList, type FileObject, type ListFilesOptions, type ListOptions, type RequestOptions, type TransferOptions, type UploadFileRequest } from "./batches.js";
 export * from "./questions.js";
 export * from "./media.js";
+export * from "./tasks.js";
+export * from "./errors.js";
+export { batchInput, parseBatchResults } from "./batches.js";
+export type { Batch, BatchErrorCode, BatchErrorEntry, BatchErrors, BatchInputLine, BatchList, BatchResultLine, BatchStatus, CreateBatchOptions, CreateBatchRequest, DeletedFile, DownloadOptions, ExpiresAfter, FileList, FileObject, FilePurpose, ListFilesOptions, ListOptions, ListPage, Metadata, RequestCounts, RequestOptions, TransferOptions, UploadContent, UploadFileRequest, } from "./batches.js";
+import type { TaskAnswer } from "./tasks.js";
 /** Native Basal wire types. Criterion order is significant; do not sort keys. */
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
@@ -23,7 +29,7 @@ export interface ToolRanking {
 }
 export type ToolDefinition = Record<string, JsonValue>;
 export interface Question {
-    type?: "choice" | "noul" | "score" | "multi" | "act" | "tool";
+    type?: "choice" | "noul" | "score" | "multi" | "act" | "tool" | "classify" | "verify" | "compress" | "extract";
     instructions?: JsonValue;
     criteria?: Record<string, JsonValue> | JsonValue[];
     levels?: Record<string, JsonValue> | JsonValue[];
@@ -35,7 +41,7 @@ export interface Question {
     base?: "noul" | "choice" | "score";
     costs?: Record<string, number> | Record<string, Record<string, number>>;
     defer_action?: string;
-    max_error?: number;
+    max_error?: number | readonly number[];
     objective?: MultiObjective;
     exclusive?: readonly string[];
     fallback?: string;
@@ -43,7 +49,17 @@ export interface Question {
     tools?: readonly ToolDefinition[];
     extra?: readonly ("answer_directly" | "ask_user" | "none")[];
     rank?: number;
+    description_chars?: number;
     multi?: boolean;
+    labels?: Record<string, JsonValue> | JsonValue[];
+    multi_label?: boolean;
+    none?: boolean;
+    claims?: Record<string, JsonValue> | JsonValue[];
+    binary?: boolean;
+    unit?: 'sentence' | 'line' | 'paragraph';
+    keep_ratio?: number;
+    min_keep?: number;
+    schema?: Record<string, JsonValue>;
 }
 export interface DecisionRequest {
     state: JsonValue;
@@ -122,7 +138,7 @@ export interface ActAnswer<K extends string = string, A extends string = string>
     max_error?: string;
     deferred?: boolean;
 }
-export type Answer = ChoiceAnswer | NoulAnswer | ScoreAnswer | MultiAnswer | ActAnswer | ToolAnswer;
+export type Answer = ChoiceAnswer | NoulAnswer | ScoreAnswer | MultiAnswer | ActAnswer | ToolAnswer | TaskAnswer;
 export interface Usage {
     input_tokens: number;
     output_tokens: number;
@@ -152,21 +168,6 @@ export interface ModelMetadata {
 export interface ModelsResponse {
     models: ModelMetadata[];
 }
-export declare class BasalError extends Error {
-}
-/** Non-2xx response. Server body and Retry-After are available without logging them. */
-export declare class BasalHTTPError extends BasalError {
-    readonly statusCode: number;
-    readonly body: unknown;
-    readonly retryAfter: string | null;
-    constructor(statusCode: number, body: unknown, retryAfter: string | null);
-}
-export declare class BasalTransportError extends BasalError {
-}
-export declare class BasalProtocolError extends BasalError {
-}
-export declare class BasalResponseTooLargeError extends BasalError {
-}
 /** Web Fetch input accepted by browsers and server runtimes. */
 export type RequestInput = string | URL | Request;
 /** A transport adapter must honor signal/redirect and return a standard Web Response. */
@@ -190,7 +191,20 @@ export declare class BasalClient {
     private readonly fetch;
     constructor(options?: BasalClientOptions);
     private request;
+    private call;
     decide(request: DecisionRequest, signal?: AbortSignal): Promise<DecisionResponse>;
     decide<const Q extends QuestionSet>(state: JsonValue, questions: Q, options?: DecisionOptions): Promise<TypedDecisionResponse<Q>>;
     models(signal?: AbortSignal): Promise<ModelsResponse>;
+    /** Upload a JSONL input file (`purpose=batch`) from caller-owned bytes, a Blob or a stream; never fetches URLs. */
+    uploadFile(request: UploadFileRequest, options?: TransferOptions): Promise<FileObject>;
+    listFiles(options?: ListFilesOptions): Promise<FileList>;
+    getFile(fileId: string, options?: RequestOptions): Promise<FileObject>;
+    deleteFile(fileId: string, options?: RequestOptions): Promise<DeletedFile>;
+    /** Raw file bytes (JSONL), buffered up to `maxBytes` (default `maxResponseBytes`); never JSON-parsed. */
+    downloadFile(fileId: string, options?: DownloadOptions): Promise<Uint8Array>;
+    createBatch(request: CreateBatchRequest, options?: CreateBatchOptions): Promise<Batch>;
+    listBatches(options?: ListOptions): Promise<BatchList>;
+    getBatch(batchId: string, options?: RequestOptions): Promise<Batch>;
+    /** Request cancellation; the batch moves to `cancelling` and later `cancelled`. Does not wait. */
+    cancelBatch(batchId: string, options?: RequestOptions): Promise<Batch>;
 }