@elevenlabs/elevenlabs-js 2.24.0 → 2.25.0

package/dist/core/exports.d.ts

@@ -1 +1,2 @@
 export * from "./file/exports";
+export * from "./logging/exports";

package/dist/core/exports.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./file/exports"), exports);
+__exportStar(require("./logging/exports"), exports);

package/dist/core/fetcher/APIResponse.d.ts

@@ -1,4 +1,4 @@
-import { RawResponse } from "./RawResponse";
+import type { RawResponse } from "./RawResponse";
 /**
  * The response of an API call.
  * It is a successful response or a failed response.

package/dist/core/fetcher/BinaryResponse.d.ts

@@ -1,4 +1,4 @@
-import { ResponseWithBody } from "./ResponseWithBody.js";
+import type { ResponseWithBody } from "./ResponseWithBody";
 export type BinaryResponse = {
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bodyUsed) */
     bodyUsed: boolean;

package/dist/core/fetcher/EndpointSupplier.d.ts

@@ -1,5 +1,5 @@
-import { EndpointMetadata } from "./EndpointMetadata";
-import { Supplier } from "./Supplier";
+import type { EndpointMetadata } from "./EndpointMetadata";
+import type { Supplier } from "./Supplier";
 type EndpointSupplierFn<T> = (arg: {
     endpointMetadata: EndpointMetadata;
 }) => T | Promise<T>;

package/dist/core/fetcher/Fetcher.d.ts

@@ -1,5 +1,6 @@
-import { APIResponse } from "./APIResponse";
-import { EndpointMetadata } from "./EndpointMetadata";
+import { type LogConfig, type Logger } from "../logging/logger";
+import type { APIResponse } from "./APIResponse";
+import type { EndpointMetadata } from "./EndpointMetadata";
 import { EndpointSupplier } from "./EndpointSupplier";
 export type FetchFunction = <R = unknown>(args: Fetcher.Args) => Promise<APIResponse<R, Fetcher.Error>>;
 export declare namespace Fetcher {
@@ -14,10 +15,12 @@ export declare namespace Fetcher {
         maxRetries?: number;
         withCredentials?: boolean;
         abortSignal?: AbortSignal;
-        requestType?: "json" | "file" | "bytes";
+        requestType?: "json" | "file" | "bytes" | "form" | "other";
         responseType?: "json" | "blob" | "sse" | "streaming" | "text" | "arrayBuffer" | "binary-response";
         duplex?: "half";
         endpointMetadata?: EndpointMetadata;
+        fetchFn?: typeof fetch;
+        logging?: LogConfig | Logger;
     }
     type Error = FailedStatusCodeError | NonJsonError | TimeoutError | UnknownError;
     interface FailedStatusCodeError {

package/dist/core/fetcher/Fetcher.js

@@ -12,21 +12,153 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetcher = void 0;
 exports.fetcherImpl = fetcherImpl;
 const json_1 = require("../json");
+const logger_1 = require("../logging/logger");
 const createRequestUrl_1 = require("./createRequestUrl");
 const EndpointSupplier_1 = require("./EndpointSupplier");
 const getErrorResponseBody_1 = require("./getErrorResponseBody");
 const getFetchFn_1 = require("./getFetchFn");
 const getRequestBody_1 = require("./getRequestBody");
 const getResponseBody_1 = require("./getResponseBody");
+const Headers_1 = require("./Headers");
 const makeRequest_1 = require("./makeRequest");
 const RawResponse_1 = require("./RawResponse");
 const requestWithRetries_1 = require("./requestWithRetries");
+const SENSITIVE_HEADERS = new Set([
+    "authorization",
+    "www-authenticate",
+    "x-api-key",
+    "api-key",
+    "apikey",
+    "x-api-token",
+    "x-auth-token",
+    "auth-token",
+    "cookie",
+    "set-cookie",
+    "proxy-authorization",
+    "proxy-authenticate",
+    "x-csrf-token",
+    "x-xsrf-token",
+    "x-session-token",
+    "x-access-token",
+]);
+function redactHeaders(headers) {
+    const filtered = {};
+    for (const [key, value] of headers instanceof Headers_1.Headers ? headers.entries() : Object.entries(headers)) {
+        if (SENSITIVE_HEADERS.has(key.toLowerCase())) {
+            filtered[key] = "[REDACTED]";
+        }
+        else {
+            filtered[key] = value;
+        }
+    }
+    return filtered;
+}
+const SENSITIVE_QUERY_PARAMS = new Set([
+    "api_key",
+    "api-key",
+    "apikey",
+    "token",
+    "access_token",
+    "access-token",
+    "auth_token",
+    "auth-token",
+    "password",
+    "passwd",
+    "secret",
+    "api_secret",
+    "api-secret",
+    "apisecret",
+    "key",
+    "session",
+    "session_id",
+    "session-id",
+]);
+function redactQueryParameters(queryParameters) {
+    if (queryParameters == null) {
+        return queryParameters;
+    }
+    const redacted = {};
+    for (const [key, value] of Object.entries(queryParameters)) {
+        if (SENSITIVE_QUERY_PARAMS.has(key.toLowerCase())) {
+            redacted[key] = "[REDACTED]";
+        }
+        else {
+            redacted[key] = value;
+        }
+    }
+    return redacted;
+}
+function redactUrl(url) {
+    const protocolIndex = url.indexOf("://");
+    if (protocolIndex === -1)
+        return url;
+    const afterProtocol = protocolIndex + 3;
+    // Find the first delimiter that marks the end of the authority section
+    const pathStart = url.indexOf("/", afterProtocol);
+    let queryStart = url.indexOf("?", afterProtocol);
+    let fragmentStart = url.indexOf("#", afterProtocol);
+    const firstDelimiter = Math.min(pathStart === -1 ? url.length : pathStart, queryStart === -1 ? url.length : queryStart, fragmentStart === -1 ? url.length : fragmentStart);
+    // Find the LAST @ before the delimiter (handles multiple @ in credentials)
+    let atIndex = -1;
+    for (let i = afterProtocol; i < firstDelimiter; i++) {
+        if (url[i] === "@") {
+            atIndex = i;
+        }
+    }
+    if (atIndex !== -1) {
+        url = `${url.slice(0, afterProtocol)}[REDACTED]@${url.slice(atIndex + 1)}`;
+    }
+    // Recalculate queryStart since url might have changed
+    queryStart = url.indexOf("?");
+    if (queryStart === -1)
+        return url;
+    fragmentStart = url.indexOf("#", queryStart);
+    const queryEnd = fragmentStart !== -1 ? fragmentStart : url.length;
+    const queryString = url.slice(queryStart + 1, queryEnd);
+    if (queryString.length === 0)
+        return url;
+    // FAST PATH: Quick check if any sensitive keywords present
+    // Using indexOf is faster than regex for simple substring matching
+    const lower = queryString.toLowerCase();
+    const hasSensitive = lower.includes("token") ||
+        lower.includes("key") ||
+        lower.includes("password") ||
+        lower.includes("passwd") ||
+        lower.includes("secret") ||
+        lower.includes("session") ||
+        lower.includes("auth");
+    if (!hasSensitive) {
+        return url;
+    }
+    // SLOW PATH: Parse and redact
+    const redactedParams = [];
+    const params = queryString.split("&");
+    for (const param of params) {
+        const equalIndex = param.indexOf("=");
+        if (equalIndex === -1) {
+            redactedParams.push(param);
+            continue;
+        }
+        const key = param.slice(0, equalIndex);
+        let shouldRedact = SENSITIVE_QUERY_PARAMS.has(key.toLowerCase());
+        if (!shouldRedact && key.includes("%")) {
+            try {
+                const decodedKey = decodeURIComponent(key);
+                shouldRedact = SENSITIVE_QUERY_PARAMS.has(decodedKey.toLowerCase());
+            }
+            catch (_a) { }
+        }
+        redactedParams.push(shouldRedact ? `${key}=[REDACTED]` : param);
+    }
+    return url.slice(0, queryStart + 1) + redactedParams.join("&") + url.slice(queryEnd);
+}
 function getHeaders(args) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
-        const newHeaders = {};
+        const newHeaders = new Headers_1.Headers();
+        newHeaders.set("Accept", args.responseType === "json" ? "application/json" : args.responseType === "text" ? "text/plain" : "*/*");
         if (args.body !== undefined && args.contentType != null) {
-            newHeaders["Content-Type"] = args.contentType;
+            newHeaders.set("Content-Type", args.contentType);
         }
         if (args.headers == null) {
             return newHeaders;
@@ -34,30 +166,52 @@ function getHeaders(args) {
         for (const [key, value] of Object.entries(args.headers)) {
             const result = yield EndpointSupplier_1.EndpointSupplier.get(value, { endpointMetadata: (_a = args.endpointMetadata) !== null && _a !== void 0 ? _a : {} });
             if (typeof result === "string") {
-                newHeaders[key] = result;
+                newHeaders.set(key, result);
                 continue;
             }
             if (result == null) {
                 continue;
             }
-            newHeaders[key] = `${result}`;
+            newHeaders.set(key, `${result}`);
         }
         return newHeaders;
     });
 }
 function fetcherImpl(args) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
         const url = (0, createRequestUrl_1.createRequestUrl)(args.url, args.queryParameters);
         const requestBody = yield (0, getRequestBody_1.getRequestBody)({
             body: args.body,
-            type: args.requestType === "json" ? "json" : "other",
+            type: (_a = args.requestType) !== null && _a !== void 0 ? _a : "other",
         });
-        const fetchFn = yield (0, getFetchFn_1.getFetchFn)();
+        const fetchFn = (_b = args.fetchFn) !== null && _b !== void 0 ? _b : (yield (0, getFetchFn_1.getFetchFn)());
+        const headers = yield getHeaders(args);
+        const logger = (0, logger_1.createLogger)(args.logging);
+        if (logger.isDebug()) {
+            const metadata = {
+                method: args.method,
+                url: redactUrl(url),
+                headers: redactHeaders(headers),
+                queryParameters: redactQueryParameters(args.queryParameters),
+                hasBody: requestBody != null,
+            };
+            logger.debug("Making HTTP request", metadata);
+        }
         try {
             const response = yield (0, requestWithRetries_1.requestWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
-                return (0, makeRequest_1.makeRequest)(fetchFn, url, args.method, yield getHeaders(args), requestBody, args.timeoutMs, args.abortSignal, args.withCredentials, args.duplex);
+                return (0, makeRequest_1.makeRequest)(fetchFn, url, args.method, headers, requestBody, args.timeoutMs, args.abortSignal, args.withCredentials, args.duplex);
             }), args.maxRetries);
             if (response.status >= 200 && response.status < 400) {
+                if (logger.isDebug()) {
+                    const metadata = {
+                        method: args.method,
+                        url: redactUrl(url),
+                        statusCode: response.status,
+                        responseHeaders: redactHeaders(response.headers),
+                    };
+                    logger.debug("HTTP request succeeded", metadata);
+                }
                 return {
                     ok: true,
                     body: (yield (0, getResponseBody_1.getResponseBody)(response, args.responseType)),
@@ -66,6 +220,15 @@ function fetcherImpl(args) {
                 };
             }
             else {
+                if (logger.isError()) {
+                    const metadata = {
+                        method: args.method,
+                        url: redactUrl(url),
+                        statusCode: response.status,
+                        responseHeaders: redactHeaders(Object.fromEntries(response.headers.entries())),
+                    };
+                    logger.error("HTTP request failed with error status", metadata);
+                }
                 return {
                     ok: false,
                     error: {
@@ -78,7 +241,14 @@ function fetcherImpl(args) {
             }
         }
         catch (error) {
-            if (args.abortSignal != null && args.abortSignal.aborted) {
+            if ((_c = args.abortSignal) === null || _c === void 0 ? void 0 : _c.aborted) {
+                if (logger.isError()) {
+                    const metadata = {
+                        method: args.method,
+                        url: redactUrl(url),
+                    };
+                    logger.error("HTTP request was aborted", metadata);
+                }
                 return {
                     ok: false,
                     error: {
@@ -89,6 +259,14 @@ function fetcherImpl(args) {
                 };
             }
             else if (error instanceof Error && error.name === "AbortError") {
+                if (logger.isError()) {
+                    const metadata = {
+                        method: args.method,
+                        url: redactUrl(url),
+                        timeoutMs: args.timeoutMs,
+                    };
+                    logger.error("HTTP request timed out", metadata);
+                }
                 return {
                     ok: false,
                     error: {
@@ -98,6 +276,14 @@ function fetcherImpl(args) {
                 };
             }
             else if (error instanceof Error) {
+                if (logger.isError()) {
+                    const metadata = {
+                        method: args.method,
+                        url: redactUrl(url),
+                        errorMessage: error.message,
+                    };
+                    logger.error("HTTP request failed with error", metadata);
+                }
                 return {
                     ok: false,
                     error: {
@@ -107,6 +293,14 @@ function fetcherImpl(args) {
                     rawResponse: RawResponse_1.unknownRawResponse,
                 };
             }
+            if (logger.isError()) {
+                const metadata = {
+                    method: args.method,
+                    url: redactUrl(url),
+                    error: (0, json_1.toJson)(error),
+                };
+                logger.error("HTTP request failed with unknown error", metadata);
+            }
             return {
                 ok: false,
                 error: {

package/dist/core/fetcher/HttpResponsePromise.d.ts

@@ -1,4 +1,4 @@
-import { WithRawResponse } from "./RawResponse";
+import type { WithRawResponse } from "./RawResponse";
 /**
  * A promise that returns the parsed response and lets you retrieve the raw response too.
  */

package/dist/core/fetcher/getErrorResponseBody.js

@@ -28,9 +28,10 @@ function getErrorResponseBody(response) {
             case "application/ld+json":
             case "application/problem+json":
             case "application/vnd.api+json":
-            case "text/json":
+            case "text/json": {
                 const text = yield response.text();
                 return text.length > 0 ? (0, json_1.fromJson)(text) : undefined;
+            }
             default:
                 if (contentType.startsWith("application/vnd.") && contentType.endsWith("+json")) {
                     const text = yield response.text();

package/dist/core/fetcher/getFetchFn.js

@@ -59,7 +59,7 @@ function getFetchFn() {
         }
         // Otherwise the SDK uses global fetch if available,
         // and falls back to node-fetch.
-        if (typeof fetch == "function") {
+        if (typeof fetch === "function") {
             return fetch;
         }
         // Defaults to node `node-fetch` if global fetch isn't available

package/dist/core/fetcher/getRequestBody.d.ts

@@ -1,7 +1,7 @@
 export declare namespace GetRequestBody {
     interface Args {
         body: unknown;
-        type: "json" | "file" | "bytes" | "other";
+        type: "json" | "file" | "bytes" | "form" | "other";
     }
 }
 export declare function getRequestBody({ body, type }: GetRequestBody.Args): Promise<BodyInit | undefined>;

package/dist/core/fetcher/getRequestBody.js

@@ -11,8 +11,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRequestBody = getRequestBody;
 const json_1 = require("../json");
+const qs_1 = require("../url/qs");
 function getRequestBody(_a) {
     return __awaiter(this, arguments, void 0, function* ({ body, type }) {
+        if (type === "form") {
+            return (0, qs_1.toQueryString)(body, { arrayFormat: "repeat", encode: true });
+        }
         if (type.includes("json")) {
             return (0, json_1.toJson)(body);
         }

package/dist/core/fetcher/getResponseBody.js

@@ -10,9 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getResponseBody = getResponseBody;
+const json_1 = require("../json");
 const BinaryResponse_1 = require("./BinaryResponse");
 const ResponseWithBody_1 = require("./ResponseWithBody");
-const json_1 = require("../json");
 function getResponseBody(response, responseType) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!(0, ResponseWithBody_1.isResponseWithBody)(response)) {
@@ -36,10 +36,10 @@ function getResponseBody(response, responseType) {
         const text = yield response.text();
         if (text.length > 0) {
             try {
-                let responseBody = (0, json_1.fromJson)(text);
+                const responseBody = (0, json_1.fromJson)(text);
                 return responseBody;
             }
-            catch (err) {
+            catch (_err) {
                 return {
                     ok: false,
                     error: {

package/dist/core/fetcher/makeRequest.d.ts

@@ -1 +1 @@
-export declare const makeRequest: (fetchFn: (url: string, init: RequestInit) => Promise<Response>, url: string, method: string, headers: Record<string, string>, requestBody: BodyInit | undefined, timeoutMs?: number, abortSignal?: AbortSignal, withCredentials?: boolean, duplex?: "half") => Promise<Response>;
+export declare const makeRequest: (fetchFn: (url: string, init: RequestInit) => Promise<Response>, url: string, method: string, headers: Headers | Record<string, string>, requestBody: BodyInit | undefined, timeoutMs?: number, abortSignal?: AbortSignal, withCredentials?: boolean, duplex?: "half") => Promise<Response>;

package/dist/core/fetcher/makeRequest.js

@@ -13,18 +13,16 @@ exports.makeRequest = void 0;
 const signals_1 = require("./signals");
 const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex) => __awaiter(void 0, void 0, void 0, function* () {
     const signals = [];
-    // Add timeout signal
-    let timeoutAbortId = undefined;
+    let timeoutAbortId;
     if (timeoutMs != null) {
         const { signal, abortId } = (0, signals_1.getTimeoutSignal)(timeoutMs);
         timeoutAbortId = abortId;
         signals.push(signal);
     }
-    // Add arbitrary signal
     if (abortSignal != null) {
         signals.push(abortSignal);
     }
-    let newSignals = (0, signals_1.anySignal)(signals);
+    const newSignals = (0, signals_1.anySignal)(signals);
     const response = yield fetchFn(url, {
         method: method,
         headers,

package/dist/core/fetcher/requestWithRetries.js

@@ -15,46 +15,38 @@ const MAX_RETRY_DELAY = 60000; // in milliseconds
 const DEFAULT_MAX_RETRIES = 2;
 const JITTER_FACTOR = 0.2; // 20% random jitter
 function addPositiveJitter(delay) {
-    // Generate a random value between 0 and +JITTER_FACTOR
     const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR;
     return delay * jitterMultiplier;
 }
 function addSymmetricJitter(delay) {
-    // Generate a random value in a JITTER_FACTOR-sized percentage range around delay
     const jitterMultiplier = 1 + (Math.random() - 0.5) * JITTER_FACTOR;
     return delay * jitterMultiplier;
 }
 function getRetryDelayFromHeaders(response, retryAttempt) {
-    // Check for Retry-After header first (RFC 7231), with no jitter
     const retryAfter = response.headers.get("Retry-After");
     if (retryAfter) {
-        // Parse as number of seconds...
         const retryAfterSeconds = parseInt(retryAfter, 10);
-        if (!isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
+        if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
             return Math.min(retryAfterSeconds * 1000, MAX_RETRY_DELAY);
         }
-        // ...or as an HTTP date; both are valid
         const retryAfterDate = new Date(retryAfter);
-        if (!isNaN(retryAfterDate.getTime())) {
+        if (!Number.isNaN(retryAfterDate.getTime())) {
             const delay = retryAfterDate.getTime() - Date.now();
             if (delay > 0) {
                 return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY);
             }
         }
     }
-    // Then check for industry-standard X-RateLimit-Reset header, with positive jitter
     const rateLimitReset = response.headers.get("X-RateLimit-Reset");
     if (rateLimitReset) {
         const resetTime = parseInt(rateLimitReset, 10);
-        if (!isNaN(resetTime)) {
-            // Assume Unix timestamp in epoch seconds
+        if (!Number.isNaN(resetTime)) {
             const delay = resetTime * 1000 - Date.now();
             if (delay > 0) {
                 return addPositiveJitter(Math.min(delay, MAX_RETRY_DELAY));
             }
         }
     }
-    // Fall back to exponential backoff, with symmetric jitter
     return addSymmetricJitter(Math.min(INITIAL_RETRY_DELAY * Math.pow(2, retryAttempt), MAX_RETRY_DELAY));
 }
 function requestWithRetries(requestFn_1) {
@@ -62,7 +54,6 @@ function requestWithRetries(requestFn_1) {
         let response = yield requestFn();
         for (let i = 0; i < maxRetries; ++i) {
             if ([408, 429].includes(response.status) || response.status >= 500) {
-                // Get delay with appropriate jitter applied
                 const delay = getRetryDelayFromHeaders(response, i);
                 yield new Promise((resolve) => setTimeout(resolve, delay));
                 response = yield requestFn();

package/dist/core/fetcher/signals.d.ts

@@ -2,10 +2,4 @@ export declare function getTimeoutSignal(timeoutMs: number): {
     signal: AbortSignal;
     abortId: NodeJS.Timeout;
 };
-/**
- * Returns an abort signal that is getting aborted when
- * at least one of the specified abort signals is aborted.
- *
- * Requires at least node.js 18.
- */
 export declare function anySignal(...args: AbortSignal[] | [AbortSignal[]]): AbortSignal;

package/dist/core/fetcher/signals.js

@@ -8,26 +8,14 @@ function getTimeoutSignal(timeoutMs) {
     const abortId = setTimeout(() => controller.abort(TIMEOUT), timeoutMs);
     return { signal: controller.signal, abortId };
 }
-/**
- * Returns an abort signal that is getting aborted when
- * at least one of the specified abort signals is aborted.
- *
- * Requires at least node.js 18.
- */
 function anySignal(...args) {
-    // Allowing signals to be passed either as array
-    // of signals or as multiple arguments.
     const signals = (args.length === 1 && Array.isArray(args[0]) ? args[0] : args);
     const controller = new AbortController();
     for (const signal of signals) {
         if (signal.aborted) {
-            // Exiting early if one of the signals
-            // is already aborted.
             controller.abort(signal === null || signal === void 0 ? void 0 : signal.reason);
             break;
         }
-        // Listening for signals and removing the listeners
-        // when at least one symbol is aborted.
         signal.addEventListener("abort", () => controller.abort(signal === null || signal === void 0 ? void 0 : signal.reason), {
             signal: controller.signal,
         });

package/dist/core/file/file.d.ts

@@ -1,5 +1,10 @@
-import { Uploadable } from "./types";
+import type { Uploadable } from "./types";
 export declare function toBinaryUploadRequest(file: Uploadable): Promise<{
     body: Uploadable.FileLike;
     headers?: Record<string, string>;
 }>;
+export declare function toMultipartDataPart(file: Uploadable): Promise<{
+    data: Uploadable.FileLike;
+    filename?: string;
+    contentType?: string;
+}>;

package/dist/core/file/file.js

@@ -43,6 +43,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toBinaryUploadRequest = toBinaryUploadRequest;
+exports.toMultipartDataPart = toMultipartDataPart;
 function toBinaryUploadRequest(file) {
     return __awaiter(this, void 0, void 0, function* () {
         const { data, filename, contentLength, contentType } = yield getFileWithMetadata(file);
@@ -62,13 +63,25 @@ function toBinaryUploadRequest(file) {
         return request;
     });
 }
-function getFileWithMetadata(file) {
+function toMultipartDataPart(file) {
     return __awaiter(this, void 0, void 0, function* () {
+        const { data, filename, contentType } = yield getFileWithMetadata(file, {
+            noSniffFileSize: true,
+        });
+        return {
+            data,
+            filename,
+            contentType,
+        };
+    });
+}
+function getFileWithMetadata(file_1) {
+    return __awaiter(this, arguments, void 0, function* (file, { noSniffFileSize } = {}) {
         var _a, _b, _c, _d, _e;
         if (isFileLike(file)) {
             return getFileWithMetadata({
                 data: file,
-            });
+            }, { noSniffFileSize });
         }
         if ("path" in file) {
             const fs = yield Promise.resolve().then(() => __importStar(require("fs")));
@@ -76,7 +89,7 @@ function getFileWithMetadata(file) {
                 throw new Error("File path uploads are not supported in this environment.");
             }
             const data = fs.createReadStream(file.path);
-            const contentLength = (_a = file.contentLength) !== null && _a !== void 0 ? _a : (yield tryGetFileSizeFromPath(file.path));
+            const contentLength = (_a = file.contentLength) !== null && _a !== void 0 ? _a : (noSniffFileSize === true ? undefined : yield tryGetFileSizeFromPath(file.path));
             const filename = (_b = file.filename) !== null && _b !== void 0 ? _b : getNameFromPath(file.path);
             return {
                 data,
@@ -87,7 +100,9 @@ function getFileWithMetadata(file) {
         }
         if ("data" in file) {
             const data = file.data;
-            const contentLength = (_c = file.contentLength) !== null && _c !== void 0 ? _c : (yield tryGetContentLengthFromFileLike(data));
+            const contentLength = (_c = file.contentLength) !== null && _c !== void 0 ? _c : (yield tryGetContentLengthFromFileLike(data, {
+                noSniffFileSize,
+            }));
             const filename = (_d = file.filename) !== null && _d !== void 0 ? _d : tryGetNameFromFileLike(data);
             return {
                 data,
@@ -119,7 +134,7 @@ function tryGetFileSizeFromPath(path) {
             const fileStat = yield fs.promises.stat(path);
             return fileStat.size;
         }
-        catch (fallbackError) {
+        catch (_fallbackError) {
             return undefined;
         }
     });
@@ -133,8 +148,8 @@ function tryGetNameFromFileLike(data) {
     }
     return undefined;
 }
-function tryGetContentLengthFromFileLike(data) {
-    return __awaiter(this, void 0, void 0, function* () {
+function tryGetContentLengthFromFileLike(data_1) {
+    return __awaiter(this, arguments, void 0, function* (data, { noSniffFileSize } = {}) {
         if (isBuffer(data)) {
             return data.length;
         }
@@ -150,6 +165,9 @@ function tryGetContentLengthFromFileLike(data) {
         if (isFile(data)) {
             return data.size;
         }
+        if (noSniffFileSize === true) {
+            return undefined;
+        }
         if (isPathedValue(data)) {
             return yield tryGetFileSizeFromPath(data.path.toString());
         }

package/dist/core/form-data-utils/FormDataWrapper.d.ts

@@ -1,3 +1,4 @@
+import { type Uploadable } from "../../core/file/index";
 interface FormDataRequest<Body> {
     body: Body;
     headers: Record<string, string>;
@@ -8,9 +9,7 @@ export declare class FormDataWrapper {
     private fd;
     setup(): Promise<void>;
     append(key: string, value: unknown): void;
-    private getFileName;
-    private convertToBlob;
-    appendFile(key: string, value: unknown, fileName?: string): Promise<void>;
+    appendFile(key: string, value: Uploadable): Promise<void>;
     getRequest(): FormDataRequest<FormData>;
 }
 export {};