@kubb/agent 5.0.0-alpha.36 → 5.0.0-alpha.39

package/.output/nitro.json

@@ -1,5 +1,5 @@
 {
-  "date": "2026-04-16T20:45:04.677Z",
+  "date": "2026-04-17T13:25:12.208Z",
   "preset": "node-server",
   "framework": {
     "name": "nitro",

package/.output/server/chunks/nitro/nitro.mjs

@@ -7,10 +7,11 @@ import https, { Server } from 'node:https';
 import { EventEmitter } from 'node:events';
 import { Buffer as Buffer$1 } from 'node:buffer';
 import { promises, existsSync } from 'node:fs';
-import path$1, { resolve, dirname, relative, join, basename, extname, posix } from 'node:path';
+import path$1, { resolve, dirname, relative, join, extname, basename, posix } from 'node:path';
 import anymatch from 'anymatch';
 import { createHash, randomBytes } from 'node:crypto';
 import process$1, { version as version$2 } from 'node:process';
+import { spawn } from 'node:child_process';
 import { Logtail } from '@logtail/node';
 import { consola } from 'consola';
 import { performance } from 'node:perf_hooks';
@@ -20,20 +21,6 @@ import { access, rm, readFile as readFile$1, readdir as readdir$1, mkdir, writeF
 import { styleText } from 'node:util';
 import { createJiti } from 'jiti';
 import { mergeDeep } from 'remeda';
-import { pluginClient } from '@kubb/plugin-client';
-import { pluginCypress } from '@kubb/plugin-cypress';
-import { pluginFaker } from '@kubb/plugin-faker';
-import { pluginMcp } from '@kubb/plugin-mcp';
-import { pluginMsw } from '@kubb/plugin-msw';
-import { pluginOas } from '@kubb/plugin-oas';
-import { pluginReactQuery } from '@kubb/plugin-react-query';
-import { pluginRedoc } from '@kubb/plugin-redoc';
-import { pluginSolidQuery } from '@kubb/plugin-solid-query';
-import { pluginSvelteQuery } from '@kubb/plugin-svelte-query';
-import { pluginSwr } from '@kubb/plugin-swr';
-import { pluginTs } from '@kubb/plugin-ts';
-import { pluginVueQuery } from '@kubb/plugin-vue-query';
-import { pluginZod } from '@kubb/plugin-zod';
 import WebSocket from 'ws';
 
 const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
@@ -4451,6 +4438,84 @@ const logger = {
 const _KZ9YuROWp70nNn4X1C4BxF_W0D7H9EWgBo03XvMd7w0 = defineNitroPlugin(() => {
 });
 
+const formatters = {
+  prettier: {
+    command: "prettier",
+    args: (outputPath) => [
+      "--ignore-unknown",
+      "--write",
+      outputPath
+    ],
+    errorMessage: "Prettier not found"
+  },
+  biome: {
+    command: "biome",
+    args: (outputPath) => [
+      "format",
+      "--write",
+      outputPath
+    ],
+    errorMessage: "Biome not found"
+  },
+  oxfmt: {
+    command: "oxfmt",
+    args: (outputPath) => [outputPath],
+    errorMessage: "Oxfmt not found"
+  }
+};
+async function isFormatterAvailable(formatter) {
+  return new Promise((resolve2) => {
+    const child = spawn(formatter, ["--version"], { stdio: "ignore" });
+    child.on("close", (code) => resolve2(code === 0));
+    child.on("error", () => resolve2(false));
+  });
+}
+async function detectFormatter() {
+  const formatterNames = /* @__PURE__ */ new Set([
+    "biome",
+    "oxfmt",
+    "prettier"
+  ]);
+  for (const formatter of formatterNames) if (await isFormatterAvailable(formatter)) return formatter;
+  return null;
+}
+const linters = {
+  eslint: {
+    command: "eslint",
+    args: (outputPath) => [outputPath, "--fix"],
+    errorMessage: "Eslint not found"
+  },
+  biome: {
+    command: "biome",
+    args: (outputPath) => [
+      "lint",
+      "--fix",
+      outputPath
+    ],
+    errorMessage: "Biome not found"
+  },
+  oxlint: {
+    command: "oxlint",
+    args: (outputPath) => ["--fix", outputPath],
+    errorMessage: "Oxlint not found"
+  }
+};
+async function isLinterAvailable(linter) {
+  return new Promise((resolve2) => {
+    const child = spawn(linter, ["--version"], { stdio: "ignore" });
+    child.on("close", (code) => resolve2(code === 0));
+    child.on("error", () => resolve2(false));
+  });
+}
+async function detectLinter() {
+  const linterNames = /* @__PURE__ */ new Set([
+    "biome",
+    "oxlint",
+    "eslint"
+  ]);
+  for (const linter of linterNames) if (await isLinterAvailable(linter)) return linter;
+  return null;
+}
 function formatMs$1(ms) {
   if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
   if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
@@ -4481,10 +4546,6 @@ function hex(color) {
   highlight: hex("#adadc6"),
   blush: hex("#FDA4AF")
 });
-function maskString(value, start = 8, end = 4) {
-  if (value.length <= start + end) return value;
-  return `${value.slice(0, start)}\u2026${value.slice(-end)}`;
-}
 function serializePluginOptions(options) {
   if (options === null || options === void 0) return {};
   if (typeof options !== "object") return options;
@@ -4500,6 +4561,10 @@ function tokenize(command) {
   var _a2;
   return ((_a2 = command.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g)) != null ? _a2 : []).map((token) => token.replace(/^["']|["']$/g, ""));
 }
+function maskString(value, start = 8, end = 4) {
+  if (value.length <= start + end) return value;
+  return `${value.slice(0, start)}\u2026${value.slice(-end)}`;
+}
 function generateToken() {
   return randomBytes(32).toString("hex");
 }
@@ -5053,11 +5118,6 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
   }) : camelCase(part));
   return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
-function trimExtName$1(text) {
-  const dotIndex = text.lastIndexOf(".");
-  if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
-  return text;
-}
 function isPromiseRejectedResult(result) {
   return result.status === "rejected";
 }
@@ -5157,56 +5217,15 @@ function isValidVarName(name) {
   }
   return true;
 }
+function trimExtName$1(text) {
+  const dotIndex = text.lastIndexOf(".");
+  if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
+  return text;
+}
 const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
 const BARREL_FILENAME = "index.ts";
 const DEFAULT_BANNER = "simple";
 const DEFAULT_EXTENSION = { ".ts": ".ts" };
-const linters = {
-  eslint: {
-    command: "eslint",
-    args: (outputPath) => [outputPath, "--fix"],
-    errorMessage: "Eslint not found"
-  },
-  biome: {
-    command: "biome",
-    args: (outputPath) => [
-      "lint",
-      "--fix",
-      outputPath
-    ],
-    errorMessage: "Biome not found"
-  },
-  oxlint: {
-    command: "oxlint",
-    args: (outputPath) => ["--fix", outputPath],
-    errorMessage: "Oxlint not found"
-  }
-};
-const formatters = {
-  prettier: {
-    command: "prettier",
-    args: (outputPath) => [
-      "--ignore-unknown",
-      "--write",
-      outputPath
-    ],
-    errorMessage: "Prettier not found"
-  },
-  biome: {
-    command: "biome",
-    args: (outputPath) => [
-      "format",
-      "--write",
-      outputPath
-    ],
-    errorMessage: "Biome not found"
-  },
-  oxfmt: {
-    command: "oxfmt",
-    args: (outputPath) => [outputPath],
-    errorMessage: "Oxfmt not found"
-  }
-};
 var Node$1 = (_a$1 = class {
   constructor(value) {
     __publicField$1(this, "value");
@@ -5391,12 +5410,12 @@ function defaultResolveOptions(node, { options, exclude = [], include, override
   return options;
 }
 function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root, output, group }) {
-  if ((pathMode != null ? pathMode : getMode(path$1.resolve(root, output.path))) === "single") return path$1.resolve(root, output.path);
+  if ((pathMode != null ? pathMode : PluginDriver.getMode(path$1.resolve(root, output.path))) === "single") return path$1.resolve(root, output.path);
   if (group && (groupPath || tag)) return path$1.resolve(root, output.path, group.name({ group: group.type === "path" ? groupPath : tag }), baseName);
   return path$1.resolve(root, output.path, baseName);
 }
 function defaultResolveFile({ name, extname: extname2, tag, path: groupPath }, context) {
-  const pathMode = getMode(path$1.resolve(context.root, context.output.path));
+  const pathMode = PluginDriver.getMode(path$1.resolve(context.root, context.output.path));
   const baseName = `${pathMode === "single" ? "" : this.default(name, "file")}${extname2}`;
   const filePath = this.resolvePath({
     baseName,
@@ -5615,10 +5634,6 @@ function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
   const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()));
   return Promise.allSettled(tasks);
 }
-function getMode(fileOrFolder) {
-  if (!fileOrFolder) return "split";
-  return extname(fileOrFolder) ? "single" : "split";
-}
 const hookFirstNullCheck = (state) => !!(state == null ? void 0 : state.result);
 var PluginDriver = (_d$1 = class {
   constructor(config, options) {
@@ -5714,6 +5729,19 @@ var PluginDriver = (_d$1 = class {
       this.plugins.set(plugin.name, plugin);
     });
   }
+  /**
+  * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+  *
+  * @example
+  * ```ts
+  * PluginDriver.getMode('src/gen/types.ts')  // 'single'
+  * PluginDriver.getMode('src/gen/types')     // 'split'
+  * ```
+  */
+  static getMode(fileOrFolder) {
+    if (!fileOrFolder) return "split";
+    return extname(fileOrFolder) ? "single" : "split";
+  }
   get hooks() {
     if (!this.options.hooks) throw new Error("hooks are not defined");
     return this.options.hooks;
@@ -5892,7 +5920,7 @@ var PluginDriver = (_d$1 = class {
         return resolve(driver.config.root, driver.config.output.path);
       },
       getMode(output) {
-        return getMode(resolve(driver.config.root, driver.config.output.path, output.path));
+        return _d$1.getMode(resolve(driver.config.root, driver.config.output.path, output.path));
       },
       hooks: driver.hooks,
       plugin,
@@ -6574,8 +6602,8 @@ var URLPath = (_b = class {
 * Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
 */
 eachParam_fn = function(fn) {
-  for (const match2 of this.path.matchAll(/\{([^}]+)\}/g)) {
-    const raw = match2[1];
+  for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
+    const raw = match[1];
     fn(raw, __privateMethod(this, _URLPath_instances, transformParam_fn).call(this, raw));
   }
 }, _b);
@@ -6621,21 +6649,26 @@ var FileProcessor = (_c = class {
 function createStorage(build2) {
   return (options) => build2(options != null ? options : {});
 }
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
 const fsStorage = createStorage(() => ({
   name: "fs",
   async hasItem(key) {
     try {
       await access(resolve(key));
       return true;
-    } catch {
-      return false;
+    } catch (error) {
+      if (isMissingPathError(error)) return false;
+      throw new Error(`Failed to access storage item "${key}"`, { cause: error });
     }
   },
   async getItem(key) {
     try {
       return await readFile$1(resolve(key), "utf8");
-    } catch {
-      return null;
+    } catch (error) {
+      if (isMissingPathError(error)) return null;
+      throw new Error(`Failed to read storage item "${key}"`, { cause: error });
     }
   },
   async setItem(key, value) {
@@ -6646,12 +6679,14 @@ const fsStorage = createStorage(() => ({
   },
   async getKeys(base) {
     const keys = [];
+    const resolvedBase = resolve(base != null ? base : process.cwd());
     async function walk2(dir, prefix) {
       let entries;
       try {
         entries = await readdir$1(dir, { withFileTypes: true });
-      } catch {
-        return;
+      } catch (error) {
+        if (isMissingPathError(error)) return;
+        throw new Error(`Failed to list storage keys under "${resolvedBase}"`, { cause: error });
       }
       for (const entry of entries) {
         const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
@@ -6659,7 +6694,7 @@ const fsStorage = createStorage(() => ({
         else keys.push(rel);
       }
     }
-    await walk2(resolve(base != null ? base : process.cwd()), "");
+    await walk2(resolvedBase, "");
     return keys;
   },
   async clear(base) {
@@ -6667,7 +6702,7 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.36";
+var version$1 = "5.0.0-alpha.39";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6764,7 +6799,7 @@ var TreeNode = (_d = class {
         name: filteredTree.name,
         path: filteredTree.path,
         file: filteredTree.file,
-        type: getMode(filteredTree.path)
+        type: PluginDriver.getMode(filteredTree.path)
       });
       const recurse = (node, item) => {
         var _a3, _b2;
@@ -6772,7 +6807,7 @@ var TreeNode = (_d = class {
           name: item.name,
           path: item.path,
           file: item.file,
-          type: getMode(item.path)
+          type: PluginDriver.getMode(item.path)
         });
         if ((_a3 = item.children) == null ? void 0 : _a3.length) (_b2 = item.children) == null ? void 0 : _b2.forEach((child) => {
           recurse(subNode, child);
@@ -6899,7 +6934,7 @@ function isInputPath(config) {
   return typeof (config == null ? void 0 : config.input) === "object" && config.input !== null && "path" in config.input;
 }
 async function setup(options) {
-  var _a2, _b2, _c2, _d2, _e2, _f, _g, _h, _i;
+  var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i;
   const { config: userConfig } = options;
   const hooks = (_a2 = options.hooks) != null ? _a2 : new AsyncEventEmitter();
   const sources = /* @__PURE__ */ new Map();
@@ -6914,7 +6949,7 @@ async function setup(options) {
       `  \u2022 Output: ${((_b2 = userConfig.output) == null ? void 0 : _b2.path) || "not specified"}`,
       `  \u2022 Plugins: ${((_c2 = userConfig.plugins) == null ? void 0 : _c2.length) || 0}`,
       "Output Settings:",
-      `  \u2022 Storage: ${((_d2 = userConfig.output) == null ? void 0 : _d2.storage) ? `custom(${userConfig.output.storage.name})` : ((_e2 = userConfig.output) == null ? void 0 : _e2.write) === false ? "disabled" : "filesystem (default)"}`,
+      `  \u2022 Storage: ${((_d2 = userConfig.output) == null ? void 0 : _d2.storage) ? `custom(${userConfig.output.storage.name})` : ((_e = userConfig.output) == null ? void 0 : _e.write) === false ? "disabled" : "filesystem (default)"}`,
       `  \u2022 Formatter: ${((_f = userConfig.output) == null ? void 0 : _f.format) || "none"}`,
       `  \u2022 Linter: ${((_g = userConfig.output) == null ? void 0 : _g.lint) || "none"}`,
       "Environment:",
@@ -7062,7 +7097,7 @@ async function runPluginAstHooks(plugin, context) {
   }
 }
 async function safeBuild(setupResult) {
-  var _a2, _b2, _c2, _d2, _e2, _f;
+  var _a2, _b2, _c2, _d2, _e, _f;
   const { driver, hooks, sources, storage } = setupResult;
   const failedPlugins = /* @__PURE__ */ new Set();
   const pluginTimings = /* @__PURE__ */ new Map();
@@ -7158,7 +7193,7 @@ async function safeBuild(setupResult) {
         exports: buildBarrelExports({
           barrelFiles,
           rootDir,
-          existingExports: new Set((_e2 = (_d2 = existingBarrel == null ? void 0 : existingBarrel.exports) == null ? void 0 : _d2.flatMap((e) => Array.isArray(e.name) ? e.name : [e.name]).filter((n) => Boolean(n))) != null ? _e2 : []),
+          existingExports: new Set((_e = (_d2 = existingBarrel == null ? void 0 : existingBarrel.exports) == null ? void 0 : _d2.flatMap((e) => Array.isArray(e.name) ? e.name : [e.name]).filter((n) => Boolean(n))) != null ? _e : []),
           config,
           driver
         }).map((e) => createExport(e)),
@@ -7358,42 +7393,8 @@ const memoryStorage = createStorage(() => {
     }
   };
 });
-async function isFormatterAvailable(formatter) {
-  try {
-    await x(formatter, ["--version"], { nodeOptions: { stdio: "ignore" } });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function detectFormatter() {
-  const formatterNames = /* @__PURE__ */ new Set([
-    "biome",
-    "oxfmt",
-    "prettier"
-  ]);
-  for (const formatter of formatterNames) if (await isFormatterAvailable(formatter)) return formatter;
-  return null;
-}
-async function isLinterAvailable(linter) {
-  try {
-    await x(linter, ["--version"], { nodeOptions: { stdio: "ignore" } });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function detectLinter() {
-  const linterNames = /* @__PURE__ */ new Set([
-    "biome",
-    "oxlint",
-    "eslint"
-  ]);
-  for (const linter of linterNames) if (await isLinterAvailable(linter)) return linter;
-  return null;
-}
 
-var version = "5.0.0-alpha.36";
+var version = "5.0.0-alpha.39";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7584,36 +7585,40 @@ async function loadConfig(resolvedConfigPath) {
   return configs[0];
 }
 
-const pluginRegistry = /* @__PURE__ */ new Map([
-  ["@kubb/plugin-client", pluginClient],
-  ["@kubb/plugin-cypress", pluginCypress],
-  ["@kubb/plugin-faker", pluginFaker],
-  ["@kubb/plugin-mcp", pluginMcp],
-  ["@kubb/plugin-msw", pluginMsw],
-  ["@kubb/plugin-oas", pluginOas],
-  ["@kubb/plugin-react-query", pluginReactQuery],
-  ["@kubb/plugin-redoc", pluginRedoc],
-  ["@kubb/plugin-solid-query", pluginSolidQuery],
-  ["@kubb/plugin-svelte-query", pluginSvelteQuery],
-  ["@kubb/plugin-swr", pluginSwr],
-  ["@kubb/plugin-ts", pluginTs],
-  ["@kubb/plugin-vue-query", pluginVueQuery],
-  ["@kubb/plugin-zod", pluginZod]
-]);
-function resolvePlugins(plugins) {
-  return plugins.map(({ name, options }) => {
-    const factory = pluginRegistry.get(name);
-    if (typeof factory !== "function") {
-      throw new Error(`Plugin "${name}" is not supported. Supported plugins: ${Object.keys(pluginRegistry).join(", ")}`);
-    }
-    return factory(options != null ? options : {});
-  });
+function toExportName(packageName) {
+  var _a;
+  const base = (_a = packageName.split("/").pop()) != null ? _a : packageName;
+  return base.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+async function loadPluginFactory(packageName) {
+  let mod;
+  try {
+    mod = await import(packageName);
+  } catch {
+    throw new Error(`Plugin "${packageName}" could not be loaded. Make sure it is installed: \`npm install ${packageName}\``);
+  }
+  const exportName = toExportName(packageName);
+  if (typeof mod[exportName] === "function") return mod[exportName];
+  if (typeof mod["default"] === "function") return mod["default"];
+  const firstFn = Object.values(mod).find((v) => typeof v === "function");
+  if (firstFn) return firstFn;
+  throw new Error(
+    `Plugin "${packageName}" does not export a callable factory. Tried: named export "${exportName}", "default", and any exported function.`
+  );
+}
+async function resolvePlugins(plugins) {
+  return Promise.all(
+    plugins.map(async ({ name, options }) => {
+      const factory = await loadPluginFactory(name);
+      return factory(options != null ? options : {});
+    })
+  );
 }
 
-function mergePlugins(diskPlugins, studioPlugins) {
+async function mergePlugins(diskPlugins, studioPlugins) {
   if (!diskPlugins && !studioPlugins) return void 0;
   if (!studioPlugins) return diskPlugins;
-  const resolvedStudio = resolvePlugins(studioPlugins);
+  const resolvedStudio = await resolvePlugins(studioPlugins);
   if (!diskPlugins) return resolvedStudio;
   const studioEntryByResolvedName = /* @__PURE__ */ new Map();
   resolvedStudio.forEach((resolved, i) => {
@@ -7623,13 +7628,16 @@ function mergePlugins(diskPlugins, studioPlugins) {
     }
   });
   const diskNames = new Set(diskPlugins.map((p) => p.name));
-  const mergedDisk = diskPlugins.map((diskPlugin) => {
-    var _a;
-    const studioEntry = studioEntryByResolvedName.get(diskPlugin.name);
-    if (!studioEntry) return diskPlugin;
-    const mergedOptions = mergeDeep(diskPlugin.options, studioEntry.options);
-    return (_a = resolvePlugins([{ name: studioEntry.name, options: mergedOptions }])[0]) != null ? _a : diskPlugin;
-  });
+  const mergedDisk = await Promise.all(
+    diskPlugins.map(async (diskPlugin) => {
+      var _a;
+      const studioEntry = studioEntryByResolvedName.get(diskPlugin.name);
+      if (!studioEntry) return diskPlugin;
+      const mergedOptions = mergeDeep(diskPlugin.options, studioEntry.options);
+      const resolved = await resolvePlugins([{ name: studioEntry.name, options: mergedOptions }]);
+      return (_a = resolved[0]) != null ? _a : diskPlugin;
+    })
+  );
   const studioOnly = resolvedStudio.filter((p) => !diskNames.has(p.name));
   return [...mergedDisk, ...studioOnly];
 }
@@ -7693,20 +7701,35 @@ function setupHookListener(hooks, root) {
   });
 }
 
-const WEBSOCKET_READY = 1;
-const WEBSOCKET_CONNECTING = 0;
-function createWebsocket(url, options) {
+const agentDefaults = {
+  studioUrl: "https://studio.kubb.dev",
+  configPath: "kubb.config.ts",
+  retryIntervalMs: 3e4,
+  heartbeatIntervalMs: 3e4,
+  poolSize: 1
+};
+const websocketDefaults = {
+  connectTimeoutMs: 5e3,
+  closeCode: {
+    timeout: 3008
+  },
+  closeReason: {
+    timeout: "Connection timeout"
+  }
+};
+
+function createWebsocket(url, options, timeoutMs = websocketDefaults.connectTimeoutMs) {
   const ws = new WebSocket(url, options);
   setTimeout(() => {
-    if (ws.readyState === WEBSOCKET_CONNECTING) {
-      ws.close(3008, "Connection timeout");
+    if (ws.readyState === WebSocket.CONNECTING) {
+      ws.close(websocketDefaults.closeCode.timeout, websocketDefaults.closeReason.timeout);
     }
-  }, 5e3);
+  }, timeoutMs);
   return ws;
 }
 function sendAgentMessage(ws, message) {
   try {
-    if (ws.readyState !== WEBSOCKET_READY) {
+    if (ws.readyState !== WebSocket.OPEN) {
       return;
     }
     ws.send(JSON.stringify(message));
@@ -7923,7 +7946,7 @@ async function connectToStudio(options) {
             const config = await loadConfig(resolvedConfigPath);
             const storedConfig = data.payload ? null : await getLatestStudioConfigFromStorage({ sessionId }).catch(() => null);
             const patch = (_b = (_a2 = data.payload) != null ? _a2 : storedConfig) != null ? _b : void 0;
-            const plugins = mergePlugins(config.plugins, patch == null ? void 0 : patch.plugins);
+            const plugins = await mergePlugins(config.plugins, patch == null ? void 0 : patch.plugins);
             const inputOverride = isSandbox ? { data: (_c = patch == null ? void 0 : patch.input) != null ? _c : "" } : void 0;
             if (allowWrite && isSandbox) {
               logger.warn(`[${maskedSessionId}] Agent is running in a sandbox environment, write will be disabled`);
@@ -7998,25 +8021,46 @@ async function connectToStudio(options) {
   }
 }
 
+function parseBooleanEnv(value) {
+  return value === "true";
+}
+function parsePositiveIntegerEnv(value, fallback) {
+  const parsed = Number.parseInt(value != null ? value : "", 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveStudioRuntimeConfig(env = process$1.env, cwd = process$1.cwd()) {
+  var _a, _b, _c;
+  const root = (_a = env.KUBB_AGENT_ROOT) != null ? _a : cwd;
+  const configPath = (_b = env.KUBB_AGENT_CONFIG) != null ? _b : agentDefaults.configPath;
+  const allowAll = parseBooleanEnv(env.KUBB_AGENT_ALLOW_ALL);
+  return {
+    studioUrl: (_c = env.KUBB_STUDIO_URL) != null ? _c : agentDefaults.studioUrl,
+    token: env.KUBB_AGENT_TOKEN,
+    configPath,
+    resolvedConfigPath: path$1.isAbsolute(configPath) ? configPath : path$1.resolve(root, configPath),
+    retryInterval: parsePositiveIntegerEnv(env.KUBB_AGENT_RETRY_TIMEOUT, agentDefaults.retryIntervalMs),
+    heartbeatInterval: parsePositiveIntegerEnv(env.KUBB_AGENT_HEARTBEAT_INTERVAL, agentDefaults.heartbeatIntervalMs),
+    root,
+    allowAll,
+    allowWrite: allowAll || parseBooleanEnv(env.KUBB_AGENT_ALLOW_WRITE),
+    allowPublish: allowAll || parseBooleanEnv(env.KUBB_AGENT_ALLOW_PUBLISH),
+    poolSize: parsePositiveIntegerEnv(env.KUBB_AGENT_POOL_SIZE, agentDefaults.poolSize),
+    hasSecret: Boolean(env.KUBB_AGENT_SECRET)
+  };
+}
+
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nitro) => {
-  const studioUrl = process$1.env.KUBB_STUDIO_URL || "https://studio.kubb.dev";
-  const token = process$1.env.KUBB_AGENT_TOKEN;
-  const configPath = process$1.env.KUBB_AGENT_CONFIG || "kubb.config.ts";
-  const retryInterval = process$1.env.KUBB_AGENT_RETRY_TIMEOUT ? Number.parseInt(process$1.env.KUBB_AGENT_RETRY_TIMEOUT, 10) : 3e4;
-  const heartbeatInterval = process$1.env.KUBB_AGENT_HEARTBEAT_INTERVAL ? Number.parseInt(process$1.env.KUBB_AGENT_HEARTBEAT_INTERVAL, 10) : 3e4;
-  const root = process$1.env.KUBB_AGENT_ROOT || process$1.cwd();
-  const allowAll = process$1.env.KUBB_AGENT_ALLOW_ALL === "true";
-  const allowWrite = allowAll || process$1.env.KUBB_AGENT_ALLOW_WRITE === "true";
-  const allowPublish = allowAll || process$1.env.KUBB_AGENT_ALLOW_PUBLISH === "true";
-  const poolSize = process$1.env.KUBB_AGENT_POOL_SIZE ? Number.parseInt(process$1.env.KUBB_AGENT_POOL_SIZE, 10) : 1;
+  const { studioUrl, token, configPath, resolvedConfigPath, retryInterval, heartbeatInterval, root, allowAll, allowWrite, allowPublish, poolSize, hasSecret } = resolveStudioRuntimeConfig(process$1.env);
   if (!token) {
     logger.warn("KUBB_AGENT_TOKEN not set", "cannot authenticate with studio");
     return null;
   }
-  if (!process$1.env.KUBB_AGENT_SECRET) {
+  if (!hasSecret) {
     logger.warn("KUBB_AGENT_SECRET not set", "secret should be set");
   }
-  const resolvedConfigPath = path$1.isAbsolute(configPath) ? configPath : path$1.resolve(root, configPath);
   const maskedToken = maskString(token);
   try {
     await registerAgent({ token, studioUrl, poolSize });
@@ -8036,8 +8080,8 @@ const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nit
     logger.info(`[${maskedToken}] Starting session pool of ${poolSize} connection(s)`);
     const sessions = /* @__PURE__ */ new Map();
     for (const index of Array.from({ length: poolSize }, (_, i) => i)) {
-      const session = await createAgentSession({ token, studioUrl }).catch((err) => {
-        logger.warn(`[${maskedToken}] Failed to pre-create pool session ${index}:`, err == null ? void 0 : err.message);
+      const session = await createAgentSession({ token, studioUrl }).catch((error) => {
+        logger.warn(`[${maskedToken}] Failed to pre-create pool session ${index}:`, getErrorMessage(error));
         return null;
       });
       sessions.set(index, session);
@@ -8048,12 +8092,12 @@ const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nit
       }
       const maskedSessionId = maskString(session.sessionId);
       logger.info(`[${maskedSessionId}] Connecting session ${index + 1}/${sessions.size}`);
-      await connectToStudio({ ...baseOptions, initialSession: session }).catch((err) => {
-        logger.warn(`[${maskedSessionId}] Session ${index + 1} failed to connect:`, err == null ? void 0 : err.message);
+      await connectToStudio({ ...baseOptions, initialSession: session }).catch((error) => {
+        logger.warn(`[${maskedSessionId}] Session ${index + 1} failed to connect:`, getErrorMessage(error));
       });
     }
   } catch (error) {
-    logger.error("Failed to connect to Kubb Studio\n", error == null ? void 0 : error.message);
+    logger.error("Failed to connect to Kubb Studio\n", getErrorMessage(error));
   }
 });