@cocaxcode/api-testing-mcp 0.2.0 → 0.4.0

package/dist/index.js

@@ -14,11 +14,13 @@ var Storage = class {
   baseDir;
   collectionsDir;
   environmentsDir;
+  specsDir;
   activeEnvFile;
   constructor(baseDir) {
     this.baseDir = baseDir ?? process.env.API_TESTING_DIR ?? join(process.cwd(), ".api-testing");
     this.collectionsDir = join(this.baseDir, "collections");
     this.environmentsDir = join(this.baseDir, "environments");
+    this.specsDir = join(this.baseDir, "specs");
     this.activeEnvFile = join(this.baseDir, "active-env");
   }
   // ── Collections ──
@@ -119,6 +121,41 @@ var Storage = class {
     const env = await this.getEnvironment(activeName);
     return env?.variables ?? {};
   }
+  // ── API Specs ──
+  async saveSpec(spec) {
+    await this.ensureDir("specs");
+    const filePath = join(this.specsDir, `${this.sanitizeName(spec.name)}.json`);
+    await this.writeJson(filePath, spec);
+  }
+  async getSpec(name) {
+    const filePath = join(this.specsDir, `${this.sanitizeName(name)}.json`);
+    return this.readJson(filePath);
+  }
+  async listSpecs() {
+    await this.ensureDir("specs");
+    const files = await this.listJsonFiles(this.specsDir);
+    const items = [];
+    for (const file of files) {
+      const spec = await this.readJson(join(this.specsDir, file));
+      if (!spec) continue;
+      items.push({
+        name: spec.name,
+        source: spec.source,
+        endpointCount: spec.endpoints.length,
+        version: spec.version
+      });
+    }
+    return items;
+  }
+  async deleteSpec(name) {
+    const filePath = join(this.specsDir, `${this.sanitizeName(name)}.json`);
+    try {
+      await unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   // ── Internal ──
   async ensureDir(subdir) {
     const dir = subdir ? join(this.baseDir, subdir) : this.baseDir;
@@ -721,8 +758,1396 @@ function registerEnvironmentTools(server, storage) {
   );
 }
 
+// src/tools/api-spec.ts
+import { z as z4 } from "zod";
+
+// src/lib/openapi-parser.ts
+var VALID_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+function resolveRef(ref, root) {
+  const parts = ref.replace(/^#\//, "").split("/");
+  let current = root;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function resolveSchema(schema, root, depth = 0) {
+  if (!schema || depth > 10) return schema;
+  if (schema.$ref) {
+    const resolved = resolveRef(schema.$ref, root);
+    if (resolved) {
+      return resolveSchema(resolved, root, depth + 1);
+    }
+    return { type: "object", description: `Unresolved: ${schema.$ref}` };
+  }
+  const result = { ...schema };
+  if (result.properties) {
+    const resolvedProps = {};
+    for (const [key, prop] of Object.entries(result.properties)) {
+      resolvedProps[key] = resolveSchema(prop, root, depth + 1) ?? prop;
+    }
+    result.properties = resolvedProps;
+  }
+  if (result.items) {
+    result.items = resolveSchema(result.items, root, depth + 1) ?? result.items;
+  }
+  return result;
+}
+function parseOpenApiSpec(doc, name, source) {
+  const info = doc.info;
+  const paths = doc.paths;
+  const components = doc.components;
+  const rawSchemas = components?.schemas ?? {};
+  const schemas = {};
+  for (const [schemaName, schema] of Object.entries(rawSchemas)) {
+    schemas[schemaName] = resolveSchema(schema, doc, 0) ?? schema;
+  }
+  const endpoints = [];
+  if (paths) {
+    for (const [path, pathItem] of Object.entries(paths)) {
+      for (const [method, operation] of Object.entries(pathItem)) {
+        const upperMethod = method.toUpperCase();
+        if (!VALID_METHODS.includes(upperMethod)) continue;
+        const op = operation;
+        const rawParams = op.parameters ?? [];
+        const parameters = rawParams.map((p) => ({
+          name: p.name,
+          in: p.in,
+          required: p.required,
+          description: p.description,
+          schema: resolveSchema(p.schema, doc)
+        }));
+        const rawBody = op.requestBody;
+        let requestBody = void 0;
+        if (rawBody) {
+          const bodyContent = rawBody.content;
+          const resolvedContent = {};
+          if (bodyContent) {
+            for (const [contentType, mediaType] of Object.entries(bodyContent)) {
+              resolvedContent[contentType] = {
+                schema: resolveSchema(mediaType.schema, doc)
+              };
+            }
+          }
+          requestBody = {
+            required: rawBody.required,
+            description: rawBody.description,
+            content: resolvedContent
+          };
+        }
+        const rawResponses = op.responses ?? {};
+        const responses = {};
+        for (const [statusCode, resp] of Object.entries(rawResponses)) {
+          const respContent = resp.content;
+          const resolvedRespContent = {};
+          if (respContent) {
+            for (const [contentType, mediaType] of Object.entries(respContent)) {
+              resolvedRespContent[contentType] = {
+                schema: resolveSchema(mediaType.schema, doc)
+              };
+            }
+          }
+          responses[statusCode] = {
+            description: resp.description,
+            content: respContent ? resolvedRespContent : void 0
+          };
+        }
+        endpoints.push({
+          method: upperMethod,
+          path,
+          summary: op.summary,
+          description: op.description,
+          tags: op.tags,
+          parameters,
+          requestBody,
+          responses
+        });
+      }
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    name,
+    source,
+    version: info?.version,
+    endpoints,
+    schemas,
+    importedAt: now,
+    updatedAt: now
+  };
+}
+
+// src/tools/api-spec.ts
+import { readFile as readFile2 } from "fs/promises";
+function registerApiSpecTools(server, storage) {
+  server.tool(
+    "api_import",
+    "Importa un spec OpenAPI/Swagger desde una URL o archivo local. Guarda los endpoints y schemas para consulta.",
+    {
+      name: z4.string().describe('Nombre para identificar este API (ej: "mi-backend", "cocaxcode-api")'),
+      source: z4.string().describe(
+        "URL del spec OpenAPI JSON (ej: http://localhost:3001/api-docs-json) o ruta a archivo local"
+      )
+    },
+    async (params) => {
+      try {
+        let rawDoc;
+        if (params.source.startsWith("http://") || params.source.startsWith("https://")) {
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), 3e4);
+          try {
+            const response = await fetch(params.source, { signal: controller.signal });
+            if (!response.ok) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Error: No se pudo descargar el spec. Status: ${response.status} ${response.statusText}`
+                  }
+                ],
+                isError: true
+              };
+            }
+            rawDoc = await response.json();
+          } finally {
+            clearTimeout(timeout);
+          }
+        } else {
+          try {
+            const content = await readFile2(params.source, "utf-8");
+            rawDoc = JSON.parse(content);
+          } catch {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: No se pudo leer el archivo '${params.source}'. Verifica que existe y es JSON v\xE1lido.`
+                }
+              ],
+              isError: true
+            };
+          }
+        }
+        if (!rawDoc.openapi && !rawDoc.swagger) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: 'Error: El documento no parece ser un spec OpenAPI/Swagger v\xE1lido. Falta la propiedad "openapi" o "swagger".'
+              }
+            ],
+            isError: true
+          };
+        }
+        const spec = parseOpenApiSpec(rawDoc, params.name, params.source);
+        await storage.saveSpec(spec);
+        const tagCounts = {};
+        for (const ep of spec.endpoints) {
+          for (const tag of ep.tags ?? ["sin-tag"]) {
+            tagCounts[tag] = (tagCounts[tag] ?? 0) + 1;
+          }
+        }
+        const tagSummary = Object.entries(tagCounts).map(([tag, count]) => `  - ${tag}: ${count} endpoints`).join("\n");
+        const schemaCount = Object.keys(spec.schemas).length;
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                `API '${params.name}' importada correctamente.`,
+                "",
+                `Versi\xF3n: ${spec.version ?? "no especificada"}`,
+                `Endpoints: ${spec.endpoints.length}`,
+                `Schemas: ${schemaCount}`,
+                "",
+                "Endpoints por tag:",
+                tagSummary,
+                "",
+                "Usa api_endpoints para ver los endpoints disponibles.",
+                "Usa api_endpoint_detail para ver el detalle de un endpoint espec\xEDfico."
+              ].join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "api_endpoints",
+    "Lista los endpoints de un API importada. Filtra por tag, m\xE9todo o path.",
+    {
+      name: z4.string().describe("Nombre del API importada"),
+      tag: z4.string().optional().describe('Filtrar por tag (ej: "blog", "auth", "users")'),
+      method: z4.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).optional().describe("Filtrar por m\xE9todo HTTP"),
+      path: z4.string().optional().describe('Filtrar por path (b\xFAsqueda parcial, ej: "/blog" muestra todos los que contienen /blog)')
+    },
+    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
+          };
+        }
+        let endpoints = spec.endpoints;
+        if (params.tag) {
+          endpoints = endpoints.filter(
+            (ep) => (ep.tags ?? []).some((t) => t.toLowerCase() === params.tag.toLowerCase())
+          );
+        }
+        if (params.method) {
+          endpoints = endpoints.filter((ep) => ep.method === params.method);
+        }
+        if (params.path) {
+          const search = params.path.toLowerCase();
+          endpoints = endpoints.filter((ep) => ep.path.toLowerCase().includes(search));
+        }
+        if (endpoints.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No se encontraron endpoints con los filtros aplicados."
+              }
+            ]
+          };
+        }
+        const lines = endpoints.map((ep) => {
+          const tags = ep.tags?.length ? ` [${ep.tags.join(", ")}]` : "";
+          const summary = ep.summary ? ` \u2014 ${ep.summary}` : "";
+          return `${ep.method.padEnd(7)} ${ep.path}${summary}${tags}`;
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                `API: ${spec.name} (${endpoints.length} endpoints)`,
+                "",
+                ...lines,
+                "",
+                "Usa api_endpoint_detail para ver par\xE1metros, body y respuestas de un endpoint."
+              ].join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "api_endpoint_detail",
+    "Muestra el detalle completo de un endpoint: par\xE1metros, body schema, y respuestas. \xDAtil para saber qu\xE9 datos enviar.",
+    {
+      name: z4.string().describe("Nombre del API importada"),
+      method: z4.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("M\xE9todo HTTP del endpoint"),
+      path: z4.string().describe('Path exacto del endpoint (ej: "/blog", "/auth/login")')
+    },
+    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) {
+          const similar = spec.endpoints.filter(
+            (ep) => ep.path.includes(params.path) || params.path.includes(ep.path)
+          );
+          const suggestion = similar.length > 0 ? `
+
+Endpoints similares:
+${similar.map((ep) => `  ${ep.method} ${ep.path}`).join("\n")}` : "";
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Endpoint ${params.method} ${params.path} no encontrado.${suggestion}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const sections = [];
+        sections.push(`## ${endpoint.method} ${endpoint.path}`);
+        if (endpoint.summary) sections.push(`**${endpoint.summary}**`);
+        if (endpoint.description) sections.push(endpoint.description);
+        if (endpoint.tags?.length) sections.push(`Tags: ${endpoint.tags.join(", ")}`);
+        if (endpoint.parameters?.length) {
+          sections.push("");
+          sections.push("### Par\xE1metros");
+          for (const param of endpoint.parameters) {
+            const required = param.required ? " (requerido)" : " (opcional)";
+            const type = param.schema?.type ?? "string";
+            const desc = param.description ? ` \u2014 ${param.description}` : "";
+            sections.push(`- **${param.name}** [${param.in}] ${type}${required}${desc}`);
+          }
+        }
+        if (endpoint.requestBody) {
+          sections.push("");
+          sections.push("### Body");
+          const required = endpoint.requestBody.required ? " (requerido)" : " (opcional)";
+          sections.push(`Body${required}`);
+          if (endpoint.requestBody.content) {
+            for (const [contentType, media] of Object.entries(endpoint.requestBody.content)) {
+              sections.push(`
+Content-Type: ${contentType}`);
+              if (media.schema) {
+                sections.push("```json");
+                sections.push(formatSchema(media.schema));
+                sections.push("```");
+              }
+            }
+          }
+        }
+        if (endpoint.responses) {
+          sections.push("");
+          sections.push("### Respuestas");
+          for (const [status, resp] of Object.entries(endpoint.responses)) {
+            const desc = resp.description ? ` \u2014 ${resp.description}` : "";
+            sections.push(`
+**${status}**${desc}`);
+            if (resp.content) {
+              for (const [, media] of Object.entries(resp.content)) {
+                if (media.schema) {
+                  sections.push("```json");
+                  sections.push(formatSchema(media.schema));
+                  sections.push("```");
+                }
+              }
+            }
+          }
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: sections.join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function formatSchema(schema, depth = 0) {
+  if (depth > 5) return '"..."';
+  const indent = "  ".repeat(depth);
+  const innerIndent = "  ".repeat(depth + 1);
+  if (schema.example !== void 0) {
+    return JSON.stringify(schema.example, null, 2).split("\n").map((line, i) => i === 0 ? line : indent + line).join("\n");
+  }
+  if (schema.enum) {
+    return JSON.stringify(schema.enum[0]);
+  }
+  if (schema.type === "object" && schema.properties) {
+    const props = Object.entries(schema.properties);
+    if (props.length === 0) return "{}";
+    const requiredFields = new Set(schema.required ?? []);
+    const lines = ["{"];
+    for (const [key, prop] of props) {
+      const isRequired = requiredFields.has(key);
+      const comment = [];
+      if (prop.description) comment.push(prop.description);
+      if (!isRequired) comment.push("opcional");
+      const commentStr = comment.length > 0 ? ` // ${comment.join(" \u2014 ")}` : "";
+      const value = formatSchema(prop, depth + 1);
+      lines.push(`${innerIndent}"${key}": ${value},${commentStr}`);
+    }
+    lines.push(`${indent}}`);
+    return lines.join("\n");
+  }
+  if (schema.type === "array" && schema.items) {
+    const itemValue = formatSchema(schema.items, depth + 1);
+    return `[${itemValue}]`;
+  }
+  switch (schema.type) {
+    case "string":
+      if (schema.format === "date-time") return '"2024-01-01T00:00:00Z"';
+      if (schema.format === "email") return '"user@example.com"';
+      if (schema.format === "uri" || schema.format === "url") return '"https://example.com"';
+      return '"string"';
+    case "number":
+    case "integer":
+      return "0";
+    case "boolean":
+      return "true";
+    default:
+      return "null";
+  }
+}
+
+// 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.1.0";
+var VERSION = "0.4.0";
 function createServer(storageDir) {
   const server = new McpServer({
     name: "api-testing-mcp",
@@ -732,6 +2157,12 @@ function createServer(storageDir) {
   registerRequestTool(server, storage);
   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;
 }