@kubb/plugin-axios 5.0.0-beta.79 → 5.0.0-beta.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-axios",
-  "version": "5.0.0-beta.79",
+  "version": "5.0.0-beta.81",
   "description": "Generate a slim, type-safe HTTP client with Kubb based on axios.",
   "keywords": [
     "api-client",
@@ -49,11 +49,11 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/ast": "5.0.0-beta.79",
-    "@kubb/core": "5.0.0-beta.79",
-    "@kubb/renderer-jsx": "5.0.0-beta.79",
-    "@kubb/plugin-ts": "5.0.0-beta.79",
-    "@kubb/plugin-zod": "5.0.0-beta.79"
+    "@kubb/ast": "5.0.0-beta.80",
+    "@kubb/core": "5.0.0-beta.80",
+    "@kubb/renderer-jsx": "5.0.0-beta.80",
+    "@kubb/plugin-ts": "5.0.0-beta.81",
+    "@kubb/plugin-zod": "5.0.0-beta.81"
   },
   "devDependencies": {
     "axios": "^1.18.1",
@@ -63,7 +63,7 @@
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.79",
+    "@kubb/renderer-jsx": "5.0.0-beta.80",
     "axios": "^1.7.2"
   },
   "peerDependenciesMeta": {

package/src/plugin.ts

@@ -80,6 +80,7 @@ export const pluginAxios = definePlugin<PluginAxios>((options) => {
         ctx.addGenerator(...selectedGenerators)
 
         const root = path.resolve(ctx.config.root, ctx.config.output.path)
+        const baseURLExpression = baseURL ? (baseURL.includes('${') ? `\`${baseURL.replaceAll('`', '\\`')}\`` : JSON.stringify(baseURL)) : undefined
 
         ctx.injectFile({
           baseName: 'serializers.ts',
@@ -91,7 +92,7 @@ export const pluginAxios = definePlugin<PluginAxios>((options) => {
           baseName: 'client.ts',
           path: path.resolve(root, '.kubb/client.ts'),
           copy: axiosClientTemplatePath,
-          footer: baseURL ? `client.setConfig({ baseURL: ${JSON.stringify(baseURL)} })` : undefined,
+          footer: baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : undefined,
         })
 
         ctx.injectFile({

package/templates/axios.ts

@@ -254,108 +254,6 @@ export type ClientInstance<TRequest = AxiosRequestConfig, TResponse = AxiosRespo
 /**
  * Thrown for a non-2xx response, so a resolved call always means success.
  */
-/**
- * One decoded Server-Sent Event, with `data` parsed as JSON when valid and kept as the raw string otherwise.
- */
-export type ServerSentEvent<TData = unknown> = {
-  data: TData
-  event?: string
-  id?: string
-  retry?: number
-}
-
-async function* readBytes(stream: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>): AsyncGenerator<Uint8Array> {
-  if (!('getReader' in stream)) {
-    yield* stream
-    return
-  }
-
-  const reader = stream.getReader()
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) return
-      yield value
-    }
-  } finally {
-    await reader.cancel().catch(() => {})
-  }
-}
-
-function parseEvent<TData>(raw: string): ServerSentEvent<TData> | undefined {
-  const data: Array<string> = []
-  const event: ServerSentEvent<TData> = { data: undefined as TData }
-  let seen = false
-
-  for (const line of raw.split('\n')) {
-    if (!line || line.startsWith(':')) continue
-    seen = true
-    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)
-  }
-
-  if (!seen) return undefined
-
-  if (data.length) {
-    const joined = data.join('\n')
-    try {
-      event.data = JSON.parse(joined) as TData
-    } catch {
-      event.data = joined as TData
-    }
-  }
-  return event
-}
-
-/**
- * Parses a `text/event-stream` body into typed Server-Sent Events, consumed with `for await` and stopped early by breaking the loop.
- */
-export async function* parseEventStream<TData = unknown>(
-  stream: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
-): AsyncGenerator<ServerSentEvent<TData>> {
-  const decoder = new TextDecoder()
-  const normalize = (text: string) => text.replace(/\r\n|\r/g, '\n')
-  let buffer = ''
-
-  for await (const chunk of readBytes(stream)) {
-    const blocks = normalize(buffer + decoder.decode(chunk, { stream: true })).split('\n\n')
-    buffer = blocks.pop() ?? ''
-    for (const block of blocks) {
-      const event = parseEvent<TData>(block)
-      if (event) yield event
-    }
-  }
-
-  const event = parseEvent<TData>(normalize(buffer + decoder.decode()))
-  if (event) yield event
-}
-
-/**
- * The resolved shape returned by a generated `text/event-stream` operation: the typed event
- * `stream` plus the native `response`.
- */
-export type EventStreamResult<TData = unknown, TResponse = AxiosResponse> = {
-  stream: AsyncGenerator<ServerSentEvent<TData>>
-  response: TResponse
-}
-
-/**
- * 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.
- */
-export async function toEventStream<TData = unknown>(result: Promise<{ data: unknown; response: AxiosResponse }>): Promise<EventStreamResult<TData>> {
-  const { data, response } = await result
-  return {
-    response,
-    stream: parseEventStream<TData>(data as ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>),
-  }
-}
-
 export class ResponseError<TError = unknown, TRequest = AxiosRequestConfig, TResponse = AxiosResponse> extends Error {
   data: TError
   status: number
@@ -416,6 +314,32 @@ 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.
+ */
+function createInterceptorChannel<T>(register: (fn: InterceptorFn<T>) => number, ejectNative: (id: number) => void): InterceptorChannel<T> {
+  const ids = new Map<number, number>()
+  let counter = 0
+  return {
+    use(fn) {
+      const id = ++counter
+      ids.set(id, register(fn))
+      return id
+    },
+    eject(id) {
+      const nativeId = ids.get(id)
+      if (nativeId === undefined) return
+      ejectNative(nativeId)
+      ids.delete(id)
+    },
+    update(id, fn) {
+      const nativeId = ids.get(id)
+      if (nativeId !== undefined) ejectNative(nativeId)
+      ids.set(id, register(fn))
+    },
+  }
+}
+
 /**
  * Walks the per-operation security in order and places the first resolved token on the request, mutating `headers` / `query` in place.
  */
@@ -428,16 +352,23 @@ export async function resolveAuth(params: {
   const { security, auth, headers, query } = params
   if (!security?.length || auth === undefined) return
 
+  // An explicit caller-set header wins over the resolved token.
+  const hasHeader = (name: string) => Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase())
+
   for (const scheme of security) {
     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') query[name] = token
-      else if (scheme.in === 'cookie') headers.Cookie = [headers.Cookie, `${name}=${token}`].filter(Boolean).join('; ')
-      else headers[name] = token
-    } else {
+      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(name)) {
+        headers[name] = token
+      }
+    } else if (!hasHeader('Authorization')) {
       headers.Authorization = scheme.scheme === 'basic' ? `Basic ${btoa(token)}` : `Bearer ${token}`
     }
     return
@@ -449,32 +380,6 @@ async function runValidator<T>(validator: Validator<T> | undefined, value: T): P
   return validateStandardSchema(validator, value)
 }
 
-/**
- * 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.
- */
-function createInterceptorChannel<T>(register: (fn: InterceptorFn<T>) => number, ejectNative: (id: number) => void): InterceptorChannel<T> {
-  const ids = new Map<number, number>()
-  let counter = 0
-  return {
-    use(fn) {
-      const id = ++counter
-      ids.set(id, register(fn))
-      return id
-    },
-    eject(id) {
-      const nativeId = ids.get(id)
-      if (nativeId === undefined) return
-      ejectNative(nativeId)
-      ids.delete(id)
-    },
-    update(id, fn) {
-      const nativeId = ids.get(id)
-      if (nativeId !== undefined) ejectNative(nativeId)
-      ids.set(id, register(fn))
-    },
-  }
-}
-
 /**
  * The base media type of a `Content-Type` value, lowercased and stripped of any `; charset=...` parameters.
  */
@@ -500,6 +405,135 @@ function resolveContentType(contentType: ContentType | undefined): { request?: s
   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,
+    bodySerializer: requestConfig.serializer?.body ?? config.serializer?.body ?? defaultBodySerializer,
+    pathSerializer: requestConfig.serializer?.path ?? config.serializer?.path ?? defaultPathSerializer,
+  }
+}
+
+/**
+ * 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,
+}: {
+  config: ClientConfig
+  requestConfig: RequestConfig<TBody, TRequest, TResponse>
+}): Promise<{ axiosConfig: AxiosRequestConfig; codecs: Record<string, Codec>; throwOnError: boolean }> {
+  const { querySerializer, bodySerializer, pathSerializer } = resolveSerializers({ config, requestConfig })
+  const codecs = { ...config.codecs, ...requestConfig.codecs }
+
+  const headers = mergeHeaders(config.headers, applyHeaderStyles(requestConfig.headers, requestConfig.styles?.header))
+  const { request: requestContentTypeOption, response: responseContentType } = resolveContentType(requestConfig.contentType)
+  const requestContentType = requestContentTypeOption ?? headers['Content-Type'] ?? headers['content-type']
+  if (responseContentType && headers['Accept'] === undefined && headers['accept'] === undefined) {
+    headers['Accept'] = responseContentType
+  }
+
+  const query: Record<string, unknown> = { ...((requestConfig.query ?? requestConfig.params) as Record<string, unknown> | undefined) }
+
+  await resolveAuth({
+    security: requestConfig.security,
+    auth: requestConfig.auth ?? config.auth,
+    headers,
+    query,
+  })
+
+  if (requestConfig.cookies) {
+    const cookie = serializeCookies(requestConfig.cookies, requestConfig.styles?.cookie)
+    if (cookie) headers.Cookie = [headers.Cookie, cookie].filter(Boolean).join('; ')
+  }
+
+  const validatedBody = await runValidator(requestConfig.validator?.request, requestConfig.body)
+  const requestContentTypeBase = baseContentType(requestContentType)
+  const contentCodec = requestContentTypeBase ? codecs[requestContentTypeBase] : undefined
+  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 (body instanceof FormData) {
+    delete headers['Content-Type']
+    delete headers['content-type']
+  } else if (requestContentTypeOption) {
+    headers['Content-Type'] = requestContentTypeOption
+  }
+
+  const pathParams = requestConfig.path ?? {}
+  const url = (requestConfig.url ?? '').replace(/\{([^{}]+)\}/g, (_, key: string) =>
+    pathSerializer({ name: key, value: pathParams[key], options: requestConfig.styles?.path?.[key] }),
+  )
+
+  const throwOnError = requestConfig.throwOnError ?? config.throwOnError ?? true
+  const validateStatus = requestConfig.validateStatus ?? config.validateStatus ?? (throwOnError ? undefined : () => true)
+
+  const options = config.options || requestConfig.options ? { ...config.options, ...requestConfig.options } : undefined
+
+  const axiosConfig: AxiosRequestConfig = {
+    ...options, // timeout, proxy, maxRedirects, decompress, onUploadProgress, …
+    url,
+    baseURL: requestConfig.baseURL ?? config.baseURL,
+    method: requestConfig.method ?? 'GET',
+    headers,
+    params: query,
+    paramsSerializer: (params) => querySerializer(params as Record<string, unknown>, requestConfig.styles?.query),
+    data: body,
+    transformRequest: (data) => data,
+    signal: requestConfig.signal,
+    responseType: requestConfig.responseType,
+    validateStatus,
+  }
+
+  // Only the fetch adapter exposes a streaming `response.data` (a ReadableStream) in the browser.
+  // The default XHR adapter buffers the whole body. Default streams to it, but respect an explicit adapter.
+  if (requestConfig.responseType === 'stream' && !axiosConfig.adapter) {
+    axiosConfig.adapter = 'fetch'
+  }
+
+  return { axiosConfig, codecs, throwOnError }
+}
+
+/**
+ * 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,
+}: {
+  response: AxiosResponse
+  codecs: Record<string, Codec>
+  validator: { response?: Validator; error?: Validator } | 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 data = isSuccess ? await runValidator(validator?.response, decoded) : undefined
+  const error = isSuccess ? undefined : await runValidator(validator?.error, decoded)
+  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 `axios.create()`), with `throwOnError` riding axios's `validateStatus`.
  */
@@ -530,96 +564,11 @@ export function createClientCore<TRequest = AxiosRequestConfig, TResponse = Axio
 
   const client = (async <TBody = unknown>(requestConfig: RequestConfig<TBody, TRequest, TResponse>): Promise<CallResult<TRequest, TResponse>> => {
     const activeInstance = requestConfig.transport ?? config.transport ?? instance
-    const querySerializer = requestConfig.serializer?.query ?? config.serializer?.query ?? defaultQuerySerializer
-    const bodySerializer = requestConfig.serializer?.body ?? config.serializer?.body ?? defaultBodySerializer
-    const pathSerializer = requestConfig.serializer?.path ?? config.serializer?.path ?? defaultPathSerializer
-    const codecs = { ...config.codecs, ...requestConfig.codecs }
-
-    const headers = mergeHeaders(config.headers, applyHeaderStyles(requestConfig.headers, requestConfig.styles?.header))
-    const { request: requestContentTypeOption, response: responseContentType } = resolveContentType(requestConfig.contentType)
-    const requestContentType = requestContentTypeOption ?? headers['Content-Type'] ?? headers['content-type']
-    if (responseContentType && headers['Accept'] === undefined && headers['accept'] === undefined) {
-      headers['Accept'] = responseContentType
-    }
-
-    const query: Record<string, unknown> = { ...((requestConfig.query ?? requestConfig.params) as Record<string, unknown> | undefined) }
-
-    await resolveAuth({
-      security: requestConfig.security,
-      auth: requestConfig.auth ?? config.auth,
-      headers,
-      query,
-    })
-
-    if (requestConfig.cookies) {
-      const cookie = serializeCookies(requestConfig.cookies, requestConfig.styles?.cookie)
-      if (cookie) headers.Cookie = [headers.Cookie, cookie].filter(Boolean).join('; ')
-    }
-
-    const validatedBody = await runValidator(requestConfig.validator?.request, requestConfig.body)
-    const requestContentTypeBase = baseContentType(requestContentType)
-    const contentCodec = requestContentTypeBase ? codecs[requestContentTypeBase] : undefined
-    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 (body instanceof FormData) {
-      delete headers['Content-Type']
-      delete headers['content-type']
-    } else if (requestContentTypeOption) {
-      headers['Content-Type'] = requestContentTypeOption
-    }
-    const pathParams = requestConfig.path ?? {}
-    const url = (requestConfig.url ?? '').replace(/\{([^{}]+)\}/g, (_, key: string) =>
-      pathSerializer({ name: key, value: pathParams[key], options: requestConfig.styles?.path?.[key] }),
-    )
-    const baseURL = [config.baseURL, requestConfig.baseURL].filter(Boolean).join('') || undefined
-
-    const throwOnError = requestConfig.throwOnError ?? config.throwOnError ?? true
-    const validateStatus = requestConfig.validateStatus ?? config.validateStatus ?? (throwOnError ? undefined : () => true)
-
-    const options = config.options || requestConfig.options ? { ...config.options, ...requestConfig.options } : undefined
-
-    const axiosConfig: AxiosRequestConfig = {
-      ...options, // timeout, proxy, maxRedirects, decompress, onUploadProgress, …
-      url,
-      baseURL,
-      method: requestConfig.method ?? 'GET',
-      headers,
-      params: query,
-      paramsSerializer: (params) => querySerializer(params as Record<string, unknown>, requestConfig.styles?.query),
-      data: body,
-      transformRequest: (data) => data,
-      signal: requestConfig.signal,
-      responseType: requestConfig.responseType,
-      validateStatus,
-    }
-
-    // Only the fetch adapter exposes a streaming `response.data` (a ReadableStream) in the browser;
-    // the default XHR adapter buffers the whole body. Default streams to it, but respect an explicit adapter.
-    if (requestConfig.responseType === 'stream' && !axiosConfig.adapter) {
-      axiosConfig.adapter = 'fetch'
-    }
+    const { axiosConfig, codecs, throwOnError } = await resolveRequest({ config, requestConfig })
 
     try {
       const response = await activeInstance.request<unknown, AxiosResponse>(axiosConfig)
-      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 data = isSuccess ? await runValidator(requestConfig.validator?.response, decoded) : undefined
-      const error = isSuccess ? undefined : await runValidator(requestConfig.validator?.error, decoded)
-      return {
-        status: response.status,
-        data,
-        error,
-        contentType,
-        request: response.config as TRequest,
-        response: response as TResponse,
-      }
+      return await settleResponse({ response, codecs, validator: requestConfig.validator })
     } catch (error) {
       const axiosError = error as AxiosError
       if (throwOnError && axiosError.response) {
@@ -642,11 +591,10 @@ export function createClientCore<TRequest = AxiosRequestConfig, TResponse = Axio
     return config
   }
   client.getUrl = (requestConfig) => {
-    const querySerializer = requestConfig.serializer?.query ?? config.serializer?.query ?? defaultQuerySerializer
-    const pathSerializer = requestConfig.serializer?.path ?? config.serializer?.path ?? defaultPathSerializer
+    const { querySerializer, pathSerializer } = resolveSerializers({ config, requestConfig })
     const query: Record<string, unknown> = { ...((requestConfig.query ?? requestConfig.params) as Record<string, unknown> | undefined) }
     return serializeUrl({
-      parts: [config.baseURL, requestConfig.baseURL, requestConfig.url],
+      parts: [requestConfig.baseURL ?? config.baseURL, requestConfig.url],
       pathParams: requestConfig.path ?? {},
       search: querySerializer(query, requestConfig.styles?.query),
       pathSerializer,
@@ -659,6 +607,108 @@ export function createClientCore<TRequest = AxiosRequestConfig, TResponse = Axio
   return client
 }
 
+/**
+ * One decoded Server-Sent Event, with `data` parsed as JSON when valid and kept as the raw string otherwise.
+ */
+export type ServerSentEvent<TData = unknown> = {
+  data: TData
+  event?: string
+  id?: string
+  retry?: number
+}
+
+async function* readBytes(stream: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>): AsyncGenerator<Uint8Array> {
+  if (!('getReader' in stream)) {
+    yield* stream
+    return
+  }
+
+  const reader = stream.getReader()
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) return
+      yield value
+    }
+  } finally {
+    await reader.cancel().catch(() => {})
+  }
+}
+
+function parseEvent<TData>(raw: string): ServerSentEvent<TData> | undefined {
+  const data: Array<string> = []
+  const event: ServerSentEvent<TData> = { data: undefined as TData }
+  let seen = false
+
+  for (const line of raw.split('\n')) {
+    if (!line || line.startsWith(':')) continue
+    seen = true
+    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)
+  }
+
+  if (!seen) return undefined
+
+  if (data.length) {
+    const joined = data.join('\n')
+    try {
+      event.data = JSON.parse(joined) as TData
+    } catch {
+      event.data = joined as TData
+    }
+  }
+  return event
+}
+
+/**
+ * Parses a `text/event-stream` body into typed Server-Sent Events, consumed with `for await` and stopped early by breaking the loop.
+ */
+export async function* parseEventStream<TData = unknown>(
+  stream: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
+): AsyncGenerator<ServerSentEvent<TData>> {
+  const decoder = new TextDecoder()
+  const normalize = (text: string) => text.replace(/\r\n|\r/g, '\n')
+  let buffer = ''
+
+  for await (const chunk of readBytes(stream)) {
+    const blocks = normalize(buffer + decoder.decode(chunk, { stream: true })).split('\n\n')
+    buffer = blocks.pop() ?? ''
+    for (const block of blocks) {
+      const event = parseEvent<TData>(block)
+      if (event) yield event
+    }
+  }
+
+  const event = parseEvent<TData>(normalize(buffer + decoder.decode()))
+  if (event) yield event
+}
+
+/**
+ * The resolved shape returned by a generated `text/event-stream` operation: the typed event
+ * `stream` plus the native `response`.
+ */
+export type EventStreamResult<TData = unknown, TResponse = AxiosResponse> = {
+  stream: AsyncGenerator<ServerSentEvent<TData>>
+  response: TResponse
+}
+
+/**
+ * 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.
+ */
+export async function toEventStream<TData = unknown>(result: Promise<{ data: unknown; response: AxiosResponse }>): Promise<EventStreamResult<TData>> {
+  const { data, response } = await result
+  return {
+    response,
+    stream: parseEventStream<TData>(data as ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>),
+  }
+}
+
 export const client = createClientCore()
 
 export const createClient = (config?: Parameters<typeof client.createClient>[0]) => client.createClient(config)