deeplake 0.1.0 → 0.2.0

package/dist/node/node/client.js

@@ -0,0 +1,670 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedClient = void 0;
+const crypto = __importStar(require("crypto"));
+const api_1 = require("../shared/api");
+const credentials_1 = require("../shared/credentials");
+const database_1 = require("../shared/database");
+const errors_1 = require("../shared/errors");
+const schema_1 = require("../shared/schema");
+const token_1 = require("../shared/token");
+const errors_2 = require("../shared/errors");
+const wasm_common_1 = require("../shared/wasm-common");
+const dict_1 = require("./normalizers/dict");
+const files_1 = require("./normalizers/files");
+const huggingface_1 = require("./normalizers/huggingface");
+const DEFAULT_API_URL = 'https://api.deeplake.ai';
+class ManagedClient {
+    token;
+    workspaceId;
+    apiUrl;
+    orgId;
+    _rootPath = null;
+    _orgIdResolved;
+    _orgIdPromise = null;
+    constructor(options) {
+        if (!options.token) {
+            throw new errors_1.AuthError('Token required. Pass token to ManagedClient() or set the ACTIVELOOP_TOKEN environment variable.');
+        }
+        this.token = options.token;
+        this.workspaceId = options.workspaceId ?? 'default';
+        this.apiUrl = (options.apiUrl ?? DEFAULT_API_URL).replace(/\/+$/, '');
+        // Try sync extraction first (works for most tokens)
+        const syncOrgId = (0, token_1.tryExtractOrgId)(this.token);
+        if (syncOrgId) {
+            this.orgId = syncOrgId;
+            this._orgIdResolved = true;
+        }
+        else {
+            this.orgId = '';
+            this._orgIdResolved = false;
+        }
+    }
+    async ensureInitialized() {
+        if (this._orgIdResolved)
+            return;
+        if (!this._orgIdPromise) {
+            this._orgIdPromise = this._resolveOrgId();
+        }
+        await this._orgIdPromise;
+    }
+    async _resolveOrgId() {
+        const orgId = await (0, token_1.fetchOrgIdFromApi)(this.token, this.apiUrl);
+        if (orgId) {
+            this.orgId = orgId;
+            this._orgIdResolved = true;
+        }
+        else {
+            throw new errors_2.TokenError('Token does not contain org_id claim and API fallback failed');
+        }
+    }
+    /**
+     * Start building a fluent query against the given table.
+     *
+     * @example
+     * const rows = await client.table("videos").select("id", "text").limit(10).execute();
+     */
+    table(tableName) {
+        return new database_1.ManagedQueryBuilder(this, tableName);
+    }
+    // ------------------------------------------------------------------
+    // Storage path
+    // ------------------------------------------------------------------
+    async getRootPath() {
+        await this.ensureInitialized();
+        if (this._rootPath !== null)
+            return this._rootPath;
+        const resp = await (0, api_1.apiRequest)(this.apiUrl, this.token, this.orgId, {
+            method: 'GET',
+            path: `/workspaces/${this.workspaceId}/storage-path`,
+        });
+        const storagePath = resp.storage_path;
+        if (!storagePath) {
+            throw new errors_1.ManagedServiceError(`No storage path returned for workspace '${this.workspaceId}'`);
+        }
+        this._rootPath = storagePath;
+        return this._rootPath;
+    }
+    async getDatasetPath(tableName) {
+        const rootPath = (await this.getRootPath()).replace(/\/+$/, '');
+        if (rootPath.endsWith(`/${this.workspaceId}`)) {
+            return `${rootPath}/${tableName}`;
+        }
+        return `${rootPath}/${this.workspaceId}/${tableName}`;
+    }
+    // ------------------------------------------------------------------
+    // Storage credentials
+    // ------------------------------------------------------------------
+    async getStorageCreds(mode = 'readwrite') {
+        await this.ensureInitialized();
+        return (0, credentials_1.getStorageCreds)(this.apiUrl, this.token, this.orgId, this.workspaceId, mode);
+    }
+    async applyStorageCreds(mode = 'readwrite') {
+        const creds = await this.getStorageCreds(mode);
+        (0, credentials_1.applyStorageCreds)(creds);
+    }
+    // ------------------------------------------------------------------
+    // Ingest pipeline
+    // ------------------------------------------------------------------
+    async ingest(tableName, data, options) {
+        const format = options?.format;
+        if (format == null && data == null) {
+            throw new errors_1.IngestError('Either data or format must be provided.');
+        }
+        if (data != null && typeof data !== 'object') {
+            throw new errors_1.IngestError('data must be a dict (object).');
+        }
+        if (data != null && Object.keys(data).length === 0 && format == null) {
+            throw new errors_1.IngestError('data must not be empty.');
+        }
+        let schema = options?.schema;
+        const onProgress = options?.onProgress;
+        const chunkSize = options?.chunkSize ?? 1000;
+        const chunkOverlap = options?.chunkOverlap ?? 200;
+        // al:// path for this table — used by the C++ backend to resolve
+        // credentials via GET /api/org/{workspace}/ds/{table}/creds
+        const alPath = `al://${this.workspaceId}/${tableName}`;
+        try {
+            // Determine batch source
+            let batches;
+            if (format != null) {
+                if (typeof format.normalize !== 'function') {
+                    throw new errors_1.IngestError('format object must have a normalize() method.');
+                }
+                // Merge format-provided schema hints with user schema
+                if (typeof format.schema === 'function') {
+                    const fmtSchema = format.schema();
+                    if (fmtSchema) {
+                        schema = { ...fmtSchema, ...(schema ?? {}) };
+                    }
+                }
+                batches = format.normalize();
+            }
+            else if (data != null && '_huggingface' in data) {
+                const datasetName = data._huggingface;
+                if (typeof datasetName !== 'string' && !Array.isArray(datasetName)) {
+                    throw new errors_1.IngestError(`_huggingface value must be a string, got ${typeof datasetName}.`);
+                }
+                batches = (0, huggingface_1.normalizeHuggingface)(Array.isArray(datasetName) ? String(datasetName[0]) : String(datasetName));
+            }
+            else if (schema &&
+                Object.values(schema).some((v) => v.toUpperCase() === 'FILE')) {
+                const fileColumns = Object.entries(schema)
+                    .filter(([, t]) => t.toUpperCase() === 'FILE')
+                    .map(([c]) => c);
+                const allFiles = [];
+                for (const col of fileColumns) {
+                    if (!(col in data)) {
+                        throw new errors_1.IngestError(`Schema declares '${col}' as FILE but column not in data.`);
+                    }
+                    allFiles.push(...data[col]);
+                }
+                if (allFiles.length === 0) {
+                    throw new errors_1.IngestError('FILE columns contain no file paths.');
+                }
+                batches = (0, files_1.normalizeFiles)(allFiles, chunkSize, chunkOverlap);
+            }
+            else {
+                batches = (0, dict_1.normalizeDict)(data);
+            }
+            // Peek at the first batch to determine schema
+            const iter = Symbol.asyncIterator in batches
+                ? batches[Symbol.asyncIterator]()
+                : batches[Symbol.iterator]();
+            const firstResult = await iter.next();
+            if (firstResult.done) {
+                throw new errors_1.IngestError('No data to ingest.');
+            }
+            let firstBatch = firstResult.value;
+            // Inject _id (UUID) into first batch so PG schema includes it
+            if (!('_id' in firstBatch)) {
+                const firstCol = Object.values(firstBatch)[0];
+                const n = Array.isArray(firstCol) ? firstCol.length : 1;
+                firstBatch['_id'] = Array.from({ length: n }, () => crypto.randomUUID());
+            }
+            // Sort columns alphabetically — pg_deeplake's DuckDB scanner
+            // expects deeplake dataset columns to match the PG table column
+            // order, and the API sorts table_schema keys alphabetically.
+            firstBatch = Object.fromEntries(Object.entries(firstBatch).sort(([a], [b]) => a.localeCompare(b)));
+            const pgSchema = (0, schema_1.buildPgSchema)(firstBatch, schema, format);
+            // Create table via API — pg_deeplake creates both the PG table
+            // and the S3 dataset in one shot.
+            await this.createTableViaApi(tableName, alPath, pgSchema);
+            // Open the dataset via al:// — the C++ backend resolves creds
+            // automatically through /api/org/{ws}/ds/{table}/creds,
+            // with automatic credential rotation.
+            // Uses atomic setEndpoint+open to prevent concurrent clients from
+            // clobbering the global endpoint between set and open.
+            const ds = await (0, wasm_common_1.deeplakeSetEndpointAndOpen)(this.apiUrl, alPath, '', this.token);
+            try {
+                // Detect image columns for thumbnail generation
+                const imageCols = this.detectImageColumns(format, pgSchema, firstBatch);
+                // Re-chain the peeked batch with the remaining batches
+                const allBatches = chainBatches(firstBatch, iter);
+                const rowCount = await this.writeBatches(ds, allBatches, schema, onProgress, imageCols);
+                // Final commit for any rows written after the last periodic commit
+                await (0, wasm_common_1.deeplakeCommit)(ds);
+                // Create indexes on requested columns
+                if (options?.index) {
+                    for (const col of options.index) {
+                        try {
+                            await this.createIndex(tableName, col);
+                        }
+                        catch (e) {
+                            // Log warning but don't fail ingestion
+                            console.warn(`Failed to create index on ${tableName}.${col}: ${e instanceof Error ? e.message : e}`);
+                        }
+                    }
+                }
+                return { tableName, rowCount, datasetPath: alPath };
+            }
+            finally {
+                (0, wasm_common_1.deeplakeRelease)(ds);
+            }
+        }
+        catch (e) {
+            if (e instanceof errors_1.IngestError || e instanceof errors_1.ManagedServiceError)
+                throw e;
+            throw new errors_1.IngestError(`Failed to ingest data: ${e instanceof Error ? e.message : e}`);
+        }
+    }
+    // ------------------------------------------------------------------
+    // Write batches
+    // ------------------------------------------------------------------
+    async writeBatches(ds, batches, schema, onProgress, imageCols = [], flushEvery = 200, commitEvery = 2000) {
+        let rowCount = 0;
+        let buffer = {};
+        let bufferRows = 0;
+        let columnsEnsured = false;
+        let rowsSinceCommit = 0;
+        // Thumbnail collection
+        let sharp = null;
+        if (imageCols.length > 0) {
+            try {
+                sharp = require('sharp');
+            }
+            catch {
+                // sharp not available — skip thumbnail generation
+            }
+        }
+        const thumbBuffer = {
+            file_id: [],
+            column_name: [],
+            dimension: [],
+            content: [],
+        };
+        let thumbCount = 0;
+        let thumbDs = null;
+        const flushThumbnails = async () => {
+            if (thumbCount === 0)
+                return;
+            if (!thumbDs) {
+                // Same flow as regular tables: create via API, then open with al://
+                // Uses atomic setEndpoint+open to prevent endpoint races.
+                const thumbAlPath = `al://${this.workspaceId}/thumbnails`;
+                const thumbPgSchema = {
+                    column_name: 'TEXT',
+                    content: 'IMAGE',
+                    dimension: 'TEXT',
+                    file_id: 'TEXT',
+                };
+                await this.createTableViaApi('thumbnails', thumbAlPath, thumbPgSchema);
+                thumbDs = await (0, wasm_common_1.deeplakeSetEndpointAndOpen)(this.apiUrl, thumbAlPath, '', this.token);
+            }
+            await (0, wasm_common_1.deeplakeAppend)(thumbDs, thumbBuffer);
+            for (const k of Object.keys(thumbBuffer)) {
+                thumbBuffer[k] = [];
+            }
+            thumbCount = 0;
+        };
+        const generateThumbnailsForBuffer = async (buf) => {
+            if (!sharp || imageCols.length === 0)
+                return;
+            const idVals = (buf['_id'] ?? []);
+            for (const col of imageCols) {
+                if (!(col in buf))
+                    continue;
+                const values = buf[col];
+                for (let i = 0; i < values.length; i++) {
+                    const val = values[i];
+                    let raw;
+                    if (Buffer.isBuffer(val)) {
+                        raw = val;
+                    }
+                    else if (val instanceof Uint8Array) {
+                        raw = Buffer.from(val);
+                    }
+                    else {
+                        continue;
+                    }
+                    if (raw.length === 0)
+                        continue;
+                    const fid = i < idVals.length ? idVals[i] : String(rowCount + i);
+                    for (const [w, h] of ManagedClient.THUMBNAIL_SIZES) {
+                        try {
+                            const thumbBuf = await sharp(raw)
+                                .resize(w, h, { fit: 'inside' })
+                                .jpeg({ quality: 85 })
+                                .toBuffer();
+                            thumbBuffer.file_id.push(fid);
+                            thumbBuffer.column_name.push(col);
+                            thumbBuffer.dimension.push(`${w}x${h}`);
+                            thumbBuffer.content.push(thumbBuf);
+                            thumbCount++;
+                        }
+                        catch {
+                            // Skip this thumbnail
+                        }
+                    }
+                    if (thumbCount >= 200) {
+                        await flushThumbnails();
+                    }
+                }
+            }
+        };
+        for await (const batch of batches) {
+            if (!batch)
+                continue;
+            const firstCol = Object.values(batch)[0];
+            if (Array.isArray(firstCol) && firstCol.length === 0)
+                continue;
+            const batchRows = Array.isArray(firstCol) ? firstCol.length : 1;
+            // Inject _id (UUID) if not already present or wrong length.
+            // Format generators may carry over an empty _id array from
+            // a previous yield, so always verify the length matches.
+            const idCol = batch['_id'];
+            if (!idCol || (Array.isArray(idCol) && idCol.length !== batchRows)) {
+                batch['_id'] = Array.from({ length: batchRows }, () => crypto.randomUUID());
+            }
+            // Merge batch into buffer
+            for (const [col, values] of Object.entries(batch)) {
+                if (!(col in buffer)) {
+                    buffer[col] = Array.isArray(values) ? [...values] : [values];
+                }
+                else {
+                    if (Array.isArray(values)) {
+                        buffer[col].push(...values);
+                    }
+                    else {
+                        buffer[col].push(values);
+                    }
+                }
+            }
+            bufferRows += batchRows;
+            // Flush buffer when large enough
+            if (bufferRows >= flushEvery) {
+                if (!columnsEnsured) {
+                    (0, schema_1.ensureColumns)(ds, buffer, schema);
+                    columnsEnsured = true;
+                }
+                // Generate thumbnails from buffer before flushing
+                await generateThumbnailsForBuffer(buffer);
+                await (0, wasm_common_1.deeplakeAppend)(ds, buffer);
+                rowCount += bufferRows;
+                rowsSinceCommit += bufferRows;
+                buffer = {};
+                bufferRows = 0;
+                if (onProgress) {
+                    onProgress(rowCount, -1);
+                }
+                // Periodic commit to free C++ buffers and enable crash recovery
+                if (rowsSinceCommit >= commitEvery) {
+                    await (0, wasm_common_1.deeplakeCommit)(ds);
+                    rowsSinceCommit = 0;
+                }
+            }
+        }
+        // Flush remaining rows
+        if (bufferRows > 0) {
+            if (!columnsEnsured) {
+                (0, schema_1.ensureColumns)(ds, buffer, schema);
+            }
+            await generateThumbnailsForBuffer(buffer);
+            await (0, wasm_common_1.deeplakeAppend)(ds, buffer);
+            rowCount += bufferRows;
+            if (onProgress) {
+                onProgress(rowCount, -1);
+            }
+        }
+        // Flush remaining thumbnails and commit
+        if (thumbCount > 0 || thumbDs) {
+            try {
+                await flushThumbnails();
+                if (thumbDs) {
+                    await (0, wasm_common_1.deeplakeCommit)(thumbDs);
+                }
+            }
+            catch {
+                // Thumbnail finalization failed — non-fatal
+            }
+            finally {
+                if (thumbDs)
+                    (0, wasm_common_1.deeplakeRelease)(thumbDs);
+            }
+        }
+        return rowCount;
+    }
+    // ------------------------------------------------------------------
+    // Table management via REST API
+    // ------------------------------------------------------------------
+    async createTableViaApi(tableName, _datasetPath, pgSchema) {
+        await this.ensureInitialized();
+        try {
+            const body = { table_name: tableName };
+            if (pgSchema)
+                body.table_schema = pgSchema;
+            await (0, api_1.apiRequest)(this.apiUrl, this.token, this.orgId, {
+                method: 'POST',
+                path: `/workspaces/${this.workspaceId}/tables`,
+                body,
+                timeoutMs: 30_000,
+            });
+        }
+        catch (e) {
+            if (e instanceof errors_1.TableError &&
+                String(e.message).toLowerCase().includes('already exists')) {
+                // Table already exists — ok
+                return;
+            }
+            throw e;
+        }
+    }
+    // ------------------------------------------------------------------
+    // Query via REST API
+    // ------------------------------------------------------------------
+    async query(sql, params) {
+        await this.ensureInitialized();
+        const body = { query: sql };
+        if (params && params.length > 0) {
+            body.params = params;
+        }
+        try {
+            const resp = await (0, api_1.apiRequest)(this.apiUrl, this.token, this.orgId, {
+                method: 'POST',
+                path: `/workspaces/${this.workspaceId}/tables/query`,
+                body,
+                timeoutMs: 60_000,
+            });
+            const columns = (resp.columns ?? []);
+            const rows = (resp.rows ?? []);
+            return rows.map((row) => {
+                const obj = {};
+                for (let i = 0; i < columns.length; i++) {
+                    obj[columns[i]] = row[i];
+                }
+                return obj;
+            });
+        }
+        catch (e) {
+            if (e instanceof errors_1.ManagedServiceError) {
+                throw new errors_1.TableError(`Query failed: ${e.message}`);
+            }
+            throw new errors_1.TableError(`Query failed: ${e instanceof Error ? e.message : e}`);
+        }
+    }
+    // ------------------------------------------------------------------
+    // List / Drop tables via REST API
+    // ------------------------------------------------------------------
+    async listTables() {
+        await this.ensureInitialized();
+        const resp = await (0, api_1.apiRequest)(this.apiUrl, this.token, this.orgId, {
+            method: 'GET',
+            path: `/workspaces/${this.workspaceId}/tables`,
+        });
+        const tables = (resp.tables ?? []);
+        return tables.map((t) => t.table_name);
+    }
+    async dropTable(tableName, ifExists = true) {
+        await this.ensureInitialized();
+        try {
+            await (0, api_1.apiRequest)(this.apiUrl, this.token, this.orgId, {
+                method: 'DELETE',
+                path: `/workspaces/${this.workspaceId}/tables/${tableName}`,
+            });
+        }
+        catch (e) {
+            if (ifExists &&
+                e instanceof errors_1.ManagedServiceError &&
+                String(e.message).toLowerCase().includes('not found')) {
+                return;
+            }
+            throw e;
+        }
+    }
+    /**
+     * Create a `deeplake_index` on a column.
+     *
+     * Suitable for EMBEDDING columns (vector similarity search) and TEXT
+     * columns (BM25 text search). This is a no-op if the index already exists.
+     */
+    async createIndex(tableName, column) {
+        const safeTable = tableName.replace(/"/g, '""');
+        const safeCol = column.replace(/"/g, '""');
+        const idxName = `idx_${tableName}_${column}`.replace(/"/g, '""');
+        const sql = `CREATE INDEX IF NOT EXISTS "${idxName}" ON "${safeTable}" USING deeplake_index ("${safeCol}")`;
+        try {
+            await this.query(sql);
+        }
+        catch (e) {
+            if (e instanceof errors_1.TableError &&
+                String(e.message).toLowerCase().includes('already exists')) {
+                return;
+            }
+            throw e;
+        }
+    }
+    async openTable(tableName) {
+        await this.ensureInitialized();
+        const alPath = `al://${this.workspaceId}/${tableName}`;
+        // Uses atomic setEndpoint+open to prevent concurrent clients from
+        // clobbering the global endpoint between set and open.
+        return (0, wasm_common_1.deeplakeSetEndpointAndOpen)(this.apiUrl, alPath, '', this.token);
+    }
+    // ------------------------------------------------------------------
+    // Direct dataset data access (bypasses SQL query API)
+    // ------------------------------------------------------------------
+    async getField(tableName, rowIndex, column) {
+        const ds = await this.openTable(tableName);
+        try {
+            return await (0, wasm_common_1.deeplakeGetField)(ds, rowIndex, column);
+        }
+        finally {
+            (0, wasm_common_1.deeplakeRelease)(ds);
+        }
+    }
+    async getRow(tableName, rowIndex, columns) {
+        const ds = await this.openTable(tableName);
+        try {
+            return await (0, wasm_common_1.deeplakeGetRow)(ds, rowIndex, columns);
+        }
+        finally {
+            (0, wasm_common_1.deeplakeRelease)(ds);
+        }
+    }
+    async getColumnData(tableName, column, start, end) {
+        const ds = await this.openTable(tableName);
+        try {
+            return await (0, wasm_common_1.deeplakeGetColumnData)(ds, column, start, end);
+        }
+        finally {
+            (0, wasm_common_1.deeplakeRelease)(ds);
+        }
+    }
+    async getNumRows(tableName) {
+        const ds = await this.openTable(tableName);
+        try {
+            return (0, wasm_common_1.deeplakeNumRows)(ds);
+        }
+        finally {
+            (0, wasm_common_1.deeplakeRelease)(ds);
+        }
+    }
+    async getSampleByRef(tableName, columnId, rowId) {
+        const ds = await this.openTable(tableName);
+        try {
+            return await (0, wasm_common_1.deeplakeGetSampleByRef)(ds, columnId, rowId);
+        }
+        finally {
+            (0, wasm_common_1.deeplakeRelease)(ds);
+        }
+    }
+    async setField(tableName, rowIndex, column, value) {
+        const ds = await this.openTable(tableName);
+        try {
+            await (0, wasm_common_1.deeplakeSetField)(ds, rowIndex, column, value);
+            await (0, wasm_common_1.deeplakeCommit)(ds, `setField ${column}[${rowIndex}]`);
+        }
+        finally {
+            (0, wasm_common_1.deeplakeRelease)(ds);
+        }
+    }
+    async setRow(tableName, rowIndex, data) {
+        const ds = await this.openTable(tableName);
+        try {
+            await (0, wasm_common_1.deeplakeSetRow)(ds, rowIndex, data);
+            await (0, wasm_common_1.deeplakeCommit)(ds, `setRow[${rowIndex}]`);
+        }
+        finally {
+            (0, wasm_common_1.deeplakeRelease)(ds);
+        }
+    }
+    // ------------------------------------------------------------------
+    // Thumbnail generation
+    // ------------------------------------------------------------------
+    detectImageColumns(format, _pgSchema, firstBatch) {
+        // 1. Format declares image_columns explicitly
+        if (format && typeof format.image_columns === 'function') {
+            const cols = format.image_columns();
+            if (cols && cols.length > 0)
+                return cols;
+        }
+        // 2. Format pg_schema declares IMAGE type
+        if (format && typeof format.pg_schema === 'function') {
+            const pg = format.pg_schema();
+            const cols = Object.entries(pg)
+                .filter(([, t]) => t.toUpperCase() === 'IMAGE')
+                .map(([c]) => c);
+            if (cols.length > 0)
+                return cols;
+        }
+        // 3. Auto-detect: the image file normalizer creates an "image" column
+        //    with Buffer/bytes data.  If "image" is in the batch, use it.
+        if ('image' in firstBatch) {
+            const sample = Array.isArray(firstBatch.image) ? firstBatch.image[0] : firstBatch.image;
+            if (Buffer.isBuffer(sample) || sample instanceof Uint8Array) {
+                return ['image'];
+            }
+        }
+        return [];
+    }
+    static THUMBNAIL_SIZES = [
+        [32, 32], [64, 64], [128, 128], [256, 256],
+    ];
+}
+exports.ManagedClient = ManagedClient;
+// =====================================================================
+// Helpers
+// =====================================================================
+async function* chainBatches(first, rest) {
+    yield first;
+    while (true) {
+        const result = await rest.next();
+        if (result.done)
+            break;
+        yield result.value;
+    }
+}
+//# sourceMappingURL=client.js.map