* **keepAliveTimeout** `number | null` (optional) - Default: `4e3` - The timeout after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. See [MDN: HTTP - Headers - Keep-Alive directives](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Keep-Alive#directives) for more details. Defaults to 4 seconds.

* **keepAliveTimeoutThreshold** `number | null` (optional) - Default: `1e3` - A number subtracted from server *keep-alive* hints when overriding `keepAliveTimeout` to account for timing inaccuracies caused by e.g. transport latency. Defaults to 1 second.

* **maxHeaderSize** `number | null` (optional) - Default: `16384` - The maximum length of request headers in bytes. Defaults to 16KiB.

* **pipelining** `number | null` (optional) - Default: `1` - The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Carefully consider your workload and environment before enabling concurrent requests as pipelining may reduce performance if used incorrectly. Pipelining is sensitive to network stack settings as well as head of line blocking caused by e.g. long running requests. Set to `0` to disable keep-alive connections.

* **connect** `ConnectOptions | Function | null` (optional) - Default: `null`.

* **strictContentLength** `Boolean` (optional) - Default: `true` - Whether to treat request content length mismatches as errors. If true, an error is thrown when the request content-length header doesn't match the length of the request body.

| `RequestContentLengthMismatchError` | `UND_ERR_REQ_CONTENT_LENGTH_MISMATCH` | request body does not match content-length header |

| `ResponseContentLengthMismatchError` | `UND_ERR_RES_CONTENT_LENGTH_MISMATCH` | response body does not match content-length header |

| `InformationalError` | `UND_ERR_INFO` | expected error with reason |

Extends: [`AgentOptions`](Agent.md#parameter-agentoptions)

* **uri** `string` (required) - It can be passed either by a string or a object containing `uri` as string.

Examples:

}

Closes the proxy agent and waits for registered pools and clients to also close before resolving.

const fetchImpl = require('./lib/fetch').fetch

module.exports.fetch = async function fetch (resource) {

try {

} catch (err) {

Error.captureStackTrace(err, this)

throw err

export * from './types/fetch'

export * from './types/file'

export * from './types/formdata'

export * from './types/diagnostics-channel'

export { Interceptable } from './types/mock-interceptor'

if (!fetchImpl) {

fetchImpl = require('./lib/fetch').fetch

}

try {

} catch (err) {

Error.captureStackTrace(err, this)

throw err

module.exports.Request = require('./lib/fetch/request').Request

module.exports.FormData = require('./lib/fetch/formdata').FormData

module.exports.File = require('./lib/fetch/file').File

const { setGlobalOrigin, getGlobalOrigin } = require('./lib/fetch/global')

}

res.on('drain', resume)

finished(res, { readable: false }, (err) => {

const { callback, res, opaque, trailers, abort } = this

SocketError,

InformationalError,

BodyTimeoutError,

} = require('./core/errors')

const buildConnector = require('./core/connect')

const {

kClose,

kDestroy,

kDispatch,

} = require('./core/symbols')

const kClosedResolve = Symbol('kClosedResolve')

maxCachedSessions,

maxRedirections,

connect,

} = {}) {

super()

throw new InvalidArgumentError('maxRequestsPerClient must be a positive number')

}

if (typeof connect !== 'function') {

connect = buildConnector({

...tls,

this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold

this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]

this[kServerName] = null

this[kResuming] = 0 // 0, idle, 1, scheduled, 2 resuming

this[kNeedDrain] = 0 // 0, idle, 1, scheduled, 2 resuming

this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}\r\n`

this[kMaxRedirections] = maxRedirections

this[kMaxRequests] = maxRequestsPerClient

this[kClosedResolve] = null

// kQueue is built up of 3 sections separated by

// the kRunningIdx and kPendingIdx indices.

this.keepAlive = ''

this.contentLength = ''

}

setTimeout (value, type) {

}

}

destroy () {

assert(this.ptr != null)

assert(currentParser == null)

}

onBody (buf) {

if (socket.destroyed) {

return -1

assert(statusCode >= 200)

this.bytesRead += buf.length

try {

// to the user.

if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {

// We treat all incoming data so for as a valid response.

return

}

if (parser.statusCode && !parser.shouldKeepAlive) {

// We treat all incoming data so far as a valid response.

return

}

function onSocketClose () {

const { [kClient]: client } = this

this[kParser].destroy()

this[kParser] = null

hostname,

protocol,

port,

},

connector: client[kConnector]

})

hostname,

protocol,

port,

}, (err, socket) => {

if (err) {

reject(err)

hostname,

protocol,

port,

},

connector: client[kConnector],

socket

hostname,

protocol,

port,

},

connector: client[kConnector],

error: err

timeout = timeout == null ? 10e3 : timeout

maxCachedSessions = maxCachedSessions == null ? 100 : maxCachedSessions

let socket

if (protocol === 'https:') {

if (!tls) {

...options,

servername,

session,

socket: httpSocket, // upgrade socket connection

port: port || 443,

host: hostname

socket = net.connect({

highWaterMark: 64 * 1024, // Same as nodejs fs streams.

...options,

port: port || 80,

host: hostname

})

}

module.exports = {

HTTPParserError,

UndiciError,

SocketError,

NotSupportedError,

ResponseContentLengthMismatchError,