@kubb/plugin-fetch 5.13.0-canary.20261105T105941 → 5.13.0

package/docs/guides/server-sent-events.md

@@ -1,94 +1,330 @@
 # Server-sent events
 
-Operations returning `text/event-stream` produce a typed stream rather than a `RequestResult`.
+An operation that returns `text/event-stream` gives you a typed stream of events instead of a `RequestResult`. Kubb takes the event types from the OpenAPI document. The runtime in `.kubb/sse.ts` parses the stream the way the WHATWG event stream specification does.
 
-## Consume a stream
+Each event on the wire has up to four fields, and a blank line ends it:
 
-Read the `EventStreamResult.stream` with `for await`:
+| Field   | Meaning                                                                          |
+| ------- | -------------------------------------------------------------------------------- |
+| `event` | The event name. `message` when the server sends none.                            |
+| `data`  | The payload. Parsed as JSON unless the document types it as a string.            |
+| `id`    | The last event ID. It carries over to later events and resumes a dropped stream. |
+| `retry` | The reconnect delay in milliseconds.                                             |
+
+## Pick a shape
+
+Kubb reads the stream's item schema in one of two shapes, and the item's properties decide which:
+
+::field-group
+
+:::field{name="event"}
+For several named events, such as `message_delta` and `ping`. The item declares `event` or `data`, and the stream yields `TypedEvent<Item>`. See [Typed events](#typed-events).
+:::
+
+:::field{name="data"}
+For one payload on every event, such as a feed of pet changes. The item declares neither, and the stream yields `ServerSentEvent<Item>`. See [Payload only](#payload-only).
+:::
+
+::
+
+`examples/advanced` shows both shapes: `streamOrderEvents` is typed by event, and `streamPetEvents` is typed by payload.
+
+## Typed events
+
+### Describe it
+
+In OpenAPI 3.2, put one `oneOf` member per event name on `itemSchema`, with a `const` on `event`. Describe JSON inside `data` with `contentMediaType` and `contentSchema`:
+
+```yaml
+/chat:
+  post:
+    operationId: streamChat
+    responses:
+      '200':
+        description: One event per oneOf member
+        content:
+          text/event-stream:
+            itemSchema:
+              type: object
+              required: [event]
+              properties:
+                data: { type: string }
+                event: { type: string }
+                id: { type: string }
+                retry: { type: integer, minimum: 0 }
+              oneOf:
+                - properties:
+                    event: { const: message_delta }
+                    data:
+                      contentMediaType: application/json
+                      contentSchema: { $ref: '#/components/schemas/MessageDelta' }
+                - properties:
+                    event: { const: ping }
+```
+
+In OpenAPI 3.0 and 3.1, put the same `oneOf` on `schema`, with a `discriminator` on `event`. Kubb reads `schema` as one event.
+
+### The stream
+
+```text
+event: message_delta
+id: 1
+data: {"text": "Hel"}
+
+event: ping
+data: keep-alive
+
+```
+
+This stream yields two events. The `id` carries over to the second one:
+
+```typescript
+{ event: 'message_delta', id: '1', data: { text: 'Hel' } }
+{ event: 'ping', id: '1', data: 'keep-alive' }
+```
+
+### Use it
+
+Kubb generates one union member per event name:
+
+```typescript
+export type StreamChatStatus200 =
+  | { data?: MessageDelta; event: 'message_delta'; id?: string; retry?: number }
+  | { data?: string; event: 'ping'; id?: string; retry?: number }
+```
+
+A `switch` on `event` narrows `data` in each `case`:
 
 ```typescript
-import { streamEvents } from './gen/clients/streamEvents'
+import { streamChat } from './gen/clients/streamChat'
 
-const { stream } = await streamEvents({})
+const { stream } = await streamChat({ body: { prompt: 'Hi' } })
 
 for await (const event of stream) {
-  console.info(event.data)
+  switch (event.event) {
+    case 'message_delta':
+      render(event.data?.text) // MessageDelta
+      break
+    case 'ping':
+      break
+  }
 }
 ```
 
-`data` is typed from the operation's response schema. Each event also carries the optional SSE
-fields, so you can branch on the event name or read the id:
+The stream yields every event the server sends. An event name the document does not declare reaches the `default` of your `switch`, and with `validator: 'zod'` the event schema rejects it, as it would any other response that does not match the document.
+
+## Payload only
+
+### Describe it
+
+Point `itemSchema` at the payload. Keep `schema: { type: string }` next to it, so tools that read OpenAPI 3.0 or 3.1 still accept the document:
+
+```yaml
+/pet/{petId}/events:
+  get:
+    operationId: streamPetEvents
+    responses:
+      '200':
+        description: Server-Sent Events stream of pet changes
+        content:
+          text/event-stream:
+            schema:
+              type: string
+            itemSchema:
+              $ref: '#/components/schemas/PetEvent'
+```
+
+In OpenAPI 3.0 and 3.1, a `schema` without `event` or `data` properties has the same shape.
+
+### The stream
+
+```text
+data: {"type": "updated", "pet": {"id": 1, "name": "Rex"}}
+
+data: {"type": "deleted", "pet": {"id": 1, "name": "Rex"}}
+
+```
+
+This stream yields two events. The server sends no `event`, so each one is named `message`:
 
 ```typescript
-type ServerSentEvent<TData> = {
-  data: TData
-  event?: string
-  id?: string
-  retry?: number
+{ event: 'message', data: { type: 'updated', pet: { id: 1, name: 'Rex' } } }
+{ event: 'message', data: { type: 'deleted', pet: { id: 1, name: 'Rex' } } }
+```
+
+### Use it
+
+Each event is a `ServerSentEvent<PetEvent>`:
+
+```typescript
+type ServerSentEvent<TData> = { data: TData; event: string; id?: string; retry?: number }
+```
+
+Read `data` straight from each event. The result also holds the native `response` of the first connection:
+
+```typescript
+import { streamPetEvents } from './gen/clients/streamPetEvents'
+
+const { stream, response } = await streamPetEvents({ path: { petId: 1 } })
+console.info(response.status) // 200
+
+for await (const { data } of stream) {
+  console.info(data.type, data.pet.name) // PetEvent
 }
 ```
 
-The runtime parses each event's `data` as JSON when it is valid and keeps it as the raw string
-otherwise.
+## Stream options
+
+Pass these on the call, next to its request params:
 
-## Stop early
+| Option         | What it does                                                                                                                    |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| `terminator`   | Ends the stream when `data` equals this value, such as `[DONE]`. Without it, the sentinel reaches your loop.                    |
+| `transform`    | Maps each event before validation, for example to camelCase its keys.                                                           |
+| `maxEventSize` | Largest event in characters. A larger one throws a `RangeError`. Defaults to `16 * 1024 * 1024`. Set `Infinity` to turn it off. |
+| `signal`       | An `AbortSignal` that ends the request and the loop.                                                                            |
 
-Break out of the loop to stop reading. The underlying reader is canceled when the iterator
-finishes, so an early `break` releases the stream:
+To stop reading, `break` out of the loop. The runtime then cancels the reader and releases the connection.
+
+## Validate events
+
+With `validator: 'zod'` in the plugin options, the validator runs on each event: the whole event for typed events, `data` for a payload. A failing event calls `onValidationError`. Return `{ value }` to keep going, or the loop throws a `ParseError`:
 
 ```typescript
-const { stream } = await streamEvents({})
+const { stream } = await streamChat({
+  body,
+  onValidationError: (error, { value }) => {
+    console.warn(error.issues)
+    return { value }
+  },
+})
+```
 
-for await (const event of stream) {
-  if (event.event === 'done') break
-  render(event.data)
+Set `validate: false` on the call or the client to skip it. See [Handle errors](https://kubb.dev/extensions/kubb-labs/plugin-fetch/guides/error-handling) for the validation options.
+
+## Resume after a drop
+
+A dropped connection ends the loop with the transport's error. The result's `lastEventId` is the `id` of the last event the server completed, so a new call with a `Last-Event-ID` header continues where the stream stopped. The runtime does not reconnect by itself, because many streams, such as a chat completion, end on purpose, and the retry policy belongs to your app:
+
+```typescript
+let lastEventId = ''
+
+for (let attempt = 0; attempt < 3; attempt++) {
+  const result = await streamChat({ body, headers: lastEventId ? { 'Last-Event-ID': lastEventId } : {} })
+  try {
+    for await (const event of result.stream) render(event)
+    break
+  } catch (error) {
+    if (ResponseError.is(error)) throw error
+    lastEventId = result.lastEventId || lastEventId
+  }
 }
 ```
 
-To stop a stream from outside the loop, pass an `AbortSignal` and abort it. Aborting ends the
-request and the iteration:
+`lastEventId` is empty until the server sends an `id`, and an empty `id:` field clears it. An `id` that contains a NULL character is ignored. Each event carries the server's `retry` hint as `retry`.
+
+## Handle errors
+
+A non-2xx response throws a `ResponseError`, from the call or from the loop:
 
 ```typescript
-const controller = new AbortController()
-const { stream } = await streamEvents({ signal: controller.signal })
+import { ResponseError } from './gen/.kubb/client'
 
-// elsewhere, for example on component unmount
-controller.abort()
+try {
+  const { stream } = await streamChat({ body })
+  for await (const event of stream) render(event)
+} catch (error) {
+  if (!ResponseError.is(error)) throw error
+  console.error('stream rejected', error.status)
+}
 ```
 
-## Read the response
+With `throwOnError: false`, the call resolves instead of throwing, as a regular call does. The result then carries the `status` and the `error` body, its `data` is `undefined`, and its stream yields nothing. Check `data` rather than `error`, because an empty error body leaves `error` undefined. Checking `status` narrows `error` to the body the document declares for that status:
 
-Read status and headers from the native `response` before iterating:
+```typescript
+const result = await streamChat({ body, throwOnError: false })
+if (!result.data) console.error('stream rejected', result.status, result.error)
+else for await (const event of result.data) render(event)
+```
+
+As on a regular call, `.unwrap()` resolves to the events. A failed call rejects with a `ResponseError` by default, and with the `error` body when the call sets `throwOnError: false`:
 
 ```typescript
-const { stream, response } = await streamEvents({})
+for await (const event of await streamChat({ body }).unwrap()) render(event)
+```
 
-console.info(response.status) // 200
-console.info(response.headers.get('x-stream-id'))
+A stream call that gets a JSON response, such as an error body, parses it like any other call, so a 2xx JSON body yields an empty stream. An operation that declares another content type next to `text/event-stream` is generated as a normal call.
 
-for await (const event of stream) {
-  handle(event.data)
-}
+Declare heartbeat and `error` events in the document, so each has a `case` in your `switch`.
+
+## Return only the events
+
+With `returnType: 'data'` in the plugin options, a stream call returns its events, as a regular call returns only its body:
+
+```typescript
+import { pluginFetch } from '@kubb/plugin-fetch'
+
+pluginFetch({ returnType: 'data' })
 ```
 
-## Handle errors
+Both modes read the same events. The table compares them for one call:
+
+|                                     | `returnType: 'full'` (default)                                 | `returnType: 'data'`                                           |
+| ----------------------------------- | -------------------------------------------------------------- | -------------------------------------------------------------- |
+| The call returns                    | `Unwrappable<StreamResult<…>>`                                 | `Promise<UnwrappedStreamResult<…>>`                            |
+| Call it                             | `const result = await streamPetEvents({ path: { petId: 1 } })` | `const events = await streamPetEvents({ path: { petId: 1 } })` |
+| Loop over the events                | `for await (const event of result.stream)`                     | `for await (const event of events)`                            |
+| Other ways to loop                  | `result`, `result.data`, or `.unwrap()`                        | none                                                           |
+| `event.data`                        | `PetEvent`                                                     | `PetEvent`                                                     |
+| A failed call, by default           | throws a `ResponseError`                                       | throws a `ResponseError`                                       |
+| With `throwOnError: false`          | the full result                                                | the full result, as in `'full'`                                |
+| `status`, `response`, `lastEventId` | available                                                      | only with `throwOnError: false`                                |
+
+Loop over the events the call resolves to:
+
+```typescript
+import { streamOrderEvents } from './gen/clients/streamOrderEvents'
+import { streamPetEvents } from './gen/clients/streamPetEvents'
+
+const events = await streamOrderEvents({ path: { orderId: 7 } })
+
+for await (const event of events) {
+  if (event.event === 'order_placed') render(event.data) // Order
+}
+
+for await (const { data } of await streamPetEvents({ path: { petId: 1 } })) {
+  console.info(data.type) // PetEvent
+}
+```
 
-Catch non-2xx responses around the call and iteration, and rethrow other errors such as connection failures:
+A failed call throws a `ResponseError` before the first event, and a dropped connection throws from the loop:
 
 ```typescript
 import { ResponseError } from './gen/.kubb/client'
 
 try {
-  const { stream } = await streamEvents({})
-  for await (const event of stream) {
-    handle(event.data)
-  }
+  for await (const event of await streamPetEvents({ path: { petId: 1 } })) render(event)
 } catch (error) {
   if (!ResponseError.is(error)) throw error
   console.error('stream rejected', error.status)
 }
 ```
 
-> [!NOTE]
-> A drop mid-stream ends the `for await` loop. Track the last event's `id` if you need to reconnect
-> from where the stream stopped.
+With `throwOnError: false`, the call returns the full result instead, as a regular call does in this mode. The events are its `data` on a 2xx response, and checking `status` narrows `error`:
+
+```typescript
+const result = await streamPetEvents({ path: { petId: 1 }, throwOnError: false })
+
+if (!result.data) console.error('stream rejected', result.status, result.error)
+else for await (const event of result.data) render(event)
+```
+
+The events alone carry no `response` or `lastEventId`. To resume a dropped stream, use the default `returnType: 'full'`, or pass `throwOnError: false` to get the full result.
+
+## The runtime files
+
+`.kubb/sse.ts` holds the parser, `toEventStream`, and the `ServerSentEvent`, `TypedEvent`, `EventStreamOptions`, and `EventStreamResult` types. A stream operation takes `StreamOptions` and returns `StreamResult`, the stream versions of `Options` and `RequestResult`. Kubb writes it only when the document has a `text/event-stream` operation, and `.kubb/client.ts` then re-exports it, so the types import from either file. Kubb regenerates both on each run, so do not edit them:
+
+```typescript
+import type { ServerSentEvent } from './gen/.kubb/client'
+```

package/kubb-extension.json

@@ -20,7 +20,7 @@
   "dependencies": ["plugin-ts"],
   "optionalDependencies": ["plugin-zod"],
   "compatibility": {
-    "kubb": ">=5.14.6",
+    "kubb": ">=5.16.0",
     "node": ">=22.22"
   },
   "role": "client",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-fetch",
-  "version": "5.13.0-canary.20261105T105941",
+  "version": "5.13.0",
   "description": "Generate a slim, type-safe HTTP client with Kubb based on the native Fetch api.",
   "keywords": [
     "api-client",
@@ -80,14 +80,15 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/kit": "^5.15.4",
-    "@kubb/plugin-ts": "^5.5.0-canary.20261105T105941",
-    "@kubb/plugin-zod": "^5.9.0-canary.20261105T105941",
-    "@kubb/renderer-jsx": "^5.15.4"
+    "@kubb/kit": "^5.16.0",
+    "@kubb/plugin-client": "^5.10.0",
+    "@kubb/plugin-ts": "^5.4.1",
+    "@kubb/plugin-zod": "^5.8.2",
+    "@kubb/renderer-jsx": "^5.16.0"
   },
   "devDependencies": {
-    "@internals/client": "0.1.0-canary.20261105T105941",
-    "@internals/shared": "0.1.0-canary.20261105T105941",
+    "@internals/client": "0.0.0",
+    "@internals/shared": "0.0.0",
     "typescript": "^7.0.2"
   },
   "peerDependencies": {},

package/src/generators/clientGenerator.tsx

@@ -1,4 +1,5 @@
 import { createClientGenerator } from '@internals/client'
+import { sseTemplatePath } from '../templates.ts'
 import type { PluginFetch } from '../types.ts'
 
 /**
@@ -6,4 +7,4 @@ import type { PluginFetch } from '../types.ts'
  * operation using the shared `Operation` component: a grouped `<Name>Request` type and a function
  * that forwards a single `options` object to the bundled `client` and returns the `RequestResult`.
  */
-export const clientGenerator = createClientGenerator<PluginFetch>('fetch')
+export const clientGenerator = createClientGenerator<PluginFetch>('fetch', { sse: sseTemplatePath })

package/src/plugin.ts

@@ -7,7 +7,7 @@ import { version } from '../package.json'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
 import { clientGenerator } from './generators/clientGenerator.tsx'
-import { fetchClientTemplatePath, fetchSerializersTemplatePath, standardSchemaTemplatePath } from './templates.ts'
+import { fetchClientTemplatePath, coreTemplatePath, serializersTemplatePath, sseTemplatePath, standardSchemaTemplatePath } from './templates.ts'
 import type { PluginFetch, ResolvedOptions, ResolverClient } from './types.ts'
 
 /**
@@ -79,22 +79,26 @@ export const pluginFetch = defineExtension<PluginFetch>({
 
     // `sdk` swaps the per-operation functions for the class-based SDK; left unset, the standalone
     // functions (which query plugins consume) stay.
-    addGenerator(resolved.sdk ? createSdkGenerator<PluginFetch>() : clientGenerator)
+    addGenerator(resolved.sdk ? createSdkGenerator<PluginFetch>({ sse: sseTemplatePath }) : clientGenerator)
 
     const root = path.resolve(config.root, config.output.path)
-    const baseURLExpression = baseURL ? (baseURL.includes('${') ? `\`${baseURL.replaceAll('`', '\\`')}\`` : JSON.stringify(baseURL)) : undefined
 
     injectFile({
       baseName: 'serializers.ts',
       path: path.resolve(root, '.kubb/serializers.ts'),
-      copy: fetchSerializersTemplatePath,
+      copy: serializersTemplatePath,
+    })
+
+    injectFile({
+      baseName: 'core.ts',
+      path: path.resolve(root, '.kubb/core.ts'),
+      copy: coreTemplatePath,
     })
 
     injectFile({
       baseName: 'client.ts',
       path: path.resolve(root, '.kubb/client.ts'),
       copy: fetchClientTemplatePath,
-      footer: baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : undefined,
     })
 
     injectFile({

package/src/templates.ts

@@ -1,13 +1,16 @@
+import { createRequire } from 'node:module'
 import { fileURLToPath } from 'node:url'
 
-/** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
-export const fetchClientTemplatePath = fileURLToPath(new URL('../templates/fetch.ts', import.meta.url))
+const require = createRequire(import.meta.url)
 
-/** Absolute path to the fetch serializers template, copied into `.kubb/serializers.ts`. */
-export const fetchSerializersTemplatePath = fileURLToPath(new URL('../templates/serializers.ts', import.meta.url))
+/** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
+export const fetchClientTemplatePath = fileURLToPath(new URL('../templates/client.ts', import.meta.url))
 
 /**
- * Absolute path to the Standard Schema runtime template. Pass it to a file node's `copy` field to
- * emit the helper into the generated `.kubb/standardSchema.ts` verbatim.
+ * Absolute paths to the runtime templates `@kubb/plugin-client` ships for every client plugin, copied into `.kubb/core.ts`,
+ * `.kubb/serializers.ts`, `.kubb/standardSchema.ts`, and `.kubb/sse.ts`.
  */
-export const standardSchemaTemplatePath = fileURLToPath(new URL('../templates/standardSchema.ts', import.meta.url))
+export const coreTemplatePath = require.resolve('@kubb/plugin-client/templates/core.ts')
+export const serializersTemplatePath = require.resolve('@kubb/plugin-client/templates/serializers.ts')
+export const standardSchemaTemplatePath = require.resolve('@kubb/plugin-client/templates/standardSchema.ts')
+export const sseTemplatePath = require.resolve('@kubb/plugin-client/templates/sse.ts')

package/templates/client.ts

@@ -0,0 +1,111 @@
+import { createClientCore, getResponseContentType, type ResponseType, type Transport, type TransportResult } from './core.ts'
+import { isJsonMediaType } from './serializers.ts'
+import * as core from './core.ts'
+
+export * from './core.ts'
+
+/** The request and response objects of this transport, carried on every result and error. */
+export type NativeRequest = Request
+export type NativeResponse = Response
+
+/**
+ * Extra `fetch` init the transport spreads onto every `Request`, an escape hatch for fields the runtime does not set itself such as `cache`, `redirect`, and Next.js's `next`.
+ */
+export type FetchOptions = RequestInit & { next?: Record<string, unknown> }
+
+export type RequestConfig<TBody = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = core.RequestConfig<TBody, TRequest, TResponse> & {
+  options?: FetchOptions
+}
+export type Options<TData extends core.DataShape, ThrowOnError extends boolean = true, TRequest = NativeRequest, TResponse = NativeResponse> = core.Options<
+  TData,
+  ThrowOnError,
+  TRequest,
+  TResponse
+> & { options?: FetchOptions }
+export type ClientConfig<TRequest = NativeRequest, TResponse = NativeResponse> = core.ClientConfig<TRequest, TResponse> & { options?: FetchOptions }
+export type ResolvedRequest = core.ResolvedRequest & { options?: FetchOptions }
+export type ResponseError<TError = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = core.ResponseError<TError, TRequest, TResponse>
+/** The core's `ResponseError` class, typed with this transport's request and response. `instanceof` and `ResponseError.is` both match what the client throws. */
+export const ResponseError = core.ResponseError as {
+  new <TError = unknown, TRequest = NativeRequest, TResponse = NativeResponse>(
+    config: ConstructorParameters<typeof core.ResponseError<TError, TRequest, TResponse>>[0],
+  ): core.ResponseError<TError, TRequest, TResponse>
+  is: typeof core.ResponseError.is
+  // `instanceof` narrows to this type, so it carries the native request and response.
+  prototype: core.ResponseError<unknown, NativeRequest, NativeResponse>
+}
+
+function detectResponseType(contentType: string | null): ResponseType | undefined {
+  if (!contentType) return undefined
+  if (contentType.includes('text/event-stream')) return 'stream'
+  if (contentType.includes('application/json') || contentType.includes('text/json')) return 'json'
+  if (contentType.includes('text/')) return 'text'
+  if (contentType.includes('image/') || contentType.includes('application/octet-stream')) return 'blob'
+  return undefined
+}
+
+async function parseResponse(response: Response, responseType?: ResponseType): Promise<unknown> {
+  if (response.status === 204 || response.status === 205 || response.status === 304 || !response.body) {
+    return undefined
+  }
+
+  const contentType = response.headers.get('Content-Type')
+  // A server may answer a streamed operation with JSON, or with an error body: both are decoded by their content type. Any other streamed success body stays a stream.
+  const detected = responseType === 'stream' && (!response.ok || isJsonMediaType(contentType)) ? undefined : responseType
+  switch (detected ?? detectResponseType(contentType)) {
+    case 'text':
+    case 'document':
+      return response.text()
+    case 'blob':
+      return response.blob()
+    case 'arraybuffer':
+      return response.arrayBuffer()
+    case 'stream':
+      return response.body ?? undefined
+    case 'json': {
+      // An empty body with a JSON content-type would make response.json() throw, so treat it as no data.
+      const body = await response.text()
+      return body ? JSON.parse(body) : undefined
+    }
+  }
+
+  const text = await response.text()
+  if (!text) return undefined
+  try {
+    return JSON.parse(text)
+  } catch {
+    return text
+  }
+}
+
+/**
+ * The default transport that sends the resolved request through `globalThis.fetch` and returns the parsed body with the native request and response.
+ */
+export const defaultTransport: Transport = async (request: ResolvedRequest): Promise<TransportResult> => {
+  const init: RequestInit = {
+    ...request.options,
+    method: request.method,
+    headers: request.headers,
+    body: request.body,
+    signal: request.signal,
+  }
+  if (request.credentials) init.credentials = request.credentials
+
+  const nativeRequest = new Request(request.url, init)
+  const response = await globalThis.fetch(nativeRequest)
+  const data = await parseResponse(response, request.responseType)
+
+  return {
+    data,
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+    contentType: getResponseContentType(response.headers),
+    request: nativeRequest,
+    response,
+  }
+}
+
+export const client = createClientCore({ defaultTransport })
+
+export const createClient = (config?: Parameters<typeof client.createClient>[0]) => client.createClient(config)

package/templates/core.ts

@@ -0,0 +1,2 @@
+// Resolves `./core.ts` for the client template next to it. The generator copies the file from `@kubb/plugin-client` into `.kubb/core.ts`.
+export * from '@kubb/plugin-client/templates/core.ts'