@kubb/plugin-fetch 5.14.0-canary.20261109T125041 → 6.0.0

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

@@ -7,7 +7,7 @@ Each event on the wire has up to four fields, and a blank line ends it:
 | 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.            |
+| `data`  | The payload. Parsed as JSON when it is valid JSON, and kept as text otherwise.   |
 | `id`    | The last event ID. It carries over to later events and resumes a dropped stream. |
 | `retry` | The reconnect delay in milliseconds.                                             |
 
@@ -33,7 +33,7 @@ For one payload on every event, such as a feed of pet changes. The item declares
 
 ### 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`:
+In OpenAPI 3.2, put one `oneOf` member per event name on `itemSchema`, with a `const` on `event`. Point `data` at the payload schema with `$ref`. A `data` string described with `contentMediaType: application/json` and `contentSchema` is typed and parsed as that schema too:
 
 ```yaml
 /chat:
@@ -53,13 +53,16 @@ In OpenAPI 3.2, put one `oneOf` member per event name on `itemSchema`, with a `c
                 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 }
+                - type: object
+                  required: [event, data]
+                  properties:
+                    event: { type: string, const: message_delta }
+                    data: { $ref: '#/components/schemas/MessageDelta' }
+                - type: object
+                  required: [event]
+                  properties:
+                    event: { type: string, const: ping }
+                    data: { type: string }
 ```
 
 In OpenAPI 3.0 and 3.1, put the same `oneOf` on `schema`, with a `discriminator` on `event`. Kubb reads `schema` as one event.
@@ -173,16 +176,63 @@ for await (const { data } of stream) {
 }
 ```
 
+## JSON Lines
+
+An operation whose only success content type is a JSON sequence, such as `application/jsonl`, `application/x-ndjson`, or `application/json-seq`, streams one item per line. Each line is parsed as JSON, so the loop gets each item as soon as its line arrives instead of waiting for the whole body. An `application/json-seq` record must fit on one line; a record that spans several lines fails to parse.
+
+### Describe it
+
+Point `itemSchema` at the schema of one line:
+
+```yaml
+/logs:
+  get:
+    operationId: streamLogs
+    responses:
+      '200':
+        description: One LogEntry per line
+        content:
+          application/jsonl:
+            itemSchema:
+              $ref: '#/components/schemas/LogEntry'
+```
+
+In OpenAPI 3.0 and 3.1, `schema` on one of these media types describes one line.
+
+### The stream
+
+```text
+{"level": "info", "message": "started"}
+{"level": "warn", "message": "slow"}
+```
+
+The call asks for the declared media type in `Accept`. A line may end with CRLF, CR, or LF, blank lines are skipped, and a last line without a line break still counts. A line that is not valid JSON throws a `SyntaxError` from the loop.
+
+### Use it
+
+Each item is a `LogEntry`, with no event wrapper:
+
+```typescript
+import { streamLogs } from './gen/clients/streamLogs'
+
+for await (const entry of await streamLogs()) {
+  console.info(entry.level, entry.message) // LogEntry
+}
+```
+
+`terminator`, `maxEventSize`, and `signal` work per line. `transform` only applies to Server-Sent Events. With `validator: 'zod'`, the validator runs on each line. `lastEventId` stays empty, since JSON Lines has no event IDs.
+
 ## Stream options
 
 Pass these on the call, next to its request params:
 
-| 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.                                                                            |
+| Option         | What it does                                                                                                                                                                   |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `terminator`   | Ends the stream when `data` equals this value, such as `[DONE]`. Without it, the sentinel reaches your loop, or fails the `validator` when it does not match the event schema. |
+| `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.                                                                                                                           |
+| `eventShape`   | What the validator checks: `data` for the payload, `event` for the whole event. Generated calls set it.                                                                        |
 
 To stop reading, `break` out of the loop. The runtime then cancels the reader and releases the connection.
 
@@ -202,6 +252,16 @@ const { stream } = await streamChat({
 
 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.
 
+## Read the response headers
+
+A stream result carries the response `headers`, as a regular result does. When the response declares headers, such as an `X-Request-ID`, the call returns `StreamResultWithHeaders`, so `headers.get` suggests their names for the narrowed `status`:
+
+```typescript
+const result = await streamChat({ body: { prompt: 'Hi' } })
+
+console.info(result.headers.get('X-Request-ID'))
+```
+
 ## 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:
@@ -239,7 +299,7 @@ try {
 }
 ```
 
-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:
+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` to tell the two apart. An empty error body sets `error` to `{ status, statusText }`. Checking `status` narrows `error` to the body the document declares for that status:
 
 ```typescript
 const result = await streamChat({ body, throwOnError: false })
@@ -253,10 +313,51 @@ As on a regular call, `.unwrap()` resolves to the events. A failed call rejects
 for await (const event of await streamChat({ body }).unwrap()) render(event)
 ```
 
-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.
+A stream call that gets a JSON error body parses it like any other call. A 2xx answer that is not an event stream, such as a JSON body, throws a `TypeError` with the body as its `cause`, and an empty 2xx answer ends as an empty stream. An operation that declares another content type next to `text/event-stream` or a JSON Lines type is a normal call. See [JSON or an event stream](#json-or-an-event-stream).
 
 Declare heartbeat and `error` events in the document, so each has a `case` in your `switch`.
 
+## JSON or an event stream
+
+Some APIs, such as Wikimedia EventStreams, declare the same response as `application/json` and as `text/event-stream`. Kubb generates a normal call for it, which returns a `RequestResult`. The call sends `Accept: text/event-stream`, so the server streams events. To ask for JSON, pass `contentType: { response: 'application/json' }`. Wikimedia answers JSON with an endless JSON Lines body, so also pass `parseAs: 'stream'` and read `result.data` with `parseJsonLines({ stream: result.data })` from `.kubb/client`. Without it, the call waits for a body that never ends.
+
+Check `contentType` on the result. For `text/event-stream`, `data` is the raw `ReadableStream<Uint8Array>`. Pass it to `parseEventStream` from `.kubb/client` to read the events:
+
+```typescript
+import { parseEventStream } from './gen/.kubb/client'
+import { getV2StreamRecentchange } from './gen/clients/getV2StreamRecentchange'
+
+const result = await getV2StreamRecentchange({ signal })
+
+if (result.contentType === 'text/event-stream') {
+  for await (const { data } of parseEventStream(result.data)) render(data)
+} else {
+  render(result.data) // the JSON body
+}
+```
+
+To get a stream result with `lastEventId`, send the same request with `client.stream`. It throws a `TypeError` when the server answers with JSON:
+
+```typescript
+import { client } from './gen/.kubb/client'
+
+const result = await client.stream({ method: 'GET', url: '/v2/stream/recentchange', eventShape: 'data', signal })
+for await (const event of result) render(event.data)
+```
+
+## Stream with the client
+
+`client.stream(config)` runs the same interceptors and transport as `client(config)`. On a 2xx answer, it reads the body item by item and validates each item with `validator.response`. A non-2xx body is decoded whole, so `error` stays a value. Type it with the responses record, `ThrowOnError`, and the item type, which defaults to `ServerSentEvent` around the success body:
+
+```typescript
+import { client, type SuccessOf } from './gen/.kubb/client'
+import type { StreamLogsResponses } from './gen/models/StreamLogs'
+
+const result = await client.stream<StreamLogsResponses, true, SuccessOf<StreamLogsResponses>>({ method: 'GET', url: '/logs' })
+```
+
+To stream another format, register a `stream` handler, as [Configure serialization](https://kubb.dev/extensions/kubb-labs/plugin-fetch/guides/serialization#add-a-media-type) shows.
+
 ## 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:
@@ -269,16 +370,16 @@ pluginFetch({ returnType: 'data' })
 
 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`                                |
+|                                                | `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`, `headers`, `response`, `lastEventId` | available                                                      | only with `throwOnError: false`                                |
 
 Loop over the events the call resolves to:
 
@@ -323,7 +424,7 @@ The events alone carry no `response` or `lastEventId`. To resume a dropped strea
 
 ## 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:
+`.kubb/sse.ts` holds `parseEventStream`, `parseJsonLines`, and the `eventStream`, `jsonLines`, and `streamMediaTypes` media types. The `ServerSentEvent`, `TypedEvent`, `EventStreamOptions`, `StreamOptions`, `StreamResult`, and `StreamResultWithHeaders` types live in `.kubb/core.ts`. A stream operation takes `StreamOptions` and returns `StreamResult`, or `StreamResultWithHeaders` when the response declares headers, the stream versions of `Options`, `RequestResult`, and `RequestResultWithHeaders`. `.kubb/client.ts` re-exports `sse.ts`, so everything imports from the client. Kubb regenerates these files on each run, so do not edit them:
 
 ```typescript
 import type { ServerSentEvent } from './gen/.kubb/client'

package/docs/guides/transport.md

@@ -6,10 +6,10 @@ The transport is a function. Use interceptors for request headers or response lo
 
 ## Write a transport function
 
-`@kubb/plugin-fetch` types the transport as a function that receives a fully resolved request and returns a result:
+`@kubb/plugin-fetch` types the transport as a function that receives a fully resolved request and returns a web `Response`:
 
 ```typescript
-type Transport = (request: ResolvedRequest) => Promise<TransportResult>
+type Transport = (request: ResolvedRequest) => Promise<Response | TransportResult>
 
 type ResolvedRequest = {
   url: string
@@ -18,22 +18,37 @@ type ResolvedRequest = {
   body?: RequestBody
   signal?: AbortSignal
   credentials?: RequestCredentials
-  options?: FetchOptions
-  responseType?: ResponseType
+  options?: NativeOptions
+  // Set when the call streams the response. Do not buffer the body.
+  stream?: boolean
 }
 
-type TransportResult<TData = unknown> = {
-  data: TData
-  status: number
-  statusText: string
-  headers: Headers
-  contentType?: string
+type TransportResult = {
+  webResponse: Response
   request: Request
   response: Response
 }
 ```
 
-The core hands you a `ResolvedRequest` with the URL built, the query and body serialized, and auth headers set. Return the parsed `data` along with the native `request` and `response`, so status, headers, and the raw body stay reachable on the result.
+The `ResolvedRequest` has the URL built, the query and body encoded, and auth headers set. Return the `Response` with its body unread. Return a `TransportResult` to set the native `request` and `response` on results and errors.
+
+## Send with another library
+
+A library that returns a `Response`, such as [ky](https://github.com/sindresorhus/ky), needs only the send. `toRequestInit(request)` gives the `RequestInit` that `fetch` and ky take:
+
+```typescript
+import ky from 'ky'
+import { client, toRequestInit } from './gen/.kubb/client'
+
+client.setConfig({
+  // The client splits success from error itself, so ky must not throw or retry on an error status. ky's `timeout`
+  // (10 seconds by default) only waits for the response headers and never ends a started body or stream. Turn it
+  // off and bound the whole call with `signal: AbortSignal.timeout(ms)`.
+  transport: (request) => ky(request.url, { ...toRequestInit(request), throwHttpErrors: false, retry: 0, timeout: false }),
+})
+```
+
+The library must hand back the body unread. `result.request` is then a `Request` built from the resolved request, without its body, since the library keeps its own. With a relative URL, it is the resolved request itself.
 
 ## Mock the network in tests
 
@@ -44,14 +59,7 @@ import { createClient } from './gen/.kubb/client'
 import { getPetById } from './gen/clients/getPetById'
 
 const testClient = createClient({
-  transport: async (request) => ({
-    data: { id: 1, name: 'Fluffy' },
-    status: 200,
-    statusText: 'OK',
-    headers: new Headers(),
-    request: new Request(request.url),
-    response: new Response(),
-  }),
+  transport: async () => Response.json({ id: 1, name: 'Fluffy' }),
 })
 
 const { data } = await getPetById({ path: { petId: 1 }, client: testClient })

package/docs/options.md

@@ -23,7 +23,7 @@ Pass these options to `pluginFetch()`. Shared options link to [Shared plugin opt
 
 ### baseURL
 
-Base URL prepended to every request. When omitted, each request uses the operation's relative path from the spec. A value with a `${...}` interpolation is emitted as a template literal in the generated client config, so `baseURL: '${process.env.API_URL}'` reads the environment variable at runtime.
+Base URL prepended to every request. When omitted, each request uses the operation's relative path from the spec. A path or operation that declares its own `servers` uses that URL instead. See [Set the base URL](https://kubb.dev/extensions/kubb-labs/plugin-fetch/guides/base-url). A value with a `${...}` interpolation is emitted as a template literal in the generated client config, so `baseURL: '${process.env.API_URL}'` reads the environment variable at runtime.
 
 |          |          |
 | -------- | -------- |
@@ -63,7 +63,7 @@ Default value. Does no validation and returns the response cast to the generated
 :::
 
 :::field{name="'zod'"}
-Validates the success response body, and the error body when a non-2xx call does not throw.
+Validates the success response body, and the error body against the schema of its status.
 :::
 
 :::field{name="{ request?: 'zod', params?: 'zod', response?: 'zod' }"}
@@ -107,7 +107,7 @@ Generates a class-based SDK. Each instance takes its own client config, so envir
 ::field-group
 
 :::field{name="'tag'"}
-Default value for `sdk.mode`. Generates one class per tag, such as `PetClient`. Set `sdk.name` to also get a root class that shares one config, used as `new PetStore(config).pet.getPetById(...)`.
+Default value for `sdk.mode`. Generates one class per tag, such as `PetClient`. Set `sdk.name` to also get a root class that shares one client with every tag, used as `new PetStore(config).pet.getPetById(...)`.
 :::
 
 :::field{name="'flat'"}
@@ -125,6 +125,16 @@ const pet = new PetClient({ baseURL: 'https://petstore.swagger.io/v2' })
 const { data } = await pet.getPetById({ path: { petId: 1 } })
 ```
 
+Each SDK class exposes its client as the read-only `client` field. Interceptors on the root class's `client` apply to every tag:
+
+```typescript
+const api = new PetStore({ baseURL: 'https://petstore.swagger.io/v2' })
+api.client.interceptors.request.use((request) => request)
+await api.pet.getPetById({ path: { petId: 1 } })
+```
+
+A tag class also accepts an existing client, as in `new PetClient(api.client)`.
+
 ### returnType
 
 Shape of the value a generated call resolves to.
@@ -138,7 +148,7 @@ Shape of the value a generated call resolves to.
 ::field-group
 
 :::field{name="'full'"}
-Default value. Returns `{ status, data, error, contentType, request, response }`.
+Default value. Returns `{ status, data, error, contentType, headers, request, response }`. `headers` is the response's `Headers`. For an operation whose responses declare `headers`, its `get` suggests those names once `status` is narrowed, and the values stay strings.
 :::
 
 :::field{name="'data'"}

package/docs/overview.md

@@ -12,7 +12,7 @@ The query plugins (`@kubb/plugin-react-query`, `@kubb/plugin-vue-query`, and `@k
 
 ## Options worth knowing
 
-- `baseURL` is prepended to every request. The spec's `servers` URL is not used, so without `baseURL` you set one at runtime with `client.setConfig({ baseURL })`.
+- `baseURL` is prepended to every request. The spec's top-level `servers` URL is not used, so without `baseURL` you set one at runtime with `client.setConfig({ baseURL })`. Operations with their own `servers`, on the path or the operation, call that URL instead.
 - `validator: 'zod'` validates response bodies with the schemas from `@kubb/plugin-zod`. Use `{ request: 'zod', response: 'zod' }` to also validate request bodies.
 - `throwOnErrorDefault: false` returns non-2xx responses as values instead of throwing. A single call can still pass `throwOnError`.
 - `returnType: 'data'` makes a call resolve to the success body instead of the full result. With `throwOnError: false`, the call still returns the full result.

package/kubb-extension.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-fetch",
-  "version": "5.14.0-canary.20261109T125041",
+  "version": "6.0.0",
   "description": "Generate a slim, type-safe HTTP client with Kubb based on the native Fetch api.",
   "keywords": [
     "api-client",
@@ -39,6 +39,10 @@
     "src",
     "dist",
     "templates",
+    "!templates/config.ts",
+    "!templates/core.ts",
+    "!templates/serializers.ts",
+    "!templates/standardSchema.ts",
     "kubb-extension.json",
     "docs",
     "!/**/**.test.**",
@@ -67,8 +71,7 @@
     "./package.json": "./package.json",
     "./kubb-extension.json": "./kubb-extension.json",
     "./templates/*.ts": {
-      "types": "./dist/templates/*.d.ts",
-      "default": "./templates/*.ts"
+      "types": "./dist/templates/*.d.ts"
     },
     "./templates/*.js": {
       "types": "./dist/templates/*.d.ts"
@@ -80,15 +83,10 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/kit": "^5.16.0",
-    "@kubb/plugin-client": "^5.12.0-canary.20261109T125041",
-    "@kubb/plugin-ts": "^5.5.0-canary.20261109T125041",
-    "@kubb/plugin-zod": "^5.9.0-canary.20261109T125041",
-    "@kubb/renderer-jsx": "^5.16.0"
+    "@kubb/kit": "^5.18.6",
+    "@kubb/plugin-client": "^6.0.0"
   },
   "devDependencies": {
-    "@internals/client": "0.1.0-canary.20261109T125041",
-    "@internals/shared": "0.1.0-canary.20261109T125041",
     "typescript": "^7.0.2"
   },
   "peerDependencies": {},

package/src/index.ts

@@ -1,3 +1,2 @@
-export { clientGenerator } from './generators/clientGenerator.tsx'
 export { default, pluginFetch, pluginFetchName } from './plugin.ts'
 export type { Options, PluginFetch, ResolvedOptions, ResolverClient } from './types.ts'

package/src/plugin.ts

@@ -1,14 +1,9 @@
-import path from 'node:path'
-import { createSdkGenerator, defaultMacros, isValidatorEnabled, resolverClient } from '@internals/client'
-import { createGroupConfig } from '@internals/shared'
-import { addGenerator, defineExtension, injectFile, Resolver, setMacros, setResolver, useConfig } from '@kubb/kit'
+import { fileURLToPath } from 'node:url'
+import { defineExtension } from '@kubb/kit'
+import { clientDependencies, resolveClientOptions, setupClient } from '@kubb/plugin-client'
 import { compatibility } from '../kubb-extension.json'
 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, coreTemplatePath, serializersTemplatePath, sseTemplatePath, standardSchemaTemplatePath } from './templates.ts'
-import type { PluginFetch, ResolvedOptions, ResolverClient } from './types.ts'
+import type { PluginFetch } from './types.ts'
 
 /**
  * Canonical plugin name for `@kubb/plugin-fetch`. Used for driver lookups and cross-plugin
@@ -41,72 +36,10 @@ export const pluginFetchName = 'plugin-fetch' satisfies PluginFetch['name']
 export const pluginFetch = defineExtension<PluginFetch>({
   kind: 'plugin',
   meta: { name: pluginFetchName, version, compatibility },
-  // `plugin-ts` supplies the operation types unless it is absent, in which case `pluginZod({ inferred: true })`
-  // does. `plugin-zod` is required once `validator` enables a direction, so a missing one fails setup instead of codegen.
-  dependencies: (options) => ({ [pluginTsName]: { optional: true }, [pluginZodName]: { optional: !isValidatorEnabled(options.validator) } }),
+  dependencies: clientDependencies,
   setup(options) {
-    const config = useConfig()
-    const {
-      output = { path: 'clients', barrel: { type: 'named' } },
-      exclude = [],
-      include,
-      override = [],
-      baseURL,
-      throwOnErrorDefault = true,
-      validator = false,
-      returnType = 'full',
-      group,
-      sdk,
-      resolver: userResolver,
-    } = options
-
-    const resolved: ResolvedOptions = {
-      output,
-      exclude,
-      include,
-      override,
-      group: createGroupConfig(group),
-      baseURL,
-      throwOnErrorDefault,
-      validator,
-      returnType,
-      sdk: sdk ? { mode: sdk.mode ?? 'tag', name: sdk.name } : undefined,
-      resolver: userResolver ? Resolver.merge<ResolverClient>(resolverClient, userResolver) : resolverClient,
-    }
-
-    setResolver(resolved.resolver)
-    setMacros([...defaultMacros, ...(options.macros ?? [])])
-
-    // `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>({ sse: sseTemplatePath }) : clientGenerator)
-
-    const root = path.resolve(config.root, config.output.path)
-
-    injectFile({
-      baseName: 'serializers.ts',
-      path: path.resolve(root, '.kubb/serializers.ts'),
-      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,
-    })
-
-    injectFile({
-      baseName: 'standardSchema.ts',
-      path: path.resolve(root, '.kubb/standardSchema.ts'),
-      copy: standardSchemaTemplatePath,
-    })
-
+    const resolved = resolveClientOptions(options)
+    setupClient({ name: 'fetch', resolved, macros: options.macros, client: fileURLToPath(new URL('../templates/client.ts', import.meta.url)) })
     return resolved
   },
 })

package/src/types.ts

@@ -1,7 +1,7 @@
 import type { PluginType } from '@kubb/kit'
-import type { Options, ResolvedOptions, ResolverClient } from '@internals/client'
+import type { ClientOptions as Options, ClientResolvedOptions as ResolvedOptions, ResolverClient } from '@kubb/plugin-client'
 
-export type { Options, ResolvedOptions, ResolverClient } from '@internals/client'
+export type { ClientOptions as Options, ClientResolvedOptions as ResolvedOptions, ResolverClient } from '@kubb/plugin-client'
 
 /**
  * The plugin factory type for `@kubb/plugin-fetch`. Shares the options surface, resolver, and