@kubb/agent 4.29.1 → 4.31.0

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

@@ -6,14 +6,15 @@ import http, { Server as Server$2 } from 'node:http';
 import https, { Server as Server$1 } from 'node:https';
 import { EventEmitter } from 'node:events';
 import { Buffer as Buffer$1 } from 'node:buffer';
-import fs$1, { promises, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import fs$1, { promises, existsSync, readFileSync } from 'node:fs';
 import path$2, { resolve, dirname, relative, join, normalize } from 'node:path';
 import anymatch from 'anymatch';
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import process$1, { version as version$2 } from 'node:process';
+import { Logtail } from '@logtail/node';
+import { consola } from 'consola';
 import { sortBy, mergeDeep, isPlainObject as isPlainObject$1, uniqueWith, isDeepEqual, isNumber, isFunction, difference } from 'remeda';
 import { x } from 'tinyexec';
-import os$1 from 'node:os';
 import { styleText } from 'node:util';
 import { access, rm, readFile as readFile$1, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
 import { performance as performance$1 } from 'node:perf_hooks';
@@ -21,6 +22,7 @@ import mod, { createRequire } from 'node:module';
 import { createFabric, createReactFabric, App, File, Function as Function$1, Const, FunctionParams, Type as Type$1, useApp } from '@kubb/react-fabric';
 import { typescriptParser } from '@kubb/react-fabric/parsers';
 import { fsPlugin } from '@kubb/react-fabric/plugins';
+import os$1 from 'node:os';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import * as pkg from 'empathic/package';
 import { coerce, satisfies } from 'semver';
@@ -4387,28 +4389,217 @@ function defineNitroPlugin(def) {
   return def;
 }
 
-const logger = {
-  info(message, details) {
-    const text = details ? `${message} ${styleText("dim", details)}` : message;
-    console.info(`${styleText("blue", "\u2139")} ${text}`);
-  },
-  success(message, details) {
-    const text = details ? `${message} ${styleText("dim", details)}` : message;
-    console.log(`${styleText("green", "\u2713")} ${text}`);
-  },
-  warn(message, details) {
-    const text = details ? `${message} ${styleText("dim", details)}` : message;
-    console.warn(`${styleText("yellow", "\u26A0")} ${text}`);
-  },
-  error(message, details) {
-    const text = details ? `${message} ${styleText("dim", details)}` : message;
-    console.error(`${styleText("red", "\u2717")} ${text}`);
+let logtail = null;
+function getLogtail() {
+  if (logtail) {
+    return logtail;
+  }
+  const token = process.env.OTLP_TOKEN;
+  if (!token) {
+    return null;
+  }
+  try {
+    logtail = new Logtail(token, {
+      endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT
+    });
+    return logtail;
+  } catch {
+    return null;
+  }
+}
+function toBetterStackContext(ctx) {
+  if (!ctx) return void 0;
+  const filtered = Object.fromEntries(Object.entries(ctx).filter(([, v]) => v !== void 0 && v !== null));
+  return Object.keys(filtered).length ? filtered : void 0;
+}
+function sendToBetterStack(level, tag, message, ctx) {
+  const client = getLogtail();
+  if (!client) {
+    return;
+  }
+  try {
+    const fullMessage = message !== void 0 ? `[${tag}] ${message}` : tag;
+    const context = toBetterStackContext(ctx);
+    if (level === "error") {
+      client.error(fullMessage, context).then(() => client.flush());
+    } else if (level === "warn") {
+      client.warn(fullMessage, context).then(() => client.flush());
+    } else {
+      client.info(fullMessage, context).then(() => client.flush());
+    }
+  } catch (_e) {
+  }
+}
+function log(level, tag, message, ctx) {
+  const displayMessage = message !== void 0 ? `[${tag}] ${message}` : tag;
+  consola[level](displayMessage);
+  if (ctx) {
+    const filtered = Object.fromEntries(Object.entries(ctx).filter(([, v]) => v !== void 0 && v !== null));
+    if (Object.keys(filtered).length) {
+      console.table(filtered);
+    }
+  }
+  if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT && process.env.OTLP_TOKEN) {
+    sendToBetterStack(level, tag, message, ctx);
   }
+}
+const logger = {
+  info: (tag, message, ctx) => log("info", tag, message, ctx),
+  success: (tag, message, ctx) => log("success", tag, message, ctx),
+  warn: (tag, message, ctx) => log("warn", tag, message, ctx),
+  error: (tag, message, ctx) => log("error", tag, message, ctx)
 };
 
 const _KZ9YuROWp70nNn4X1C4BxF_W0D7H9EWgBo03XvMd7w0 = defineNitroPlugin(() => {
 });
 
+function maskedString(value, start = 8, end = 4) {
+  if (value.length <= start + end) return value;
+  return `${value.slice(0, start)}\u2026${value.slice(-end)}`;
+}
+
+const HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
+const _a2VEEUGb5K4b1gyM9hOmO1Xz0hUJSFuGyIT3cHsvE = defineNitroPlugin((nitro) => {
+  const heartbeatUrl = process$1.env.KUBB_AGENT_HEARTBEAT_URL;
+  if (!heartbeatUrl) {
+    return;
+  }
+  const maskedUrl = maskedString(heartbeatUrl);
+  const timer = setInterval(async () => {
+    try {
+      await $fetch(heartbeatUrl, { method: "GET" });
+      logger.info(`Heartbeat sent to ${maskedUrl}`);
+    } catch (error) {
+      logger.warn(`Failed to send heartbeat to ${maskedUrl}`, error == null ? void 0 : error.message);
+    }
+  }, HEARTBEAT_INTERVAL_MS);
+  nitro.hooks.hook("close", () => {
+    clearInterval(timer);
+  });
+});
+
+function getStorage() {
+  return useStorage("kubb");
+}
+function isSessionValid(session) {
+  try {
+    const expiresAt = new Date(session.expiresAt);
+    const now = /* @__PURE__ */ new Date();
+    return now.getTime() < expiresAt.getTime() - 6e4;
+  } catch {
+    return false;
+  }
+}
+function getSessionKey(token) {
+  return `sessions:${createHash("sha512").update(token).digest("hex")}`;
+}
+async function getCachedSession(sessionKey) {
+  const storage = getStorage();
+  const agentSession = await storage.getItem(sessionKey);
+  if (!agentSession) {
+    return null;
+  }
+  if (!isSessionValid(agentSession)) {
+    return null;
+  }
+  return agentSession;
+}
+async function cacheSession({ sessionKey, session }) {
+  const storage = getStorage();
+  await storage.setItem(sessionKey, { ...session, storedAt: (/* @__PURE__ */ new Date()).toISOString(), configs: [] });
+}
+async function removeCachedSession(sessionKey) {
+  const storage = getStorage();
+  const maskedSessionKey = maskedString(sessionKey.replace("sessions:", ""));
+  logger.info(`[${maskedSessionKey}] Removing expired agent session from cache...`);
+  await storage.removeItem(sessionKey);
+  logger.success(`[${maskedSessionKey}] Removed expired agent session from cache`);
+}
+async function saveStudioConfigToStorage({ sessionKey, config }) {
+  const storage = getStorage();
+  const agentSession = await getCachedSession(sessionKey);
+  if (!agentSession) {
+    throw new Error("No valid session found for retrieving previous configs");
+  }
+  await storage.setItem(sessionKey, { ...agentSession, configs: [...agentSession.configs, { config, storedAt: (/* @__PURE__ */ new Date()).toISOString() }] });
+}
+
+function generateToken() {
+  return randomBytes(32).toString("hex");
+}
+function generateMachineToken() {
+  return process.env.KUBB_AGENT_SECRET ? process.env.KUBB_AGENT_SECRET : createHash("sha256").update(generateToken()).digest("hex");
+}
+
+async function createAgentSession({ token, studioUrl, noCache, cacheKey }) {
+  const machineToken = generateMachineToken();
+  const sessionKey = cacheKey != null ? cacheKey : getSessionKey(token);
+  const maskedSessionKey = maskedString(sessionKey.replace("sessions:", ""));
+  const connectUrl = `${studioUrl}/api/agent/session/create`;
+  const canCache = !noCache;
+  if (canCache) {
+    const cachedSession = await getCachedSession(sessionKey);
+    if (cachedSession) {
+      logger.success(`[${maskedSessionKey}] Using cached agent session`);
+      return cachedSession;
+    }
+    await removeCachedSession(sessionKey);
+  }
+  try {
+    logger.info(`[${maskedSessionKey}] Creating agent session with Studio...`);
+    const data = await $fetch(connectUrl, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+      body: { machineToken }
+    });
+    if (!data) {
+      throw new Error("No data available for agent session");
+    }
+    if (canCache) {
+      await cacheSession({ sessionKey, session: { ...data, storedAt: (/* @__PURE__ */ new Date()).toISOString(), configs: [] } });
+      logger.success(`[${maskedSessionKey}] Saved agent session to cache`);
+    }
+    logger.info(`[${maskedSessionKey}] Created agent session with Studio`);
+    return data;
+  } catch (error) {
+    throw new Error("Failed to get agent session from Kubb Studio", { cause: error });
+  }
+}
+async function registerAgent({ token, studioUrl, poolSize }) {
+  var _a, _b;
+  const machineToken = generateMachineToken();
+  const registerUrl = `${studioUrl}/api/agent/register`;
+  try {
+    logger.info("Registering agent with Studio...");
+    await $fetch(registerUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`
+      },
+      body: { machineToken, poolSize }
+    });
+    logger.success(`Agent registered with Studio with token ${maskedString(token)}`);
+  } catch (error) {
+    logger.error("Failed to register agent with Studio", (_b = (_a = error == null ? void 0 : error.cause) == null ? void 0 : _a.message) != null ? _b : error == null ? void 0 : error.message);
+  }
+}
+async function disconnect({ sessionId, token, studioUrl }) {
+  const disconnectUrl = `${studioUrl}/api/agent/session/${sessionId}/disconnect`;
+  const maskedSessionKey = maskedString(sessionId);
+  try {
+    logger.info(`[${maskedSessionKey}] Disconnecting from Studio...`);
+    await $fetch(disconnectUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    logger.success(`[${maskedSessionKey}] Disconnected from Studio`);
+  } catch (error) {
+    throw new Error("Failed to notify Studio of disconnection on exit", { cause: error });
+  }
+}
+
 async function clean(path) {
   return rm(path, {
     recursive: true,
@@ -5882,116 +6073,16 @@ function tokenize(command) {
   return args;
 }
 
+var version = "4.31.0";
+
 function isCommandMessage(msg) {
   return msg.type === "command";
 }
 function isPongMessage(msg) {
   return msg.type === "pong";
 }
-
-function getSessionKey(token) {
-  return `sessions:${createHash("sha512").update(token).digest("hex")}`;
-}
-
-function isSessionValid(session) {
-  try {
-    const expiresAt = new Date(session.expiresAt);
-    const now = /* @__PURE__ */ new Date();
-    return now.getTime() < expiresAt.getTime() - 6e4;
-  } catch {
-    return false;
-  }
-}
-
-function hashToken(input) {
-  return createHash("sha256").update(input).digest("hex");
-}
-function generateMachineToken() {
-  if (process.env.KUBB_STUDIO_SECRET) {
-    return hashToken(process.env.KUBB_STUDIO_SECRET);
-  }
-  const interfaces = os$1.networkInterfaces();
-  const macs = [];
-  for (const name in interfaces) {
-    for (const iface of interfaces[name]) {
-      if (!iface.internal && iface.mac !== "00:00:00:00:00:00") {
-        macs.push(iface.mac);
-      }
-    }
-  }
-  return hashToken(macs.join(",") + os$1.hostname());
-}
-
-async function createAgentSession({ token, studioUrl, noCache }) {
-  const storage = useStorage("kubb");
-  if (!noCache) {
-    const sessionKey = getSessionKey(token);
-    const stored = await storage.getItem(sessionKey);
-    if (stored && isSessionValid(stored)) {
-      logger.success("Using cached agent session");
-      return stored;
-    }
-    if (stored) {
-      await storage.removeItem(sessionKey);
-    }
-  }
-  const connectUrl = `${studioUrl}/api/agent/session/create`;
-  try {
-    const machineToken = generateMachineToken();
-    const data = await $fetch(connectUrl, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`
-      },
-      body: { machineToken }
-    });
-    if (!data) {
-      throw new Error("No data available for agent session");
-    }
-    if (!noCache) {
-      const sessionKey = getSessionKey(token);
-      await storage.setItem(sessionKey, {
-        ...data,
-        storedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      logger.success("Cached agent session");
-    }
-    logger.success("Agent session created");
-    return data;
-  } catch (error) {
-    throw new Error("Failed to get agent session from Kubb Studio", { cause: error });
-  }
-}
-async function registerAgent({ token, studioUrl }) {
-  var _a, _b;
-  const machineToken = generateMachineToken();
-  const registerUrl = `${studioUrl}/api/agent/register`;
-  try {
-    await $fetch(registerUrl, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`
-      },
-      body: { machineToken }
-    });
-    logger.success("Agent registered with Studio");
-  } catch (error) {
-    logger.warn("Failed to register agent with Studio", (_b = (_a = error == null ? void 0 : error.cause) == null ? void 0 : _a.message) != null ? _b : error == null ? void 0 : error.message);
-  }
-}
-async function disconnect({ sessionToken, token, studioUrl }) {
-  try {
-    const disconnectUrl = `${studioUrl}/api/agent/session/${sessionToken}/disconnect`;
-    await $fetch(disconnectUrl, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    });
-    logger.success("Sent disconnect notification to Studio on exit");
-  } catch (error) {
-    throw new Error("Failed to notify Studio of disconnection on exit", { cause: error });
-  }
+function isDisconnectMessage(msg) {
+  return msg.type === "disconnect";
 }
 
 var __typeError$3 = (msg) => {
@@ -6027,7 +6118,7 @@ var BaseGenerator = (_a$3 = class {
 function isInputPath(config) {
   return typeof (config == null ? void 0 : config.input) === "object" && config.input !== null && "path" in config.input;
 }
-var version$1 = "4.29.1";
+var version$1 = "4.31.0";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6505,6 +6596,15 @@ async function getCosmiConfig(configPath) {
   }
 }
 
+async function loadConfig(resolvedConfigPath) {
+  const result = await getCosmiConfig(resolvedConfigPath);
+  const configs = await getConfigs(result.config, {});
+  if (configs.length === 0) {
+    throw new Error("No configs found");
+  }
+  return configs[0];
+}
+
 var __defProp$8 = Object.defineProperty;
 var __name$5 = (target, value) => __defProp$8(target, "name", {
   value,
@@ -11464,6 +11564,7 @@ async function buildOperations(operations, { config, fabric, plugin, generator,
     })
   }));
   await fabric.context.fileManager.upsert(...fabricChild.files);
+  fabricChild.unmount();
 }
 async function buildOperation(operation, { config, fabric, plugin, generator, Component }) {
   if (!Component) return;
@@ -11484,6 +11585,7 @@ async function buildOperation(operation, { config, fabric, plugin, generator, Co
     })
   }));
   await fabric.context.fileManager.upsert(...fabricChild.files);
+  fabricChild.unmount();
 }
 async function buildSchema(schema, { config, fabric, plugin, Component, generator }) {
   if (!Component) return;
@@ -11504,6 +11606,7 @@ async function buildSchema(schema, { config, fabric, plugin, Component, generato
     })
   }));
   await fabric.context.fileManager.upsert(...fabricChild.files);
+  fabricChild.unmount();
 }
 var SchemaGenerator = (_b = class extends BaseGenerator {
   constructor() {
@@ -11781,6 +11884,16 @@ getRefAlias_fn = function(schemaObject, name) {
       }
     }];
   }
+  if ($ref.startsWith("#") && !$ref.startsWith("#/components/")) try {
+    const inlineSchema = this.context.oas.get($ref);
+    if (inlineSchema && !isReference(inlineSchema)) return this.parse({
+      schema: inlineSchema,
+      name,
+      parentName: null,
+      rootName: null
+    });
+  } catch {
+  }
   __privateMethod$1(this, _SchemaGenerator_instances, ensureNameMapping_fn).call(this);
   const originalName = $ref.replace(/.+\//, "");
   const resolvedName = __privateGet(this, _schemaNameMapping).get($ref) || originalName;
@@ -217747,7 +217860,7 @@ const infiniteQueryGenerator$1 = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -217766,7 +217879,7 @@ const infiniteQueryGenerator$1 = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: query.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -217973,7 +218086,7 @@ const mutationGenerator$4 = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -217992,7 +218105,7 @@ const mutationGenerator$4 = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: mutation.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -218183,7 +218296,7 @@ const queryGenerator$4 = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -218202,7 +218315,7 @@ const queryGenerator$4 = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: query.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -218405,7 +218518,7 @@ const suspenseInfiniteQueryGenerator = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -218424,7 +218537,7 @@ const suspenseInfiniteQueryGenerator = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: query.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -218639,7 +218752,7 @@ const suspenseQueryGenerator = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -218658,7 +218771,7 @@ const suspenseQueryGenerator = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: query.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -219538,7 +219651,7 @@ const mutationGenerator$3 = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -219557,7 +219670,7 @@ const mutationGenerator$3 = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: mutation.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -219731,7 +219844,7 @@ const queryGenerator$3 = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -219750,7 +219863,7 @@ const queryGenerator$3 = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: query.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -220552,7 +220665,7 @@ const mutationGenerator$2 = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -220571,7 +220684,7 @@ const mutationGenerator$2 = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: mutation.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -220744,7 +220857,7 @@ const queryGenerator$2 = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -220763,7 +220876,7 @@ const queryGenerator$2 = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: query.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -221603,7 +221716,7 @@ const mutationGenerator$1 = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -221622,7 +221735,7 @@ const mutationGenerator$1 = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: mutation.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -221791,7 +221904,7 @@ const queryGenerator$1 = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -221810,7 +221923,7 @@ const queryGenerator$1 = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: query.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -222965,7 +223078,7 @@ const infiniteQueryGenerator = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -222984,7 +223097,7 @@ const infiniteQueryGenerator = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: query.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -223189,7 +223302,7 @@ const mutationGenerator = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -223208,7 +223321,7 @@ const mutationGenerator = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: mutation.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -223382,7 +223495,7 @@ const queryGenerator = createReactGenerator({
           path: zod.file.path
         }),
         options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: "fetch",
             path: options.client.importPath
           }),
@@ -223401,7 +223514,7 @@ const queryGenerator = createReactGenerator({
             isTypeOnly: true
           })
         ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(File.Import, {
+          !shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
             name: ["fetch"],
             root: query.file.path,
             path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts")
@@ -223690,20 +223803,41 @@ function resolvePlugins(plugins) {
   });
 }
 
-function readStudioConfig(configPath) {
-  const studioConfigPath = path$2.join(path$2.dirname(configPath), "kubb.config.studio.json");
-  if (!existsSync(studioConfigPath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(readFileSync(studioConfigPath, "utf-8"));
-  } catch {
-    return null;
-  }
+function mergePlugins(diskPlugins, studioPlugins) {
+  if (!diskPlugins && !studioPlugins) return void 0;
+  if (!studioPlugins) return diskPlugins;
+  const resolvedStudio = resolvePlugins(studioPlugins);
+  if (!diskPlugins) return resolvedStudio;
+  const studioByName = new Map(resolvedStudio.map((p) => [p.name, p]));
+  const diskNames = new Set(diskPlugins.map((p) => p.name));
+  const mergedDisk = diskPlugins.map((diskPlugin) => {
+    const studioPlugin = studioByName.get(diskPlugin.name);
+    if (!studioPlugin) return diskPlugin;
+    return { ...diskPlugin, options: mergeDeep(diskPlugin.options, studioPlugin.options) };
+  });
+  const studioOnly = resolvedStudio.filter((p) => !diskNames.has(p.name));
+  return [...mergedDisk, ...studioOnly];
 }
-function writeStudioConfig(configPath, config) {
-  const studioConfigPath = path$2.join(path$2.dirname(configPath), "kubb.config.studio.json");
-  writeFileSync(studioConfigPath, JSON.stringify(config, null, 2), "utf-8");
+
+function setupHookListener(events, root) {
+  events.on("hook:start", async ({ id, command, args }) => {
+    if (!id) {
+      return;
+    }
+    const commandWithArgs = (args == null ? void 0 : args.length) ? `${command} ${args.join(" ")}` : command;
+    try {
+      const result = await x(command, [...args != null ? args : []], {
+        nodeOptions: { cwd: root, detached: true },
+        throwOnError: true
+      });
+      console.log(result.stdout.trimEnd());
+      await events.emit("hook:end", { command, args, id, success: true, error: null });
+    } catch (_err) {
+      const errorMessage = new Error(`Hook execute failed: ${commandWithArgs}`);
+      await events.emit("hook:end", { command, args, id, success: false, error: errorMessage });
+      await events.emit("error", errorMessage);
+    }
+  });
 }
 
 const WEBSOCKET_READY = 1;
@@ -223835,7 +223969,165 @@ function setupEventsStream(ws, events) {
   });
 }
 
-var version = "4.29.1";
+async function connectToStudio(options) {
+  var _a;
+  const {
+    token,
+    studioUrl,
+    configPath,
+    resolvedConfigPath,
+    noCache,
+    allowAll,
+    allowWrite,
+    root,
+    retryInterval,
+    heartbeatInterval = 3e4,
+    initialSession,
+    sessionKey,
+    nitro
+  } = options;
+  const events = new AsyncEventEmitter();
+  const maskedSessionKey = maskedString(sessionKey.replace("sessions:", ""));
+  async function removeSession() {
+    if (!noCache) {
+      await removeCachedSession(sessionKey);
+    }
+  }
+  async function reconnect() {
+    logger.info(`[${maskedSessionKey}] Retrying connection in ${formatMs(retryInterval)} to Kubb Studio ...`);
+    await removeSession();
+    setTimeout(() => connectToStudio({ ...options, initialSession: void 0 }), retryInterval);
+  }
+  try {
+    setupHookListener(events, root);
+    const { sessionId, wsUrl, isSandbox } = initialSession != null ? initialSession : await createAgentSession({ noCache, token, studioUrl, cacheKey: sessionKey });
+    const ws = createWebsocket(wsUrl, { headers: { Authorization: `Bearer ${token}` } });
+    const maskedWsUrl = maskedString(wsUrl);
+    const effectiveAllowAll = isSandbox ? false : allowAll;
+    const effectiveWrite = isSandbox ? false : allowWrite;
+    let serverDisconnected = false;
+    let heartbeatTimer;
+    async function cleanup(reason = "cleanup") {
+      try {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = void 0;
+        events.removeAll();
+        ws.close(1e3, reason);
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("close", onClose);
+        ws.removeEventListener("error", onError);
+      } catch (_error) {
+      }
+    }
+    const onOpen = () => {
+      logger.success(`[${maskedSessionKey}] Connected to Kubb Studio on "${maskedWsUrl}"`);
+    };
+    const onClose = async () => {
+      if (serverDisconnected) {
+        return;
+      }
+      serverDisconnected = true;
+      await cleanup();
+      await disconnect({ sessionId, studioUrl, token }).catch(() => {
+      });
+      await reconnect();
+    };
+    const onError = async () => {
+      logger.error(`[${maskedSessionKey}] Failed to connect to Kubb Studio on "${maskedWsUrl}"`);
+      await cleanup();
+      await reconnect();
+    };
+    ws.addEventListener("open", onOpen);
+    ws.addEventListener("close", onClose);
+    ws.addEventListener("error", onError);
+    nitro.hooks.hook("close", async () => {
+      await cleanup();
+      await disconnect({ sessionId, studioUrl, token }).catch(() => {
+      });
+    });
+    heartbeatTimer = setInterval(() => sendAgentMessage(ws, { type: "ping" }), heartbeatInterval);
+    setupEventsStream(ws, events);
+    ws.addEventListener("message", async (message) => {
+      var _a2, _b, _c;
+      try {
+        const data = JSON.parse(message.data);
+        logger.info(`[${maskedSessionKey}] Received "${data.type}" from Studio`);
+        if (isPongMessage(data)) {
+          return;
+        }
+        if (isDisconnectMessage(data)) {
+          logger.warn(`[${maskedSessionKey}] Agent session disconnected by Studio with reason: ${data.reason}`);
+          if (data.reason === "revoked") {
+            await cleanup(`session_${data.reason}`);
+            await removeSession();
+            return;
+          }
+          if (data.reason === "expired") {
+            await cleanup();
+            await reconnect();
+            return;
+          }
+          return;
+        }
+        if (isCommandMessage(data)) {
+          if (data.command === "generate") {
+            const config = await loadConfig(resolvedConfigPath);
+            const patch = data.payload;
+            const plugins = mergePlugins(config.plugins, patch == null ? void 0 : patch.plugins);
+            const inputOverride = isSandbox ? { data: (_a2 = patch == null ? void 0 : patch.input) != null ? _a2 : "" } : void 0;
+            if (allowWrite && isSandbox) {
+              logger.warn(`[${maskedSessionKey}] Agent is running in a sandbox environment, write will be disabled`);
+            }
+            if ((patch == null ? void 0 : patch.input) && !isSandbox) {
+              logger.warn(`[${maskedSessionKey}] Input override via payload is only supported in sandbox mode and will be ignored`);
+            }
+            if (data.payload && effectiveWrite) {
+              await saveStudioConfigToStorage({ sessionKey, config: data.payload }).catch((err) => {
+                logger.warn(`[${maskedSessionKey}] Failed to save studio config: ${err == null ? void 0 : err.message}`);
+              });
+            }
+            await generate({
+              config: {
+                ...config,
+                root,
+                input: inputOverride != null ? inputOverride : config.input,
+                output: { ...config.output, write: effectiveWrite },
+                plugins
+              },
+              events
+            });
+            logger.success(`[${maskedSessionKey}] Completed "${data.type}" from Studio`);
+            return;
+          }
+          if (data.command === "connect") {
+            const config = await loadConfig(resolvedConfigPath);
+            sendAgentMessage(ws, {
+              type: "connected",
+              payload: {
+                version,
+                configPath,
+                permissions: { allowAll: effectiveAllowAll, allowWrite: effectiveWrite },
+                config: {
+                  plugins: (_b = config.plugins) == null ? void 0 : _b.map((plugin) => ({
+                    name: `@kubb/${plugin.name}`,
+                    options: serializePluginOptions(plugin.options)
+                  }))
+                }
+              }
+            });
+            logger.success(`[${maskedSessionKey}] Completed "${data.type}" from Studio`);
+            return;
+          }
+        }
+        logger.warn(`[${maskedSessionKey}] Unknown message type from Kubb Studio: ${message.data}`);
+      } catch (error) {
+        logger.error(`[${maskedSessionKey}] [unhandledRejection] ${(_c = error == null ? void 0 : error.message) != null ? _c : error}`);
+      }
+    });
+  } catch (error) {
+    throw new Error(`[unhandledRejection] ${(_a = error == null ? void 0 : error.message) != null ? _a : error}`, { cause: error });
+  }
+}
 
 const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nitro) => {
   const studioUrl = process$1.env.KUBB_STUDIO_URL || "https://studio.kubb.dev";
@@ -223843,196 +224135,70 @@ const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nit
   const configPath = process$1.env.KUBB_AGENT_CONFIG || "kubb.config.ts";
   const noCache = process$1.env.KUBB_AGENT_NO_CACHE === "true";
   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 poolSize = process$1.env.KUBB_AGENT_POOL_SIZE ? Number.parseInt(process$1.env.KUBB_AGENT_POOL_SIZE, 10) : 1;
   if (!token) {
     logger.warn("KUBB_AGENT_TOKEN not set", "cannot authenticate with studio");
     return null;
   }
+  if (!process$1.env.KUBB_AGENT_SECRET) {
+    logger.warn("KUBB_AGENT_SECRET not set", "secret should be set");
+  }
   const resolvedConfigPath = path$2.isAbsolute(configPath) ? configPath : path$2.resolve(root, configPath);
-  const events = new AsyncEventEmitter();
   const storage = useStorage("kubb");
-  async function loadConfig() {
-    const result = await getCosmiConfig(resolvedConfigPath);
-    const configs = await getConfigs(result.config, {});
-    if (configs.length === 0) {
-      throw new Error("No configs found");
-    }
-    return configs[0];
-  }
-  const wsOptions = {
-    headers: {
-      Authorization: `Bearer ${token}`
-    }
-  };
-  async function reconnectToStudio() {
-    logger.info(`Retrying connection in ${formatMs(retryInterval)} to Kubb Studio ...`);
-    setTimeout(async () => {
-      await connectToStudio();
-    }, retryInterval);
-  }
-  async function connectToStudio() {
-    try {
-      events.removeAll();
-      events.on("hook:start", async ({ id, command, args }) => {
-        const commandWithArgs = (args == null ? void 0 : args.length) ? `${command} ${args.join(" ")}` : command;
-        if (!id) {
-          return;
-        }
-        try {
-          const result = await x(command, [...args != null ? args : []], {
-            nodeOptions: { cwd: root, detached: true },
-            throwOnError: true
-          });
-          console.log(result.stdout.trimEnd());
-          await events.emit("hook:end", {
-            command,
-            args,
-            id,
-            success: true,
-            error: null
-          });
-        } catch (_err) {
-          const errorMessage = new Error(`Hook execute failed: ${commandWithArgs}`);
-          await events.emit("hook:end", {
-            command,
-            args,
-            id,
-            success: false,
-            error: errorMessage
-          });
-          await events.emit("error", errorMessage);
-        }
-      });
-      const { sessionToken, wsUrl, isSandbox } = await createAgentSession({
-        noCache,
-        token,
-        studioUrl
+  const sessionKey = getSessionKey(token);
+  const maskedSessionKey = maskedString(sessionKey.replace("sessions:", ""));
+  try {
+    await registerAgent({ token, studioUrl, poolSize });
+    const baseOptions = {
+      token,
+      studioUrl,
+      configPath,
+      resolvedConfigPath,
+      noCache,
+      allowAll,
+      allowWrite,
+      root,
+      retryInterval,
+      heartbeatInterval,
+      storage,
+      sessionKey,
+      nitro
+    };
+    logger.info(`[${maskedSessionKey}] Starting session pool of ${poolSize} connection(s)`);
+    const sessions = /* @__PURE__ */ new Map();
+    for (const index2 of Array.from({ length: poolSize }, (_, i) => i)) {
+      const cacheKey = `${sessionKey}-${index2}`;
+      const maskedSessionKey2 = maskedString(cacheKey);
+      const session = await createAgentSession({ noCache, token, studioUrl, cacheKey }).catch((err) => {
+        logger.warn(`[${maskedSessionKey2}] Failed to pre-create pool session:`, err == null ? void 0 : err.message);
+        return null;
       });
-      const ws = createWebsocket(wsUrl, wsOptions);
-      const onError = async () => {
-        cleanup();
-        logger.error(`Failed to connect to Kubb Studio on "${wsUrl}"`);
-        if (!noCache) {
-          const sessionKey = getSessionKey(token);
-          const stored = await storage.getItem(sessionKey);
-          if (stored && isSessionValid(stored)) {
-            await storage.removeItem(sessionKey);
-            await reconnectToStudio();
-          }
-        }
-      };
-      const onOpen = () => {
-        logger.success(`Connected to Kubb Studio on "${wsUrl}"`);
-      };
-      const onClose = async () => {
-        cleanup();
-        logger.info("Disconnecting from Studio ...");
-        if (sessionToken) {
-          await disconnect({
-            sessionToken,
-            studioUrl,
-            token
-          }).catch(async () => {
-          });
-          await storage.removeItem(getSessionKey(token));
-          await reconnectToStudio();
-        }
-      };
-      const cleanup = () => {
-        ws.removeEventListener("open", onOpen);
-        ws.removeEventListener("close", onClose);
-        ws.removeEventListener("error", onError);
-      };
-      ws.addEventListener("open", onOpen);
-      ws.addEventListener("close", onClose);
-      ws.addEventListener("error", onError);
-      nitro.hooks.hook("close", onClose);
-      setInterval(() => {
-        sendAgentMessage(ws, {
-          type: "ping"
-        });
-      }, 3e4);
-      setupEventsStream(ws, events);
-      ws.addEventListener("message", async (message) => {
-        var _a, _b, _c, _d;
-        try {
-          const data = JSON.parse(message.data);
-          if (isPongMessage(data)) {
-            logger.info("Received pong from Studio");
-            return;
-          }
-          if (isCommandMessage(data)) {
-            if (data.command === "generate") {
-              const config = await loadConfig();
-              const studioConfig = readStudioConfig(resolvedConfigPath);
-              const patch = (_a = data.payload) != null ? _a : studioConfig;
-              const resolvedPlugins = (patch == null ? void 0 : patch.plugins) ? resolvePlugins(patch.plugins) : void 0;
-              if (allowWrite && isSandbox) {
-                logger.warn("Agent is running in a sandbox environment, write will be disabled");
-              }
-              if ((patch == null ? void 0 : patch.input) && !isSandbox) {
-                logger.warn("Input override via payload is only supported in sandbox mode and will be ignored");
-              }
-              const inputOverride = isSandbox ? { data: (_b = patch.input) != null ? _b : "" } : void 0;
-              await generate({
-                config: {
-                  ...config,
-                  input: inputOverride != null ? inputOverride : config.input,
-                  plugins: resolvedPlugins != null ? resolvedPlugins : config.plugins,
-                  root,
-                  output: {
-                    ...config.output,
-                    write: isSandbox ? false : allowWrite
-                  }
-                },
-                events
-              });
-              if (allowWrite) {
-                writeStudioConfig(resolvedConfigPath, data.payload);
-              }
-              logger.success("Generated command success");
-            }
-            if (data.command === "connect") {
-              const config = await loadConfig();
-              sendAgentMessage(ws, {
-                type: "connected",
-                payload: {
-                  version,
-                  configPath,
-                  permissions: {
-                    allowAll: isSandbox ? false : allowWrite,
-                    allowWrite: isSandbox ? false : allowWrite
-                  },
-                  config: {
-                    plugins: (_c = config.plugins) == null ? void 0 : _c.map((plugin) => ({
-                      name: `@kubb/${plugin.name}`,
-                      options: serializePluginOptions(plugin.options)
-                    }))
-                  }
-                }
-              });
-            }
-            return;
-          }
-          logger.warn(`Unknown message type from Kubb Studio: ${message.data}`);
-        } catch (error) {
-          logger.error(`[unhandledRejection] ${(_d = error == null ? void 0 : error.message) != null ? _d : error}`);
-        }
+      sessions.set(cacheKey, session);
+    }
+    let index = 0;
+    for (const [cacheKey, session] of sessions) {
+      index++;
+      if (!session) {
+        continue;
+      }
+      const maskedSessionKey2 = maskedString(session.sessionId);
+      logger.info(`[${maskedSessionKey2}] Connecting session ${index}/${sessions.size}`);
+      await connectToStudio({ ...baseOptions, initialSession: session, sessionKey: cacheKey }).catch((err) => {
+        logger.warn(`[${maskedSessionKey2}] Session ${index} failed to connect:`, err == null ? void 0 : err.message);
       });
-    } catch (error) {
-      await storage.removeItem(getSessionKey(token));
-      logger.error(`Something went wrong ${error}`);
-      await reconnectToStudio();
     }
+  } catch (error) {
+    logger.error("Failed to connect to Kubb Studio\n", error == null ? void 0 : error.message);
   }
-  await registerAgent({ token, studioUrl });
-  await connectToStudio();
 });
 
 const plugins = [
   _KZ9YuROWp70nNn4X1C4BxF_W0D7H9EWgBo03XvMd7w0,
+_a2VEEUGb5K4b1gyM9hOmO1Xz0hUJSFuGyIT3cHsvE,
 _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E
 ];