@cocaxcode/api-testing-mcp 0.3.0 → 0.4.0

package/dist/index.js

@@ -1214,8 +1214,940 @@ function formatSchema(schema, depth = 0) {
   }
 }
 
+// src/tools/assert.ts
+import { z as z5 } from "zod";
+var AssertionSchema = z5.object({
+  path: z5.string().describe(
+    'JSONPath al valor a validar: "status", "body.data.id", "headers.content-type", "timing.total_ms"'
+  ),
+  operator: z5.enum(["eq", "neq", "gt", "gte", "lt", "lte", "contains", "not_contains", "exists", "type"]).describe(
+    "Operador: eq (igual), neq (no igual), gt/gte/lt/lte (num\xE9ricos), contains/not_contains (strings/arrays), exists (campo existe), type (typeof)"
+  ),
+  expected: z5.any().optional().describe('Valor esperado (no necesario para "exists")')
+});
+function getByPath(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function evaluateAssertion(response, assertion) {
+  const actual = getByPath(response, assertion.path);
+  switch (assertion.operator) {
+    case "eq":
+      return {
+        pass: actual === assertion.expected,
+        message: actual === assertion.expected ? `${assertion.path} === ${JSON.stringify(assertion.expected)}` : `${assertion.path}: esperado ${JSON.stringify(assertion.expected)}, recibido ${JSON.stringify(actual)}`
+      };
+    case "neq":
+      return {
+        pass: actual !== assertion.expected,
+        message: actual !== assertion.expected ? `${assertion.path} !== ${JSON.stringify(assertion.expected)}` : `${assertion.path}: no deber\xEDa ser ${JSON.stringify(assertion.expected)}`
+      };
+    case "gt":
+      return {
+        pass: typeof actual === "number" && actual > assertion.expected,
+        message: `${assertion.path}: ${actual} > ${assertion.expected} \u2192 ${typeof actual === "number" && actual > assertion.expected}`
+      };
+    case "gte":
+      return {
+        pass: typeof actual === "number" && actual >= assertion.expected,
+        message: `${assertion.path}: ${actual} >= ${assertion.expected} \u2192 ${typeof actual === "number" && actual >= assertion.expected}`
+      };
+    case "lt":
+      return {
+        pass: typeof actual === "number" && actual < assertion.expected,
+        message: `${assertion.path}: ${actual} < ${assertion.expected} \u2192 ${typeof actual === "number" && actual < assertion.expected}`
+      };
+    case "lte":
+      return {
+        pass: typeof actual === "number" && actual <= assertion.expected,
+        message: `${assertion.path}: ${actual} <= ${assertion.expected} \u2192 ${typeof actual === "number" && actual <= assertion.expected}`
+      };
+    case "contains": {
+      let pass = false;
+      if (typeof actual === "string") {
+        pass = actual.includes(String(assertion.expected));
+      } else if (Array.isArray(actual)) {
+        pass = actual.includes(assertion.expected);
+      }
+      return {
+        pass,
+        message: pass ? `${assertion.path} contiene ${JSON.stringify(assertion.expected)}` : `${assertion.path}: no contiene ${JSON.stringify(assertion.expected)}`
+      };
+    }
+    case "not_contains": {
+      let pass = true;
+      if (typeof actual === "string") {
+        pass = !actual.includes(String(assertion.expected));
+      } else if (Array.isArray(actual)) {
+        pass = !actual.includes(assertion.expected);
+      }
+      return {
+        pass,
+        message: pass ? `${assertion.path} no contiene ${JSON.stringify(assertion.expected)}` : `${assertion.path}: contiene ${JSON.stringify(assertion.expected)} (no deber\xEDa)`
+      };
+    }
+    case "exists":
+      return {
+        pass: actual !== void 0 && actual !== null,
+        message: actual !== void 0 && actual !== null ? `${assertion.path} existe` : `${assertion.path}: no existe`
+      };
+    case "type":
+      return {
+        pass: typeof actual === assertion.expected,
+        message: typeof actual === assertion.expected ? `${assertion.path} es tipo ${assertion.expected}` : `${assertion.path}: esperado tipo ${assertion.expected}, recibido ${typeof actual}`
+      };
+    default:
+      return { pass: false, message: `Operador desconocido: ${assertion.operator}` };
+  }
+}
+function registerAssertTool(server, storage) {
+  server.tool(
+    "assert",
+    "Ejecuta un request y valida la respuesta con assertions. Retorna resultado pass/fail por cada assertion.",
+    {
+      method: z5.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
+      url: z5.string().describe("URL del endpoint (soporta /relativa y {{variables}})"),
+      headers: z5.record(z5.string()).optional().describe("Headers HTTP"),
+      body: z5.any().optional().describe("Body del request (JSON)"),
+      query: z5.record(z5.string()).optional().describe("Query parameters"),
+      auth: z5.object({
+        type: z5.enum(["bearer", "api-key", "basic"]),
+        token: z5.string().optional(),
+        key: z5.string().optional(),
+        header: z5.string().optional(),
+        username: z5.string().optional(),
+        password: z5.string().optional()
+      }).optional().describe("Autenticaci\xF3n"),
+      assertions: z5.array(AssertionSchema).describe("Lista de assertions a validar contra la respuesta")
+    },
+    async (params) => {
+      try {
+        const variables = await storage.getActiveVariables();
+        let resolvedUrl = params.url;
+        if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
+          const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
+          resolvedUrl = `${baseUrl}${resolvedUrl}`;
+        }
+        const config = {
+          method: params.method,
+          url: resolvedUrl,
+          headers: params.headers,
+          body: params.body,
+          query: params.query,
+          auth: params.auth
+        };
+        const interpolated = interpolateRequest(config, variables);
+        const response = await executeRequest(interpolated);
+        const results = params.assertions.map((assertion) => {
+          const result = evaluateAssertion(response, assertion);
+          return { ...result, assertion };
+        });
+        const passed = results.filter((r) => r.pass).length;
+        const failed = results.filter((r) => !r.pass).length;
+        const allPassed = failed === 0;
+        const lines = [
+          `${allPassed ? "\u2705 PASS" : "\u274C FAIL"} \u2014 ${passed}/${results.length} assertions passed`,
+          `${params.method} ${params.url} \u2192 ${response.status} ${response.statusText} (${response.timing.total_ms}ms)`,
+          ""
+        ];
+        for (const r of results) {
+          const icon = r.pass ? "\u2705" : "\u274C";
+          lines.push(`${icon} ${r.message}`);
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }],
+          isError: !allPassed
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/flow.ts
+import { z as z6 } from "zod";
+var FlowStepSchema = z6.object({
+  name: z6.string().describe('Nombre del paso (ej: "login", "crear-post")'),
+  method: z6.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
+  url: z6.string().describe("URL del endpoint"),
+  headers: z6.record(z6.string()).optional().describe("Headers HTTP"),
+  body: z6.any().optional().describe("Body del request"),
+  query: z6.record(z6.string()).optional().describe("Query parameters"),
+  auth: z6.object({
+    type: z6.enum(["bearer", "api-key", "basic"]),
+    token: z6.string().optional(),
+    key: z6.string().optional(),
+    header: z6.string().optional(),
+    username: z6.string().optional(),
+    password: z6.string().optional()
+  }).optional().describe("Autenticaci\xF3n"),
+  extract: z6.record(z6.string()).optional().describe(
+    'Variables a extraer de la respuesta para pasos siguientes. Key = nombre variable, value = path (ej: { "TOKEN": "body.token", "USER_ID": "body.data.id" })'
+  )
+});
+function getByPath2(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object") {
+      if (Array.isArray(current) && /^\d+$/.test(part)) {
+        current = current[parseInt(part)];
+      } else {
+        current = current[part];
+      }
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function registerFlowTool(server, storage) {
+  server.tool(
+    "flow_run",
+    "Ejecuta una secuencia de requests en orden. Extrae variables de cada respuesta para usar en pasos siguientes con {{variable}}.",
+    {
+      steps: z6.array(FlowStepSchema).describe("Pasos a ejecutar en orden"),
+      stop_on_error: z6.boolean().optional().describe("Detener al primer error (default: true)")
+    },
+    async (params) => {
+      try {
+        const stopOnError = params.stop_on_error ?? true;
+        const envVariables = await storage.getActiveVariables();
+        const flowVariables = { ...envVariables };
+        const results = [];
+        for (const step of params.steps) {
+          try {
+            let resolvedUrl = step.url;
+            if (resolvedUrl.startsWith("/") && flowVariables.BASE_URL) {
+              const baseUrl = flowVariables.BASE_URL.replace(/\/+$/, "");
+              resolvedUrl = `${baseUrl}${resolvedUrl}`;
+            }
+            const config = {
+              method: step.method,
+              url: resolvedUrl,
+              headers: step.headers,
+              body: step.body,
+              query: step.query,
+              auth: step.auth
+            };
+            const interpolated = interpolateRequest(config, flowVariables);
+            const response = await executeRequest(interpolated);
+            const extracted = {};
+            if (step.extract) {
+              for (const [varName, path] of Object.entries(step.extract)) {
+                const value = getByPath2(response, path);
+                if (value !== void 0 && value !== null) {
+                  extracted[varName] = String(value);
+                  flowVariables[varName] = String(value);
+                }
+              }
+            }
+            results.push({
+              name: step.name,
+              status: response.status,
+              timing: response.timing.total_ms,
+              extracted
+            });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            results.push({
+              name: step.name,
+              status: 0,
+              timing: 0,
+              extracted: {},
+              error: message
+            });
+            if (stopOnError) break;
+          }
+        }
+        const allOk = results.every((r) => !r.error && r.status >= 200 && r.status < 400);
+        const lines = [
+          `${allOk ? "\u2705 FLOW COMPLETO" : "\u274C FLOW CON ERRORES"} \u2014 ${results.length}/${params.steps.length} pasos ejecutados`,
+          ""
+        ];
+        for (let i = 0; i < results.length; i++) {
+          const r = results[i];
+          const icon = r.error ? "\u274C" : r.status >= 200 && r.status < 400 ? "\u2705" : "\u26A0\uFE0F";
+          lines.push(`${icon} Paso ${i + 1}: ${r.name}`);
+          if (r.error) {
+            lines.push(`   Error: ${r.error}`);
+          } else {
+            lines.push(`   Status: ${r.status} | Tiempo: ${r.timing}ms`);
+          }
+          if (Object.keys(r.extracted).length > 0) {
+            const vars = Object.entries(r.extracted).map(([k, v]) => `${k}=${v.length > 50 ? v.substring(0, 50) + "..." : v}`).join(", ");
+            lines.push(`   Extra\xEDdo: ${vars}`);
+          }
+          lines.push("");
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }],
+          isError: !allOk
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/utilities.ts
+import { z as z7 } from "zod";
+function registerUtilityTools(server, storage) {
+  server.tool(
+    "export_curl",
+    "Genera un comando cURL a partir de un request guardado en la colecci\xF3n. Listo para copiar y pegar.",
+    {
+      name: z7.string().describe("Nombre del request guardado en la colecci\xF3n"),
+      resolve_variables: z7.boolean().optional().describe("Resolver {{variables}} del entorno activo (default: true)")
+    },
+    async (params) => {
+      try {
+        const saved = await storage.getCollection(params.name);
+        if (!saved) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Request '${params.name}' no encontrado en la colecci\xF3n.`
+              }
+            ],
+            isError: true
+          };
+        }
+        let config = saved.request;
+        const resolveVars = params.resolve_variables ?? true;
+        if (resolveVars) {
+          const variables = await storage.getActiveVariables();
+          let resolvedUrl = config.url;
+          if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
+            const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
+            resolvedUrl = `${baseUrl}${resolvedUrl}`;
+          }
+          config = { ...config, url: resolvedUrl };
+          config = interpolateRequest(config, variables);
+        }
+        const parts = ["curl"];
+        if (config.method !== "GET") {
+          parts.push(`-X ${config.method}`);
+        }
+        let url = config.url;
+        if (config.query && Object.keys(config.query).length > 0) {
+          const queryStr = Object.entries(config.query).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+          url += (url.includes("?") ? "&" : "?") + queryStr;
+        }
+        parts.push(`'${url}'`);
+        if (config.headers) {
+          for (const [key, value] of Object.entries(config.headers)) {
+            parts.push(`-H '${key}: ${value}'`);
+          }
+        }
+        if (config.auth) {
+          switch (config.auth.type) {
+            case "bearer":
+              if (config.auth.token) {
+                parts.push(`-H 'Authorization: Bearer ${config.auth.token}'`);
+              }
+              break;
+            case "api-key":
+              if (config.auth.key) {
+                const header = config.auth.header ?? "X-API-Key";
+                parts.push(`-H '${header}: ${config.auth.key}'`);
+              }
+              break;
+            case "basic":
+              if (config.auth.username && config.auth.password) {
+                parts.push(`-u '${config.auth.username}:${config.auth.password}'`);
+              }
+              break;
+          }
+        }
+        if (config.body !== void 0 && config.body !== null) {
+          const bodyStr = typeof config.body === "string" ? config.body : JSON.stringify(config.body);
+          parts.push(`-H 'Content-Type: application/json'`);
+          parts.push(`-d '${bodyStr}'`);
+        }
+        const curlCommand = parts.join(" \\\n  ");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `cURL para '${params.name}':
+
+${curlCommand}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "diff_responses",
+    "Ejecuta dos requests y compara sus respuestas. \xDAtil para detectar regresiones o comparar entornos.",
+    {
+      request_a: z7.object({
+        label: z7.string().optional().describe('Etiqueta (ej: "antes", "dev", "v1")'),
+        method: z7.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
+        url: z7.string(),
+        headers: z7.record(z7.string()).optional(),
+        body: z7.any().optional(),
+        query: z7.record(z7.string()).optional(),
+        auth: z7.object({
+          type: z7.enum(["bearer", "api-key", "basic"]),
+          token: z7.string().optional(),
+          key: z7.string().optional(),
+          header: z7.string().optional(),
+          username: z7.string().optional(),
+          password: z7.string().optional()
+        }).optional()
+      }).describe("Primer request"),
+      request_b: z7.object({
+        label: z7.string().optional().describe('Etiqueta (ej: "despu\xE9s", "prod", "v2")'),
+        method: z7.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
+        url: z7.string(),
+        headers: z7.record(z7.string()).optional(),
+        body: z7.any().optional(),
+        query: z7.record(z7.string()).optional(),
+        auth: z7.object({
+          type: z7.enum(["bearer", "api-key", "basic"]),
+          token: z7.string().optional(),
+          key: z7.string().optional(),
+          header: z7.string().optional(),
+          username: z7.string().optional(),
+          password: z7.string().optional()
+        }).optional()
+      }).describe("Segundo request")
+    },
+    async (params) => {
+      try {
+        const variables = await storage.getActiveVariables();
+        const executeOne = async (req) => {
+          let resolvedUrl = req.url;
+          if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
+            const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
+            resolvedUrl = `${baseUrl}${resolvedUrl}`;
+          }
+          const config = {
+            method: req.method,
+            url: resolvedUrl,
+            headers: req.headers,
+            body: req.body,
+            query: req.query,
+            auth: req.auth
+          };
+          return executeRequest(interpolateRequest(config, variables));
+        };
+        const [responseA, responseB] = await Promise.all([
+          executeOne(params.request_a),
+          executeOne(params.request_b)
+        ]);
+        const labelA = params.request_a.label ?? "A";
+        const labelB = params.request_b.label ?? "B";
+        const diffs = [];
+        if (responseA.status !== responseB.status) {
+          diffs.push(
+            `Status: ${labelA}=${responseA.status} vs ${labelB}=${responseB.status}`
+          );
+        }
+        const timingDiff = Math.abs(responseA.timing.total_ms - responseB.timing.total_ms);
+        if (timingDiff > 100) {
+          diffs.push(
+            `Timing: ${labelA}=${responseA.timing.total_ms}ms vs ${labelB}=${responseB.timing.total_ms}ms (\u0394${Math.round(timingDiff)}ms)`
+          );
+        }
+        const bodyA = JSON.stringify(responseA.body, null, 2);
+        const bodyB = JSON.stringify(responseB.body, null, 2);
+        if (bodyA !== bodyB) {
+          diffs.push("Body: diferente");
+          if (typeof responseA.body === "object" && typeof responseB.body === "object" && responseA.body && responseB.body) {
+            const keysA = new Set(Object.keys(responseA.body));
+            const keysB = new Set(Object.keys(responseB.body));
+            const onlyInA = [...keysA].filter((k) => !keysB.has(k));
+            const onlyInB = [...keysB].filter((k) => !keysA.has(k));
+            const common = [...keysA].filter((k) => keysB.has(k));
+            if (onlyInA.length > 0) diffs.push(`  Solo en ${labelA}: ${onlyInA.join(", ")}`);
+            if (onlyInB.length > 0) diffs.push(`  Solo en ${labelB}: ${onlyInB.join(", ")}`);
+            for (const key of common) {
+              const valA = JSON.stringify(
+                responseA.body[key]
+              );
+              const valB = JSON.stringify(
+                responseB.body[key]
+              );
+              if (valA !== valB) {
+                const shortA = valA.length > 50 ? valA.substring(0, 50) + "..." : valA;
+                const shortB = valB.length > 50 ? valB.substring(0, 50) + "..." : valB;
+                diffs.push(`  ${key}: ${labelA}=${shortA} vs ${labelB}=${shortB}`);
+              }
+            }
+          }
+        }
+        const sizeDiff = Math.abs(responseA.size_bytes - responseB.size_bytes);
+        if (sizeDiff > 0) {
+          diffs.push(
+            `Size: ${labelA}=${responseA.size_bytes}B vs ${labelB}=${responseB.size_bytes}B`
+          );
+        }
+        const identical = diffs.length === 0;
+        const lines = [
+          identical ? "\u2705 ID\xC9NTICAS" : `\u26A0\uFE0F ${diffs.length} DIFERENCIAS ENCONTRADAS`,
+          "",
+          `${labelA}: ${params.request_a.method} ${params.request_a.url} \u2192 ${responseA.status} (${responseA.timing.total_ms}ms)`,
+          `${labelB}: ${params.request_b.method} ${params.request_b.url} \u2192 ${responseB.status} (${responseB.timing.total_ms}ms)`
+        ];
+        if (!identical) {
+          lines.push("");
+          lines.push("Diferencias:");
+          for (const diff of diffs) {
+            lines.push(`  ${diff}`);
+          }
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "bulk_test",
+    "Ejecuta todos los requests guardados en la colecci\xF3n y reporta resultados. Filtrable por tag.",
+    {
+      tag: z7.string().optional().describe("Filtrar por tag"),
+      expected_status: z7.number().optional().describe("Status HTTP esperado para todos (default: cualquier 2xx)")
+    },
+    async (params) => {
+      try {
+        const collections = await storage.listCollections(params.tag);
+        if (collections.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: params.tag ? `No hay requests guardados con tag '${params.tag}'.` : "No hay requests guardados en la colecci\xF3n."
+              }
+            ]
+          };
+        }
+        const variables = await storage.getActiveVariables();
+        const results = [];
+        for (const item of collections) {
+          const saved = await storage.getCollection(item.name);
+          if (!saved) continue;
+          try {
+            let config = saved.request;
+            let resolvedUrl = config.url;
+            if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
+              const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
+              resolvedUrl = `${baseUrl}${resolvedUrl}`;
+            }
+            config = { ...config, url: resolvedUrl };
+            const interpolated = interpolateRequest(config, variables);
+            const response = await executeRequest(interpolated);
+            const pass = params.expected_status ? response.status === params.expected_status : response.status >= 200 && response.status < 300;
+            results.push({
+              name: item.name,
+              method: config.method,
+              url: item.url,
+              status: response.status,
+              timing: response.timing.total_ms,
+              pass
+            });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            results.push({
+              name: item.name,
+              method: item.method,
+              url: item.url,
+              status: 0,
+              timing: 0,
+              pass: false,
+              error: message
+            });
+          }
+        }
+        const passed = results.filter((r) => r.pass).length;
+        const failed = results.filter((r) => !r.pass).length;
+        const totalTime = Math.round(results.reduce((sum, r) => sum + r.timing, 0) * 100) / 100;
+        const lines = [
+          `${failed === 0 ? "\u2705" : "\u274C"} BULK TEST \u2014 ${passed}/${results.length} passed | ${totalTime}ms total`,
+          ""
+        ];
+        for (const r of results) {
+          const icon = r.pass ? "\u2705" : "\u274C";
+          if (r.error) {
+            lines.push(`${icon} ${r.name} \u2014 ERROR: ${r.error}`);
+          } else {
+            lines.push(`${icon} ${r.name} \u2014 ${r.method} ${r.url} \u2192 ${r.status} (${r.timing}ms)`);
+          }
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }],
+          isError: failed > 0
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/mock.ts
+import { z as z8 } from "zod";
+function generateMockData(schema, depth = 0) {
+  if (depth > 8) return null;
+  if (schema.example !== void 0) return schema.example;
+  if (schema.enum && schema.enum.length > 0) {
+    return schema.enum[Math.floor(Math.random() * schema.enum.length)];
+  }
+  switch (schema.type) {
+    case "object": {
+      if (!schema.properties) return {};
+      const obj = {};
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        obj[key] = generateMockData(propSchema, depth + 1);
+      }
+      return obj;
+    }
+    case "array": {
+      if (!schema.items) return [];
+      const count = Math.floor(Math.random() * 3) + 1;
+      return Array.from(
+        { length: count },
+        () => generateMockData(schema.items, depth + 1)
+      );
+    }
+    case "string": {
+      switch (schema.format) {
+        case "date-time":
+          return (/* @__PURE__ */ new Date()).toISOString();
+        case "date":
+          return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        case "email":
+          return `user${Math.floor(Math.random() * 1e3)}@example.com`;
+        case "uri":
+        case "url":
+          return "https://example.com/resource";
+        case "uuid":
+          return crypto.randomUUID();
+        case "ipv4":
+          return `192.168.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}`;
+        default: {
+          const desc = (schema.description ?? "").toLowerCase();
+          if (desc.includes("name") || desc.includes("nombre"))
+            return `Test User ${Math.floor(Math.random() * 100)}`;
+          if (desc.includes("title") || desc.includes("t\xEDtulo"))
+            return `Test Title ${Math.floor(Math.random() * 100)}`;
+          if (desc.includes("description") || desc.includes("descripci\xF3n"))
+            return "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+          if (desc.includes("password") || desc.includes("contrase\xF1a"))
+            return "TestPass123!";
+          if (desc.includes("slug"))
+            return `test-slug-${Math.floor(Math.random() * 1e3)}`;
+          if (desc.includes("phone") || desc.includes("tel\xE9fono"))
+            return "+34612345678";
+          return `mock-string-${Math.floor(Math.random() * 1e4)}`;
+        }
+      }
+    }
+    case "number":
+    case "integer":
+      return Math.floor(Math.random() * 1e3);
+    case "boolean":
+      return Math.random() > 0.5;
+    default:
+      return null;
+  }
+}
+function registerMockTool(server, storage) {
+  server.tool(
+    "mock",
+    "Genera datos mock/fake para un endpoint bas\xE1ndose en su spec OpenAPI importada. \xDAtil para frontend sin backend.",
+    {
+      name: z8.string().describe("Nombre del API importada"),
+      method: z8.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("M\xE9todo HTTP del endpoint"),
+      path: z8.string().describe('Path del endpoint (ej: "/users", "/blog")'),
+      target: z8.enum(["request", "response"]).optional().describe("Generar mock del body de request o de la response (default: response)"),
+      status: z8.string().optional().describe('Status code de la respuesta a mockear (default: "200" o "201")'),
+      count: z8.number().optional().describe("N\xFAmero de items mock a generar si el schema es un array (default: 3)")
+    },
+    async (params) => {
+      try {
+        const spec = await storage.getSpec(params.name);
+        if (!spec) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: API '${params.name}' no encontrada. Usa api_import para importarla primero.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const endpoint = spec.endpoints.find(
+          (ep) => ep.method === params.method && ep.path === params.path
+        );
+        if (!endpoint) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Endpoint ${params.method} ${params.path} no encontrado en '${params.name}'.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const target = params.target ?? "response";
+        let schema;
+        if (target === "request") {
+          const content = endpoint.requestBody?.content;
+          if (content) {
+            const jsonContent = content["application/json"];
+            schema = jsonContent?.schema;
+          }
+          if (!schema) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: El endpoint ${params.method} ${params.path} no tiene un body schema definido.`
+                }
+              ],
+              isError: true
+            };
+          }
+        } else {
+          const statusCode = params.status ?? (params.method === "POST" ? "201" : "200");
+          const response = endpoint.responses?.[statusCode];
+          if (!response) {
+            const twoXX = Object.keys(endpoint.responses ?? {}).find((s) => s.startsWith("2"));
+            if (twoXX && endpoint.responses) {
+              const fallbackResp = endpoint.responses[twoXX];
+              const content = fallbackResp?.content;
+              if (content) {
+                const jsonContent = content["application/json"];
+                schema = jsonContent?.schema;
+              }
+            }
+          } else {
+            const content = response.content;
+            if (content) {
+              const jsonContent = content["application/json"];
+              schema = jsonContent?.schema;
+            }
+          }
+          if (!schema) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: No se encontr\xF3 un schema de respuesta para ${params.method} ${params.path}.`
+                }
+              ],
+              isError: true
+            };
+          }
+        }
+        let mockData;
+        if (schema.type === "array" && params.count) {
+          mockData = Array.from(
+            { length: params.count },
+            () => generateMockData(schema.items ?? { type: "object" })
+          );
+        } else {
+          mockData = generateMockData(schema);
+        }
+        const label = target === "request" ? "REQUEST BODY" : "RESPONSE";
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                `Mock ${label} para ${params.method} ${params.path}:`,
+                "",
+                "```json",
+                JSON.stringify(mockData, null, 2),
+                "```",
+                "",
+                "Datos generados autom\xE1ticamente desde el spec OpenAPI.",
+                target === "request" ? "Puedes usar estos datos directamente en un request." : "Estos son datos de ejemplo que devolver\xEDa el endpoint."
+              ].join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/load-test.ts
+import { z as z9 } from "zod";
+function registerLoadTestTool(server, storage) {
+  server.tool(
+    "load_test",
+    "Lanza N requests concurrentes al mismo endpoint y mide tiempos promedio, percentiles y tasa de errores.",
+    {
+      method: z9.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
+      url: z9.string().describe("URL del endpoint"),
+      headers: z9.record(z9.string()).optional().describe("Headers HTTP"),
+      body: z9.any().optional().describe("Body del request"),
+      query: z9.record(z9.string()).optional().describe("Query parameters"),
+      auth: z9.object({
+        type: z9.enum(["bearer", "api-key", "basic"]),
+        token: z9.string().optional(),
+        key: z9.string().optional(),
+        header: z9.string().optional(),
+        username: z9.string().optional(),
+        password: z9.string().optional()
+      }).optional().describe("Autenticaci\xF3n"),
+      concurrent: z9.number().describe("N\xFAmero de requests concurrentes a lanzar (max: 100)"),
+      timeout: z9.number().optional().describe("Timeout por request en ms (default: 30000)")
+    },
+    async (params) => {
+      try {
+        const concurrentCount = Math.min(Math.max(params.concurrent, 1), 100);
+        const variables = await storage.getActiveVariables();
+        let resolvedUrl = params.url;
+        if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
+          const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
+          resolvedUrl = `${baseUrl}${resolvedUrl}`;
+        }
+        const baseConfig = {
+          method: params.method,
+          url: resolvedUrl,
+          headers: params.headers,
+          body: params.body,
+          query: params.query,
+          auth: params.auth,
+          timeout: params.timeout
+        };
+        const interpolated = interpolateRequest(baseConfig, variables);
+        const startTotal = performance.now();
+        const promises = Array.from(
+          { length: concurrentCount },
+          () => executeRequest(interpolated).then((response) => ({
+            status: response.status,
+            timing: response.timing.total_ms,
+            error: void 0
+          })).catch((error) => ({
+            status: 0,
+            timing: 0,
+            error: error instanceof Error ? error.message : String(error)
+          }))
+        );
+        const results = await Promise.all(promises);
+        const endTotal = performance.now();
+        const wallTime = Math.round((endTotal - startTotal) * 100) / 100;
+        const successful = results.filter((r) => !r.error);
+        const failed = results.filter((r) => r.error);
+        const timings = successful.map((r) => r.timing).sort((a, b) => a - b);
+        const statusCounts = {};
+        for (const r of successful) {
+          statusCounts[r.status] = (statusCounts[r.status] ?? 0) + 1;
+        }
+        const avg = timings.length > 0 ? Math.round(timings.reduce((s, t) => s + t, 0) / timings.length * 100) / 100 : 0;
+        const min = timings.length > 0 ? timings[0] : 0;
+        const max = timings.length > 0 ? timings[timings.length - 1] : 0;
+        const p50 = timings.length > 0 ? timings[Math.floor(timings.length * 0.5)] : 0;
+        const p95 = timings.length > 0 ? timings[Math.floor(timings.length * 0.95)] : 0;
+        const p99 = timings.length > 0 ? timings[Math.floor(timings.length * 0.99)] : 0;
+        const rps = wallTime > 0 ? Math.round(successful.length / (wallTime / 1e3) * 100) / 100 : 0;
+        const lines = [
+          `\u{1F4CA} LOAD TEST \u2014 ${params.method} ${params.url}`,
+          "",
+          `Requests: ${concurrentCount} concurrentes`,
+          `Exitosos: ${successful.length} | Fallidos: ${failed.length}`,
+          `Tiempo total: ${wallTime}ms`,
+          `Requests/segundo: ${rps}`,
+          "",
+          "\u23F1\uFE0F Tiempos de respuesta:",
+          `  Min:  ${min}ms`,
+          `  Avg:  ${avg}ms`,
+          `  p50:  ${p50}ms`,
+          `  p95:  ${p95}ms`,
+          `  p99:  ${p99}ms`,
+          `  Max:  ${max}ms`
+        ];
+        if (Object.keys(statusCounts).length > 0) {
+          lines.push("");
+          lines.push("\u{1F4CB} Status codes:");
+          for (const [status, count] of Object.entries(statusCounts)) {
+            const pct = Math.round(count / concurrentCount * 100);
+            lines.push(`  ${status}: ${count} (${pct}%)`);
+          }
+        }
+        if (failed.length > 0) {
+          lines.push("");
+          lines.push("\u274C Errores:");
+          const errorCounts = {};
+          for (const r of failed) {
+            const errMsg = r.error ?? "Unknown";
+            errorCounts[errMsg] = (errorCounts[errMsg] ?? 0) + 1;
+          }
+          for (const [err, count] of Object.entries(errorCounts)) {
+            lines.push(`  ${err}: ${count}x`);
+          }
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }],
+          isError: failed.length > successful.length
+          // More than 50% failed
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // src/server.ts
-var VERSION = "0.3.0";
+var VERSION = "0.4.0";
 function createServer(storageDir) {
   const server = new McpServer({
     name: "api-testing-mcp",
@@ -1226,6 +2158,11 @@ function createServer(storageDir) {
   registerCollectionTools(server, storage);
   registerEnvironmentTools(server, storage);
   registerApiSpecTools(server, storage);
+  registerAssertTool(server, storage);
+  registerFlowTool(server, storage);
+  registerUtilityTools(server, storage);
+  registerMockTool(server, storage);
+  registerLoadTestTool(server, storage);
   return server;
 }