@deepraxis/sdk 0.1.0-dev.a5cf3ce → 0.1.0-dev.b7ae389

package/dist/helpers/file-upload.d.ts

@@ -0,0 +1,24 @@
+import type { Praxis } from '../core/client.js';
+import type { OwnFileOpenAiFile } from '../generated/types.gen.js';
+export interface UploadFileOptions {
+    /** user_data for conversation attachments; assistants for assistant files; vision for PNG/JPEG/GIF/WebP. */
+    purpose: 'user_data' | 'assistants' | 'vision';
+    /** Defaults to File.name, or upload for a Blob. */
+    filename?: string;
+    /** Fixed part size in bytes, 5 MiB–64 MB; defaults to 50 MiB. */
+    partSize?: number;
+    /** Concurrent part requests, a positive integer; defaults to 3. */
+    concurrency?: number;
+    /** Aborts outstanding requests and cancels an unfinished Upload. */
+    signal?: AbortSignal;
+    /** Acknowledged byte fraction, 0–1. A value of 1 does not imply processing has finished. */
+    onProgress?: (fraction: number) => void;
+}
+export type UploadedFile = OwnFileOpenAiFile;
+/** Upload a nonempty file up to 2 GiB, returning only after processing reaches active.
+ * Files up to 32 MiB use one request; larger files use fixed-size Uploads parts.
+ * Parts and complete each retry transient failures at most five times with exponential backoff.
+ * A terminal failure or abort cancels the Upload. Completed files cannot be cancelled;
+ * if abort occurs during processing, delete the resulting file explicitly if no longer needed.
+ */
+export declare function uploadFile(client: Pick<Praxis, 'file'>, file: Blob | File, options: UploadFileOptions): Promise<UploadedFile>;

package/dist/helpers/file-upload.js

@@ -0,0 +1,113 @@
+import { PraxisError, PraxisConnectionError, PraxisTimeoutError } from "../core/errors.js";
+import { sleep } from "../core/retry.js";
+const MAX_RETRIES = 5;
+function retryable(error) {
+    return error instanceof PraxisConnectionError || error instanceof PraxisTimeoutError
+        || error instanceof SyntaxError
+        || (error instanceof PraxisError && (error.status === 408 || error.status === 429 || (error.status !== undefined && error.status >= 500 && error.status <= 599)));
+}
+async function retry(signal, operation) {
+    for (let used = 0;; used++) {
+        signal.throwIfAborted();
+        try {
+            return await operation();
+        }
+        catch (error) {
+            signal.throwIfAborted();
+            if (used >= MAX_RETRIES || !retryable(error))
+                throw error;
+            await sleep(500 * 2 ** used, signal);
+        }
+    }
+}
+/** Upload a nonempty file up to 2 GiB, returning only after processing reaches active.
+ * Files up to 32 MiB use one request; larger files use fixed-size Uploads parts.
+ * Parts and complete each retry transient failures at most five times with exponential backoff.
+ * A terminal failure or abort cancels the Upload. Completed files cannot be cancelled;
+ * if abort occurs during processing, delete the resulting file explicitly if no longer needed.
+ */
+export async function uploadFile(client, file, options) {
+    options.signal?.throwIfAborted();
+    if (file.size < 1 || file.size > 2 * 1024 ** 3)
+        throw new RangeError('File size must be 1 byte through 2 GiB');
+    const partSize = options.partSize ?? 50 * 1024 ** 2;
+    const concurrency = options.concurrency ?? 3;
+    if (!Number.isSafeInteger(partSize) || partSize < 5 * 1024 ** 2 || partSize > 64_000_000)
+        throw new RangeError('partSize must be an integer from 5242880 through 64000000');
+    if (!Number.isSafeInteger(concurrency) || concurrency < 1)
+        throw new RangeError('concurrency must be a positive integer');
+    const filename = options.filename ?? (typeof File !== 'undefined' && file instanceof File ? file.name : 'upload');
+    const work = new AbortController();
+    const abort = () => work.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', abort, { once: true });
+    const signal = work.signal;
+    const request = { signal, maxRetries: 0, timeoutMs: 120_000 };
+    let uploadId;
+    const active = async (initial) => {
+        let result = initial;
+        for (let polls = 0;; polls++) {
+            signal.throwIfAborted();
+            if (result.state === 'active')
+                return result;
+            if (result.state !== 'processing')
+                throw new PraxisError({ code: 'FILE_PROCESSING_FAILED', message: `File ${result.id} is not active (${result.state})` });
+            await sleep(Math.min(5000, 1000 * 2 ** polls), signal);
+            result = await retry(signal, () => client.file.files.retrieve({ path: { file_id: result.id }, ...request }));
+        }
+    };
+    try {
+        signal.throwIfAborted();
+        options.onProgress?.(0);
+        if (file.size <= 32 * 1024 ** 2) {
+            const result = await client.file.files.create({ body: { file: new File([file], filename, { type: file.type }), purpose: options.purpose }, ...request });
+            options.onProgress?.(1);
+            return await active(result);
+        }
+        const upload = await client.file.uploads.create({ body: { bytes: file.size, filename, mime_type: file.type || 'application/octet-stream', purpose: options.purpose, part_size: partSize }, ...request });
+        uploadId = upload.id;
+        signal.throwIfAborted();
+        const path = { upload_id: uploadId };
+        const count = Math.ceil(file.size / partSize);
+        const ids = new Array(count);
+        let cursor = 0, confirmed = 0;
+        const worker = async () => {
+            while (cursor < count) {
+                signal.throwIfAborted();
+                const index = cursor++;
+                const chunk = file.slice(index * partSize, Math.min(file.size, (index + 1) * partSize));
+                const part = await retry(signal, () => client.file.uploads.parts.create({ path, query: { part_number: index + 1 }, body: { data: new File([chunk], filename) }, ...request }));
+                ids[index] = part.id;
+                confirmed += chunk.size;
+                options.onProgress?.(confirmed / file.size);
+            }
+        };
+        const workers = Array.from({ length: Math.min(concurrency, count) }, worker);
+        try {
+            await Promise.all(workers);
+        }
+        catch (error) {
+            work.abort();
+            await Promise.allSettled(workers);
+            throw error;
+        }
+        const result = await retry(signal, () => client.file.uploads.complete({ path, body: { part_ids: ids }, ...request }));
+        if (result.error)
+            throw new PraxisError({ code: result.error.code, message: result.error.message });
+        if (result.status !== 'completed' || !result.file)
+            throw new PraxisError({ code: 'INVALID_RESPONSE', message: 'Complete did not return a completed Upload with a file' });
+        return await active(result.file);
+    }
+    catch (error) {
+        work.abort();
+        if (uploadId) {
+            // Cleanup uses its own timeout and must not inherit the aborted work signal.
+            await client.file.uploads.cancel({ path: { upload_id: uploadId }, maxRetries: 0, timeoutMs: 10_000 }).catch(() => { });
+        }
+        if (options.signal?.aborted)
+            throw options.signal.reason;
+        throw error;
+    }
+    finally {
+        options.signal?.removeEventListener('abort', abort);
+    }
+}

package/dist/index.d.ts

@@ -9,3 +9,5 @@ export { publish } from './helpers/application-publish.js';
 export type { PublishInput, PublishResult, AssetsConfig } from './helpers/application-publish.js';
 export { count } from './helpers/database-count.js';
 export type { CountInput, CountResult } from './helpers/database-count.js';
+export { uploadFile } from './helpers/file-upload.js';
+export type { UploadFileOptions, UploadedFile } from './helpers/file-upload.js';

package/dist/index.js

@@ -4,3 +4,4 @@ export { Page } from "./core/pagination.js";
 export { parseSSE } from "./core/sse.js";
 export { publish } from "./helpers/application-publish.js";
 export { count } from "./helpers/database-count.js";
+export { uploadFile } from "./helpers/file-upload.js";