@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/llm-deepseek/lib/types/file-store.d.ts

@@ -0,0 +1,83 @@
+/** DeepSeek Files API upload reuse, invalidation, and quota recovery. @module nomix-llm-deepseek/file-store */
+import type { RequestImageAttachment } from '../../../attachment/lib/index.js';
+import type { DeepSeekFileId } from './file-id.ts';
+import { DeepSeekUploadIndex } from './upload-index.ts';
+import type { DeepSeekUploadRecord } from './upload-index.ts';
+/** DeepSeek chat accepts at most 32 MiB per image even when it is referenced by file id. */
+export declare const MAX_CHAT_IMAGE_BYTES: number;
+/** Resolved file-store policy from the plugin configuration. */
+export interface DeepSeekFilePolicy {
+    expiresAfterSeconds: number;
+    refreshMarginSeconds: number;
+    quotaCleanupBatch: number;
+}
+/** Connection facts needed by file operations. */
+export interface DeepSeekFileConnection {
+    baseURL: string;
+    apiKey: string;
+}
+/** Result of one file-id resolution. */
+export interface DeepSeekFileReference {
+    record: DeepSeekUploadRecord;
+    uploaded: boolean;
+}
+interface FileStoreOptions {
+    index?: DeepSeekUploadIndex;
+    now?: () => number;
+    fetch?: typeof fetch;
+}
+/** User-scoped durable file-id reuse for the DeepSeek route. */
+export declare class DeepSeekFileStore {
+    private readonly index;
+    private readonly now;
+    private readonly fetchImpl;
+    private readonly inflight;
+    /**
+     * @param options - testable index, clock, and transport boundaries.
+     */
+    constructor(options?: FileStoreOptions);
+    private client;
+    /**
+     * Resolve or upload one deterministic request image. Concurrent calls share one upload while retaining independent waits.
+     * @param version - deterministic model-request bytes and complete transformation identity.
+     * @param connection - endpoint and API-key snapshot.
+     * @param policy - expiry and quota-recovery policy.
+     * @param signal - cancellation of this wait; shared transport stops when no waiter remains.
+     * @returns a reusable file id and whether this call published a new upload.
+     */
+    ensureUploaded(version: RequestImageAttachment, connection: DeepSeekFileConnection, policy: DeepSeekFilePolicy, signal?: AbortSignal): Promise<DeepSeekFileReference>;
+    private ensureUploadedOnce;
+    /**
+     * Invalidate one exact local mapping after the chat endpoint rejects its remote id.
+     * @param version - request-image version whose remote generation failed.
+     * @param fileId - exact rejected file id.
+     * @param connection - endpoint and API-key snapshot.
+     */
+    invalidate(version: RequestImageAttachment, fileId: DeepSeekFileId, connection: DeepSeekFileConnection): Promise<void>;
+    /**
+     * Delete the indexed remote file for one attachment and remove its local mapping.
+     * @param version - exact request-image version to release.
+     * @param connection - endpoint and API-key snapshot.
+     * @param policy - expiry policy used to locate a reusable mapping.
+     * @param signal - request cancellation.
+     * @returns whether an indexed file existed and was deleted.
+     */
+    release(version: RequestImageAttachment, connection: DeepSeekFileConnection, policy: DeepSeekFilePolicy, signal?: AbortSignal): Promise<boolean>;
+    /**
+     * Delete the oldest provider files whose names identify harness ownership.
+     * @param connection - endpoint and API-key snapshot.
+     * @param count - positive maximum number of files to delete.
+     * @param signal - request cancellation.
+     * @returns number of successfully deleted files.
+     */
+    reclaimOldestOwned(connection: DeepSeekFileConnection, count: number, signal?: AbortSignal): Promise<number>;
+    /**
+     * Delete every remote harness-owned file in the active API-key namespace and clear its index.
+     * @param connection - endpoint and API-key snapshot.
+     * @param signal - request cancellation.
+     * @returns number of deleted files.
+     */
+    releaseAll(connection: DeepSeekFileConnection, signal?: AbortSignal): Promise<number>;
+}
+export {};
+//# sourceMappingURL=file-store.d.ts.map

package/dist/kernel/llm-deepseek/lib/types/file-store.js

@@ -0,0 +1,261 @@
+/** DeepSeek Files API upload reuse, invalidation, and quota recovery. @module nomix-llm-deepseek/file-store */
+import { LlmError } from '../../../llm/lib/index.js';
+import { DeepSeekFilesClient, isFilesQuotaError } from "./files-api.js";
+import { deepSeekFileScope, DeepSeekUploadIndex } from "./upload-index.js";
+/** DeepSeek chat accepts at most 32 MiB per image even when it is referenced by file id. */
+export const MAX_CHAT_IMAGE_BYTES = 32 * 1024 * 1024;
+const OWNED_FILE_PREFIX = 'nomix-';
+function abortReason(signal) {
+    const reason = signal.reason;
+    return reason instanceof Error
+        ? reason
+        : new Error('DeepSeek file upload cancelled with a non-Error reason.', { cause: reason });
+}
+function uploadFailure(error) {
+    return error instanceof Error
+        ? error
+        : new Error('DeepSeek file upload failed with a non-Error reason.', { cause: error });
+}
+function waitForUpload(operation, signal) {
+    signal?.throwIfAborted();
+    operation.waiters += 1;
+    let released = false;
+    const release = (cancelledReason) => {
+        if (released)
+            return;
+        released = true;
+        operation.waiters -= 1;
+        if (cancelledReason !== undefined && operation.waiters === 0 && !operation.settled) {
+            operation.controller.abort(cancelledReason);
+        }
+    };
+    if (signal === undefined) {
+        return operation.promise.finally(() => {
+            release();
+        });
+    }
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            const reason = abortReason(signal);
+            release(reason);
+            reject(reason);
+        };
+        signal.addEventListener('abort', abort, { once: true });
+        void operation.promise.then((value) => {
+            signal.removeEventListener('abort', abort);
+            release();
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', abort);
+            release();
+            reject(uploadFailure(error));
+        });
+    });
+}
+function extension(mediaType) {
+    switch (mediaType) {
+        case 'image/png': return 'png';
+        case 'image/jpeg': return 'jpeg';
+        case 'image/webp': return 'webp';
+        case 'image/gif': return 'gif';
+    }
+}
+function filename(version) {
+    const attachment = String(version.attachment.attachmentId).slice('sha256:'.length, 'sha256:'.length + 16);
+    const variant = String(version.variantId).slice('sha256:'.length, 'sha256:'.length + 8);
+    return `${OWNED_FILE_PREFIX}${attachment}-${variant}.${extension(version.mediaType)}`;
+}
+/** User-scoped durable file-id reuse for the DeepSeek route. */
+export class DeepSeekFileStore {
+    index;
+    now;
+    fetchImpl;
+    inflight = new Map();
+    /**
+     * @param options - testable index, clock, and transport boundaries.
+     */
+    constructor(options = {}) {
+        this.index = options.index ?? new DeepSeekUploadIndex();
+        this.now = options.now ?? Date.now;
+        this.fetchImpl = options.fetch;
+    }
+    client(connection) {
+        return new DeepSeekFilesClient({
+            baseURL: connection.baseURL,
+            apiKey: connection.apiKey,
+            ...this.fetchImpl === undefined ? {} : { fetch: this.fetchImpl },
+        });
+    }
+    /**
+     * Resolve or upload one deterministic request image. Concurrent calls share one upload while retaining independent waits.
+     * @param version - deterministic model-request bytes and complete transformation identity.
+     * @param connection - endpoint and API-key snapshot.
+     * @param policy - expiry and quota-recovery policy.
+     * @param signal - cancellation of this wait; shared transport stops when no waiter remains.
+     * @returns a reusable file id and whether this call published a new upload.
+     */
+    ensureUploaded(version, connection, policy, signal) {
+        signal?.throwIfAborted();
+        const scope = deepSeekFileScope(connection.baseURL, connection.apiKey);
+        const key = `${scope}\0${version.variantId}`;
+        let active = this.inflight.get(key);
+        if (active?.controller.signal.aborted) {
+            this.inflight.delete(key);
+            active = undefined;
+        }
+        if (active !== undefined)
+            return waitForUpload(active, signal);
+        const controller = new AbortController();
+        const shared = {
+            controller,
+            settled: false,
+            waiters: 0,
+            promise: undefined,
+        };
+        shared.promise = this.ensureUploadedOnce(version, connection, policy, controller.signal).then((value) => {
+            shared.settled = true;
+            return value;
+        }, (error) => {
+            shared.settled = true;
+            throw uploadFailure(error);
+        });
+        this.inflight.set(key, shared);
+        void shared.promise.finally(() => {
+            if (this.inflight.get(key) === shared)
+                this.inflight.delete(key);
+        }).catch(() => { });
+        return waitForUpload(shared, signal);
+    }
+    async ensureUploadedOnce(version, connection, policy, signal) {
+        if (version.bytes > MAX_CHAT_IMAGE_BYTES) {
+            throw new LlmError('DeepSeek chat image exceeds the 32 MiB per-image limit.', 'INVALID_REQUEST');
+        }
+        const scope = deepSeekFileScope(connection.baseURL, connection.apiKey);
+        const now = this.now();
+        const marginMs = policy.refreshMarginSeconds * 1_000;
+        const cached = await this.index.get(scope, version.variantId, now, marginMs);
+        if (cached !== undefined)
+            return { record: cached, uploaded: false };
+        const client = this.client(connection);
+        const upload = async () => {
+            const remote = await client.upload({
+                data: version.data,
+                mediaType: version.mediaType,
+                filename: filename(version),
+                expiresAfterSeconds: policy.expiresAfterSeconds,
+                signal,
+            });
+            if (remote.bytes !== version.data.byteLength) {
+                throw new LlmError('DeepSeek Files API upload response does not match the submitted image.', 'INVALID_RESPONSE');
+            }
+            return {
+                scope,
+                attachmentId: version.attachment.attachmentId,
+                variantId: version.variantId,
+                fileId: remote.id,
+                bytes: remote.bytes,
+                createdAt: remote.createdAt * 1_000,
+                expiresAt: remote.expiresAt * 1_000,
+            };
+        };
+        let candidate;
+        try {
+            candidate = await upload();
+        }
+        catch (error) {
+            if (!isFilesQuotaError(error))
+                throw error;
+            const deleted = await this.reclaimOldestOwned(connection, policy.quotaCleanupBatch, signal);
+            if (deleted === 0)
+                throw error;
+            candidate = await upload();
+        }
+        const committed = await this.index.commit(candidate, this.now(), marginMs);
+        if (!committed.accepted) {
+            try {
+                await client.delete(candidate.fileId, signal);
+            }
+            catch {
+                // The winning mapping is durable. A failed duplicate cleanup affects quota only and is retried by recovery.
+            }
+        }
+        return { record: committed.record, uploaded: committed.accepted };
+    }
+    /**
+     * Invalidate one exact local mapping after the chat endpoint rejects its remote id.
+     * @param version - request-image version whose remote generation failed.
+     * @param fileId - exact rejected file id.
+     * @param connection - endpoint and API-key snapshot.
+     */
+    async invalidate(version, fileId, connection) {
+        await this.index.remove(deepSeekFileScope(connection.baseURL, connection.apiKey), version.variantId, fileId);
+    }
+    /**
+     * Delete the indexed remote file for one attachment and remove its local mapping.
+     * @param version - exact request-image version to release.
+     * @param connection - endpoint and API-key snapshot.
+     * @param policy - expiry policy used to locate a reusable mapping.
+     * @param signal - request cancellation.
+     * @returns whether an indexed file existed and was deleted.
+     */
+    async release(version, connection, policy, signal) {
+        const scope = deepSeekFileScope(connection.baseURL, connection.apiKey);
+        const record = await this.index.get(scope, version.variantId, this.now(), policy.refreshMarginSeconds * 1_000);
+        if (record === undefined)
+            return false;
+        await this.client(connection).delete(record.fileId, signal);
+        await this.index.remove(scope, version.variantId, record.fileId);
+        return true;
+    }
+    /**
+     * Delete the oldest provider files whose names identify harness ownership.
+     * @param connection - endpoint and API-key snapshot.
+     * @param count - positive maximum number of files to delete.
+     * @param signal - request cancellation.
+     * @returns number of successfully deleted files.
+     */
+    async reclaimOldestOwned(connection, count, signal) {
+        const client = this.client(connection);
+        let after;
+        const owned = [];
+        while (owned.length < count) {
+            const page = await client.list({
+                ...after === undefined ? {} : { after },
+                limit: 1_000,
+                order: 'asc',
+                ...signal === undefined ? {} : { signal },
+            });
+            for (const file of page.data) {
+                if (!file.filename.startsWith(OWNED_FILE_PREFIX))
+                    continue;
+                owned.push(file.id);
+                if (owned.length === count)
+                    break;
+            }
+            if (!page.hasMore || page.lastId === undefined || page.lastId === after)
+                break;
+            after = page.lastId;
+        }
+        for (const fileId of owned)
+            await client.delete(fileId, signal);
+        return owned.length;
+    }
+    /**
+     * Delete every remote harness-owned file in the active API-key namespace and clear its index.
+     * @param connection - endpoint and API-key snapshot.
+     * @param signal - request cancellation.
+     * @returns number of deleted files.
+     */
+    async releaseAll(connection, signal) {
+        let total = 0;
+        for (;;) {
+            const deleted = await this.reclaimOldestOwned(connection, 1_000, signal);
+            total += deleted;
+            if (deleted < 1_000)
+                break;
+        }
+        await this.index.clear(deepSeekFileScope(connection.baseURL, connection.apiKey));
+        return total;
+    }
+}
+//# sourceMappingURL=file-store.js.map

package/dist/kernel/llm-deepseek/lib/types/files-api.d.ts

@@ -0,0 +1,103 @@
+/** OpenAI-compatible DeepSeek Files API transport. @module nomix-llm-deepseek/files-api */
+import { LlmError } from '../../../llm/lib/index.js';
+import type { ImageMediaType } from '../../../attachment/lib/index.js';
+import type { DeepSeekFileId as DeepSeekFileIdType } from './file-id.ts';
+/** Minimum provider-supported file lifetime. */
+export declare const MIN_FILE_EXPIRY_SECONDS = 3600;
+/** Maximum provider-supported file lifetime. */
+export declare const MAX_FILE_EXPIRY_SECONDS = 2592000;
+/** Maximum Files API upload size. */
+export declare const MAX_FILE_UPLOAD_BYTES: number;
+/** Current per-key file-count quota. */
+export declare const MAX_STORED_FILE_COUNT = 10000;
+/** Current per-key storage quota. */
+export declare const MAX_STORED_FILE_BYTES: number;
+/** Validated file object returned by the OpenAI-compatible endpoint. */
+export interface DeepSeekFileObject {
+    id: DeepSeekFileIdType;
+    bytes: number;
+    createdAt: number;
+    filename: string;
+    purpose: 'user_data';
+    expiresAt?: number;
+}
+/** One page returned by `GET /files`. */
+export interface DeepSeekFilePage {
+    data: DeepSeekFileObject[];
+    firstId?: DeepSeekFileIdType;
+    lastId?: DeepSeekFileIdType;
+    hasMore: boolean;
+}
+/** Files API operation failure with its HTTP status retained for recovery policy. */
+export declare class DeepSeekFilesError extends LlmError {
+    /** Parsed provider detail used only for error classification. */
+    readonly detail: string;
+    /**
+     * @param message - user-readable provider failure.
+     * @param status - HTTP status returned by the Files API.
+     * @param detail - provider error fields joined for classification.
+     */
+    constructor(message: string, status: number, detail: string);
+}
+/**
+ * Whether an upload failure reports a provider storage or file-count quota.
+ * @param error - Files API operation failure.
+ * @returns whether one bounded remote cleanup and upload retry may recover.
+ */
+export declare function isFilesQuotaError(error: unknown): error is DeepSeekFilesError;
+interface FilesApiOptions {
+    baseURL: string;
+    apiKey: string;
+    fetch?: typeof fetch;
+}
+/** Direct client for the OpenAI-compatible `/files` endpoints. */
+export declare class DeepSeekFilesClient {
+    private readonly baseURL;
+    private readonly apiKey;
+    private readonly fetchImpl;
+    /**
+     * @param options - endpoint, API-key snapshot, and optional test transport.
+     */
+    constructor(options: FilesApiOptions);
+    private request;
+    /**
+     * Upload one image with an explicit expiry.
+     * @param input - deterministic request-version bytes, media type, filename, lifetime, and cancellation.
+     * @returns the validated provider file object, including `expires_at`.
+     */
+    upload(input: {
+        data: Uint8Array;
+        mediaType: ImageMediaType;
+        filename: string;
+        expiresAfterSeconds: number;
+        signal?: AbortSignal;
+    }): Promise<DeepSeekFileObject & {
+        expiresAt: number;
+    }>;
+    /**
+     * List one ascending or descending page of user-data files.
+     * @param options - pagination, ordering, and cancellation.
+     * @returns the validated page.
+     */
+    list(options?: {
+        after?: DeepSeekFileIdType;
+        limit?: number;
+        order?: 'asc' | 'desc';
+        signal?: AbortSignal;
+    }): Promise<DeepSeekFilePage>;
+    /**
+     * Retrieve one file object.
+     * @param fileId - provider file identifier.
+     * @param signal - request cancellation.
+     * @returns the validated file object.
+     */
+    retrieve(fileId: DeepSeekFileIdType, signal?: AbortSignal): Promise<DeepSeekFileObject>;
+    /**
+     * Delete one provider file.
+     * @param fileId - provider file identifier.
+     * @param signal - request cancellation.
+     */
+    delete(fileId: DeepSeekFileIdType, signal?: AbortSignal): Promise<void>;
+}
+export {};
+//# sourceMappingURL=files-api.d.ts.map

package/dist/kernel/llm-deepseek/lib/types/files-api.js

@@ -0,0 +1,206 @@
+/** OpenAI-compatible DeepSeek Files API transport. @module nomix-llm-deepseek/files-api */
+import { attributionHeaders, LlmError } from '../../../llm/lib/index.js';
+import { DeepSeekFileId } from "./file-id.js";
+/** Minimum provider-supported file lifetime. */
+export const MIN_FILE_EXPIRY_SECONDS = 3_600;
+/** Maximum provider-supported file lifetime. */
+export const MAX_FILE_EXPIRY_SECONDS = 2_592_000;
+/** Maximum Files API upload size. */
+export const MAX_FILE_UPLOAD_BYTES = 128 * 1024 * 1024;
+/** Current per-key file-count quota. */
+export const MAX_STORED_FILE_COUNT = 10_000;
+/** Current per-key storage quota. */
+export const MAX_STORED_FILE_BYTES = 25 * 1024 * 1024 * 1024;
+/** Files API operation failure with its HTTP status retained for recovery policy. */
+export class DeepSeekFilesError extends LlmError {
+    /** Parsed provider detail used only for error classification. */
+    detail;
+    /**
+     * @param message - user-readable provider failure.
+     * @param status - HTTP status returned by the Files API.
+     * @param detail - provider error fields joined for classification.
+     */
+    constructor(message, status, detail) {
+        super(message, status === 401 || status === 403
+            ? 'AUTH'
+            : status === 429
+                ? 'RATE_LIMIT'
+                : status >= 500
+                    ? 'SERVER'
+                    : 'FILES_API', { status });
+        this.name = 'DeepSeekFilesError';
+        this.detail = detail;
+    }
+}
+/**
+ * Whether an upload failure reports a provider storage or file-count quota.
+ * @param error - Files API operation failure.
+ * @returns whether one bounded remote cleanup and upload retry may recover.
+ */
+export function isFilesQuotaError(error) {
+    return error instanceof DeepSeekFilesError
+        && /(?:quota|storage|stored files|file count|too many files)/iu.test(error.detail);
+}
+function invalidResponse(operation) {
+    return new LlmError(`DeepSeek Files API returned an invalid ${operation} response.`, 'INVALID_RESPONSE');
+}
+function parseFileObject(value, operation) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw invalidResponse(operation);
+    const wire = value;
+    if (typeof wire.id !== 'string' || wire.id.length === 0
+        || wire.object !== 'file'
+        || !Number.isSafeInteger(wire.bytes) || wire.bytes < 0
+        || !Number.isSafeInteger(wire.created_at) || wire.created_at < 0
+        || typeof wire.filename !== 'string' || wire.filename.length === 0
+        || wire.purpose !== 'user_data'
+        || (wire.expires_at !== undefined
+            && (!Number.isSafeInteger(wire.expires_at) || wire.expires_at < 0))) {
+        throw invalidResponse(operation);
+    }
+    return {
+        id: DeepSeekFileId(wire.id),
+        bytes: wire.bytes,
+        createdAt: wire.created_at,
+        filename: wire.filename,
+        purpose: 'user_data',
+        ...wire.expires_at === undefined ? {} : { expiresAt: wire.expires_at },
+    };
+}
+function providerErrorDetail(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return { detail: '' };
+    const error = value.error;
+    if (error === null || typeof error !== 'object' || Array.isArray(error))
+        return { detail: '' };
+    const fields = error;
+    const message = typeof fields.message === 'string' ? fields.message : undefined;
+    return {
+        ...message === undefined ? {} : { message },
+        detail: [fields.code, fields.type, fields.message]
+            .filter((field) => typeof field === 'string')
+            .join(' '),
+    };
+}
+/** Direct client for the OpenAI-compatible `/files` endpoints. */
+export class DeepSeekFilesClient {
+    baseURL;
+    apiKey;
+    fetchImpl;
+    /**
+     * @param options - endpoint, API-key snapshot, and optional test transport.
+     */
+    constructor(options) {
+        this.baseURL = options.baseURL.replace(/\/+$/u, '');
+        this.apiKey = options.apiKey;
+        this.fetchImpl = options.fetch ?? globalThis.fetch;
+    }
+    async request(path, init, signal) {
+        let response;
+        try {
+            const headers = new Headers(attributionHeaders());
+            headers.set('authorization', `Bearer ${this.apiKey}`);
+            response = await this.fetchImpl(`${this.baseURL}${path}`, {
+                ...init,
+                headers,
+                ...signal === undefined ? {} : { signal },
+            });
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            throw new LlmError(`DeepSeek Files API request to ${this.baseURL} failed`, 'TRANSPORT', { cause: error });
+        }
+        if (response.ok)
+            return response;
+        let parsed;
+        try {
+            parsed = await response.json();
+        }
+        catch {
+            // A status remains sufficient to report the provider failure.
+        }
+        const { message, detail } = providerErrorDetail(parsed);
+        throw new DeepSeekFilesError(message ?? `DeepSeek Files API error (HTTP ${response.status})`, response.status, detail);
+    }
+    /**
+     * Upload one image with an explicit expiry.
+     * @param input - deterministic request-version bytes, media type, filename, lifetime, and cancellation.
+     * @returns the validated provider file object, including `expires_at`.
+     */
+    async upload(input) {
+        if (input.data.byteLength > MAX_FILE_UPLOAD_BYTES) {
+            throw new LlmError('DeepSeek Files API upload exceeds 128 MiB.', 'INVALID_REQUEST');
+        }
+        if (!Number.isSafeInteger(input.expiresAfterSeconds)
+            || input.expiresAfterSeconds < MIN_FILE_EXPIRY_SECONDS
+            || input.expiresAfterSeconds > MAX_FILE_EXPIRY_SECONDS) {
+            throw new LlmError('DeepSeek file expiry must be between 3600 and 2592000 seconds.', 'INVALID_REQUEST');
+        }
+        const form = new FormData();
+        form.set('purpose', 'user_data');
+        form.set('expires_after[anchor]', 'created_at');
+        form.set('expires_after[seconds]', String(input.expiresAfterSeconds));
+        form.set('file', new Blob([Uint8Array.from(input.data).buffer], { type: input.mediaType }), input.filename);
+        const response = await this.request('/files', { method: 'POST', body: form }, input.signal);
+        const file = parseFileObject(await response.json(), 'upload');
+        if (file.expiresAt === undefined)
+            throw invalidResponse('upload');
+        return { ...file, expiresAt: file.expiresAt };
+    }
+    /**
+     * List one ascending or descending page of user-data files.
+     * @param options - pagination, ordering, and cancellation.
+     * @returns the validated page.
+     */
+    async list(options = {}) {
+        const query = new URLSearchParams({ purpose: 'user_data' });
+        if (options.after !== undefined)
+            query.set('after', options.after);
+        if (options.limit !== undefined)
+            query.set('limit', String(options.limit));
+        if (options.order !== undefined)
+            query.set('order', options.order);
+        const response = await this.request(`/files?${query.toString()}`, { method: 'GET' }, options.signal);
+        const value = await response.json();
+        if (value === null || typeof value !== 'object' || Array.isArray(value))
+            throw invalidResponse('list');
+        const wire = value;
+        if (wire.object !== 'list' || !Array.isArray(wire.data) || typeof wire.has_more !== 'boolean'
+            || (wire.first_id !== undefined && typeof wire.first_id !== 'string')
+            || (wire.last_id !== undefined && typeof wire.last_id !== 'string')) {
+            throw invalidResponse('list');
+        }
+        return {
+            data: wire.data.map(item => parseFileObject(item, 'list')),
+            ...typeof wire.first_id === 'string' ? { firstId: DeepSeekFileId(wire.first_id) } : {},
+            ...typeof wire.last_id === 'string' ? { lastId: DeepSeekFileId(wire.last_id) } : {},
+            hasMore: wire.has_more,
+        };
+    }
+    /**
+     * Retrieve one file object.
+     * @param fileId - provider file identifier.
+     * @param signal - request cancellation.
+     * @returns the validated file object.
+     */
+    async retrieve(fileId, signal) {
+        const response = await this.request(`/files/${encodeURIComponent(fileId)}`, { method: 'GET' }, signal);
+        return parseFileObject(await response.json(), 'retrieve');
+    }
+    /**
+     * Delete one provider file.
+     * @param fileId - provider file identifier.
+     * @param signal - request cancellation.
+     */
+    async delete(fileId, signal) {
+        const response = await this.request(`/files/${encodeURIComponent(fileId)}`, { method: 'DELETE' }, signal);
+        const value = await response.json();
+        if (value === null || typeof value !== 'object' || Array.isArray(value))
+            throw invalidResponse('delete');
+        const wire = value;
+        if (wire.id !== fileId || wire.object !== 'file' || wire.deleted !== true)
+            throw invalidResponse('delete');
+    }
+}
+//# sourceMappingURL=files-api.js.map