@kubb/agent 4.27.4 → 4.28.1

package/.output/server/node_modules/readdirp/index.js

@@ -0,0 +1,272 @@
+import { lstat, readdir, realpath, stat } from 'node:fs/promises';
+import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from 'node:path';
+import { Readable } from 'node:stream';
+export const EntryTypes = {
+    FILE_TYPE: 'files',
+    DIR_TYPE: 'directories',
+    FILE_DIR_TYPE: 'files_directories',
+    EVERYTHING_TYPE: 'all',
+};
+const defaultOptions = {
+    root: '.',
+    fileFilter: (_entryInfo) => true,
+    directoryFilter: (_entryInfo) => true,
+    type: EntryTypes.FILE_TYPE,
+    lstat: false,
+    depth: 2147483648,
+    alwaysStat: false,
+    highWaterMark: 4096,
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+const ALL_TYPES = [
+    EntryTypes.DIR_TYPE,
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+    EntryTypes.FILE_TYPE,
+];
+const DIR_TYPES = new Set([
+    EntryTypes.DIR_TYPE,
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+]);
+const FILE_TYPES = new Set([
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+    EntryTypes.FILE_TYPE,
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === 'win32';
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+    if (filter === undefined)
+        return emptyFn;
+    if (typeof filter === 'function')
+        return filter;
+    if (typeof filter === 'string') {
+        const fl = filter.trim();
+        return (entry) => entry.basename === fl;
+    }
+    if (Array.isArray(filter)) {
+        const trItems = filter.map((item) => item.trim());
+        return (entry) => trItems.some((f) => entry.basename === f);
+    }
+    return emptyFn;
+};
+/** Readable readdir stream, emitting new files as they're being listed. */
+export class ReaddirpStream extends Readable {
+    parents;
+    reading;
+    parent;
+    _stat;
+    _maxDepth;
+    _wantsDir;
+    _wantsFile;
+    _wantsEverything;
+    _root;
+    _isDirent;
+    _statsProp;
+    _rdOptions;
+    _fileFilter;
+    _directoryFilter;
+    constructor(options = {}) {
+        super({
+            objectMode: true,
+            autoDestroy: true,
+            highWaterMark: options.highWaterMark,
+        });
+        const opts = { ...defaultOptions, ...options };
+        const { root, type } = opts;
+        this._fileFilter = normalizeFilter(opts.fileFilter);
+        this._directoryFilter = normalizeFilter(opts.directoryFilter);
+        const statMethod = opts.lstat ? lstat : stat;
+        // Use bigint stats if it's windows and stat() supports options (node 10+).
+        if (wantBigintFsStats) {
+            this._stat = (path) => statMethod(path, { bigint: true });
+        }
+        else {
+            this._stat = statMethod;
+        }
+        this._maxDepth =
+            opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+        this._wantsDir = type ? DIR_TYPES.has(type) : false;
+        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+        this._root = presolve(root);
+        this._isDirent = !opts.alwaysStat;
+        this._statsProp = this._isDirent ? 'dirent' : 'stats';
+        this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+        // Launch stream with one parent, the root dir.
+        this.parents = [this._exploreDir(root, 1)];
+        this.reading = false;
+        this.parent = undefined;
+    }
+    async _read(batch) {
+        if (this.reading)
+            return;
+        this.reading = true;
+        try {
+            while (!this.destroyed && batch > 0) {
+                const par = this.parent;
+                const fil = par && par.files;
+                if (fil && fil.length > 0) {
+                    const { path, depth } = par;
+                    const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+                    const awaited = await Promise.all(slice);
+                    for (const entry of awaited) {
+                        if (!entry)
+                            continue;
+                        if (this.destroyed)
+                            return;
+                        const entryType = await this._getEntryType(entry);
+                        if (entryType === 'directory' && this._directoryFilter(entry)) {
+                            if (depth <= this._maxDepth) {
+                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                            }
+                            if (this._wantsDir) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                        else if ((entryType === 'file' || this._includeAsFile(entry)) &&
+                            this._fileFilter(entry)) {
+                            if (this._wantsFile) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                    }
+                }
+                else {
+                    const parent = this.parents.pop();
+                    if (!parent) {
+                        this.push(null);
+                        break;
+                    }
+                    this.parent = await parent;
+                    if (this.destroyed)
+                        return;
+                }
+            }
+        }
+        catch (error) {
+            this.destroy(error);
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    async _exploreDir(path, depth) {
+        let files;
+        try {
+            files = await readdir(path, this._rdOptions);
+        }
+        catch (error) {
+            this._onError(error);
+        }
+        return { files, depth, path };
+    }
+    async _formatEntry(dirent, path) {
+        let entry;
+        const basename = this._isDirent ? dirent.name : dirent;
+        try {
+            const fullPath = presolve(pjoin(path, basename));
+            entry = { path: prelative(this._root, fullPath), fullPath, basename };
+            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        }
+        catch (err) {
+            this._onError(err);
+            return;
+        }
+        return entry;
+    }
+    _onError(err) {
+        if (isNormalFlowError(err) && !this.destroyed) {
+            this.emit('warn', err);
+        }
+        else {
+            this.destroy(err);
+        }
+    }
+    async _getEntryType(entry) {
+        // entry may be undefined, because a warning or an error were emitted
+        // and the statsProp is undefined
+        if (!entry && this._statsProp in entry) {
+            return '';
+        }
+        const stats = entry[this._statsProp];
+        if (stats.isFile())
+            return 'file';
+        if (stats.isDirectory())
+            return 'directory';
+        if (stats && stats.isSymbolicLink()) {
+            const full = entry.fullPath;
+            try {
+                const entryRealPath = await realpath(full);
+                const entryRealPathStats = await lstat(entryRealPath);
+                if (entryRealPathStats.isFile()) {
+                    return 'file';
+                }
+                if (entryRealPathStats.isDirectory()) {
+                    const len = entryRealPath.length;
+                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                        // @ts-ignore
+                        recursiveError.code = RECURSIVE_ERROR_CODE;
+                        return this._onError(recursiveError);
+                    }
+                    return 'directory';
+                }
+            }
+            catch (error) {
+                this._onError(error);
+                return '';
+            }
+        }
+    }
+    _includeAsFile(entry) {
+        const stats = entry && entry[this._statsProp];
+        return stats && this._wantsEverything && !stats.isDirectory();
+    }
+}
+/**
+ * Streaming version: Reads all files and directories in given root recursively.
+ * Consumes ~constant small amount of RAM.
+ * @param root Root directory
+ * @param options Options to specify root (start directory), filters and recursion depth
+ */
+export function readdirp(root, options = {}) {
+    // @ts-ignore
+    let type = options.entryType || options.type;
+    if (type === 'both')
+        type = EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
+    if (type)
+        options.type = type;
+    if (!root) {
+        throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+    }
+    else if (typeof root !== 'string') {
+        throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+    }
+    else if (type && !ALL_TYPES.includes(type)) {
+        throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+    }
+    options.root = root;
+    return new ReaddirpStream(options);
+}
+/**
+ * Promise version: Reads all files and directories in given root recursively.
+ * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
+ * @returns array of paths and their entry infos
+ */
+export function readdirpPromise(root, options = {}) {
+    return new Promise((resolve, reject) => {
+        const files = [];
+        readdirp(root, options)
+            .on('data', (entry) => files.push(entry))
+            .on('end', () => resolve(files))
+            .on('error', (error) => reject(error));
+    });
+}
+export default readdirp;

package/.output/server/node_modules/readdirp/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "readdirp",
+  "description": "Recursive version of fs.readdir with small RAM & CPU footprint",
+  "version": "5.0.0",
+  "homepage": "https://github.com/paulmillr/readdirp",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/paulmillr/readdirp.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/paulmillr/readdirp/issues"
+  },
+  "author": "Thorsten Lorenz <thlorenz@gmx.de> (thlorenz.com)",
+  "contributors": [
+    "Thorsten Lorenz <thlorenz@gmx.de> (thlorenz.com)",
+    "Paul Miller (https://paulmillr.com)"
+  ],
+  "engines": {
+    "node": ">= 20.19.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "index.d.ts.map",
+    "index.js.map"
+  ],
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": "./index.js"
+  },
+  "sideEffects": false,
+  "keywords": [
+    "recursive",
+    "fs",
+    "stream",
+    "streams",
+    "readdir",
+    "filesystem",
+    "find",
+    "filter"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "prettier --check index.ts test/index.test.js",
+    "format": "prettier --write index.ts test/index.test.js",
+    "test": "node test/index.test.js",
+    "test:coverage": "c8 node test/index.test.js"
+  },
+  "devDependencies": {
+    "@paulmillr/jsbt": "0.4.5",
+    "@types/node": "24.10.1",
+    "c8": "10.1.3",
+    "chai": "4.3.4",
+    "chai-subset": "1.6.0",
+    "prettier": "3.1.1",
+    "typescript": "5.9.2"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://paulmillr.com/funding/"
+  }
+}

package/.output/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/agent-prod",
-  "version": "4.27.4",
+  "version": "4.28.1",
   "type": "module",
   "private": true,
   "dependencies": {
@@ -22,11 +22,13 @@
     "@sindresorhus/merge-streams": "4.0.0",
     "ajv": "8.17.1",
     "ajv-draft-04": "1.0.0",
+    "anymatch": "3.1.3",
     "balanced-match": "1.0.2",
     "brace-expansion": "1.1.12",
     "buffer-from": "1.1.2",
     "bytes": "3.0.0",
     "call-me-maybe": "1.0.2",
+    "chokidar": "5.0.0",
     "compute-gcd": "1.2.1",
     "compute-lcm": "1.1.2",
     "concat-map": "0.0.1",
@@ -78,6 +80,7 @@
     "natural-orderby": "5.0.0",
     "next-tick": "1.1.0",
     "node-fetch-h2": "2.3.0",
+    "normalize-path": "3.0.0",
     "npm-run-path": "6.0.0",
     "oas": "28.9.0",
     "oas-kit-common": "1.0.8",
@@ -90,9 +93,11 @@
     "path-key": "4.0.0",
     "path-to-regexp": "8.3.0",
     "picocolors": "1.1.1",
+    "picomatch": "2.3.1",
     "pretty-ms": "9.3.0",
     "range-parser": "1.2.0",
     "react-devtools-core": "6.1.5",
+    "readdirp": "5.0.0",
     "reftools": "1.1.9",
     "remeda": "2.33.6",
     "remove-undefined-objects": "7.0.0",

package/README.md

@@ -13,7 +13,7 @@ Kubb Agent Server — HTTP server for code generation powered by [Nitro](https:/
 - 🔧 Easy integration with Kubb configuration
 - 📊 Health and info endpoints
 - 🔗 Bidirectional WebSocket with Kubb Studio
-- 🖥️ Machine binding — token locked to the registered machine via stable `machineId`
+- 🖥️ Machine binding — token locked to the registered machine via stable `machineToken`
 - 💾 Automatic session caching for faster reconnects
 - ⚡ Production-ready
 
@@ -53,64 +53,72 @@ The server will be available at `http://localhost:3000`.
 
 ### Docker
 
-Run the agent standalone, mounting your config file into the container:
+Run the agent standalone:
 
 ```bash
 docker run --env-file .env \
   -p 3000:3000 \
-  -v ./kubb.config.ts:/kubb/agent/kubb.config.ts \
+  kubblabs/kubb-agent
+```
+
+A default `kubb.config.ts` is baked into the image at `/kubb/agent/data/kubb.config.ts`. To use your own config, bind-mount it over the default:
+
+```bash
+docker run --env-file .env \
+  -p 3000:3000 \
+  -v ./kubb.config.ts:/kubb/agent/data/kubb.config.ts \
   kubblabs/kubb-agent
 ```
 
 ### Docker Compose
 
-To run the full stack (Studio + Agent + Postgres), use the provided `docker-compose.yml`:
+Use the provided `docker-compose.yaml` in `packages/agent`:
 
 ```yaml
 services:
   agent:
     image: kubblabs/kubb-agent:latest
-    ports:
-      - "3001:3000"
-    env_file:
-      - .env
+    container_name: kubb-agent
     environment:
-      PORT: 3000
-      KUBB_AGENT_ROOT: /kubb/agent
-      KUBB_AGENT_CONFIG: kubb.config.ts
-      KUBB_STUDIO_URL: http://kubb-studio:3000
+      PORT: 80
+      KUBB_AGENT_ROOT: /kubb/agent/data
+      KUBB_AGENT_CONFIG: ./kubb.config.ts
+      KUBB_STUDIO_URL: https://studio.kubb.dev
     volumes:
-      - ./kubb.config.ts:/kubb/agent/kubb.config.ts
-    depends_on:
-      studio:
-        condition: service_healthy
+      - agent_kv:/kubb/agent/.kubb/data
     restart: unless-stopped
     healthcheck:
-      test: ["CMD-SHELL", "wget -qO- http://localhost:3000/api/health || exit 1"]
-      interval: 30s
-      timeout: 5s
-      start_period: 10s
-      retries: 3
+      test: ["CMD", "node", "-e", "fetch('http://localhost:3000/api/health').then(r => r.ok ? process.exit(0) : process.exit(1)).catch(() => process.exit(1))"]
+      interval: 15s
+      timeout: 10s
+      start_period: 60s
+      retries: 5
+
+volumes:
+  agent_kv:
 ```
 
 ```bash
 docker compose up
 ```
 
+The `agent_kv` named volume persists the KV store (session cache, machine token) across container restarts and upgrades.
+
 ### Environment Variables
 
-| Variable | Default | Description |
-|---|---|---|
-| `KUBB_AGENT_CONFIG` | `kubb.config.ts` | Path to your Kubb config file. Relative paths are resolved against `KUBB_AGENT_ROOT`. |
-| `KUBB_AGENT_ROOT` | `/kubb/agent` (Docker) / `cwd` | Root directory for resolving relative paths. |
-| `PORT` | `3000` | Server port. |
-| `HOST` | `0.0.0.0` | Server host. |
-| `KUBB_STUDIO_URL` | `https://studio.kubb.dev` | Kubb Studio WebSocket URL. |
-| `KUBB_AGENT_TOKEN` | _(empty)_ | Authentication token for Studio. Required to connect. |
-| `KUBB_AGENT_NO_CACHE` | `false` | Set to `true` to disable session caching. |
-| `KUBB_AGENT_ALLOW_WRITE` | `false` | Set to `true` to allow writing generated files to disk. |
-| `KUBB_AGENT_ALLOW_ALL` | `false` | Set to `true` to grant all permissions (implies `KUBB_AGENT_ALLOW_WRITE=true`). |
-| `KUBB_AGENT_RETRY_TIMEOUT` | `30000` | Milliseconds to wait before retrying a failed Studio connection. |
+| Variable                     | Default | Description |
+|------------------------------|---|---|
+| `KUBB_AGENT_CONFIG`          | `kubb.config.ts` | Path to your Kubb config file. Relative paths are resolved against `KUBB_AGENT_ROOT`. |
+| `KUBB_AGENT_ROOT`            | `/kubb/agent` (Docker) / `cwd` | Root directory for resolving relative paths. |
+| `PORT`                       | `3000` | Server port. |
+| `HOST`                       | `0.0.0.0` | Server host. |
+| `KUBB_STUDIO_URL`            | `https://studio.kubb.dev` | Kubb Studio WebSocket URL. |
+| `KUBB_AGENT_TOKEN`           | _(empty)_ | Authentication token for Studio. Required to connect. |
+| `KUBB_AGENT_NO_CACHE`        | `false` | Set to `true` to disable session caching. |
+| `KUBB_AGENT_ALLOW_WRITE`     | `false` | Set to `true` to allow writing generated files to disk. |
+| `KUBB_AGENT_ALLOW_ALL`       | `false` | Set to `true` to grant all permissions (implies `KUBB_AGENT_ALLOW_WRITE=true`). |
+| `KUBB_AGENT_RETRY_TIMEOUT`   | `30000` | Milliseconds to wait before retrying a failed Studio connection. |
+| `KUBB_STUDIO_SECRET` | _(empty)_ | Fixed machine name for stable identity across container restarts (e.g. Docker). When set, the `machineToken` is derived from this value instead of network interfaces and hostname. |
 
 ### Automatic .env Loading
 
@@ -146,9 +154,9 @@ The agent connects to Kubb Studio on startup when `KUBB_AGENT_TOKEN` is set.
 
 On startup the agent performs these steps before opening a WebSocket:
 
-1. **Register** — calls `POST /api/agent/register` with a stable `machineId` derived from the machine's network interfaces and hostname (SHA-256). This binds the token to the machine. If registration fails the agent throws and does not continue.
-2. **Create session** — calls `POST /api/agent/session/create` (includes `machineId` for verification) and receives a WebSocket URL.
-3. **Connect** — opens a WebSocket to the returned URL (appends `?machineId=` for server-side verification).
+1. **Register** — calls `POST /api/agent/register` with a stable `machineToken` derived from the machine's network interfaces and hostname (SHA-256). This binds the token to the machine. Registration failure is non-fatal — a warning is logged and the agent continues.
+2. **Create session** — calls `POST /api/agent/session/create` (includes `machineToken` for verification) and receives a WebSocket URL.
+3. **Connect** — opens a WebSocket to the returned URL using the `Authorization` header for authentication.
 
 ### Connection Features
 
@@ -160,7 +168,7 @@ On startup the agent performs these steps before opening a WebSocket:
 
 ### Session Caching
 
-Sessions are cached in `~/.kubb/config.json` for faster reconnects:
+Sessions are cached in `./.kubb/data` (relative to the working directory, or `agent_kv` volume in Docker) for faster reconnects:
 - Tokens are hashed (non-reversible) for security
 - Sessions auto-expire after 24 hours
 - Use `--no-cache` flag to disable caching
@@ -219,7 +227,9 @@ Available `payload.type` values: `plugin:start`, `plugin:end`, `files:processing
   "payload": { "plugins": [] }
 }
 ```
-`payload` is optional. When omitted, the agent uses the config loaded from disk.
+`payload` is optional. When omitted, the agent falls back to `kubb.config.studio.json` (a temporal config file next to `kubb.config.ts`), and then to the config loaded from disk.
+
+The `payload` may also include an `input` field containing a raw OpenAPI / Swagger spec (YAML or JSON string). **This field is only honoured in sandbox mode** — outside of sandbox it is silently ignored for security reasons. See [Sandbox Mode](#sandbox-mode) below.
 
 **Connect Command** — requests agent info
 ```json
@@ -233,6 +243,56 @@ Available `payload.type` values: `plugin:start`, `plugin:end`, `files:processing
 }
 ```
 
+**Pong** — sent by Studio in response to an agent ping
+```json
+{ "type": "pong" }
+```
+
+**Status** — sent by Studio with information about connected agents
+```json
+{
+  "type": "status",
+  "message": "...",
+  "connectedAgents": 1,
+  "agents": [
+    { "name": "...", "connectedAt": "..." }
+  ]
+}
+```
+
+## Sandbox Mode
+
+When Kubb Studio provisions a session for the **Sandbox Agent** (the shared agent hosted by Studio itself), it sets `isSandbox: true` in the session response. In sandbox mode the agent behaves differently from a user-owned agent:
+
+| Behaviour | Normal agent | Sandbox agent |
+|---|---|---|
+| Write generated files to disk | ✅ (when `KUBB_AGENT_ALLOW_WRITE=true`) | ❌ Never |
+| Read `input.path` from disk | ✅ | ✅ (falls back when no inline input supplied) |
+| Accept inline `input` in generate payload | ❌ Ignored | ✅ |
+
+### Why no filesystem writes?
+
+The sandbox agent runs in a shared, docker environment inside Kubb Studio. Allowing arbitrary disk writes would create security and isolation problems. Instead, `output.write` is always set to `false`, and the generated files are returned to Studio via the WebSocket `generation:end` event where the UI renders them.
+
+### Inline `input` in sandbox mode
+
+Because the sandbox agent cannot read arbitrary files from disk, callers must supply the OpenAPI / Swagger spec content inline via the `input` field in the generate command payload:
+
+```json
+{
+  "type": "command",
+  "command": "generate",
+  "payload": {
+    "input": "openapi: 3.0.0\ninfo:\n  title: Pet Store\n  version: 1.0.0\n...",
+    "plugins": [
+      { "name": "@kubb/plugin-ts", "options": {} }
+    ]
+  }
+}
+```
+
+The `input` value is treated as `InputData` (i.e. `{ data: "<content>" }`) and overrides the `input` from the loaded config for that generation cycle.  **Outside of sandbox mode this field is ignored.**
+
 ## Configuration Example
 
 ### 1. Create a Kubb configuration file (`kubb.config.ts`):
@@ -263,7 +323,3 @@ npx kubb agent start
 ```
 
 You'll receive a stream of events as the code generation progresses.
-
-## License
-
-MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/agent",
-  "version": "4.27.4",
+  "version": "4.28.1",
   "description": "Agent server for Kubb, enabling HTTP-based access to code generation capabilities.",
   "keywords": [
     "agent",
@@ -23,15 +23,8 @@
   "sideEffects": false,
   "type": "module",
   "exports": {
-    ".": {
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.js"
-    },
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.cts",
   "files": [
     ".output",
     "!/**/**.test.**",
@@ -44,21 +37,21 @@
     "picocolors": "^1.1.1",
     "string-argv": "^0.3.2",
     "ws": "^8.19.0",
-    "@kubb/core": "4.27.4",
-    "@kubb/plugin-client": "4.27.4",
-    "@kubb/plugin-cypress": "4.27.4",
-    "@kubb/plugin-faker": "4.27.4",
-    "@kubb/plugin-mcp": "4.27.4",
-    "@kubb/plugin-msw": "4.27.4",
-    "@kubb/plugin-oas": "4.27.4",
-    "@kubb/plugin-react-query": "4.27.4",
-    "@kubb/plugin-redoc": "4.27.4",
-    "@kubb/plugin-solid-query": "4.27.4",
-    "@kubb/plugin-svelte-query": "4.27.4",
-    "@kubb/plugin-swr": "4.27.4",
-    "@kubb/plugin-ts": "4.27.4",
-    "@kubb/plugin-vue-query": "4.27.4",
-    "@kubb/plugin-zod": "4.27.4"
+    "@kubb/core": "4.28.1",
+    "@kubb/plugin-client": "4.28.1",
+    "@kubb/plugin-cypress": "4.28.1",
+    "@kubb/plugin-faker": "4.28.1",
+    "@kubb/plugin-mcp": "4.28.1",
+    "@kubb/plugin-msw": "4.28.1",
+    "@kubb/plugin-oas": "4.28.1",
+    "@kubb/plugin-react-query": "4.28.1",
+    "@kubb/plugin-redoc": "4.28.1",
+    "@kubb/plugin-solid-query": "4.28.1",
+    "@kubb/plugin-svelte-query": "4.28.1",
+    "@kubb/plugin-swr": "4.28.1",
+    "@kubb/plugin-ts": "4.28.1",
+    "@kubb/plugin-vue-query": "4.28.1",
+    "@kubb/plugin-zod": "4.28.1"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",