@kubb/plugin-axios 5.9.0 → 5.9.2

package/templates/axios.ts

@@ -9,14 +9,8 @@ import { ParseError, type StandardSchemaValidator, validateStandardSchema } from
  */
 export type SuccessStatusCode = '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226'
 
-/**
- * The success members of a per-status responses record.
- */
 export type SuccessOf<TResponses> = TResponses[Extract<keyof TResponses, SuccessStatusCode>]
 
-/**
- * The error members of a per-status responses record, every documented status that is not a 2xx.
- */
 export type ErrorOf<TResponses> = TResponses[Exclude<keyof TResponses, SuccessStatusCode>]
 
 /**
@@ -25,12 +19,12 @@ export type ErrorOf<TResponses> = TResponses[Exclude<keyof TResponses, SuccessSt
 export type ToStatusNumber<TStatus> = TStatus extends `${infer TNumber extends number}` ? TNumber : number
 
 /**
- * The plain body of a per-status response, unwrapping the `{ contentType; data }` union so an error result keeps the bare body union on `error`.
+ * Unwraps content-type variants to keep the bare body on `error`.
  */
 export type DataOf<T> = T extends { contentType: string; data: infer TData } ? TData : T
 
 /**
- * The success variant for a single status, flattened so the negotiated `contentType` sits next to `data` and `switch (result.contentType)` narrows it.
+ * Keeps `contentType` beside `data` so switching on it narrows the body.
  */
 export type SuccessVariant<TStatus, TEntry, TRequest, TResponse> = TEntry extends { contentType: string; data: unknown }
   ? TEntry extends { contentType: infer TContentType; data: infer TData }
@@ -39,7 +33,7 @@ export type SuccessVariant<TStatus, TEntry, TRequest, TResponse> = TEntry extend
   : { status: ToStatusNumber<TStatus>; data: TEntry; error: undefined; contentType: string | undefined; request: TRequest; response: TResponse }
 
 /**
- * One result variant for a single documented status, keyed by the numeric `status` so a `switch (result.status)` narrows `data` or `error`.
+ * Narrows `data` or `error` when switching on the numeric status.
  */
 export type ResultByStatus<TResponses, TStatus extends keyof TResponses, TRequest, TResponse> = TStatus extends SuccessStatusCode
   ? SuccessVariant<TStatus, TResponses[TStatus], TRequest, TResponse>
@@ -52,22 +46,19 @@ export type ResultByStatus<TResponses, TStatus extends keyof TResponses, TReques
       response: TResponse
     }
 
-/**
- * The union of every documented status' result variant.
- */
 export type ResultUnion<TResponses, TRequest, TResponse> = {
   [TStatus in keyof TResponses]: ResultByStatus<TResponses, TStatus, TRequest, TResponse>
 }[keyof TResponses]
 
 /**
- * The union of just the success (2xx) status variants, selected by status code so an untyped error payload can never widen `data`.
+ * Selects success statuses without letting untyped error payloads widen `data`.
  */
 export type SuccessResultUnion<TResponses, TRequest, TResponse> = {
   [TStatus in Extract<keyof TResponses, SuccessStatusCode>]: ResultByStatus<TResponses, TStatus, TRequest, TResponse>
 }[Extract<keyof TResponses, SuccessStatusCode>]
 
 /**
- * The shape every generated function returns, discriminated by the top-level `status`, narrowing to the 2xx variants under `throwOnError` and to every documented status without it.
+ * Narrows `data` and `error` by status. With `throwOnError`, includes only success variants.
  */
 export type RequestResult<TResponses, ThrowOnError extends boolean = true, TRequest = AxiosRequestConfig, TResponse = AxiosResponse> = ThrowOnError extends true
   ? [SuccessResultUnion<TResponses, TRequest, TResponse>] extends [never]
@@ -94,11 +85,15 @@ export type Unwrappable<T extends { data: unknown; error: unknown }> = Promise<T
 /**
  * Attaches `unwrap()` to a result promise, which rejects with `error` when the result carried one.
  *
- * @example Full result
- * `const { data, error } = await getPetById({ path: { petId: 1 } })`
+ * @example
+ * ```ts
+ * const { data, error } = await getPetById({ path: { petId: 1 } })
+ * ```
  *
- * @example Success body only
- * `const pet = await getPetById({ path: { petId: 1 } }).unwrap()`
+ * @example
+ * ```ts
+ * const pet = await getPetById({ path: { petId: 1 } }).unwrap()
+ * ```
  */
 export function withUnwrap<T extends { data: unknown; error: unknown }>(promise: Promise<T>): Unwrappable<T> {
   const unwrappable = promise as Unwrappable<T>
@@ -123,33 +118,27 @@ export type UnwrappedResult<
 
 /**
  * Returns the success body when `throwOnError` is true, or the full result when it is false.
- * Backs generated operations with `returnType: 'data'`.
  */
 export function unwrapResult<T extends { data: unknown; error: unknown }>(promise: Promise<T>, throwOnError: boolean | undefined): Promise<T | T['data']> {
   return promise.then((result) => ((throwOnError ?? true) ? result.data : result))
 }
 
-/**
- * The data-shaped keys of the grouped options object, which `Options` re-adds typed per operation.
- */
 export type DataShape = { body?: unknown; cookies?: unknown; headers?: unknown; path?: unknown; query?: unknown }
 
 export type ResponseType = 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream' | 'formdata'
 
 /**
- * Turns a raw response body into a parsed value, registered per media type as a codec's `deserialize` to handle formats the runtime does not decode itself.
+ * Decodes a response body for a codec's media type.
  */
 export type Deserializer<T = unknown> = (raw: unknown, contentType: string) => T | Promise<T>
 
 /**
- * Serializes a request body for a single media type, registered per content type as a codec's `serialize` to encode formats the default serializer does not handle.
+ * Encodes a request body for a codec's media type.
  */
 export type ContentBodySerializer = (body: unknown, contentType?: string) => unknown
 
 /**
- * A per-content-type codec registered on `codecs`, keyed by content type. `serialize` encodes the
- * request body for that media type and `deserialize` decodes the response body. Either half is
- * optional, so a codec can handle one direction.
+ * Encodes requests or decodes responses for a media type. Either direction can be omitted.
  */
 export type Codec = {
   serialize?: ContentBodySerializer
@@ -157,23 +146,17 @@ export type Codec = {
 }
 
 /**
- * The per-call content type selection, where a bare string sets the request content type and the object form also sets the response format sent as `Accept`.
+ * A string sets the request content type. The object form can also set `Accept`.
  */
 export type ContentType = string | { request?: string; response?: string }
 
 /**
- * A Standard Schema validator (zod, valibot, arktype) that parses a value before it is sent or after
- * it is received. `runValidator` runs it through `validateStandardSchema`. Wired through the per-call
- * `validator.request` / `validator.response` / `validator.error` hooks (`error` runs on the error body when a
- * non-2xx call does not throw), and `validator.path` / `validator.query` / `validator.headers` for the
- * request params.
+ * Validates request bodies and params, success bodies, or non-throwing error bodies with Standard Schema.
  */
 export type Validator<T = unknown> = StandardSchemaValidator<T>
 
 /**
- * The failing value and the call it came from, handed to `onValidationError` alongside the `ParseError`.
- * `direction` says which side rejected it: the request, the success body, or the error body. `source`
- * says which part of it: the body, or one of the request param groups.
+ * Identifies the value and request that failed validation in `onValidationError`.
  */
 export type ValidationErrorContext = {
   value: unknown
@@ -185,9 +168,7 @@ export type ValidationErrorContext = {
 }
 
 /**
- * Decides what a failed validation does. Returning nothing rethrows the `ParseError`; returning
- * `{ value }` resolves the call with that value instead, so a drifted body can be reported and still
- * delivered. The box keeps an explicit `{ value: undefined }` substitution distinct from declining.
+ * Return `{ value }` to substitute a failed value, including `undefined`. Returning nothing rethrows the `ParseError`.
  */
 export type ValidationErrorHandler = (error: ParseError, context: ValidationErrorContext) => { value: unknown } | void | Promise<{ value: unknown } | void>
 
@@ -203,7 +184,7 @@ export type Auth = {
 }
 
 /**
- * The raw token a consumer returns for a scheme (or `user:password` for basic), or `undefined` to skip it.
+ * Return `user:password` for basic auth, or `undefined` to skip a scheme.
  */
 export type AuthToken = string | undefined
 
@@ -217,9 +198,6 @@ export type AuthResolver = AuthToken | ((auth: Auth) => AuthToken | Promise<Auth
  */
 export type AxiosOptions = AxiosRequestConfig
 
-/**
- * The request a generated function hands to the runtime, with `body` / `headers` / `path` / `query` from the grouped options.
- */
 export type RequestConfig<TBody = unknown, TRequest = AxiosRequestConfig, TResponse = AxiosResponse> = {
   baseURL?: string
   url?: string
@@ -248,8 +226,7 @@ export type RequestConfig<TBody = unknown, TRequest = AxiosRequestConfig, TRespo
 }
 
 /**
- * The grouped options object passed to every generated function: the request config minus the
- * data-shaped keys and the literal `url`, plus the per-operation `<Name>Request`.
+ * Combines client options with the operation's typed request params and body.
  */
 export type Options<TData extends DataShape, ThrowOnError extends boolean = true, TRequest = AxiosRequestConfig, TResponse = AxiosResponse> = Omit<
   RequestConfig<unknown, TRequest, TResponse>,
@@ -276,9 +253,6 @@ export type ClientConfig = {
   auth?: AuthResolver
 }
 
-/**
- * The result a resolved call produces before it is cast to `RequestResult` by the generated wrapper.
- */
 export type CallResult<TRequest = AxiosRequestConfig, TResponse = AxiosResponse> = {
   status: number
   data: unknown
@@ -294,7 +268,7 @@ export type InterceptorFn<T, TRequest = AxiosRequestConfig, TResponse = AxiosRes
 ) => T | Promise<T>
 
 /**
- * A single interceptor channel with a transport-agnostic `use` / `eject` / `update` API, backed by axios's native interceptor managers.
+ * Registers, removes, or replaces handlers on axios's native interceptor managers.
  */
 export type InterceptorChannel<T, TRequest = AxiosRequestConfig, TResponse = AxiosResponse> = {
   use: (fn: InterceptorFn<T, TRequest, TResponse>) => number
@@ -303,7 +277,7 @@ export type InterceptorChannel<T, TRequest = AxiosRequestConfig, TResponse = Axi
 }
 
 /**
- * The three interceptor channels every client instance exposes, wrapping axios's native managers with `error` mapped onto the response rejection handler.
+ * Maps error interceptors to axios's response rejection handler.
  */
 export type Interceptors<TRequest = AxiosRequestConfig, TResponse = AxiosResponse> = {
   request: InterceptorChannel<InternalAxiosRequestConfig, TRequest, TResponse>
@@ -410,13 +384,6 @@ function getHeader(headers: Record<string, string>, name: string): string | unde
   return key ? headers[key] : undefined
 }
 
-function hasHeader(headers: Record<string, string>, name: string): boolean {
-  return Object.keys(headers).some((k) => k.toLowerCase() === name.toLowerCase())
-}
-
-/**
- * Joins the URL parts, interpolates URL-encoded `{param}` segments, and appends the serialized query, backing `getUrl`.
- */
 function serializeUrl({
   parts,
   pathParams,
@@ -437,69 +404,48 @@ function serializeUrl({
   return path + (search ? `?${search}` : '')
 }
 
-/**
- * Wraps an axios interceptor registration behind the shared `use` / `eject` / `update` API, mapping a stable external id onto axios's own so `update` can swap a handler in place.
- * `detach` / `attach` move every registered handler to another instance, keeping the external ids.
- */
-function createInterceptorChannel<T, TRequest, TResponse>(
-  register: (fn: InterceptorFn<T, TRequest, TResponse>) => number,
-  ejectNative: (id: number) => void,
-  getRequestConfig: (value: T) => RequestConfig<unknown, TRequest, TResponse> | undefined,
-  getContextId: (value: T) => number | undefined,
-  setContextId: (value: T, id: number | undefined) => void,
-  nextSeq?: () => number,
-): InterceptorChannel<T, TRequest, TResponse> & {
+function createInterceptorChannel<T, TRequest, TResponse>({
+  register,
+  ejectNative,
+  nextSeq,
+}: {
+  register: (fn: InterceptorFn<T, TRequest, TResponse>) => number
+  ejectNative: (id: number) => void
+  nextSeq: () => number
+}): InterceptorChannel<T, TRequest, TResponse> & {
   detach: () => void
-  attach: () => void
   getEntries: () => Array<{ seq: number; attach: () => void }>
 } {
-  const ids = new Map<number, number>()
-  const handlers = new Map<number, { fn: InterceptorFn<T, TRequest, TResponse>; seq: number }>()
+  const handlers = new Map<number, { fn: InterceptorFn<T, TRequest, TResponse>; seq: number; nativeId: number }>()
   let counter = 0
-  const getSeq = nextSeq ?? (() => ++counter)
-  const registerWithContext = (fn: InterceptorFn<T, TRequest, TResponse>) =>
-    register(async (value) => {
-      const contextId = getContextId(value)
-      const result = await fn(value, getRequestConfig(value))
-      if (contextId !== undefined) setContextId(result, contextId)
-      return result
-    })
 
   return {
     use(fn) {
       const id = ++counter
-      const seq = getSeq()
-      handlers.set(id, { fn, seq })
-      ids.set(id, registerWithContext(fn))
+      handlers.set(id, { fn, seq: nextSeq(), nativeId: register(fn) })
       return id
     },
     eject(id) {
-      const nativeId = ids.get(id)
-      if (nativeId === undefined) return
-      ejectNative(nativeId)
-      ids.delete(id)
+      const entry = handlers.get(id)
+      if (!entry) return
+      ejectNative(entry.nativeId)
       handlers.delete(id)
     },
     update(id, fn) {
-      const nativeId = ids.get(id)
-      if (nativeId === undefined) return
-      ejectNative(nativeId)
-      const seq = getSeq()
-      handlers.set(id, { fn, seq })
-      ids.set(id, registerWithContext(fn))
+      const entry = handlers.get(id)
+      if (!entry) return
+      ejectNative(entry.nativeId)
+      handlers.set(id, { fn, seq: nextSeq(), nativeId: register(fn) })
     },
     detach() {
-      for (const nativeId of ids.values()) ejectNative(nativeId)
-      ids.clear()
-    },
-    attach() {
-      const sorted = Array.from(handlers.entries()).sort((a, b) => a[1].seq - b[1].seq)
-      for (const [id, entry] of sorted) ids.set(id, registerWithContext(entry.fn))
+      for (const entry of handlers.values()) ejectNative(entry.nativeId)
     },
     getEntries() {
-      return Array.from(handlers.entries()).map(([id, entry]) => ({
+      return Array.from(handlers.values(), (entry) => ({
         seq: entry.seq,
-        attach: () => ids.set(id, registerWithContext(entry.fn)),
+        attach() {
+          entry.nativeId = register(entry.fn)
+        },
       }))
     },
   }
@@ -521,18 +467,23 @@ export async function resolveAuth(params: {
     const token = typeof auth === 'function' ? await auth(scheme) : auth
     if (token === undefined) continue
 
-    if (scheme.type === 'apiKey') {
-      const name = scheme.name ?? 'Authorization'
-      if (scheme.in === 'query') {
-        if (query[name] === undefined) query[name] = token
-      } else if (scheme.in === 'cookie') {
-        headers['Cookie'] = [headers['Cookie'], `${name}=${token}`].filter(Boolean).join('; ')
-      } else if (!hasHeader(headers, name)) {
-        headers[name] = token
+    if (scheme.type !== 'apiKey') {
+      if (getHeader(headers, 'Authorization') === undefined) {
+        headers['Authorization'] = scheme.scheme === 'basic' ? `Basic ${btoa(token)}` : `Bearer ${token}`
       }
-    } else if (!hasHeader(headers, 'Authorization')) {
-      headers['Authorization'] = scheme.scheme === 'basic' ? `Basic ${btoa(token)}` : `Bearer ${token}`
+      return
+    }
+
+    const name = scheme.name ?? 'Authorization'
+    if (scheme.in === 'query') {
+      if (query[name] === undefined) query[name] = token
+      return
+    }
+    if (scheme.in === 'cookie') {
+      headers['Cookie'] = [headers['Cookie'], `${name}=${token}`].filter(Boolean).join('; ')
+      return
     }
+    if (getHeader(headers, name) === undefined) headers[name] = token
     return
   }
 }
@@ -559,35 +510,17 @@ async function runValidator<T>({
   }
 }
 
-/**
- * The base media type of a `Content-Type` value, lowercased and stripped of any `; charset=...` parameters.
- */
 function baseContentType(value: string | null | undefined): string | undefined {
   if (!value) return undefined
   return value.split(';')[0]!.trim().toLowerCase() || undefined
 }
 
-/**
- * Reads the negotiated response content type from the response headers as a base media type.
- */
 function getResponseContentType(headers: Record<string, unknown> | undefined): string | undefined {
   if (!headers) return undefined
   const value = headers['content-type'] ?? headers['Content-Type']
   return baseContentType(typeof value === 'string' ? value : undefined)
 }
 
-/**
- * Normalizes the `contentType` option to its `{ request, response }` form, treating a bare string as the request content type.
- */
-function resolveContentType(contentType: ContentType | undefined): { request?: string; response?: string } {
-  if (typeof contentType === 'string') return { request: contentType }
-  return contentType ?? {}
-}
-
-/**
- * The per-concern serializers for a call, the per-call serializer winning over the client's and
- * falling back to the defaults.
- */
 function resolveSerializers({ config, requestConfig }: { config: { serializer?: Serializers }; requestConfig: { serializer?: Serializers } }) {
   return {
     querySerializer: requestConfig.serializer?.query ?? config.serializer?.query ?? defaultQuerySerializer,
@@ -596,11 +529,6 @@ function resolveSerializers({ config, requestConfig }: { config: { serializer?:
   }
 }
 
-/**
- * Resolves everything a call needs before it touches axios: merged headers with the negotiated
- * content type, auth on headers or query, serialized cookies, the validated and serialized body,
- * and the final axios request config with `throwOnError` riding `validateStatus`.
- */
 async function resolveRequest<TBody, TRequest, TResponse>({
   config,
   requestConfig,
@@ -626,9 +554,10 @@ async function resolveRequest<TBody, TRequest, TResponse>({
   )
 
   const headers = serializeHeaders(applyHeaderStyles(validatedHeaders as HeadersInit | undefined, requestConfig.styles?.header))
-  const { request: requestContentTypeOption, response: responseContentType } = resolveContentType(requestConfig.contentType)
+  const contentType = requestConfig.contentType
+  const { request: requestContentTypeOption, response: responseContentType } = typeof contentType === 'string' ? { request: contentType } : (contentType ?? {})
   const requestContentType = requestContentTypeOption ?? getHeader(headers, 'content-type')
-  if (responseContentType && !hasHeader(headers, 'accept')) {
+  if (responseContentType && getHeader(headers, 'accept') === undefined) {
     headers['Accept'] = responseContentType
   }
 
@@ -658,17 +587,18 @@ async function resolveRequest<TBody, TRequest, TResponse>({
   const body = contentCodec?.serialize
     ? contentCodec.serialize(validatedBody, requestContentType)
     : bodySerializer({ body: validatedBody, contentType: requestContentType, encoding: requestConfig.styles?.body })
-  // A FormData body must keep its Content-Type unset so axios appends the multipart boundary.
+  if (requestContentTypeOption) headers['Content-Type'] = requestContentTypeOption
+  if (body instanceof URLSearchParams && getHeader(headers, 'content-type') === undefined) {
+    headers['Content-Type'] = 'application/x-www-form-urlencoded'
+  }
+  if (usesDefaultBodySerializer && isDefaultJsonBody(validatedBody) && getHeader(headers, 'content-type') === undefined) {
+    headers['Content-Type'] = 'application/json'
+  }
+  // The transport must set the multipart boundary, even when a content type was explicitly provided.
   if (body instanceof FormData) {
     for (const key of Object.keys(headers)) {
       if (key.toLowerCase() === 'content-type') delete headers[key]
     }
-  } else if (requestContentTypeOption) {
-    headers['Content-Type'] = requestContentTypeOption
-  } else if (body instanceof URLSearchParams && !hasHeader(headers, 'content-type')) {
-    headers['Content-Type'] = 'application/x-www-form-urlencoded'
-  } else if (usesDefaultBodySerializer && isDefaultJsonBody(validatedBody) && !hasHeader(headers, 'content-type')) {
-    headers['Content-Type'] = 'application/json'
   }
 
   const pathParams = (validatedPath ?? {}) as Record<string, unknown>
@@ -683,7 +613,7 @@ async function resolveRequest<TBody, TRequest, TResponse>({
   const options = config.options || requestConfig.options ? { ...config.options, ...requestConfig.options } : undefined
 
   const axiosConfig: AxiosRequestConfig = {
-    ...options, // timeout, proxy, maxRedirects, decompress, onUploadProgress, …
+    ...options,
     url,
     baseURL: requestConfig.baseURL ?? config.baseURL,
     method: requestConfig.method ?? 'GET',
@@ -708,61 +638,7 @@ async function resolveRequest<TBody, TRequest, TResponse>({
 }
 
 /**
- * Turns an axios response into the call result: decodes the body through the matching codec and
- * validates the success or error body. A thrown axios error never reaches this, so `error` here is
- * always the body of a non-2xx response that `validateStatus` let through.
- */
-async function settleResponse<TRequest, TResponse>({
-  response,
-  codecs,
-  validator,
-  onValidationError,
-}: {
-  response: AxiosResponse
-  codecs: Record<string, Codec>
-  validator: { response?: Validator; error?: Validator } | undefined
-  onValidationError: ValidationErrorHandler | undefined
-}): Promise<CallResult<TRequest, TResponse>> {
-  const isSuccess = response.status >= 200 && response.status < 300
-  const contentType = getResponseContentType(response.headers as Record<string, unknown>)
-  let decoded: unknown = response.data
-  if (contentType) {
-    const codec = codecs[contentType]
-    if (codec?.deserialize) decoded = await codec.deserialize(response.data, contentType)
-  }
-  const validationContext = {
-    method: response.config?.method?.toUpperCase(),
-    url: response.config?.url,
-    status: response.status,
-  }
-  const data = isSuccess
-    ? await runValidator({
-        validator: validator?.response,
-        value: decoded,
-        context: { direction: 'response', source: 'body', ...validationContext },
-        onValidationError,
-      })
-    : undefined
-  const error = isSuccess
-    ? undefined
-    : await runValidator({
-        validator: validator?.error,
-        value: decoded,
-        context: { direction: 'error', source: 'body', ...validationContext },
-        onValidationError,
-      })
-  return {
-    status: response.status,
-    data,
-    error,
-    contentType,
-    request: response.config as TRequest,
-    response: response as TResponse,
-  }
-}
-
-/**
- * Builds the shared client core bound to an axios instance (defaulting to `defaultTransport`, else `axios.create()`), with `throwOnError` riding axios's `validateStatus`.
+ * Uses the configured axios instance or creates one. `throwOnError` sets axios's default `validateStatus`.
  */
 export function createClientCore<TRequest = AxiosRequestConfig, TResponse = AxiosResponse>(
   options: { defaultTransport?: AxiosInstance } & ClientConfig = {},
@@ -778,51 +654,54 @@ export function createClientCore<TRequest = AxiosRequestConfig, TResponse = Axio
     const axiosConfig = 'config' in value ? value.config : value
     return (axiosConfig as (AxiosRequestConfig & { __kubbRequestContext?: number }) | undefined)?.__kubbRequestContext
   }
-  const getRequestConfig = (value: AxiosRequestConfig | AxiosResponse | AxiosError) => {
-    const id = getContextId(value)
-    return id === undefined ? undefined : requestContexts.get(id)
-  }
   const setContextId = (value: AxiosRequestConfig | AxiosResponse | AxiosError, id: number | undefined) => {
     if (!value || typeof value !== 'object') return
     const axiosConfig = 'config' in value ? value.config : value
     if (!axiosConfig) return
     const contextualConfig = axiosConfig as AxiosRequestConfig & { __kubbRequestContext?: number }
-    if (id === undefined) delete contextualConfig.__kubbRequestContext
-    else contextualConfig.__kubbRequestContext = id
+    if (id === undefined) {
+      delete contextualConfig.__kubbRequestContext
+      return
+    }
+    contextualConfig.__kubbRequestContext = id
   }
 
+  const withContext =
+    <T extends AxiosRequestConfig | AxiosResponse | AxiosError>(fn: InterceptorFn<T, TRequest, TResponse>) =>
+    async (value: T) => {
+      const contextId = getContextId(value)
+      const requestConfig = contextId === undefined ? undefined : requestContexts.get(contextId)
+      const result = await fn(value, requestConfig)
+      if (contextId !== undefined) setContextId(result, contextId)
+      return result
+    }
+
   let sequenceCounter = 0
   const nextSeq = () => ++sequenceCounter
 
   // Read at call time so the channels follow a transport swapped in through setConfig.
   const channels = {
-    request: createInterceptorChannel<InternalAxiosRequestConfig, TRequest, TResponse>(
-      (fn) => instance.interceptors.request.use(fn),
-      (id) => instance.interceptors.request.eject(id),
-      getRequestConfig,
-      getContextId,
-      setContextId,
+    request: createInterceptorChannel<InternalAxiosRequestConfig, TRequest, TResponse>({
       nextSeq,
-    ),
-    response: createInterceptorChannel<AxiosResponse, TRequest, TResponse>(
-      (fn) => instance.interceptors.response.use(fn),
-      (id) => instance.interceptors.response.eject(id),
-      getRequestConfig,
-      getContextId,
-      setContextId,
+      register: (fn) => instance.interceptors.request.use(withContext(fn)),
+      ejectNative: (id) => instance.interceptors.request.eject(id),
+    }),
+    response: createInterceptorChannel<AxiosResponse, TRequest, TResponse>({
       nextSeq,
-    ),
-    error: createInterceptorChannel<AxiosError, TRequest, TResponse>(
-      (fn) =>
-        instance.interceptors.response.use(undefined, (error: unknown) =>
-          Promise.resolve(fn(error as AxiosError)).then((result) => Promise.reject(result ?? error)),
-        ),
-      (id) => instance.interceptors.response.eject(id),
-      getRequestConfig,
-      getContextId,
-      setContextId,
+      register: (fn) => instance.interceptors.response.use(withContext(fn)),
+      ejectNative: (id) => instance.interceptors.response.eject(id),
+    }),
+    error: createInterceptorChannel<AxiosError, TRequest, TResponse>({
       nextSeq,
-    ),
+      register: (fn) => {
+        const onError = withContext(fn)
+        return instance.interceptors.response.use(undefined, async (error: unknown) => {
+          const result = await onError(error as AxiosError)
+          throw result ?? error
+        })
+      },
+      ejectNative: (id) => instance.interceptors.response.eject(id),
+    }),
   }
   const channelList = [channels.request, channels.response, channels.error]
   const interceptors: Interceptors<TRequest, TResponse> = {
@@ -839,34 +718,52 @@ export function createClientCore<TRequest = AxiosRequestConfig, TResponse = Axio
     ;(axiosConfig as AxiosRequestConfig & { __kubbRequestContext: number }).__kubbRequestContext = contextId
 
     try {
-      try {
-        const response = await activeInstance.request<unknown, AxiosResponse>(axiosConfig)
-        const result = await settleResponse<TRequest, TResponse>({
-          response,
-          codecs,
-          validator: requestConfig.validator,
-          onValidationError: requestConfig.onValidationError ?? config.onValidationError,
+      const response = await activeInstance.request<unknown, AxiosResponse>(axiosConfig)
+      const validator = requestConfig.validator
+      const onValidationError = requestConfig.onValidationError ?? config.onValidationError
+      const isSuccess = response.status >= 200 && response.status < 300
+      const contentType = getResponseContentType(response.headers as Record<string, unknown>)
+      const codec = contentType ? codecs[contentType] : undefined
+      const decoded: unknown = contentType && codec?.deserialize ? await codec.deserialize(response.data, contentType) : response.data
+      const data = await runValidator({
+        validator: isSuccess ? validator?.response : validator?.error,
+        value: decoded,
+        context: {
+          direction: isSuccess ? 'response' : 'error',
+          source: 'body',
+          method: response.config?.method?.toUpperCase(),
+          url: response.config?.url,
+          status: response.status,
+        },
+        onValidationError,
+      })
+      const result = {
+        status: response.status,
+        data: isSuccess ? data : undefined,
+        error: isSuccess ? undefined : data,
+        contentType,
+        request: response.config as TRequest,
+        response: response as TResponse,
+      }
+      setContextId(response, undefined)
+      return result
+    } catch (error) {
+      const axiosError = error as AxiosError
+      setContextId(axiosError, undefined)
+      if (axiosError.response) setContextId(axiosError.response, undefined)
+      if (throwOnError && axiosError.response) {
+        throw new ResponseError({
+          data: axiosError.response.data,
+          status: axiosError.response.status,
+          statusText: axiosError.response.statusText,
+          contentType: getResponseContentType(axiosError.response.headers as Record<string, unknown>),
+          request: axiosError.config as TRequest,
+          response: axiosError.response as TResponse,
+          method: axiosError.config?.method?.toUpperCase(),
+          url: [axiosError.config?.baseURL?.replace(/\/+$/, ''), axiosError.config?.url].filter(Boolean).join(''),
         })
-        setContextId(response, undefined)
-        return result
-      } catch (error) {
-        const axiosError = error as AxiosError
-        setContextId(axiosError, undefined)
-        if (axiosError.response) setContextId(axiosError.response, undefined)
-        if (throwOnError && axiosError.response) {
-          throw new ResponseError({
-            data: axiosError.response.data,
-            status: axiosError.response.status,
-            statusText: axiosError.response.statusText,
-            contentType: getResponseContentType(axiosError.response.headers as Record<string, unknown>),
-            request: axiosError.config as TRequest,
-            response: axiosError.response as TResponse,
-            method: axiosError.config?.method?.toUpperCase(),
-            url: [axiosError.config?.baseURL?.replace(/\/+$/, ''), axiosError.config?.url].filter(Boolean).join(''),
-          })
-        }
-        throw error
       }
+      throw error
     } finally {
       setContextId(axiosConfig, undefined)
       requestContexts.delete(contextId)
@@ -880,9 +777,8 @@ export function createClientCore<TRequest = AxiosRequestConfig, TResponse = Axio
     if (nextInstance !== instance) {
       for (const channel of channelList) channel.detach()
       instance = nextInstance
-      channels.request.attach()
-      const responseEntries = [...channels.response.getEntries(), ...channels.error.getEntries()].sort((a, b) => a.seq - b.seq)
-      for (const entry of responseEntries) entry.attach()
+      const entries = channelList.flatMap((channel) => channel.getEntries()).sort((a, b) => a.seq - b.seq)
+      for (const entry of entries) entry.attach()
     }
     return config
   }
@@ -947,10 +843,20 @@ function parseEvent<TData>(raw: string): ServerSentEvent<TData> | undefined {
     const index = line.indexOf(':')
     const field = index === -1 ? line : line.slice(0, index)
     const value = index === -1 ? '' : line.slice(index + 1).replace(/^ /, '')
-    if (field === 'data') data.push(value)
-    else if (field === 'event') event.event = value
-    else if (field === 'id') event.id = value
-    else if (field === 'retry' && Number.isFinite(Number(value))) event.retry = Number(value)
+    switch (field) {
+      case 'data':
+        data.push(value)
+        break
+      case 'event':
+        event.event = value
+        break
+      case 'id':
+        event.id = value
+        break
+      case 'retry':
+        if (Number.isFinite(Number(value))) event.retry = Number(value)
+        break
+    }
   }
 
   if (!seen) return undefined
@@ -990,8 +896,7 @@ export async function* parseEventStream<TData = unknown>(
 }
 
 /**
- * The resolved shape returned by a generated `text/event-stream` operation: the typed event
- * `stream` plus the native `response`.
+ * Returns parsed events alongside the native response.
  */
 export type EventStreamResult<TData = unknown, TResponse = AxiosResponse> = {
   stream: AsyncGenerator<ServerSentEvent<TData>>
@@ -999,8 +904,7 @@ export type EventStreamResult<TData = unknown, TResponse = AxiosResponse> = {
 }
 
 /**
- * Wraps a transport result whose `data` is a streaming body into an `EventStreamResult`, exposing
- * the parsed events as a typed async iterator. Generated SSE operations call this.
+ * Exposes a streaming response body as typed Server-Sent Events.
  */
 export async function toEventStream<TData = unknown>(result: Promise<{ data: unknown; response: AxiosResponse }>): Promise<EventStreamResult<TData>> {
   const { data, response } = await result