@api-client/core 0.18.11 → 0.18.13

package/src/runtime/http-engine/CoreEngine.ts

@@ -1,61 +1,364 @@
 import net from 'net'
+import { URL } from 'url'
 import tls from 'tls'
-import http from 'http'
-import https from 'https'
-import { HttpEngine, HttpEngineOptions, HeadersReceivedDetail } from './HttpEngine.js'
+import { EventEmitter } from 'events'
+import { Logger, type ILogObj } from 'tslog'
 import { IRequestLog } from '../../models/RequestLog.js'
-import { IHttpRequest } from '../../models/HttpRequest.js'
+import { IHttpRequest, HttpRequest } from '../../models/HttpRequest.js'
+import { IRequestBaseConfig } from '../../models/RequestConfig.js'
+import { IRequestAuthorization } from '../../models/RequestAuthorization.js'
+
+import { HttpCertificate } from '../../models/ClientCertificate.js'
+import { SentRequest } from '../../models/SentRequest.js'
 import { Response } from '../../models/Response.js'
+import { ErrorResponse } from '../../models/ErrorResponse.js'
+import { RequestsSize } from '../../models/RequestsSize.js'
+import { HttpResponse } from '../../models/HttpResponse.js'
+import { ResponseRedirect } from '../../models/ResponseRedirect.js'
+import { RequestLog } from '../../models/RequestLog.js'
+import { RequestTime } from '../../models/RequestTime.js'
 import { SerializableError } from '../../models/SerializableError.js'
+import { ResponseAuthorization } from '../../models/ResponseAuthorization.js'
 import { Headers } from '../../lib/headers/Headers.js'
+import { getPort } from './RequestUtils.js'
+
+import { HttpResponseParser, ParserCallbacks, RequestState } from './parsers/index.js'
+import { ConnectionManager } from './connections/index.js'
+import { AuthManager, type ProxyAuthCredentials } from './auth/index.js'
+import { MessageBuilder } from './message/index.js'
+import { HttpEngineErrorFactory } from './errors/index.js'
+import { isMethodWithoutBody, HEADER_PROXY_AUTHORIZATION } from './constants.js'
+import { decompress } from './compression/index.js'
+import { checkServerIdentity } from './certificates/index.js'
+import { readUrl, getHostHeader, getRedirectLocation, isRedirectLoop } from './url/index.js'
+import { processRedirectCookies } from './cookies/index.js'
+import { computeStats } from './statistics/index.js'
+import { processResponse } from './response/index.js'
+import { getCodeMessage } from './HttpErrorCodes.js'
+import { createLogger } from '../../lib/logging/index.js'
 import * as PayloadSupport from './PayloadSupport.js'
-import { addContentLength, getPort } from './RequestUtils.js'
-import { INtlmAuthorization } from '../../models/Authorization.js'
-import { NtlmAuth, INtlmAuthConfig } from './ntlm/NtlmAuth.js'
+import { addContentLength } from './RequestUtils.js'
 import { PayloadSerializer } from '../../lib/transformers/PayloadSerializer.js'
-import { ResponseRedirect } from '../../models/ResponseRedirect.js'
+import { ProxyAuthenticationError } from './errors/HttpEngineErrors.js'
 
-const nlBuffer = Buffer.from([13, 10])
-const nlNlBuffer = Buffer.from([13, 10, 13, 10])
+export interface HttpEngineOptions extends IRequestBaseConfig {
+  /**
+   * The authorization configuration to apply to the request.
+   */
+  authorization?: IRequestAuthorization[]
+  /**
+   * Logger object.
+   */
+  logger?: Logger<ILogObj>
+  /**
+   * A certificate to use with the request.
+   */
+  certificates?: HttpCertificate[]
+}
 
-export enum RequestState {
-  Status,
-  Headers,
-  Body,
-  Done,
+export interface RequestStats {
+  firstReceiveTime?: number
+  lastReceivedTime?: number
+  messageStart?: number
+  sentTime?: number
+  connectionTime?: number
+  lookupTime?: number
+  connectedTime?: number
+  secureStartTime?: number
+  secureConnectedTime?: number
+  startTime?: number
+  responseTime?: number
+  receivingTime?: number
 }
 
-interface ResponseInfo {
-  contentLength?: number
-  chunked: boolean
-  body?: Buffer
-  chunk?: Buffer
-  chunkSize?: number
+export interface ResponseErrorInit {
+  code?: number | string
+  message?: string
 }
 
+export interface BeforeRedirectDetail {
+  location: string
+  returnValue: boolean
+}
+
+export interface HeadersReceivedDetail {
+  value: string
+  returnValue: boolean
+}
+
+export interface IRequestAuthState {
+  method: 'ntlm'
+  state: number
+  headers?: string
+  challengeHeader?: string
+}
+
+export const mainPromiseSymbol = Symbol('mainPromise')
+
 /**
- * API Client's HTTP engine.
+ * API Client's HTTP engine with refactored parsing and connection handling.
  * An HTTP 1.1 engine working directly on the socket. It communicates with the remote machine and
  * collects stats about the request and response.
  */
-export class CoreEngine extends HttpEngine {
-  state = RequestState.Status
-  rawHeaders?: Buffer
-  _hostTestReg = /^\s*host\s*:/im
+export class CoreEngine extends EventEmitter {
+  request: HttpRequest
+  opts: HttpEngineOptions
+  logger: Logger<ILogObj>
+
+  /**
+   * The current sent request
+   */
+  sentRequest: SentRequest
+
+  redirects: ResponseRedirect[] = []
+  /**
+   * When true the request has been aborted.
+   */
+  aborted = false
+  /**
+   * Parsed value of the request URL.
+   */
+  uri: URL
+
+  socket?: net.Socket
+  /**
+   * Host header can be different than registered URL because of
+   * `hosts` rules.
+   * If a rule changes host value of the URL the original URL host value
+   * is used when generating the request and not overwritten one.
+   * This way virtual hosts can be tested using hosts.
+   */
+  hostHeader: string | undefined
+
+  protected hostTestReg = /^\s*host\s*:/im
+  /**
+   * Set when the request is redirected.
+   */
+  redirecting = false
+
+  /**
+   * The response headers.
+   * The object may be empty when the response is not set.
+   */
+  currentHeaders = new Headers()
+
+  /**
+   * The response object build during the execution.
+   */
+  currentResponse?: Response
+
+  /**
+   * Keeps the raw body in a temporary buffer while processing the response.
+   */
+  _rawBody?: Buffer
+
+  stats: RequestStats = {}
+
+  auth?: IRequestAuthState
+
+  protected mainResolver?: (log: IRequestLog) => void
+  protected mainRejecter?: (err: SerializableError) => void;
+  [mainPromiseSymbol]?: Promise<IRequestLog>
+
+  protected _signal?: AbortSignal
+
+  // CoreEngine specific properties
+  private parser: HttpResponseParser
+  private connectionManager: ConnectionManager
+  private authManager: AuthManager
+  private messageBuilder: MessageBuilder
 
-  responseInfo: ResponseInfo
   hasProxy: boolean
   isProxyTunnel: boolean
   isProxySsl: boolean
 
-  constructor(request: IHttpRequest, opts: HttpEngineOptions = {}) {
-    super(request, opts)
-    this.responseInfo = {
-      chunked: false,
+  /**
+   * @return True if following redirects is allowed.
+   */
+  get followRedirects(): boolean {
+    const { opts } = this
+    if (typeof opts.followRedirects === 'boolean') {
+      return opts.followRedirects
     }
+    return true
+  }
+
+  /**
+   * The request timeout.
+   */
+  get timeout(): number {
+    const { opts } = this
+    if (typeof opts.timeout === 'number') {
+      return opts.timeout
+    }
+    return 0
+  }
+
+  /**
+   * The abort signal to set on this request.
+   * Aborts the request when the signal fires.
+   */
+  get signal(): AbortSignal | undefined {
+    return this._signal
+  }
+
+  set signal(value: AbortSignal | undefined) {
+    const old = this._signal
+    if (old === value) {
+      return
+    }
+    this._signal = value
+    if (old) {
+      old.removeEventListener('abort', this._abortHandler)
+    }
+    if (value) {
+      value.addEventListener('abort', this._abortHandler)
+    }
+  }
+
+  constructor(request: IHttpRequest, opts: HttpEngineOptions = {}) {
+    super()
+    this.request = new HttpRequest({ ...request })
+    this.opts = opts
+    this.logger = this.setupLogger(opts)
+    this.sentRequest = new SentRequest({ ...request, startTime: Date.now() })
+    this.uri = this.readUrl(request.url)
+    this.hostHeader = this.getHostHeader(request.url)
+
+    // CoreEngine specific initialization
     this.hasProxy = !!this.opts.proxy
     this.isProxyTunnel = this.hasProxy && this.request.url.startsWith('https:')
     this.isProxySsl = !!this.opts.proxy && this.opts.proxy.startsWith('https:')
+
+    // Initialize the HTTP response parser
+    this.parser = new HttpResponseParser(this.logger, this.createParserCallbacks())
+
+    // Initialize the connection manager
+    this.connectionManager = new ConnectionManager(this.logger, this.stats)
+
+    // Initialize the auth manager
+    const proxyCredentials: ProxyAuthCredentials = {
+      proxyUsername: this.opts.proxyUsername,
+      proxyPassword: this.opts.proxyPassword,
+      proxyAuthorization: this.opts.proxyAuthorization,
+    }
+
+    this.authManager = new AuthManager({
+      logger: this.logger,
+      proxyCredentials,
+    })
+
+    // Initialize the message builder
+    this.messageBuilder = new MessageBuilder({
+      logger: this.logger,
+      request: this.request as IHttpRequest,
+      hasProxy: this.hasProxy,
+      isProxyTunnel: this.isProxyTunnel,
+      hostHeader: this.hostHeader,
+    })
+
+    this._abortHandler = this._abortHandler.bind(this)
+    if (opts.signal) {
+      this.signal = opts.signal
+    }
+  }
+
+  /**
+   * Creates a logger object to log debug output.
+   */
+  setupLogger(opts: HttpEngineOptions = {}): Logger<ILogObj> {
+    if (opts.logger) {
+      return opts.logger
+    }
+    return createLogger()
+  }
+
+  /**
+   * Updates the `uri` property from current request URL
+   */
+  readUrl(value: string): URL {
+    return readUrl(value, { hosts: this.opts.hosts })
+  }
+
+  /**
+   * Get host header for the request
+   */
+  getHostHeader(url: string): string | undefined {
+    return getHostHeader(url, { hosts: this.opts.hosts })
+  }
+
+  /**
+   * Aborts current request.
+   * It emits `error` event
+   */
+  abort(): void {
+    this.logger.debug('Aborting the request...')
+    this.aborted = true
+    if (!this.socket) {
+      return
+    }
+    this.socket.removeAllListeners()
+    if (this.socket.destroyed) {
+      this.socket = undefined
+      return
+    }
+    this.socket.pause()
+    this.socket.destroy()
+    this.socket = undefined
+  }
+
+  /**
+   * Handler for the `abort` event on the `AbortSignal`.
+   */
+  protected _abortHandler(): void {
+    const e = new SerializableError('Request aborted', 3)
+    this._errorRequest(e)
+    this.abort()
+  }
+
+  /**
+   * Create parser callbacks to handle parsed data
+   */
+  private createParserCallbacks(): ParserCallbacks {
+    return {
+      onStatusParsed: (status: number, statusText: string) => {
+        this.logger.debug('onStatusParsed called', status, statusText)
+        const response = Response.fromValues(status, statusText)
+        response.loadingTime = 0
+        this.currentResponse = response
+      },
+      onHeadersParsed: (headers: Headers) => {
+        this.logger.debug('onHeadersParsed called')
+        this.currentHeaders = headers
+        if (this.currentResponse) {
+          this.currentResponse.headers = headers.toString()
+        }
+      },
+      onBodyComplete: (body: Buffer) => {
+        this.logger.debug('onBodyComplete called')
+        this._rawBody = body
+        this._reportResponse().catch((error) => {
+          this.logger.error('Error in _reportResponse:', error)
+          this._errorRequest({
+            message: `Response processing failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          })
+        })
+      },
+      onError: (error: Error) => {
+        this.logger.debug('onError called', error)
+        this._errorRequest({
+          message: error.message || 'Unknown error occurred',
+        })
+      },
+      onAbort: () => {
+        this.logger.debug('onAbort called')
+        this.abort()
+      },
+      emit: (event: string, detail?: unknown) => {
+        this.logger.debug('emit called', event, detail)
+        this.emit(event, detail)
+      },
+    }
   }
 
   /**
@@ -69,17 +372,31 @@ export class CoreEngine extends HttpEngine {
 
   private async sendRequest(): Promise<void> {
     try {
-      if (this.hasProxy) {
-        await this.connectProxy()
-      } else {
-        await this.connect()
-      }
-      if (!this.socket || this.aborted) {
+      // Use the connection manager to establish the connection
+      const socket = await this.establishConnection()
+      if (!socket || this.aborted) {
         return
       }
+
       const message = await this.prepareMessage()
       await this.writeMessage(message)
     } catch (cause) {
+      if (cause instanceof ProxyAuthenticationError) {
+        this.currentHeaders = new Headers(cause.response.headers)
+        const currentResponse = Response.fromValues(
+          cause.response.statusCode || 401,
+          cause.response.statusMessage,
+          this.currentHeaders.toString()
+        )
+        currentResponse.loadingTime = 0
+        this.currentResponse = currentResponse
+        if (cause.head.length) {
+          this._rawBody = cause.head
+          currentResponse.payload = PayloadSerializer.stringifyBuffer(cause.head)
+        }
+        this._publishResponse()
+        return
+      }
       const e = cause as SerializableError
       const err = new SerializableError(e.message, { cause: e })
       if (e.code || e.code === 0) {
@@ -90,341 +407,491 @@ export class CoreEngine extends HttpEngine {
         message: err.message,
         code: err.code,
       })
-      throw cause
     }
   }
 
   /**
-   * Cleans the state after finished.
+   * Establish connection using the connection manager
    */
-  override _cleanUp(): void {
-    super._cleanUp()
-    this.state = RequestState.Status
-    this.rawHeaders = undefined
-    this.responseInfo = {
-      chunked: false,
+  private async establishConnection(): Promise<net.Socket> {
+    const port = getPort(this.uri.port, this.uri.protocol)
+    const host = this.uri.hostname
+    const protocol = this.uri.protocol
+
+    const socket = await this.connectionManager.createConnection(host, port, protocol, this.opts)
+    const { timeout } = this
+    if (timeout > 0) {
+      socket.setTimeout(timeout)
     }
+    this.socket = socket
+    this._addSocketListeners(socket)
+    socket.resume()
+    return socket
+  }
+
+  /**
+   * Decompresses received body if `content-encoding` header is set.
+   */
+  async decompress(body?: Buffer): Promise<Buffer | undefined> {
+    return decompress(body, {
+      aborted: this.aborted,
+      headers: this.currentHeaders,
+    })
+  }
+
+  /**
+   * Prepares headers list to be send to the remote machine.
+   * If `defaultHeaders` option is set then it adds `user-agent` and `accept`
+   * headers.
+   */
+  prepareHeaders(headers: Headers, withPayload = false): void {
+    if (this.opts.defaultHeaders) {
+      if (!headers.has('user-agent')) {
+        if (this.opts.defaultUserAgent) {
+          headers.set('user-agent', this.opts.defaultUserAgent)
+        } else {
+          headers.set('user-agent', 'api client')
+        }
+      }
+      if (!headers.has('accept')) {
+        if (this.opts.defaultAccept) {
+          headers.set('accept', this.opts.defaultAccept)
+        } else {
+          headers.set('accept', '*/*')
+        }
+      }
+    }
+    if (withPayload) {
+      if (!headers.has('content-type') && this.request.payloadOptions) {
+        if (this.request.payloadOptions.mime) {
+          headers.set('content-type', this.request.payloadOptions.mime)
+        }
+      }
+    }
+  }
+
+  /**
+   * Cleans the state after finished.
+   */
+  _cleanUp(): void {
+    this.redirects = []
+    this.currentHeaders = new Headers()
+    this.currentResponse = undefined
+    this._rawBody = undefined
+    this.redirecting = false
+    this.stats = {}
+    this.mainRejecter = undefined
+    this.mainResolver = undefined
+    this._clearSocketEventListeners()
+    this.parser.reset()
   }
 
   /**
    * Cleans up the state for redirect.
    */
-  override _cleanUpRedirect(): void {
-    super._cleanUpRedirect()
-    this.state = RequestState.Status
-    this.rawHeaders = undefined
-    this.responseInfo = {
-      chunked: false,
+  _cleanUpRedirect(): void {
+    this.currentHeaders = new Headers()
+    this.currentResponse = undefined
+    this._rawBody = undefined
+    this.stats = {}
+    this._clearSocketEventListeners()
+    this.parser.reset()
+  }
+
+  /**
+   * Reports response when redirected.
+   */
+  _reportRedirect(status: number): boolean {
+    const { request, currentHeaders } = this
+    if (!currentHeaders) {
+      return false
+    }
+    const rerUrl = currentHeaders.get('location')
+    // https://github.com/jarrodek/socket-fetch/issues/13
+    const redirectOptions = this.getRedirectOptions(status, request.method, rerUrl)
+    if (!redirectOptions.redirect) {
+      return false
+    }
+    this.redirecting = true
+    setTimeout(() => this._redirectRequest(redirectOptions))
+    return true
+  }
+
+  /**
+   * Get redirect options based on status and method
+   */
+  private getRedirectOptions(
+    status: number,
+    method?: string,
+    location?: string
+  ): { redirect: boolean; location?: string; forceGet?: boolean } {
+    if (!location) {
+      return { redirect: false }
     }
+
+    // 301, 302, 303, 307, 308 are redirect status codes
+    if (status >= 300 && status < 400) {
+      const forceGet = status === 301 || status === 302 || status === 303
+      return { redirect: true, location, forceGet }
+    }
+
+    return { redirect: false }
   }
 
   /**
-   * Prepares an HTTP message from API Client's request object.
-   *
-   * @returns Resolved promise to an `ArrayBuffer`.
+   * Creates a response and adds it to the redirects list and redirects
+   * the request to the new location.
    */
-  async prepareMessage(): Promise<Buffer> {
-    let payload = this.request.payload
-    if (['get', 'head'].includes(this.request.method.toLowerCase())) {
-      payload = undefined
+  async _redirectRequest(options: { redirect: boolean; location?: string; forceGet?: boolean }): Promise<void> {
+    if (this.followRedirects === false) {
+      this._publishResponse()
+      return
     }
-    const headers = new Headers(this.request.toHeadersString())
-    this.prepareHeaders(headers, !!payload)
-    const auth = this.hasProxy && !this.isProxyTunnel ? this._proxyAuthHeader() : undefined
-    if (auth) {
-      headers.set('proxy-authorization', auth)
+    const location = options.location && this.getRedirectLocation(options.location, this.request.url)
+    if (!location) {
+      this._errorRequest({ code: 302 })
+      return
     }
-    const buffer = PayloadSupport.payloadToBuffer(headers, payload)
-    if (buffer) {
-      addContentLength(this.request.method || 'GET', buffer, headers)
+
+    // check if this is infinite loop
+    if (this.isRedirectLoop(location, this.redirects)) {
+      this._errorRequest({ code: 310 })
+      return
     }
 
-    this._handleAuthorization(headers)
-    this.sentRequest.headers = headers.toString()
-    const message = this._prepareMessage(headers, buffer)
-    if (this.auth) {
-      // This restores altered by authorization original headers
-      // so it can be safe to use when redirecting
-      if (this.auth.headers) {
-        this.request.headers = this.auth.headers
-        delete this.auth.headers
+    const detail: BeforeRedirectDetail = {
+      location,
+      returnValue: true,
+    }
+    this.emit('beforeredirect', detail)
+    if (!detail.returnValue) {
+      this._publishResponse()
+      return
+    }
+    try {
+      const responseCookies = this.currentHeaders.get('set-cookie')
+      const response = await this._createRedirectResponse(location)
+      this.redirects.push(response)
+      this._cleanUpRedirect()
+      if (responseCookies) {
+        this._processRedirectCookies(responseCookies, location)
       }
+      this.redirecting = false
+
+      this.request.url = location
+      this.sentRequest.url = location
+      if (options.forceGet) {
+        this.request.method = 'GET'
+      }
+      this.uri = this.readUrl(location)
+      this.hostHeader = this.getHostHeader(location)
+      // No idea why but without setTimeout the program loses it's
+      // scope after calling the function.
+      setTimeout(() => this.send())
+    } catch (e) {
+      const error = e as Error
+      this._errorRequest({
+        message: (error && error.message) || 'Unknown error occurred',
+      })
     }
-    return message
   }
 
   /**
-   * Sends a data to a socket.
-   *
-   * @param buffer HTTP message to send
+   * Get redirect location
    */
-  writeMessage(buffer: Buffer): Promise<void> {
-    this.logger.debug(`Writing the message to the socket...`)
-    let msg = buffer.toString()
-    const limit = this.opts.sentMessageLimit
-    if (limit && limit > 0 && msg.length >= limit) {
-      msg = msg.substr(0, limit)
-      msg += ' ...'
+  private getRedirectLocation(location: string, currentUrl: string): string {
+    return getRedirectLocation(location, currentUrl)
+  }
+
+  /**
+   * Check if redirect is a loop
+   */
+  private isRedirectLoop(location: string, redirects: ResponseRedirect[]): boolean {
+    return isRedirectLoop(location, redirects)
+  }
+
+  /**
+   * @param location The redirect location.
+   * @return Redirect response object
+   */
+  async _createRedirectResponse(location: string): Promise<ResponseRedirect> {
+    const { currentResponse = new Response() } = this
+
+    const response = HttpResponse.fromValues(
+      currentResponse.status,
+      currentResponse.statusText,
+      currentResponse.headers
+    )
+    if (currentResponse.payload) {
+      response.payload = currentResponse.payload
     }
-    this.sentRequest.httpMessage = msg
-    const startTime = Date.now()
-    this.stats.startTime = startTime
-    this.sentRequest.startTime = startTime
 
-    this.stats.messageStart = Date.now()
-    return new Promise((resolve) => {
-      this.socket?.write(buffer, () => {
-        this.logger.debug(`The message has been sent.`)
-        this.stats.sentTime = Date.now()
-        try {
-          this.emit('loadstart')
-        } catch {
-          //
-        }
-        resolve()
-      })
-    })
+    const body = await this.decompress(this._rawBody)
+    if (body) {
+      await response.writePayload(body)
+      currentResponse.payload = response.payload
+    }
+
+    const redirect = ResponseRedirect.fromValues(
+      location,
+      response.toJSON(),
+      this.stats.startTime,
+      this.stats.responseTime
+    )
+    redirect.timings = this._computeStats(this.stats)
+
+    return redirect
   }
 
   /**
-   * Connects to a server and sends the message.
-   *
-   * @returns Promise resolved when socket is connected.
+   * Creates a response object
    */
-  async connect(): Promise<net.Socket> {
-    const port = getPort(this.uri.port, this.uri.protocol)
-    const host = this.uri.hostname
-    let socket
-    if (port === 443 || this.uri.protocol === 'https:') {
-      socket = await this._connectTls(port, host)
-    } else {
-      socket = await this._connect(port, host)
+  async _createResponse(): Promise<Response> {
+    if (this.aborted) {
+      throw new Error(`Request aborted.`)
     }
-    const { timeout } = this
-    if (timeout > 0) {
-      socket.setTimeout(timeout)
+    const { currentResponse } = this
+    if (!currentResponse) {
+      throw new Error(`Tried to create a response but no response data is set.`)
     }
-    this.socket = socket
-    this._addSocketListeners(socket)
-    socket.resume()
-    return socket
+    const { status } = currentResponse
+    if (status === undefined) {
+      throw new Error(`The response status is empty.
+It means that the successful connection wasn't made.
+Check your request parameters.`)
+    }
+    const body = await this.decompress(this._rawBody)
+    const response = Response.fromValues(status, currentResponse.statusText, currentResponse.headers)
+    response.timings = this._computeStats(this.stats)
+    response.loadingTime = response.timings.total()
+    if (body) {
+      await response.writePayload(body)
+      currentResponse.payload = response.payload
+    }
+    if (status === 401) {
+      this.logger.silly('Setting auth on the response...')
+      response.auth = this._getAuth()
+    }
+    return response
   }
 
   /**
-   * Connects to a server and writes a message using insecure connection.
-   *
-   * @param port A port number to connect to.
-   * @param host A host name to connect to
-   * @returns A promise resolved when the message was sent to a server
+   * Finishes the response with error message.
    */
-  _connect(port: number, host: string): Promise<net.Socket> {
-    this.logger.debug('Opening an HTTP connection...')
-    return new Promise((resolve, reject) => {
-      this.stats.connectionTime = Date.now()
-      const isIp = net.isIP(host)
-      if (isIp) {
-        this.stats.lookupTime = Date.now()
-      }
-      const client = net.createConnection(port, host, () => {
-        this.logger.debug('HTTP connection established.')
-        this.stats.connectedTime = Date.now()
-        resolve(client)
-      })
-      client.pause()
-      if (!isIp) {
-        client.once('lookup', () => {
-          this.stats.lookupTime = Date.now()
-        })
-      }
-      client.once('error', (err: Error) => reject(err))
-    })
+  _errorRequest(opts: ResponseErrorInit): void {
+    const { currentResponse } = this
+    this.aborted = true
+    let message
+    if (opts.code && !opts.message) {
+      message = getCodeMessage(opts.code)
+    } else if (opts.message) {
+      message = opts.message
+    }
+    message = message || 'Unknown error occurred'
+    const error = new SerializableError(message, opts.code)
+    const log = RequestLog.fromRequest(this.sentRequest.toJSON())
+    const response = ErrorResponse.fromError(error)
+    log.response = response
+    if (currentResponse && currentResponse.status) {
+      response.status = currentResponse.status
+      response.statusText = currentResponse.statusText
+      response.headers = currentResponse.headers
+      response.payload = currentResponse.payload
+    }
+    this.finalizeRequest(log)
+    this._cleanUp()
   }
 
   /**
-   * Connects to a server and writes a message using secured connection.
-   *
-   * @param port A port number to connect to.
-   * @param host A host name to connect to
-   * @returns A promise resolved when the message was sent to a server
+   * Generates authorization info object from response.
    */
-  _connectTls(port: number, host: string): Promise<tls.TLSSocket> {
-    this.logger.debug('Opening an SSL connection...')
-    const { opts } = this
-    const options: tls.ConnectionOptions = {}
-    const isIp = net.isIP(host)
-    if (!isIp) {
-      options.servername = host
-    }
-    if (opts.validateCertificates) {
-      options.checkServerIdentity = this._checkServerIdentity.bind(this)
-    } else {
-      options.rejectUnauthorized = false
-      options.checkServerIdentity = (): Error | undefined => {
-        return undefined
+  _getAuth(): ResponseAuthorization {
+    this.logger.debug('Getting auth from response headers')
+    let auth = this.currentHeaders.get('www-authenticate')
+    const result = new ResponseAuthorization()
+    if (auth) {
+      this.logger.silly('Auth header found', auth)
+      auth = auth.toLowerCase()
+      if (auth.indexOf('ntlm') !== -1) {
+        this.logger.silly('Detected NTLM authorization')
+        result.method = 'ntlm'
+      } else if (auth.indexOf('basic') !== -1) {
+        result.method = 'basic'
+        this.logger.silly('Detected basic authorization')
+      } else if (auth.indexOf('digest') !== -1) {
+        result.method = 'digest'
+        this.logger.silly('Detected digest authorization')
       }
-      // target.requestOCSP = false;
     }
-    const certs = this.opts.certificates
-    if (Array.isArray(certs)) {
-      certs.forEach((cert) => this._addClientCertificate(cert, options))
+    return result
+  }
+
+  /**
+   * Creates HAR 1.2 timings object from stats.
+   */
+  _computeStats(stats: RequestStats): RequestTime {
+    return computeStats(stats)
+  }
+
+  /**
+   * Handles cookie exchange when redirecting the request.
+   */
+  _processRedirectCookies(responseCookies: string, location: string): void {
+    this.request.headers = processRedirectCookies(
+      responseCookies,
+      location,
+      this.request.url,
+      this.request.toHeadersString()
+    )
+  }
+
+  /**
+   * Checks certificate identity using TLS api.
+   */
+  _checkServerIdentity(host: string, cert: tls.PeerCertificate): Error | undefined {
+    return checkServerIdentity(host, cert)
+  }
+
+  /**
+   * Clears event listeners of the socket object,
+   */
+  _clearSocketEventListeners(): void {
+    if (!this.socket) {
+      return
     }
-    return new Promise((resolve, reject) => {
-      const time = Date.now()
-      this.stats.connectionTime = time
-      if (isIp) {
-        this.stats.lookupTime = time
-      }
-      const client = tls.connect(port, host, options, () => {
-        this.logger.debug('SSL connection established.')
-        const connectTime = Date.now()
-        this.stats.connectedTime = connectTime
-        this.stats.secureStartTime = connectTime
-        resolve(client)
-      })
-      client.pause()
-      client.once('error', (e: Error) => reject(e))
-      if (!isIp) {
-        client.once('lookup', () => {
-          this.stats.lookupTime = Date.now()
-        })
-      }
-      client.once('secureConnect', () => {
-        this.stats.secureConnectedTime = Date.now()
-      })
-    })
+    this.socket.removeAllListeners('error')
+    this.socket.removeAllListeners('timeout')
+    this.socket.removeAllListeners('end')
   }
 
   /**
-   * Prepares a full HTTP message body
-   *
-   * @param httpHeaders The list ogf headers to append.
-   * @param buffer The buffer with the HTTP message
-   * @returns The Buffer of the HTTP message
+   * Called with the `send()` function to initialize the main promise returned by the send function.
+   * The send function returns a promise that is resolved when the request finish.
    */
-  _prepareMessage(httpHeaders: Headers, buffer?: Buffer): Buffer {
-    this.logger.debug('Preparing an HTTP message...')
-    const headers = []
-    // const search = this.uri.search;
-    // let path = this.uri.pathname;
-    // if (search) {
-    //   path += search;
-    // }
-    // headers.push(`${this.arcRequest.method} ${path} HTTP/1.1`);
-    const status = this._createHttpStatus()
-    this.logger.debug(`Created message status: ${status}`)
-    headers.push(status)
-    if (this._hostRequired()) {
-      this.logger.debug(`Adding the "host" header: ${this.hostHeader}`)
-      headers.push(`Host: ${this.hostHeader}`)
+  protected wrapExecution(): Promise<IRequestLog> {
+    let promise: Promise<IRequestLog>
+    if (this[mainPromiseSymbol]) {
+      promise = this[mainPromiseSymbol] as Promise<IRequestLog>
+    } else {
+      promise = new Promise((resolve, reject) => {
+        this.mainResolver = resolve
+        this.mainRejecter = reject
+      })
+      this[mainPromiseSymbol] = promise
     }
-    let str = headers.join('\r\n')
-    const addHeaders = httpHeaders.toString()
-    if (addHeaders) {
-      this.logger.debug(`Adding headers to the request...`)
-      str += '\r\n'
-      str += PayloadSupport.normalizeString(addHeaders)
+    return promise
+  }
+
+  /**
+   * Called by the request finalizer or error finalized to report the response.
+   */
+  protected finalizeRequest(log: RequestLog | SerializableError): void {
+    const { mainRejecter, mainResolver } = this
+    if (!mainRejecter || !mainResolver) {
+      return
     }
-    const startBuffer = Buffer.from(str, 'utf8')
-    const endBuffer = Buffer.from(new Uint8Array([13, 10, 13, 10]))
-    let body
-    let sum = startBuffer.length + endBuffer.length
-    if (buffer) {
-      sum += buffer.length
-      body = Buffer.concat([startBuffer, endBuffer, buffer], sum)
+
+    if (log instanceof SerializableError) {
+      mainRejecter(log)
     } else {
-      body = Buffer.concat([startBuffer, endBuffer], sum)
+      mainResolver(log.toJSON())
     }
-    this.logger.debug(`The message is ready.`)
-    return body
+    this.mainRejecter = undefined
+    this.mainResolver = undefined
+    this[mainPromiseSymbol] = undefined
   }
 
   /**
-   * Creates an HTTP status line for the message.
-   * For proxy connections it, depending whether target is SSL or not, sets the path
-   * as the full URL or just the authority.
-   * @returns The generates status message.
+   * Prepares an HTTP message from API Client's request object.
    */
-  _createHttpStatus(): string {
-    const { request, uri, hasProxy, isProxyTunnel } = this
-    const parts = [request.method]
-    if (hasProxy && !isProxyTunnel) {
-      // if (isProxyTunnel) {
-      //   // when a tunnel then the target is over SSL so the default port is 443.
-      //   parts.push(`${uri.hostname}:${uri.port || 443}`);
-      // } else {
-      //   parts.push(arcRequest.url);
-      // }
-      parts.push(request.url)
-    } else {
-      let path = uri.pathname
-      if (uri.search) {
-        path += uri.search
-      }
-      parts.push(path)
+  async prepareMessage(): Promise<Buffer> {
+    let payload = this.request.payload
+    if (isMethodWithoutBody(this.request.method)) {
+      payload = undefined
     }
+    const headers = new Headers(this.request.toHeadersString())
+    this.prepareHeaders(headers, !!payload)
+    const auth = this.hasProxy && !this.isProxyTunnel ? this._proxyAuthHeader() : undefined
+    if (auth) {
+      headers.set(HEADER_PROXY_AUTHORIZATION, auth)
+    }
+    const buffer = PayloadSupport.payloadToBuffer(headers, payload)
+    if (buffer) {
+      addContentLength(this.request.method || 'GET', buffer, headers)
+    }
+
+    this._handleAuthorization(headers)
+    this.sentRequest.headers = headers.toString()
+
+    // Update message builder with current host header
+    this.messageBuilder.updateHostHeader(this.hostHeader || '')
 
-    parts.push('HTTP/1.1')
-    return parts.join(' ')
+    const message = this.messageBuilder.buildMessage(headers, buffer)
+    if (this.auth) {
+      // This restores altered by authorization original headers
+      // so it can be safe to use when redirecting
+      if (this.auth.headers) {
+        this.request.headers = this.auth.headers
+        delete this.auth.headers
+      }
+    }
+    return message
   }
 
   /**
-   * Tests if current connection is required to add `host` header.
-   * It returns `false` only if `host` header has been already provided.
-   *
-   * @returns True when the `host` header should be added to the headers list.
+   * Sends a data to a socket.
    */
-  _hostRequired(): boolean {
-    const headers = this.request.headers
-    if (typeof headers !== 'string') {
-      return true
+  writeMessage(buffer: Buffer): Promise<void> {
+    this.logger.debug(`Writing the message to the socket...`)
+    let msg = buffer.toString()
+    const limit = this.opts.sentMessageLimit
+    if (limit && limit > 0 && msg.length >= limit) {
+      msg = msg.substring(0, limit)
+      msg += ' ...'
     }
-    return !this._hostTestReg.test(headers)
+    this.sentRequest.httpMessage = msg
+    const startTime = Date.now()
+    this.stats.startTime = startTime
+    this.sentRequest.startTime = startTime
+
+    this.stats.messageStart = Date.now()
+    return new Promise((resolve) => {
+      this.socket?.write(buffer, () => {
+        this.logger.debug(`The message has been sent.`)
+        this.stats.sentTime = Date.now()
+        try {
+          this.emit('loadstart')
+        } catch {
+          //
+        }
+        resolve()
+      })
+    })
   }
 
   /**
    * Alters authorization header depending on the `auth` object
-   * @param headers A headers object where to append headers when needed
    */
   _handleAuthorization(headers: Headers): void {
     const { authorization } = this.opts
-    const enabled = Array.isArray(authorization) ? authorization.filter((i) => i.enabled) : []
-    if (!enabled.length) {
-      return
-    }
-    const ntlm = enabled.find((i) => i.type === 'ntlm')
-    if (ntlm) {
-      this._authorizeNtlm(ntlm.config as INtlmAuthorization, headers)
+    this.authManager.handleRequestAuthorization(headers, authorization, this.uri.host)
+
+    // Sync the auth state from AuthManager to parent class for compatibility
+    const authState = this.authManager.getAuthState()
+    if (authState) {
+      this.auth = authState
     }
   }
 
   /**
-   * Authorize the request with NTLM
-   * @param authData Credentials to use
-   * @param headers A headers object where to append headers if needed
+   * Generate proxy authorization header
    */
-  _authorizeNtlm(authData: INtlmAuthorization, headers: Headers): void {
-    const init = { ...authData, url: this.request.url } as INtlmAuthConfig
-    const auth = new NtlmAuth(init)
-    if (!this.auth) {
-      this.auth = {
-        method: 'ntlm',
-        state: 0,
-        headers: headers.toString(),
-      }
-      const msg = auth.createMessage1(this.uri.host)
-      headers.set('Authorization', `NTLM ${msg.toBase64()}`)
-      headers.set('Connection', 'keep-alive')
-    } else if (this.auth && this.auth.state === 1) {
-      const msg = auth.createMessage3(this.auth.challengeHeader as string, this.uri.host)
-      this.auth.state = 2
-      headers.set('Authorization', `NTLM ${msg.toBase64()}`)
-    }
+  _proxyAuthHeader(): string | undefined {
+    return this.authManager.generateProxyAuthHeader()
   }
 
   /**
    * Add event listeners to existing socket.
-   * @param socket An instance of the socket.
-   * @return The same socket. Used for chaining.
    */
   _addSocketListeners(socket: net.Socket): net.Socket {
     let received = false
@@ -438,8 +905,11 @@ export class CoreEngine extends HttpEngine {
       }
       data = Buffer.from(data)
       try {
-        this._processSocketMessage(data)
+        // Use the new parser instead of the old parsing methods
+        this.parser.processData(data)
+        this.logger.debug('Parser state:', this.parser.getState())
       } catch (e) {
+        this.logger.error('Error in _addSocketListeners:', e)
         const err = e as Error
         this._errorRequest({
           message: err.message || 'Unknown error occurred',
@@ -448,51 +918,44 @@ export class CoreEngine extends HttpEngine {
       }
     })
     socket.once('timeout', () => {
-      this.state = RequestState.Done
-      this._errorRequest(new Error('Connection timeout.'))
+      this.logger.debug(`Socket timeout occurred after ${this.timeout}ms.`)
+      this.parser.abort()
+      this._errorRequest(HttpEngineErrorFactory.connectionTimeout(this.timeout))
       socket.destroy()
     })
     socket.on('end', () => {
+      const endTime = Date.now()
       this.logger.debug(`Server connection ended.`)
       socket.removeAllListeners('timeout')
       socket.removeAllListeners('error')
-      const endTime = Date.now()
+      socket.removeAllListeners('data')
       this.stats.lastReceivedTime = endTime
       this.sentRequest.endTime = endTime
-      if (this.state !== RequestState.Done) {
+      // console.log(`Socket ended at ${endTime} in state`, this.parser.getState())
+      if (this.parser.getState() !== RequestState.Done) {
         if (!this.currentResponse) {
-          this.logger.error(`Connection closed without receiving any data.`)
-          // The parser haven't found the end of message so there was no message!
-          const e = new SerializableError('Connection closed without receiving any data', 100)
+          const message = `Connection closed without receiving any data.`
+          this.logger.error(message)
+          const e = HttpEngineErrorFactory.connectionError(message, 100)
           this._errorRequest(e)
         } else {
-          // There is an issue with the response. Size mismatch? Anyway,
-          // it tries to create a response from current data.
           this.emit('loadend')
           this._publishResponse()
         }
       }
     })
     socket.once('error', (err) => {
+      this.logger.error(`Socket error occurred: ${err.message}`)
       socket.removeAllListeners('timeout')
       this._errorRequest(err)
     })
     return socket
   }
 
-  /**
-   * Processes response message chunk
-   * @param buffer Message buffer
-   */
-  _processResponse(buffer: Buffer): void {
-    this._processSocketMessage(buffer)
-    this._reportResponse()
-  }
-
   /**
    * Reports response after processing it.
    */
-  _reportResponse(): void {
+  async _reportResponse(): Promise<void> {
     this._clearSocketEventListeners()
     const { aborted, currentResponse } = this
     if (aborted || !currentResponse) {
@@ -504,617 +967,119 @@ export class CoreEngine extends HttpEngine {
     this.stats.lastReceivedTime = endTime
     this.sentRequest.endTime = endTime
 
-    if (status >= 300 && status < 400) {
-      if (this.followRedirects && this._reportRedirect(status)) {
-        this.closeClient()
-        return
-      }
-    } else if (status === 401 && this.auth) {
-      switch (this.auth.method) {
-        case 'ntlm':
-          this.handleNtlmResponse()
-          return
-      }
-    }
-    this.closeClient()
-    this.emit('loadend')
-    this._publishResponse()
-  }
-
-  /**
-   * Generate response object and publish it to the listeners.
-   */
-  override _publishResponse(): Promise<void> {
-    this.state = RequestState.Done
-    if (!this._rawBody) {
-      if (this.responseInfo.body) {
-        this._rawBody = this.responseInfo.body
-      } else if (this.responseInfo.chunk) {
-        this._rawBody = this.responseInfo.chunk
-      }
-    }
-    return super._publishResponse()
-  }
-
-  /**
-   * @param location The redirect location.
-   * @return Redirect response object
-   */
-  override async _createRedirectResponse(location: string): Promise<ResponseRedirect> {
-    const { currentResponse = new Response() } = this
-    this.currentResponse = currentResponse
-    if (!this.currentResponse.payload) {
-      if (this._rawBody) {
-        this.currentResponse.payload = PayloadSerializer.stringifyBuffer(this._rawBody)
-      } else if (this.responseInfo.body) {
-        this.currentResponse.payload = PayloadSerializer.stringifyBuffer(this.responseInfo.body)
-      } else if (this.responseInfo.chunk) {
-        this.currentResponse.payload = PayloadSerializer.stringifyBuffer(this.responseInfo.chunk)
-      }
-    }
-    return super._createRedirectResponse(location)
-  }
-
-  /**
-   * closes the connection, if any
-   */
-  closeClient(): void {
-    if (this.socket && !this.socket.destroyed) {
-      this.socket.destroy()
-    }
-  }
-
-  /**
-   * Handles the response with NTLM authorization
-   */
-  handleNtlmResponse(): void {
-    const { auth } = this
-    if (!auth) {
-      throw new Error('No auth data.')
-    }
-    if (auth.state === 0) {
-      if (this.currentHeaders.has('www-authenticate')) {
-        auth.state = 1
-        auth.challengeHeader = this.currentHeaders.get('www-authenticate')
-        this._cleanUpRedirect()
-        this.prepareMessage().then((message) => this.writeMessage(message))
-        return
-      }
-    }
-    delete this.auth
-    this.emit('loadend')
-    this._publishResponse()
-  }
-
-  /**
-   * Process received message.
-   *
-   * @param data Received message.
-   */
-  _processSocketMessage(data: Buffer): void {
-    if (this.aborted) {
-      return
-    }
-    if (this.state === RequestState.Done) {
-      return
-    }
-    let remaining: Buffer | undefined = data
-    if (this.state === RequestState.Status) {
-      remaining = this._processStatus(remaining)
-      if (!remaining) {
-        return
-      }
-    }
-    if (this.state === RequestState.Headers) {
-      remaining = this._processHeaders(remaining)
-      if (!remaining) {
-        return
-      }
-    }
-    if (this.state === RequestState.Body) {
-      this._processBody(remaining)
-      return
-    }
-  }
-
-  /**
-   * Read status line from the response.
-   * This function will set `status` and `statusText` fields
-   * and then will set `state` to HEADERS.
-   *
-   * @param data The received data
-   */
-  _processStatus(data?: Buffer): Buffer | undefined {
-    if (this.aborted) {
-      return
-    }
-    const response = Response.fromValues(0)
-    response.loadingTime = 0
-    this.currentResponse = response
-    if (!data) {
-      return
-    }
-
-    this.logger.info('Processing status')
-    const index = data.indexOf(nlBuffer)
-    let statusLine = data.slice(0, index).toString()
-    data = data.slice(index + 2)
-    statusLine = statusLine.replace(/HTTP\/\d(\.\d)?\s/, '')
-    const delimiterPos = statusLine.indexOf(' ')
-    let status
-    let msg = ''
-    if (delimiterPos === -1) {
-      status = statusLine
-    } else {
-      status = statusLine.substr(0, delimiterPos)
-      msg = statusLine.substr(delimiterPos + 1)
-    }
-    let typedStatus = Number(status)
-    if (Number.isNaN(typedStatus)) {
-      typedStatus = 0
-    }
-    if (msg && msg.indexOf('\n') !== -1) {
-      msg = msg.split('\n')[0]
-    }
-    const cr = this.currentResponse as Response
-    cr.status = typedStatus
-    cr.statusText = msg
-    this.logger.info('Received status', typedStatus, msg)
-    this.state = RequestState.Headers
-    return data
-  }
-
-  /**
-   * Read headers from the received data.
-   *
-   * @param data Received data
-   * @returns Remaining data in the buffer.
-   */
-  _processHeaders(data?: Buffer): Buffer | undefined {
-    if (this.aborted) {
-      return
-    }
-    if (!data) {
-      this._parseHeaders()
-      return
-    }
-    this.logger.info('Processing headers')
-    // Looking for end of headers section
-    let index = data.indexOf(nlNlBuffer)
-    let padding = 4
-    if (index === -1) {
-      // It can also be 2x ASCII 10
-      const _index = data.indexOf(Buffer.from([10, 10]))
-      if (_index !== -1) {
-        index = _index
-        padding = 2
-      }
-    }
-
-    // https://github.com/jarrodek/socket-fetch/issues/3
-    const enterIndex = data.indexOf(nlBuffer)
-    if (index === -1 && enterIndex !== 0) {
-      // end in next chunk
-      if (!this.rawHeaders) {
-        this.rawHeaders = data
-      } else {
-        const sum = this.rawHeaders.length + data.length
-        this.rawHeaders = Buffer.concat([this.rawHeaders, data], sum)
-      }
-      return
-    }
-    if (enterIndex !== 0) {
-      const headersArray = data.slice(0, index)
-      if (!this.rawHeaders) {
-        this.rawHeaders = headersArray
-      } else {
-        const sum = this.rawHeaders.length + headersArray.length
-        this.rawHeaders = Buffer.concat([this.rawHeaders, headersArray], sum)
-      }
-    }
-    this._parseHeaders(this.rawHeaders)
-    delete this.rawHeaders
-    this.state = RequestState.Body
-    const start = index === -1 ? 0 : index
-    const move = enterIndex === 0 ? 2 : padding
-    data = data.slice(start + move)
-    return this._postHeaders(data)
-  }
-
-  /**
-   * Check the response headers and end the request if necessary.
-   * @param data Current response data buffer
-   */
-  _postHeaders(data: Buffer): Buffer | undefined {
-    if (this.request.method === 'HEAD') {
-      this._reportResponse()
-      return
-    }
-    if (data.length === 0) {
-      if (this.currentResponse?.status === 204) {
-        this._reportResponse()
-        return
-      }
-      if (this.currentHeaders.has('Content-Length')) {
-        // If the server do not close the connection and clearly indicate that
-        // there are no further data to receive the app can close the connection
-        // and prepare the response.
-        const length = Number(this.currentHeaders.get('Content-Length'))
-        if (!Number.isNaN(length) && length === 0) {
-          this._reportResponse()
-          return
-        }
-      }
-      // See: https://github.com/advanced-rest-client/arc-electron/issues/106
-      // The client should wait until the connection is closed instead of assuming it should end the request.
-
-      //  else if (!this.currentHeaders.has('Transfer-Encoding') || !this.currentHeaders.get('Transfer-Encoding')) {
-      //   // Fix for https://github.com/jarrodek/socket-fetch/issues/6
-      //   // There is no body in the response.
-      //   // this._reportResponse();
-      //   return;
-      // }
-      return
-    }
-    return data
-  }
-
-  /**
-   * This function assumes that all headers has been read and it's
-   * just before changing the status to BODY.
-   */
-  _parseHeaders(buffer?: Buffer): void {
-    let raw = ''
-    if (buffer) {
-      raw = buffer.toString()
-    }
-    ;(this.currentResponse as Response).headers = raw
-    this.logger.info('Received headers list', raw)
-    const headers = new Headers(raw)
-    this.currentHeaders = headers
-    if (headers.has('Content-Length')) {
-      this.responseInfo.contentLength = Number(headers.get('Content-Length'))
-    }
-    if (headers.has('Transfer-Encoding')) {
-      const tr = headers.get('Transfer-Encoding')
-      if (tr === 'chunked') {
-        this.responseInfo.chunked = true
-      }
-    }
-    const rawHeaders = headers.toString()
-    const detail: HeadersReceivedDetail = {
-      returnValue: true,
-      value: rawHeaders,
-    }
-    this.emit('headersreceived', detail)
-    if (!detail.returnValue) {
-      this.abort()
-    }
-  }
-
-  /**
-   * @param data A data to process
-   */
-  _processBody(data?: Buffer): void {
-    if (this.aborted || !data) {
-      return
-    }
-    if (this.responseInfo.chunked) {
-      this._processBodyChunked(data)
-    } else {
-      this._processBodyContentLength(data)
-    }
-  }
-
-  _processBodyContentLength(data: Buffer): void {
-    if (typeof this.responseInfo.contentLength === 'undefined') {
-      this._errorRequest(new Error(`The content-length header of the response is missing.`))
-      return
-    }
-    if (!this.responseInfo.body) {
-      this.responseInfo.body = data
-      if (data.length >= this.responseInfo.contentLength) {
-        this._reportResponse()
-        return
-      }
-      return
-    }
-    const sum = this.responseInfo.body.length + data.length
-    this.responseInfo.body = Buffer.concat([this.responseInfo.body, data], sum)
-    if (this.responseInfo.body.length >= this.responseInfo.contentLength) {
-      this._reportResponse()
-      return
-    }
-  }
-
-  /**
-   * @param data A latest data to process
-   */
-  _processBodyChunked(data?: Buffer): void {
-    if (!data) {
-      return
-    }
-    if (this.responseInfo.chunk) {
-      data = Buffer.concat([this.responseInfo.chunk, data], this.responseInfo.chunk.length + data.length)
-      this.responseInfo.chunk = undefined
-    }
+    const result = processResponse({
+      status,
+      currentResponse,
+      currentHeaders: this.currentHeaders,
+      followRedirects: this.followRedirects,
+      auth: this.auth,
+      aborted: this.aborted,
+    })
 
-    while (true) {
-      if (this.responseInfo.chunkSize === 0 && data.indexOf(nlNlBuffer) === 0) {
-        this._reportResponse()
-        return
-      }
-      if (!this.responseInfo.chunkSize) {
-        data = this.readChunkSize(data)
-        if (!data) {
+    switch (result.action) {
+      case 'redirect':
+        if (this._reportRedirect(status)) {
+          this.closeClient()
           return
         }
-        if (!this.responseInfo.chunkSize && this.responseInfo.chunkSize !== 0) {
-          // It may happen that node's buffer cuts the data
-          // just before the chunk size.
-          // It should proceed it in next portion of the data.
-          this.responseInfo.chunk = data
+        break
+      case 'auth':
+        if (result.data?.method === 'ntlm') {
+          await this.handleNtlmResponse()
           return
         }
-        if (!this.responseInfo.chunkSize) {
-          this._reportResponse()
-          return
-        }
-      }
-      const size = Math.min(this.responseInfo.chunkSize, data.length)
-      const sliced = data.slice(0, size)
-      if (!this._rawBody) {
-        this._rawBody = sliced
-      } else {
-        const sum = size + this._rawBody.length
-        this._rawBody = Buffer.concat([this._rawBody, sliced], sum)
-      }
-
-      this.responseInfo.chunkSize -= size
-      if (data.length === 0) {
-        // this.logger.warn('Next chunk will start with CRLF!');
-        return
-      }
-      data = data.slice(size + 2) // + CR
-      if (data.length === 0) {
-        // this.logger.info('No more data here. Waiting for new chunk');
-        return
-      }
+        break
+      case 'publish':
+        this.closeClient()
+        this.emit('loadend')
+        this._publishResponse()
+        break
+      case 'abort':
+        // Already aborted, do nothing
+        break
     }
   }
 
   /**
-   * If response's Transfer-Encoding is 'chunked' read until next CR.
-   * Everything before it is a chunk size.
+   * Generate response object and publish it to the listeners.
    */
-  readChunkSize(array: Buffer): Buffer | undefined {
+  async _publishResponse(): Promise<void> {
     if (this.aborted) {
       return
     }
-    let index = array.indexOf(nlBuffer)
-    if (index === -1) {
-      // not found in this portion of data.
-      return array
-    }
-    if (index === 0) {
-      // Node's buffer cuts CRLF after the end of chunk data, without last CLCR,
-      // here's to fix it.
-      // It can be either new line from the last chunk or end of
-      // the message where
-      // the rest of the array is [13, 10, 48, 13, 10, 13, 10]
-      if (array.indexOf(nlNlBuffer) === 0) {
-        this.responseInfo.chunkSize = 0
-        return Buffer.alloc(0)
+    try {
+      const response = await this._createResponse()
+      const result = RequestLog.fromRequestResponse(this.sentRequest.toJSON(), response.toJSON())
+      if (this.redirects.length) {
+        result.redirects = this.redirects
       }
-      array = array.slice(index + 2)
-      index = array.indexOf(nlBuffer)
-    }
-    // this.logger.info('Size index: ', index);
-    const chunkSize = parseInt(array.slice(0, index).toString(), 16)
-    if (Number.isNaN(chunkSize)) {
-      this.responseInfo.chunkSize = undefined
-      return array.slice(index + 2)
+      result.size = new RequestsSize()
+      if (this.sentRequest.httpMessage) {
+        result.size.request = Buffer.from(this.sentRequest.httpMessage).length
+      }
+      if (response.payload) {
+        if (typeof response.payload === 'string') {
+          result.size.response = response.payload.length
+        } else {
+          result.size.response = response.payload.data.length
+        }
+      }
+      this.finalizeRequest(result)
+    } catch (e) {
+      const error = e as Error
+      this.logger.error('Error in _publishResponse:', error)
+      this._errorRequest({
+        message: (error && error.message) || 'Unknown error occurred',
+      })
     }
-    this.responseInfo.chunkSize = chunkSize
-    return array.slice(index + 2)
+    this.abort()
+    this._cleanUp()
   }
 
   /**
-   * Connects to a server through a proxy. Depending on the proxy type the returned socket
-   * is a socket created after creating a tunnel (SSL) or the proxy socket.
-   *
-   * @returns Promise resolved when socket is connected.
+   * closes the connection, if any
    */
-  async connectProxy(): Promise<net.Socket | undefined> {
-    let socket
-    if (this.isProxyTunnel) {
-      socket = await this.connectTunnel(this.isProxySsl)
-    } else {
-      socket = await this.proxyHttp(this.isProxySsl)
-    }
-    if (!socket) {
-      return
-    }
-    const { timeout } = this
-    if (timeout > 0) {
-      socket.setTimeout(timeout)
+  closeClient(): void {
+    if (this.socket && !this.socket.destroyed) {
+      this.logger.debug('Closing the socket connection...')
+      this.socket.destroy()
     }
-    this.socket = socket
-    this._addSocketListeners(socket)
-    socket.resume()
-    return socket
   }
 
   /**
-   * Creates a tunnel to a Proxy for SSL connections.
-   * The returned socket is the one created after the tunnel is established.
-   * @param proxyIsSsl Whether the proxy is an SSL connection.
-   * @returns Promise resolved when socket is connected.
+   * Handles the response with NTLM authorization
    */
-  async connectTunnel(proxyIsSsl = false): Promise<net.Socket | undefined> {
-    this.logger.debug(`Creating a tunnel through the proxy...`)
-    const { proxy } = this.opts
-    const { url } = this.request
-    if (!proxy) {
-      throw new Error(`No proxy configuration found.`)
-    }
-    let proxyUrl = proxy
-    if (proxyIsSsl && !proxyUrl.startsWith('https:')) {
-      proxyUrl = `https://${proxyUrl}`
-    } else if (!proxyIsSsl && !proxyUrl.startsWith('http:')) {
-      proxyUrl = `http://${proxyUrl}`
-    }
-    const proxyUri = new URL(proxyUrl)
-    const targetUrl = new URL(url)
-    const proxyPort = proxyUri.port || (proxyIsSsl ? 443 : 80)
-    const targetPort = targetUrl.port || 443 // target is always SSL so 443.
-    const authority = `${targetUrl.hostname}:${targetPort}`
-    const connectOptions: https.RequestOptions = {
-      host: proxyUri.hostname,
-      port: proxyPort,
-      method: 'CONNECT',
-      path: authority,
-      headers: {
-        host: authority,
-      },
-    }
-    if (proxyIsSsl) {
-      connectOptions.rejectUnauthorized = false
-      // @ts-expect-error This is correct!
-      connectOptions.requestOCSP = false
-    }
-    const auth = this._proxyAuthHeader()
-    if (auth) {
-      this.logger.debug(`Adding proxy authorization.`)
-      ;(connectOptions.headers as http.OutgoingHttpHeaders)['proxy-authorization'] = auth
-    }
-    const lib = proxyIsSsl ? https : http
-    return new Promise((resolve, reject) => {
-      this.stats.connectionTime = Date.now()
-      const connectRequest = lib.request(connectOptions)
-      connectRequest.once('socket', (socket: net.Socket) => {
-        socket.on('lookup', () => {
-          this.stats.lookupTime = Date.now()
-        })
-      })
+  async handleNtlmResponse(): Promise<void> {
+    this.logger.debug('Handling NTLM response...')
+    this.logger.debug('Current headers:', this.currentHeaders?.toString())
+    this.logger.debug('Auth state:', this.authManager.getAuthState())
 
-      connectRequest.on('error', (err) => {
-        this.logger.error('Error establishing proxy tunnel:', err)
-        reject(
-          new SerializableError(
-            `Failed to establish proxy tunnel: ${err.message}`,
-            (err as Error & { code: string }).code ? Number((err as Error & { code: string }).code) : 111
-          )
-        )
-      })
+    const shouldRetry = this.authManager.handleNtlmResponse(this.currentHeaders)
+    this.logger.debug('Should retry NTLM:', shouldRetry)
 
-      connectRequest.on('connect', async (res: http.IncomingMessage, socket: net.Socket, head: Buffer) => {
-        const time = Date.now()
-        this.stats.connectedTime = time
-        this.stats.secureStartTime = time
-        if (typeof this.stats.lookupTime === 'undefined') {
-          this.stats.lookupTime = time
-        }
-        if (res.statusCode === 401) {
-          this.currentHeaders = new Headers(res.headers)
-          const currentResponse = Response.fromValues(res.statusCode, res.statusMessage, this.currentHeaders.toString())
-          currentResponse.loadingTime = 0
-          this.currentResponse = currentResponse
-          if (head.length) {
-            this._rawBody = head
-            currentResponse.payload = PayloadSerializer.stringifyBuffer(head)
-          }
-          connectRequest.destroy()
-          resolve(undefined)
-          setTimeout(() => {
-            // const e = new NetError('The proxy requires authentication.', 127);
-            this._publishResponse()
-          })
-        } else if (res.statusCode === 407) {
-          await this.handleProxyAuthentication(res, socket)
-        } else if (res.statusCode !== 200) {
-          this.logger.debug(`The proxy tunnel ended with ${res.statusCode} status code. Erroring request.`)
-          connectRequest.destroy()
-          const errorMessage =
-            res.statusMessage || `Proxy tunnel establishment failed with status code ${res.statusCode}`
-          const e = new SerializableError(errorMessage, res.statusCode)
-          reject(e)
-        } else {
-          this.logger.debug(`Established a proxy tunnel.`)
-          this.logger.debug(`Upgrading connection to SSL...`)
-          const tlsSocket = tls.connect({ socket, rejectUnauthorized: false }, () => {
-            this.logger.debug(`Connection upgraded to SSL.`)
-            resolve(tlsSocket)
-          })
-          tlsSocket.once('secureConnect', () => {
-            this.stats.secureConnectedTime = Date.now()
-          })
-        }
-      })
-      connectRequest.end()
-    })
-  }
+    if (shouldRetry) {
+      // Update the parent auth state to match AuthManager state
+      this.auth = this.authManager.getAuthState()
+      this._cleanUpRedirect()
 
-  async handleProxyAuthentication(res: http.IncomingMessage, socket: net.Socket): Promise<void> {
-    if (res.statusCode === 407) {
-      // Proxy Authentication Required
-      this.currentHeaders = new Headers(res.headers)
-      const authHeader = this.currentHeaders.get('proxy-authenticate')
-
-      if (authHeader && authHeader.startsWith('Digest')) {
-        // Parse the Digest challenge and update _proxyAuthHeader to generate the correct response.
-        this._errorRequest(new SerializableError(`Unsupported proxy authentication scheme: ${authHeader}`, 127))
-        socket.destroy()
-        // this._cleanUpRedirect(); // Might need adjustments
-        // const message = await this.prepareMessage();
-        // this.writeMessage(message);
-      } else if (authHeader && authHeader.startsWith('Basic')) {
-        // Basic auth is usually handled directly in _proxyAuthHeader, so this might be redundant.
-        this._cleanUpRedirect() // Might need adjustments
+      try {
         const message = await this.prepareMessage()
-        this.writeMessage(message)
-      } else {
-        // Unsupported authentication scheme
-        this._errorRequest(new SerializableError(`Unsupported proxy authentication scheme: ${authHeader}`, 127))
-        socket.destroy()
+        await this.writeMessage(message)
+        // Don't return here - let the socket listeners handle the response
+      } catch (error) {
+        this.logger.error('Failed to retry NTLM authentication:', error)
+        this._errorRequest({
+          message: `NTLM retry failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        })
       }
+      return
     }
-  }
 
-  /**
-   * Creates connection to a proxy for an HTTP (non-SSL) transport.
-   * This is the same as calling _connect or _connectTls but the target is the proxy and not the
-   * target URL. The message sent to the proxy server is different than the one sent
-   * to the target.
-   * @param proxyIsSsl
-   * @returns Promise resolved when socket is connected.
-   */
-  async proxyHttp(proxyIsSsl = false): Promise<net.Socket> {
-    this.logger.debug('Proxying an HTTP request...')
-    const { proxy } = this.opts
-    if (!proxy) {
-      throw new Error(`No proxy configuration found.`)
-    }
-    let proxyUrl = proxy
-    if (proxyIsSsl && !proxyUrl.startsWith('https:')) {
-      proxyUrl = `https://${proxyUrl}`
-    } else if (!proxyIsSsl && !proxyUrl.startsWith('http:')) {
-      proxyUrl = `http://${proxyUrl}`
-    }
-    const proxyUri = new URL(proxyUrl)
-    const port = Number(proxyUri.port || 443)
-    const host = proxyUri.hostname
-    let socket
-    try {
-      if (proxyIsSsl) {
-        socket = await this._connectTls(port, host)
-      } else {
-        socket = await this._connect(port, host)
-      }
-    } catch (error) {
-      const err = error as Error & { code?: string }
-      throw new SerializableError(`Failed to connect to proxy: ${err.message}`, err.code ? Number(err.code) : 112)
-    }
-    return socket
+    this.logger.debug('NTLM authentication completed')
+    // Clear both auth states
+    this.authManager.clearAuthState()
+    delete this.auth
+    this.emit('loadend')
+    this._publishResponse()
   }
 }