apify-client 3.0.0-beta.23 → 3.0.0-beta.25

package/dist/resource_clients/dataset.js

@@ -247,7 +247,7 @@ export class DatasetClient extends ResourceClient {
                 format,
                 ...query,
             }),
-            forceBuffer: true,
+            responseType: 'buffer',
             timeoutSecs,
         });
         return cast(data);
@@ -295,7 +295,7 @@ export class DatasetClient extends ResourceClient {
             },
             data: items,
             params: this.buildParams(),
-            doNotRetryTimeouts: true, // see timeoutSecs handling in http-client
+            doNotRetryTimeouts: true,
             timeoutSecs,
         });
     }
@@ -370,6 +370,7 @@ export class DatasetClient extends ResourceClient {
         return createdItemsPublicUrl.toString();
     }
     #createPaginationList(response, userProvidedDesc) {
+        const descHeader = response.headers['x-apify-pagination-desc'];
         const page = {
             items: response.data,
             total: Number(response.headers['x-apify-pagination-total']),
@@ -379,7 +380,7 @@ export class DatasetClient extends ResourceClient {
             count: response.data.length,
             limit: Number(response.headers['x-apify-pagination-limit']), // API returns 999999999999 when no limit is used
             // TODO: Replace this once https://github.com/apify/apify-core/issues/3503 is solved
-            desc: JSON.parse(response.headers['x-apify-pagination-desc'] ?? userProvidedDesc),
+            desc: typeof descHeader === 'string' ? JSON.parse(descHeader) : userProvidedDesc,
         };
         // The offset iterator paginates by the scanned number, so it travels with the page outside its public shape.
         return Object.defineProperty(page, SCANNED_COUNT, {

package/dist/resource_clients/key_value_store.d.ts

@@ -174,8 +174,14 @@ export declare class KeyValueStoreClient extends ResourceClient {
      */
     recordExists(key: string, options?: TimeoutOptions): Promise<boolean>;
     /**
+     * By default, the value is parsed by the record's content type: `application/json` is parsed into a value,
+     * `text/*` and `application/*xml` are decoded to a string, and anything else is returned as a Buffer (Node.js)
+     * or ArrayBuffer (browser). A record whose body does not parse as its content type claims, such as a non-JSON
+     * string stored under `application/json`, makes the call throw an {@link InvalidResponseBodyError}, which
+     * carries the raw body in `error.response`.
+     *
      * You can use the `buffer` option to get the value in a Buffer (Node.js)
-     * or ArrayBuffer (browser) format. In Node.js (not in browser) you can also
+     * or ArrayBuffer (browser) format, which skips the parsing. In Node.js (not in browser) you can also
      * use the `stream` option to get a Readable stream.
      *
      * When the record does not exist, the function resolves to `undefined`. It does
@@ -198,6 +204,9 @@ export declare class KeyValueStoreClient extends ResourceClient {
      * The content type is automatically determined based on the value type, but can be
      * overridden using the `contentType` property.
      *
+     * A string is sent as it is, even under `application/json`, so a string stored under a JSON content type has
+     * to be valid JSON already, or {@link getRecord} fails to parse it back.
+     *
      * **Note about streams:** If the value is a stream object (has `.pipe` and `.on` methods),
      * the upload cannot be retried on failure or follow redirects. For reliable uploads,
      * buffer the entire stream into memory first.

package/dist/resource_clients/key_value_store.js

@@ -328,7 +328,7 @@ export class KeyValueStoreClient extends ResourceClient {
             timeoutSecs: parsed.timeoutSecs ?? 'long',
         };
         if (parsed.buffer)
-            requestOpts.forceBuffer = true;
+            requestOpts.responseType = 'buffer';
         if (parsed.stream)
             requestOpts.responseType = 'stream';
         try {
@@ -351,6 +351,9 @@ export class KeyValueStoreClient extends ResourceClient {
      * The content type is automatically determined based on the value type, but can be
      * overridden using the `contentType` property.
      *
+     * A string is sent as it is, even under `application/json`, so a string stored under a JSON content type has
+     * to be valid JSON already, or {@link getRecord} fails to parse it back.
+     *
      * **Note about streams:** If the value is a stream object (has `.pipe` and `.on` methods),
      * the upload cannot be retried on failure or follow redirects. For reliable uploads,
      * buffer the entire stream into memory first.

package/dist/resource_clients/run.d.ts

@@ -2,7 +2,7 @@ import type { RUN_GENERAL_ACCESS } from '@apify/consts';
 import { Log } from '@apify/log';
 import type { ApiClientOptionsWithOptionalResourcePath } from '../base/api_client.js';
 import { ResourceClient } from '../base/resource_client.js';
-import type { ApifyResponse } from '../http_client.js';
+import type { ApifyResponse } from '../http_clients/index.js';
 import type { TimeoutOptions } from '../timeouts.js';
 import type { ActorInput, ActorRun } from './actor.js';
 import { DatasetClient } from './dataset.js';

package/dist/resource_clients/run.js

@@ -169,8 +169,7 @@ export class RunClient extends ResourceClient {
             method: 'POST',
             data: input,
             params: this.buildParams(params),
-            // Apify internal property. Tells the request serialization interceptor
-            // to stringify functions to JSON, instead of omitting them.
+            // Actor input may carry page functions, which plain JSON serialization would drop.
             stringifyFunctions: true,
             timeoutSecs: parsed.timeoutSecs ?? 'medium',
         };

package/dist/resource_clients/task.js

@@ -173,8 +173,7 @@ export class TaskClient extends ResourceClient {
             method: 'POST',
             data: input,
             params: this.buildParams(params),
-            // Apify internal property. Tells the request serialization interceptor
-            // to stringify functions to JSON, instead of omitting them.
+            // Actor input may carry page functions, which plain JSON serialization would drop.
             stringifyFunctions: true,
             headers: {
                 'Content-Type': 'application/json',

package/dist/utils.d.ts

@@ -3,7 +3,7 @@ import type { TypedArray } from 'type-fest';
 import { z } from 'zod';
 import type { ApifyApiError } from './apify_api_error.js';
 import { parseArgument } from '@apify/validations';
-import type { ApifyResponse } from './http_client.js';
+import type { ApifyResponse } from './http_clients/index.js';
 import type { RequestQueueClientListRequestsOptions, RequestQueueClientListRequestsResult } from './resource_clients/request_queue.js';
 import type { WebhookUpdateData } from './resource_clients/webhook.js';
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-client",
-  "version": "3.0.0-beta.23",
+  "version": "3.0.0-beta.25",
   "description": "Apify API client for JavaScript",
   "engines": {
     "node": ">=22.0.0"
@@ -69,7 +69,6 @@
     "@apify/validations": "^1.1.0",
     "@crawlee/types": "^3.18.1",
     "ansi-colors": "^4.1.3",
-    "async-retry": "^1.3.3",
     "axios": "^1.20.0",
     "content-type": "^1.0.5",
     "proxy-agent": "^8.0.2",
@@ -85,7 +84,6 @@
     "@rsbuild/plugin-node-polyfill": "^1.4.6",
     "@rspack/cli": "^2.2.2",
     "@rspack/core": "^2.2.2",
-    "@types/async-retry": "^1.4.9",
     "@types/compression": "^1.8.1",
     "@types/content-type": "^1.1.9",
     "@types/express": "^5.0.6",

package/dist/http_client.d.ts

@@ -1,62 +0,0 @@
-import type http from 'node:http';
-import type https from 'node:https';
-import type { AxiosInstance, AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
-import type { Log } from '@apify/log';
-import type { HttpCompressor } from './http_compressors/base.js';
-import type { RequestInterceptorFunction } from './interceptors.js';
-import type { Statistics } from './statistics.js';
-import type { Timeout, TimeoutTier } from './timeouts.js';
-export declare class HttpClient {
-    #private;
-    stats: Statistics;
-    maxRetries: number;
-    minDelayBetweenRetriesMillis: number;
-    userProvidedRequestInterceptors: RequestInterceptorFunction[];
-    /**
-     * Compressor applied to request bodies that are worth compressing. The request interceptor captures it at
-     * construction, so it is fixed for the lifetime of the client.
-     */
-    readonly httpCompressor: HttpCompressor;
-    logger: Log;
-    /** Duration of each timeout tier, in milliseconds. */
-    timeoutMillis: Record<TimeoutTier, number>;
-    /** Cap on the timeout of a single request attempt, in milliseconds. */
-    timeoutMaxMillis: number;
-    httpAgent?: http.Agent;
-    httpsAgent?: https.Agent;
-    axios: AxiosInstance;
-    workflowKey?: string;
-    constructor(options: HttpClientOptions);
-    call<T = any>(config: ApifyRequestConfig): Promise<ApifyResponse<T>>;
-}
-export interface ApifyRequestConfig extends Omit<AxiosRequestConfig, 'timeout'> {
-    stringifyFunctions?: boolean;
-    forceBuffer?: boolean;
-    doNotRetryTimeouts?: boolean;
-    /**
-     * Timeout of the request: a tier name, a number of seconds, or `'noTimeout'`. The client resolves it to
-     * the axios `timeout` in milliseconds for each attempt, before axios runs its interceptors, so a request
-     * interceptor already sees a number of milliseconds.
-     * @default 'medium'
-     */
-    timeoutSecs?: Timeout;
-}
-export interface ApifyResponse<T = any> extends AxiosResponse<T> {
-    config: ApifyRequestConfig & InternalAxiosRequestConfig;
-}
-export interface HttpClientOptions {
-    apifyClientStats: Statistics;
-    maxRetries: number;
-    minDelayBetweenRetriesMillis: number;
-    requestInterceptors: RequestInterceptorFunction[];
-    httpCompressor: HttpCompressor;
-    timeoutShortSecs: number;
-    timeoutMediumSecs: number;
-    timeoutLongSecs: number;
-    timeoutMaxSecs: number;
-    logger: Log;
-    token?: string;
-    workflowKey?: string;
-    /** @internal */
-    userAgentSuffix?: string | string[];
-}

package/dist/http_client.js

@@ -1,266 +0,0 @@
-import retry from 'async-retry';
-import axios, { AxiosHeaders } from 'axios';
-import { APIFY_ENV_VARS } from '@apify/consts';
-import { concatStreamToBuffer } from '@apify/utilities';
-import { ApifyApiError } from './apify_api_error.js';
-import { createRequestInterceptors, InvalidResponseBodyError, responseInterceptors } from './interceptors.js';
-import { runtime } from '#runtime';
-import { asArray, cast, getEnv, isStream, version } from './utils.js';
-const RATE_LIMIT_EXCEEDED_STATUS_CODE = 429;
-export class HttpClient {
-    stats;
-    maxRetries;
-    minDelayBetweenRetriesMillis;
-    userProvidedRequestInterceptors;
-    /**
-     * Compressor applied to request bodies that are worth compressing. The request interceptor captures it at
-     * construction, so it is fixed for the lifetime of the client.
-     */
-    httpCompressor;
-    logger;
-    /** Duration of each timeout tier, in milliseconds. */
-    timeoutMillis;
-    /** Cap on the timeout of a single request attempt, in milliseconds. */
-    timeoutMaxMillis;
-    httpAgent;
-    httpsAgent;
-    axios;
-    workflowKey;
-    #httpAgentsPromise;
-    constructor(options) {
-        const { token } = options;
-        this.stats = options.apifyClientStats;
-        this.maxRetries = options.maxRetries;
-        this.minDelayBetweenRetriesMillis = options.minDelayBetweenRetriesMillis;
-        this.userProvidedRequestInterceptors = options.requestInterceptors;
-        this.httpCompressor = options.httpCompressor;
-        this.timeoutMillis = {
-            short: options.timeoutShortSecs * 1000,
-            medium: options.timeoutMediumSecs * 1000,
-            long: options.timeoutLongSecs * 1000,
-        };
-        this.timeoutMaxMillis = options.timeoutMaxSecs * 1000;
-        this.logger = options.logger;
-        this.workflowKey = options.workflowKey || getEnv(APIFY_ENV_VARS.WORKFLOW_KEY);
-        this.axios = axios.create({
-            // Disable axios's built-in proxy handling since we're using custom agents
-            proxy: false,
-            paramsSerializer: (params) => {
-                const formattedParams = Object.entries(params)
-                    .filter(([, value]) => value !== undefined)
-                    .map(([key, value]) => {
-                    if (value instanceof Date) {
-                        return [key, value.toISOString()];
-                    }
-                    const updatedValue = typeof value === 'boolean' ? Number(value) : value;
-                    return [key, String(updatedValue)];
-                });
-                return new URLSearchParams(formattedParams).toString();
-            },
-            validateStatus: null,
-            // Interceptors serialize requests and parse responses instead. Empty arrays rather than `undefined`,
-            // which axios fills in with its default transforms.
-            transformRequest: [],
-            transformResponse: [],
-            responseType: 'arraybuffer',
-            // Every request sets its own timeout in `createRequestHandler`, so the default only backs a raw
-            // `axios.request()` call.
-            timeout: this.timeoutMaxMillis,
-            // maxBodyLength needs to be Infinity, because -1 falls back to a 10 MB default
-            // from an axios subdependency - 'follow-redirects'
-            maxBodyLength: Infinity,
-            // maxContentLength must be -1, because Infinity will cause axios to run super slow
-            // thanks to a bug that's now fixed, but not released yet https://github.com/axios/axios/pull/3738
-            maxContentLength: -1,
-        });
-        // Clean all default headers because they only make a mess and their merging is difficult to understand and buggy.
-        this.axios.defaults.headers = new AxiosHeaders();
-        // If workflow key is available, pass it as a header
-        if (this.workflowKey) {
-            this.axios.defaults.headers['X-Apify-Workflow-Key'] = this.workflowKey;
-        }
-        // Attach Authorization header for all requests if token was provided
-        if (token) {
-            this.axios.defaults.headers.Authorization = `Bearer ${token}`;
-        }
-        // Browsers do not let a page set the header, so it is only sent where the runtime describes its platform.
-        if (runtime.platform) {
-            const isAtHome = !!getEnv(APIFY_ENV_VARS.IS_AT_HOME);
-            let userAgent = `ApifyClient/${version} (${runtime.platform}); isAtHome/${isAtHome}`;
-            if (options.userAgentSuffix) {
-                userAgent += `; ${asArray(options.userAgentSuffix).join('; ')}`;
-            }
-            this.axios.defaults.headers['User-Agent'] = userAgent;
-        }
-        createRequestInterceptors(this.httpCompressor).forEach((i) => this.axios.interceptors.request.use(i));
-        this.userProvidedRequestInterceptors.forEach((i) => this.axios.interceptors.request.use(i));
-        responseInterceptors.forEach((i) => this.axios.interceptors.response.use(i));
-    }
-    async #ensureHttpAgents() {
-        this.#httpAgentsPromise ??= this.#initHttpAgents();
-        return this.#httpAgentsPromise;
-    }
-    async #initHttpAgents() {
-        const agents = await runtime.createHttpAgents({ timeoutMillis: this.timeoutMaxMillis });
-        if (!agents)
-            return;
-        this.httpAgent = agents.httpAgent;
-        this.httpsAgent = agents.httpsAgent;
-        this.axios.defaults.httpAgent = this.httpAgent;
-        this.axios.defaults.httpsAgent = this.httpsAgent;
-    }
-    async call(config) {
-        await this.#ensureHttpAgents();
-        this.stats.calls++;
-        const makeRequest = this.#createRequestHandler(config);
-        return retry(makeRequest, {
-            retries: this.maxRetries,
-            minTimeout: this.minDelayBetweenRetriesMillis,
-            onRetry: (error, attempt) => this.#onRequestRetry(error, attempt),
-        });
-    }
-    #informAboutStreamNoRetry() {
-        this.logger.warningOnce('Request body was a stream - retrying will not work, as part of it was already consumed.');
-        this.logger.warningOnce('If you want Apify client to handle retries for you, collect the stream into a buffer before sending it.');
-    }
-    /**
-     * Successful responses are returned, errors and unsuccessful
-     * status codes are retried. See the following functions for the
-     * retrying logic.
-     */
-    #createRequestHandler(config) {
-        const { timeoutSecs = 'medium', ...axiosConfig } = config;
-        const makeRequest = async (stopTrying, attempt) => {
-            this.stats.requests++;
-            let response;
-            const requestIsStream = isStream(config.data);
-            try {
-                if (requestIsStream) {
-                    // Handling redirects is not possible without buffering - part of the stream has already been sent and can't be recovered
-                    // when server sends the redirect. Therefore we need to override this in Axios config to prevent it from buffering the body.
-                    // see also axios/axios#1045
-                    axiosConfig.maxRedirects = 0;
-                }
-                response = await this.axios.request({
-                    ...axiosConfig,
-                    timeout: this.#computeTimeoutMillis(timeoutSecs, attempt),
-                });
-                if (this.#isStatusOk(response.status))
-                    return response;
-                // A failed request with `responseType: 'stream'` carries the API error body in the stream. Read
-                // it so that `ApifyApiError` can parse it like any other error body. A body that cannot be read
-                // leaves the error without a message, which beats losing the status code to a stream error.
-                if (isStream(response.data)) {
-                    response.data = await concatStreamToBuffer(response.data).catch(() => undefined);
-                }
-            }
-            catch (err) {
-                return cast(this.#handleRequestError(err, config, stopTrying));
-            }
-            if (response.status === RATE_LIMIT_EXCEEDED_STATUS_CODE) {
-                this.stats.addRateLimitError(attempt);
-            }
-            const apiError = ApifyApiError.fromResponse(response, attempt);
-            if (this.#isStatusCodeRetryable(response.status)) {
-                if (requestIsStream) {
-                    this.#informAboutStreamNoRetry();
-                }
-                else {
-                    // allow a retry
-                    throw apiError;
-                }
-            }
-            stopTrying(apiError);
-            return response;
-        };
-        return makeRequest;
-    }
-    #isStatusOk(statusCode) {
-        return statusCode < 300;
-    }
-    /**
-     * Resolves `timeoutSecs` to the number of milliseconds the given attempt gets. A tier name resolves to
-     * its configured duration, a number is taken as seconds, and `'noTimeout'` becomes `0`, which axios reads
-     * as no timeout. The result doubles with each attempt and is capped at `timeoutMaxMillis`. A requested
-     * value above the cap is capped too, which warns once, since it does not take effect in full.
-     */
-    #computeTimeoutMillis(timeoutSecs, attempt) {
-        if (timeoutSecs === 'noTimeout')
-            return 0;
-        const requestedMillis = typeof timeoutSecs === 'number' ? timeoutSecs * 1000 : this.timeoutMillis[timeoutSecs];
-        if (requestedMillis > this.timeoutMaxMillis) {
-            // `warningOnce` keys by message, so each requested value warns once.
-            this.logger.warningOnce(`The requested timeout of ${requestedMillis / 1000}s exceeds timeoutMaxSecs ` +
-                `(${this.timeoutMaxMillis / 1000}s) and is capped at it. ` +
-                'Raise timeoutMaxSecs on the client to allow longer request timeouts.');
-        }
-        return Math.min(requestedMillis * 2 ** (attempt - 1), this.timeoutMaxMillis);
-    }
-    /**
-     * Handles all unexpected errors that can happen, but are not
-     * Apify API typed errors. E.g. network errors, timeouts and so on.
-     */
-    #handleRequestError(err, config, stopTrying) {
-        if (this.#isTimeoutError(err) && config.doNotRetryTimeouts) {
-            return stopTrying(err);
-        }
-        if (this.#isRetryableError(err)) {
-            if (isStream(config.data)) {
-                this.#informAboutStreamNoRetry();
-            }
-            else {
-                throw err;
-            }
-        }
-        return stopTrying(err);
-    }
-    /**
-     * Axios calls req.abort() on timeouts so timeout errors will
-     * have a code ECONNABORTED.
-     */
-    #isTimeoutError(err) {
-        return err.code === 'ECONNABORTED';
-    }
-    /**
-     * We don't want to retry every exception thrown from Axios.
-     * The common denominator for retryable errors are network issues.
-     * @param {Error} err
-     * @private
-     */
-    #isRetryableError(err) {
-        return this.#isNetworkError(err) || this.#isResponseBodyInvalid(err);
-    }
-    /**
-     * When a network connection to our API is interrupted in the middle of streaming
-     * a response, the request often does not fail, but simply contains
-     * an incomplete response. This can often be fixed by retrying.
-     */
-    #isResponseBodyInvalid(err) {
-        return err instanceof InvalidResponseBodyError;
-    }
-    /**
-     * When a network request is attempted by axios and fails,
-     * it throws an AxiosError, which will have the request
-     * and config (and other) properties.
-     */
-    #isNetworkError(err) {
-        const hasRequest = err.request && typeof err.request === 'object';
-        const hasConfig = err.config && typeof err.config === 'object';
-        return hasRequest && hasConfig;
-    }
-    /**
-     * We retry 429 (rate limit) and 500+.
-     * For status codes 300-499 (except 429) we do not retry the request,
-     * because it's probably caused by invalid url (redirect 3xx) or invalid user input (4xx).
-     */
-    #isStatusCodeRetryable(statusCode) {
-        const isRateLimitError = statusCode === RATE_LIMIT_EXCEEDED_STATUS_CODE;
-        const isInternalError = statusCode >= 500;
-        return isRateLimitError || isInternalError;
-    }
-    #onRequestRetry(error, attempt) {
-        if (attempt === Math.round(this.maxRetries / 2)) {
-            this.logger.warning(`API request failed ${attempt} times. Max attempts: ${this.maxRetries + 1}.\nCause:${error.stack}`);
-        }
-    }
-}

package/dist/interceptors.d.ts

@@ -1,26 +0,0 @@
-import type { AxiosInterceptorManager, AxiosResponse } from 'axios';
-import type { ApifyRequestConfig, ApifyResponse } from './http_client.js';
-import type { HttpCompressor } from './http_compressors/base.js';
-/**
- * This error exists for the quite common situation, where only a partial JSON response is received and
- * an attempt to parse the JSON throws an error. In most cases this can be resolved by retrying the
- * request. We do that by identifying this error in HttpClient.
- *
- * The properties mimic AxiosError for easier integration in HttpClient error handling.
- */
-export declare class InvalidResponseBodyError extends Error {
-    code: string;
-    response: AxiosResponse;
-    cause: Error;
-    constructor(response: AxiosResponse, cause: Error);
-}
-export type RequestInterceptorFunction = Parameters<AxiosInterceptorManager<ApifyRequestConfig>['use']>[0];
-export type ResponseInterceptorFunction = Parameters<AxiosInterceptorManager<ApifyResponse>['use']>[0];
-/**
- * The client's own request interceptors, in registration order. Axios runs request interceptors in the reverse
- * order of registration, so the body is serialized before it is compressed, and interceptors registered later,
- * such as the user-provided ones, run before both.
- * @internal
- */
-export declare function createRequestInterceptors(compressor: HttpCompressor): RequestInterceptorFunction[];
-export declare const responseInterceptors: ResponseInterceptorFunction[];

package/dist/interceptors.js

@@ -1,153 +0,0 @@
-import axios, { AxiosHeaders } from 'axios';
-import contentTypeParser from 'content-type';
-import { maybeParseBody } from './body_parser.js';
-import { runtime } from '#runtime';
-import { isCompressibleContentType, MIN_COMPRESS_BYTES, toBytes } from './utils.js';
-/**
- * This error exists for the quite common situation, where only a partial JSON response is received and
- * an attempt to parse the JSON throws an error. In most cases this can be resolved by retrying the
- * request. We do that by identifying this error in HttpClient.
- *
- * The properties mimic AxiosError for easier integration in HttpClient error handling.
- */
-export class InvalidResponseBodyError extends Error {
-    code;
-    response;
-    constructor(response, cause) {
-        super(`Response body could not be parsed.\nCause:${cause.message}`);
-        this.name = this.constructor.name;
-        this.code = 'invalid-response-body';
-        this.response = response;
-        this.cause = cause;
-    }
-}
-/**
- * Reads a request header regardless of the casing it was set with, since HTTP header names are case-insensitive
- * while the config keeps whatever casing the caller used.
- */
-function getHeader(config, name) {
-    const wanted = name.toLowerCase();
-    const key = Object.keys(config.headers ?? {}).find((candidate) => candidate.toLowerCase() === wanted);
-    const value = key === undefined ? undefined : config.headers?.[key];
-    return typeof value === 'string' ? value : undefined;
-}
-/** Removes a request header regardless of the casing it was set with. */
-function deleteHeader(config, name) {
-    const { headers } = config;
-    if (!headers)
-        return;
-    const wanted = name.toLowerCase();
-    for (const key of Object.keys(headers)) {
-        if (key.toLowerCase() === wanted)
-            delete headers[key];
-    }
-}
-function serializeRequest(config) {
-    // A string body with an explicit content type is already serialized and goes out as it is. The axios default
-    // transform would otherwise parse a JSON one in full just to check that it is valid, which for a body assembled
-    // from thousands of pre-serialized requests costs about as much as serializing them did.
-    if (typeof config.data === 'string' && getHeader(config, 'content-type'))
-        return config;
-    const [defaultTransform] = axios.defaults.transformRequest;
-    // The function not only serializes data, but it also adds correct headers.
-    const data = defaultTransform(config.data, config.headers);
-    // Actor inputs can include functions and we don't want to omit those,
-    // because it's convenient for users. JSON.stringify removes them.
-    // It's a bit inefficient that we serialize the JSON twice, but I feel
-    // it's a small price to pay. The axios default transform does a lot
-    // of body type checks and we would have to copy all of them to the resource clients.
-    if (config.stringifyFunctions) {
-        const contentTypeHeader = getHeader(config, 'content-type');
-        try {
-            const type = contentTypeHeader ? contentTypeParser.parse(contentTypeHeader).type : undefined;
-            if (type === 'application/json' && typeof config.data === 'object') {
-                config.data = stringifyWithFunctions(config.data);
-            }
-            else {
-                config.data = data;
-            }
-        }
-        catch {
-            config.data = data;
-        }
-    }
-    else {
-        config.data = data;
-    }
-    return config;
-}
-function ensureHeadersPrototype(config) {
-    if (config.headers && !(config.headers instanceof AxiosHeaders)) {
-        Object.setPrototypeOf(config.headers, AxiosHeaders.prototype);
-    }
-    return config;
-}
-/**
- * JSON.stringify() that serializes functions to string instead
- * of replacing them with null or removing them.
- */
-function stringifyWithFunctions(obj) {
-    return JSON.stringify(obj, (_key, value) => {
-        return typeof value === 'function' ? value.toString() : value;
-    });
-}
-/**
- * Compresses the request body with the client's compressor and labels it with the compressor's `Content-Encoding`.
- *
- * Runs after `serializeRequest`, so a JSON body is already a string here. A caller-set `Content-Encoding` is
- * forwarded verbatim, which is how a pre-encoded body is uploaded, and `Content-Encoding: identity` opts a single
- * request out of compression. The built-in compressors need `node:zlib`, so a body sent from a browser or an edge
- * runtime goes out as it is.
- *
- * Compressing changes the body length, so any `Content-Length` the caller set describes the wrong body and has to
- * go. Axios keeps a caller-set one over the size it computes, which would stall the request until it times out.
- */
-async function maybeCompressRequest(config, compressor) {
-    if (!runtime.isNode)
-        return config;
-    const bytes = toBytes(config.data);
-    if (!bytes || bytes.byteLength < MIN_COMPRESS_BYTES)
-        return config;
-    // A caller-supplied encoding means the body is already encoded and the header describes it, so leave both alone.
-    if (getHeader(config, 'content-encoding'))
-        return config;
-    if (!isCompressibleContentType(getHeader(config, 'content-type')))
-        return config;
-    config.data = await compressor.compress(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
-    config.headers ??= {};
-    config.headers['content-encoding'] = compressor.contentEncoding;
-    deleteHeader(config, 'content-length');
-    return config;
-}
-function parseResponseData(response) {
-    if (!response.data || // Nothing to do here.
-        response.config.responseType !== 'arraybuffer' || // We don't want to parse custom response types.
-        response.config.forceBuffer // Apify custom property to prevent parsing of buffer.
-    ) {
-        return response;
-    }
-    // A `Buffer` from the Node.js adapter and an `ArrayBuffer` from the browser ones both carry `byteLength`.
-    if (!response.data.byteLength) {
-        // undefined is better than an empty buffer
-        response.data = undefined;
-        return response;
-    }
-    const contentTypeHeader = response.headers['content-type'];
-    try {
-        response.data = maybeParseBody(response.data, contentTypeHeader);
-    }
-    catch (err) {
-        throw new InvalidResponseBodyError(response, err);
-    }
-    return response;
-}
-/**
- * The client's own request interceptors, in registration order. Axios runs request interceptors in the reverse
- * order of registration, so the body is serialized before it is compressed, and interceptors registered later,
- * such as the user-provided ones, run before both.
- * @internal
- */
-export function createRequestInterceptors(compressor) {
-    return [async (config) => maybeCompressRequest(config, compressor), serializeRequest, ensureHeadersPrototype];
-}
-export const responseInterceptors = [parseResponseData];