callman-mcp 0.6.0 → 0.7.0

package/dist-cjs/tools/loadTest.js

@@ -0,0 +1,335 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLoadTestTool = void 0;
+const zod_1 = require("zod");
+const callman_core_1 = require("callman-core");
+const errors_js_1 = require("../client/errors.js");
+const redact_js_1 = require("../lib/redact.js");
+const resolveTemplate_js_1 = require("../run/resolveTemplate.js");
+const run_js_1 = require("./run.js");
+const lookups_js_1 = require("./lookups.js");
+const shared_js_1 = require("./shared.js");
+// Load / stress testing from an AI tool. Same engine as the desktop's Load test
+// tab and `callme perf run` (callman-core/loadtest), so the numbers agree.
+//
+// Generating load is the one thing here that can hurt a third party, so it is
+// two steps: without `confirm: true` the tool only PREVIEWS (which hosts, which
+// requests, how much traffic, hard limits); the run starts on the second call.
+// Hard caps (users, rate, duration) come from the server config, because a
+// blocking tool call also has to finish inside the client's timeout.
+const PRESETS = ["smoke", "load", "stress", "spike", "breakpoint"];
+const rampable = (executor, rampMs) => {
+    if (rampMs <= 0)
+        return executor;
+    if (executor.type === "constant-vus") {
+        const ramp = Math.min(rampMs, Math.max(1000, executor.durationMs - 1000));
+        return {
+            type: "ramping-vus",
+            startVus: 0,
+            stages: [
+                { durationMs: ramp, target: executor.vus },
+                { durationMs: executor.durationMs - ramp, target: executor.vus },
+            ],
+        };
+    }
+    if (executor.type === "constant-arrival-rate") {
+        const ramp = Math.min(rampMs, Math.max(1000, executor.durationMs - 1000));
+        return {
+            type: "ramping-arrival-rate",
+            startRate: 1,
+            stages: [
+                { durationMs: ramp, target: executor.rate },
+                { durationMs: executor.durationMs - ramp, target: executor.rate },
+            ],
+            ...(executor.maxVus ? { maxVus: executor.maxVus } : {}),
+        };
+    }
+    return executor;
+};
+const round = (value, digits = 2) => Math.round(value * 10 ** digits) / 10 ** digits;
+const summarize = (result, redact) => {
+    const summary = result.summary;
+    const failedRate = summary.totalRequests === 0 ? 0 : summary.failedCount / summary.totalRequests;
+    const verdict = result.abortedByThreshold
+        ? "aborted"
+        : result.thresholds.some((entry) => !entry.passed)
+            ? "failed"
+            : result.stoppedByUser
+                ? "stopped"
+                : "passed";
+    return {
+        verdict,
+        passed: verdict === "passed",
+        durationSeconds: round(summary.durationMs / 1000, 1),
+        requests: summary.totalRequests,
+        iterations: summary.totalIterations,
+        droppedIterations: summary.droppedIterations,
+        throughputPerSecond: { average: round(summary.avgRps, 1), peak: round(summary.peakRps, 1) },
+        failedRate: round(failedRate, 4),
+        latencyMs: {
+            average: round(result.duration.avg),
+            median: round(result.duration.p50),
+            p90: round(result.duration.p90),
+            p95: round(result.duration.p95),
+            p99: round(result.duration.p99),
+            max: round(result.duration.max),
+        },
+        ...(result.correctedDuration
+            ? { latencyFromIntendedStartMs: { p95: round(result.correctedDuration.p95), p99: round(result.correctedDuration.p99) } }
+            : {}),
+        peakConcurrency: summary.peakVus,
+        checks: summary.checksPassed + summary.checksFailed > 0 ? { passed: summary.checksPassed, failed: summary.checksFailed } : undefined,
+        steps: result.steps.map((step) => ({
+            name: step.name,
+            requests: step.requests,
+            failedRate: round(step.failedRate, 4),
+            p95Ms: round(step.duration.p95),
+            throughputPerSecond: round(step.rps, 1),
+        })),
+        thresholds: result.thresholds.map((entry) => ({
+            expression: entry.threshold.expression,
+            passed: entry.passed,
+            actual: entry.actual === null ? null : round(entry.actual, 3),
+            ...(entry.aborted ? { stoppedTheRun: true } : {}),
+        })),
+        errors: result.errors.slice(0, 5).map((error) => ({
+            kind: error.errorClass,
+            causedBy: error.blame === "generator" ? "the load generator (this machine)" : error.blame === "server" ? "the target or the network" : error.blame === "http" ? "an HTTP error status" : "the request setup",
+            count: error.count,
+            example: redact(error.example),
+        })),
+        loadGenerator: {
+            workers: result.generator.workers,
+            saturated: result.generator.saturated,
+            maxEventLoopLagMs: result.generator.maxLoopLagMs,
+            ...(result.generator.saturated
+                ? { warning: "The machine generating the load was saturated, so latencies are likely overstated. Lower the load." }
+                : {}),
+        },
+    };
+};
+const registerLoadTestTool = (server, ctx) => {
+    const { loadTestMaxSeconds, loadTestMaxVus, loadTestMaxRate } = ctx.config;
+    server.registerTool("run_load_test", {
+        title: "Load / stress test a collection",
+        description: `Generate load against the requests of a collection from THIS machine and judge it against pass criteria. Same engine as the desktop's Load test and \`callme perf run\`. The requests of the collection (or one folder, or the ones named in \`only\`) run in order as one flow per iteration, with the environment's variables.\n` +
+            `Two steps: without \`confirm: true\` it only PREVIEWS (target hosts, requests, planned traffic, limits) — show that to the user, then call again with confirm: true. Only test systems the user owns or may load-test.\n` +
+            `Pattern: \`mode: "vus"\` (a closed crowd of virtual users looping the flow; slow servers slow them down) or \`mode: "rate"\` (an open model: iterations START at \`rate\` per second whatever the server does; iterations that cannot start are reported as dropped). \`rampUpSeconds\` ramps to the level first. Or pick a \`preset\` (smoke, load, stress, spike, breakpoint) tuned by vus / rate / durationSeconds.\n` +
+            `Pass criteria: \`thresholds\` like "p95<500", "fail<1%", "checks>99%", "rps>100" or "http_req_duration{step:Login}:p(95)<300"; \`abortOn\` takes the same but stops the run when one breaks (use it to find the breaking point).\n` +
+            `Returns the verdict, throughput, latency percentiles, failures by cause (and whether the load generator or the target is to blame), per-step numbers and threshold results. Scripts, DB and Redis steps are not run. Limits here: ${loadTestMaxVus} users, ${loadTestMaxRate} iterations/s, ${loadTestMaxSeconds} s per run. Needs requests:run.`,
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            collection: (0, shared_js_1.refArg)("Collection"),
+            folder: zod_1.z.string().max(300).optional().describe("Only this folder (id, name or path), subfolders included"),
+            only: zod_1.z.array(zod_1.z.string().min(1).max(500)).max(50).optional().describe("Only these requests (ids or names), in this order"),
+            environment: zod_1.z.string().max(200).optional(),
+            mode: zod_1.z.enum(["vus", "rate"]).optional().describe('"vus" (default) = virtual users; "rate" = iterations per second'),
+            vus: zod_1.z.number().int().min(1).optional().describe(`Virtual users (max ${loadTestMaxVus}); the preset's intensity in vus mode`),
+            rate: zod_1.z.number().int().min(1).optional().describe(`Iterations per second (max ${loadTestMaxRate}) for mode "rate"`),
+            maxVus: zod_1.z.number().int().min(1).optional().describe("Rate mode: most iterations in flight before new ones are dropped"),
+            durationSeconds: zod_1.z.number().int().min(5).optional().describe(`How long (5–${loadTestMaxSeconds}; default 30)`),
+            rampUpSeconds: zod_1.z.number().int().min(0).optional().describe("Ramp to the level over this many seconds first"),
+            preset: zod_1.z.enum(PRESETS).optional().describe("A ready-made pattern; vus / rate / durationSeconds tune it"),
+            thresholds: zod_1.z.array(zod_1.z.string().min(1).max(200)).max(20).optional().describe('Pass criteria, e.g. ["p95<500", "fail<1%"]'),
+            abortOn: zod_1.z.array(zod_1.z.string().min(1).max(200)).max(10).optional().describe("Criteria that stop the run when violated"),
+            thinkTimeMinMs: zod_1.z.number().int().min(0).max(60_000).optional(),
+            thinkTimeMaxMs: zod_1.z.number().int().min(0).max(60_000).optional(),
+            confirm: zod_1.z.boolean().optional().describe("true = actually generate the load. Omit for the preview."),
+        },
+        annotations: shared_js_1.RUN,
+    }, (0, shared_js_1.guarded)(async (args) => {
+        const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, args.workspace, args.collection);
+        const prepared = await (0, run_js_1.prepareRun)(ctx, ws.id, resolved.item.id, args.environment);
+        // ── Which requests ─────────────────────────────────────────────────
+        let folderIds = null;
+        if (args.folder) {
+            const target = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, resolved.item.id, args.folder);
+            if (!target)
+                throw new errors_js_1.ToolInputError("REF_REQUIRED", "folder is required.");
+            folderIds = (0, lookups_js_1.requestIdsInFolder)(await (0, lookups_js_1.loadTree)(ctx, ws.id, resolved.item.id), target.item.id);
+        }
+        let onlyIds = null;
+        if (args.only && args.only.length > 0) {
+            onlyIds = [];
+            for (const ref of args.only)
+                onlyIds.push((await (0, lookups_js_1.resolveRequest)(ctx, ws.id, ref, resolved.item.id)).request.id);
+        }
+        const byId = new Map(prepared.collection.requests.map((request) => [request.id, request]));
+        const chosen = (onlyIds
+            ? onlyIds.filter((id) => !folderIds || folderIds.includes(id)).map((id) => byId.get(id))
+            : prepared.collection.requests.filter((request) => request.isEnabledInRunner !== false && (!folderIds || folderIds.includes(request.id)))).filter((request) => Boolean(request));
+        if (chosen.length === 0)
+            throw new errors_js_1.ToolInputError("NOTHING_TO_RUN", "The selection contains no requests.");
+        // ── Pattern ────────────────────────────────────────────────────────
+        const durationSeconds = args.durationSeconds ?? 30;
+        if (durationSeconds > loadTestMaxSeconds) {
+            throw new errors_js_1.ToolInputError("LIMIT_EXCEEDED", `durationSeconds ${durationSeconds} exceeds this server's limit of ${loadTestMaxSeconds} s (CALLMAN_LOADTEST_MAX_SECONDS). Use the desktop app or \`callme perf run\` for longer tests.`);
+        }
+        const mode = args.mode ?? (args.rate && !args.vus ? "rate" : "vus");
+        const vus = args.vus ?? (args.preset ? 20 : 10);
+        const rate = args.rate ?? 50;
+        if (vus > loadTestMaxVus)
+            throw new errors_js_1.ToolInputError("LIMIT_EXCEEDED", `vus ${vus} exceeds this server's limit of ${loadTestMaxVus} (CALLMAN_LOADTEST_MAX_VUS).`);
+        if (rate > loadTestMaxRate)
+            throw new errors_js_1.ToolInputError("LIMIT_EXCEEDED", `rate ${rate} exceeds this server's limit of ${loadTestMaxRate}/s (CALLMAN_LOADTEST_MAX_RATE).`);
+        let executor;
+        if (args.preset) {
+            executor = (0, callman_core_1.buildPresetExecutor)(args.preset, { vus, rate, durationMs: durationSeconds * 1000 });
+        }
+        else if (mode === "rate") {
+            executor = rampable({ type: "constant-arrival-rate", rate, durationMs: durationSeconds * 1000, maxVus: args.maxVus ?? Math.min(Math.max(rate, 50), loadTestMaxVus * 5) }, (args.rampUpSeconds ?? 0) * 1000);
+        }
+        else {
+            executor = rampable({ type: "constant-vus", vus, durationMs: durationSeconds * 1000 }, (args.rampUpSeconds ?? 0) * 1000);
+        }
+        // The preset can climb past the caller's number (stress ×2, spike ×3,
+        // breakpoint ×10): hold it to the configured ceiling too.
+        const peak = executor.type === "constant-vus" ? executor.vus
+            : executor.type === "ramping-vus" ? Math.max(executor.startVus, ...executor.stages.map((stage) => stage.target))
+                : executor.type === "constant-arrival-rate" ? executor.rate
+                    : Math.max(executor.startRate, ...executor.stages.map((stage) => stage.target));
+        const peakLimit = executor.type === "constant-vus" || executor.type === "ramping-vus" ? loadTestMaxVus : loadTestMaxRate;
+        if (peak > peakLimit) {
+            throw new errors_js_1.ToolInputError("LIMIT_EXCEEDED", `This pattern peaks at ${peak}, above this server's limit of ${peakLimit}. Lower ${executor.type.includes("rate") ? "rate" : "vus"}${args.preset ? ` (the ${args.preset} preset climbs above the value you give)` : ""}.`);
+        }
+        const thresholds = [
+            ...(args.thresholds ?? []).map((expression, index) => ({ id: `t${index + 1}`, expression })),
+            ...(args.abortOn ?? []).map((expression, index) => ({ id: `a${index + 1}`, expression, abortOnFail: true, delayAbortEvalMs: 5000 })),
+        ];
+        for (const threshold of thresholds) {
+            try {
+                (0, callman_core_1.parseThreshold)(threshold.expression);
+            }
+            catch (error) {
+                throw new errors_js_1.ToolInputError("INVALID_THRESHOLD", error instanceof Error ? error.message : String(error));
+            }
+        }
+        const environment = {};
+        for (const [key, value] of Object.entries({ ...prepared.globals, ...prepared.env })) {
+            if (typeof value === "string")
+                environment[key] = value;
+        }
+        const thinkMin = args.thinkTimeMinMs ?? 0;
+        const thinkMax = Math.max(args.thinkTimeMaxMs ?? thinkMin, thinkMin);
+        const config = {
+            runId: `mcp-${Date.now().toString(36)}`,
+            name: resolved.item.name,
+            executor,
+            steps: chosen.map(callman_core_1.requestToLoadStep),
+            environment,
+            thresholds,
+            ...(thinkMax > 0 ? { thinkTimeMs: { min: thinkMin, max: thinkMax } } : {}),
+            keepAlive: true,
+            verifySsl: true,
+            monitor: { enabled: false },
+        };
+        const issues = (0, callman_core_1.validateLoadTestConfig)(config);
+        if ((0, callman_core_1.hasBlockingIssues)(issues)) {
+            throw new errors_js_1.ToolInputError("INVALID_LOAD_TEST", issues.filter((issue) => issue.severity === "error").map((issue) => issue.message).join(" "));
+        }
+        const redactor = (0, redact_js_1.createRedactor)(Object.entries(environment), prepared.redaction);
+        const hosts = new Set();
+        for (const request of chosen) {
+            try {
+                hosts.add(new URL(/^[a-z]+:\/\//i.test(request.url) ? (0, resolveTemplate_js_1.resolveTemplate)(request.url, environment) : `http://${(0, resolveTemplate_js_1.resolveTemplate)(request.url, environment)}`).host);
+            }
+            catch {
+                hosts.add(redactor.text((0, resolveTemplate_js_1.resolveTemplate)(request.url, environment)));
+            }
+        }
+        const estimate = (0, callman_core_1.estimateLoad)(config, 250 * chosen.length);
+        const notes = chosen
+            .map((request) => {
+            const features = [];
+            if (request.preRequestScript?.trim() || request.postResponseScript?.trim() || request.tests?.trim())
+                features.push("scripts and tests");
+            if (request.database?.preRequest?.enabled || request.database?.postResponse?.enabled)
+                features.push("database steps");
+            if (request.redis?.enabled)
+                features.push("Redis commands");
+            return features.length > 0 ? `${request.name}: ${features.join(", ")} are not run in a load test.` : null;
+        })
+            .filter((note) => note !== null);
+        const warnings = [...prepared.warnings, ...notes, ...issues.filter((issue) => issue.severity === "warning").map((issue) => issue.message)];
+        if (thresholds.length === 0)
+            warnings.push("No pass criteria were given, so the verdict can only be 'passed'. Add thresholds such as [\"p95<500\", \"fail<1%\"].");
+        const pattern = {
+            type: executor.type,
+            ...(executor.type === "constant-vus" ? { vus: executor.vus } : {}),
+            ...(executor.type === "constant-arrival-rate" ? { ratePerSecond: executor.rate } : {}),
+            durationSeconds,
+            ...(args.rampUpSeconds ? { rampUpSeconds: args.rampUpSeconds } : {}),
+            ...(args.preset ? { preset: args.preset } : {}),
+        };
+        if (args.confirm !== true) {
+            return (0, shared_js_1.ok)({
+                preview: true,
+                message: "Nothing was sent. Show this to the user and call run_load_test again with confirm: true to generate the load. Only test systems you own or may load-test.",
+                workspace: (0, lookups_js_1.workspaceTag)(ws),
+                collection: { id: resolved.item.id, name: resolved.item.name },
+                environment: prepared.environment,
+                targetHosts: [...hosts],
+                flow: chosen.map((request) => ({ name: request.name, method: request.method, url: redactor.text((0, resolveTemplate_js_1.resolveTemplate)(request.url, environment)) })),
+                pattern,
+                estimate: { requests: estimate.totalRequests, uploadMegabytes: round(estimate.estimatedUploadMb, 1), impactOnThisMachine: estimate.impact },
+                limits: { maxVus: loadTestMaxVus, maxRatePerSecond: loadTestMaxRate, maxSeconds: loadTestMaxSeconds },
+                thresholds: thresholds.map((threshold) => ({ expression: threshold.expression, ...(threshold.abortOnFail ? { stopsTheRun: true } : {}) })),
+                warnings,
+            });
+        }
+        const { startLoadTest } = await Promise.resolve().then(() => __importStar(require("callman-core/loadtest")));
+        const result = await ctx.withRunLock(async () => {
+            const handle = startLoadTest(config, { onEvent: () => undefined, ...(ctx.config.loadWorkerEntry ? { workerEntry: ctx.config.loadWorkerEntry } : {}) });
+            const stopTimer = setTimeout(() => handle.stop(), (durationSeconds + 20) * 1000);
+            try {
+                return await handle.done;
+            }
+            finally {
+                clearTimeout(stopTimer);
+            }
+        });
+        return (0, shared_js_1.ok)({
+            ...summarize(result, (text) => redactor.text(text)),
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
+            collection: { id: resolved.item.id, name: resolved.item.name },
+            environment: prepared.environment,
+            targetHosts: [...hosts],
+            pattern,
+            warnings,
+        });
+    }));
+};
+exports.registerLoadTestTool = registerLoadTestTool;

package/dist-cjs/tools/lookups.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sameName = exports.connectionResolverFor = exports.loadConnections = exports.resolveUiTest = exports.resolveUiTestFolder = exports.uiTestFolderSubtree = exports.loadUiTestFolders = exports.loadUiTests = exports.resolveDiagram = exports.resolveDiagramFolder = exports.diagramFolderPath = exports.diagramFolderRows = exports.loadDiagramFolders = exports.loadDiagrams = exports.resolveScenarioFolder = exports.resolveScenario = exports.loadScenarioCatalog = exports.resolveEnvironment = exports.loadEnvironments = exports.resolveRequest = exports.searchRequests = exports.requestIdsInFolder = exports.resolveFolder = exports.loadTree = exports.resolveCollection = exports.findEnvironment = exports.findRequest = exports.findCollection = exports.findInWorkspaces = exports.workspaceTag = exports.workspacesForListing = exports.isAllWorkspaces = exports.loadCollections = void 0;
+exports.sameName = exports.connectionResolverFor = exports.loadConnections = exports.resolveUiTest = exports.resolveUiTestFolder = exports.uiTestFolderSubtree = exports.loadUiTestFolders = exports.loadUiTests = exports.resolveDiagram = exports.loadDiagrams = exports.resolveScenarioFolder = exports.resolveScenario = exports.loadScenarioCatalog = exports.resolveEnvironment = exports.loadEnvironments = exports.resolveRequest = exports.searchRequests = exports.requestIdsInFolder = exports.resolveFolder = exports.loadTree = exports.resolveCollection = exports.findEnvironment = exports.findRequest = exports.findCollection = exports.findInWorkspaces = exports.workspaceTag = exports.workspacesForListing = exports.isAllWorkspaces = exports.loadCollections = void 0;
 const errors_js_1 = require("../client/errors.js");
 const requestIntegrations_js_1 = require("../domain/requestIntegrations.js");
 const resolve_js_1 = require("../domain/resolve.js");
@@ -240,51 +240,6 @@ const resolveScenarioFolder = async (ctx, ws, ref) => (0, resolve_js_1.resolveRe
 exports.resolveScenarioFolder = resolveScenarioFolder;
 const loadDiagrams = (ctx) => ctx.cache.getOrSet("diagrams", () => ctx.api.listDiagrams());
 exports.loadDiagrams = loadDiagrams;
-// ── diagram folders (the token owner's private library tree) ──────────
-const loadDiagramFolders = (ctx) => ctx.cache.getOrSet("diagram-folders", () => ctx.api.listDiagramFolders());
-exports.loadDiagramFolders = loadDiagramFolders;
-// The tree as rows with paths ("Architecture/Payments"), depth-first,
-// siblings by name — what a model refers to folders by. An older backend
-// without the route yields no rows (every diagram is then at the top level).
-const diagramFolderRows = async (ctx) => {
-    let folders;
-    try {
-        folders = await (0, exports.loadDiagramFolders)(ctx);
-    }
-    catch (error) {
-        if (error instanceof errors_js_1.CallmanApiError && (error.status === 404 || error.status === 403))
-            return [];
-        throw error;
-    }
-    const byName = (a, b) => a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" }) || a.id.localeCompare(b.id);
-    const out = [];
-    const seen = new Set();
-    const walk = (parentId, prefix, depth) => {
-        for (const folder of folders.filter((entry) => entry.parentId === parentId).sort(byName)) {
-            if (seen.has(folder.id))
-                continue; // a corrupt cycle must not recurse forever
-            seen.add(folder.id);
-            const path = prefix ? `${prefix}/${folder.name}` : folder.name;
-            out.push({ id: folder.id, name: folder.name, parentId: folder.parentId, path, depth });
-            walk(folder.id, path, depth + 1);
-        }
-    };
-    walk(null, "", 0);
-    return out;
-};
-exports.diagramFolderRows = diagramFolderRows;
-const diagramFolderPath = (rows, folderId) => folderId ? (rows.find((row) => row.id === folderId)?.path ?? null) : null;
-exports.diagramFolderPath = diagramFolderPath;
-// A folder by id, exact path, exact name (unique) or unique substring.
-const resolveDiagramFolder = async (ctx, ref, options = {}) => {
-    const rows = await (0, exports.diagramFolderRows)(ctx);
-    return (0, resolve_js_1.resolveRef)("diagram folder", ref, rows, {
-        describe: (folder) => ({ path: folder.path }),
-        aliases: (folder) => [folder.path],
-        exact: options.exact,
-    });
-};
-exports.resolveDiagramFolder = resolveDiagramFolder;
 const resolveDiagram = async (ctx, ref, options = {}) => {
     if ((0, ids_js_1.isObjectId)(ref))
         return { item: await ctx.api.getDiagram(ref), matched: "id" };

package/dist-cjs/tools/requests.js

@@ -45,7 +45,7 @@ const registerRequestTools = (server, ctx) => {
     }));
     server.registerTool("get_request", {
         title: "Get a request",
-        description: "Read one saved request in the SAME shape create_request / update_request accept: url, headers, query, pathVariables, body (a JSON value or { mode, … }), auth ({ type, token | username/password | key/value/location | oauth2 fields }), scripts, isEnabledInRunner, plus which database / Kafka / Redis steps it has. Secrets in auth and sensitive headers are masked (••••ab) unless reveal: true — sending a masked value back unchanged keeps the stored secret. A long body comes back as bodyPreview (body: null) unless full: true.",
+        description: "Read one saved request in the SAME shape create_request / update_request accept: url, headers, query, pathVariables, body (a JSON value or { mode, … }), auth ({ type, token | username/password | key/value/location | oauth2 fields }), scripts, isEnabledInRunner, plus which database / Redis steps it has. Secrets in auth and sensitive headers are masked (••••ab) unless reveal: true — sending a masked value back unchanged keeps the stored secret. A long body comes back as bodyPreview (body: null) unless full: true.",
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             request: (0, shared_js_1.refArg)("Request", "(name, \"METHOD url\" or id)"),
@@ -65,7 +65,7 @@ const registerRequestTools = (server, ctx) => {
     }));
     server.registerTool("create_request", {
         title: "Create a request",
-        description: "Create one saved request in a collection (optionally inside a folder by id, name or path): method, url, headers, query, path variables, body (a JSON value, a raw string, or { mode: raw|formdata|urlencoded|json }), auth (bearer, basic, apiKey, oauth2), pre-request / post-response / tests scripts, and optional database / Kafka / Redis steps and DB assertions (connections by id or name — list_connections). Use {{variable}} for hosts and secrets and put the values in an environment. Contract checks are added with add_contract_rules / set_data_contract. For many requests use create_requests_bulk (one call, atomic). Reference: callman://docs/request-schema.",
+        description: "Create one saved request in a collection (optionally inside a folder by id, name or path): method, url, headers, query, path variables, body (a JSON value, a raw string, or { mode: raw|formdata|urlencoded|json }), auth (bearer, basic, apiKey, oauth2), pre-request / post-response scripts (put pm.test assertions in the post-response script; testsScript is a legacy slot), and optional database / Redis steps and DB assertions (connections by id or name — list_connections). Use {{variable}} for hosts and secrets and put the values in an environment. Contract checks are added with add_contract_rules / set_data_contract. For many requests use create_requests_bulk (one call, atomic). Reference: callman://docs/request-schema.",
         inputSchema: { workspace: shared_js_1.workspaceArg, collection: (0, shared_js_1.refArg)("Collection"), ...requestShape_js_1.requestInputSchema.omit({ folderKey: true }).shape },
         annotations: shared_js_1.WRITE,
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, ...item }) => {
@@ -237,7 +237,7 @@ const registerRequestTools = (server, ctx) => {
     }));
     server.registerTool("update_request", {
         title: "Update a request",
-        description: "Change fields of a saved request — only the fields you pass change, in the same shape as create_request. `headers` / `query` / `pathVariables` / `dbAssertions` replace the whole list; `url` and `query` are kept in sync (a ?query in the url becomes rows). `database` / `kafka` merge: a phase or field you leave out is kept, null turns it off. A masked secret sent back unchanged keeps the stored value. isEnabledInRunner toggles the runner switch. To move it, use move_requests; contract checks: add_contract_rules / set_data_contract.",
+        description: "Change fields of a saved request — only the fields you pass change, in the same shape as create_request. `headers` / `query` / `pathVariables` / `dbAssertions` replace the whole list; `url` and `query` are kept in sync (a ?query in the url becomes rows). `database` merges: a phase or field you leave out is kept, null turns it off. A masked secret sent back unchanged keeps the stored value. isEnabledInRunner toggles the runner switch. To move it, use move_requests; contract checks: add_contract_rules / set_data_contract.",
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             request: (0, shared_js_1.refArg)("Request", "(name, \"METHOD url\" or id)"),

package/dist-cjs/tools/run.js

@@ -33,8 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerRunTools = void 0;
+exports.registerRunTools = exports.prepareRun = void 0;
 const zod_1 = require("zod");
+const callman_core_1 = require("callman-core");
 const errors_js_1 = require("../client/errors.js");
 const resolve_js_1 = require("../domain/resolve.js");
 const redact_js_1 = require("../lib/redact.js");
@@ -51,7 +52,7 @@ const shared_js_1 = require("./shared.js");
 // {{key}}). One run at a time.
 // What a local run does NOT do, stated up front so a model does not read a
 // missing check as a pass.
-const LOCAL_RUN_LIMITS = "Local-run limits: Kafka steps are skipped; DB assertions (dbAssertions) are evaluated only by the desktop app; no cookie jar between requests; no client certificates (mTLS); each request times out after 30 s. Database and Redis steps run when the collection's runnerSettings allow them and the connection is usable from this machine.";
+const LOCAL_RUN_LIMITS = "Local-run limits: DB assertions (dbAssertions) are evaluated only by the desktop app; no cookie jar between requests; no client certificates (mTLS); each request times out after 30 s. Database and Redis steps run when the collection's runnerSettings allow them and the connection is usable from this machine.";
 const maxBodyArg = zod_1.z.number().int().min(256).max(truncate_js_1.LIMITS.RUN_BODY_MAX).optional().describe("Response body preview cap in bytes (default 16 KB)");
 // apiKey auth names its own header / query parameter — mask those too, and
 // note the steps a local run skips.
@@ -69,8 +70,6 @@ const inspectBundle = (rawCollection) => {
         const notes = [];
         if (Array.isArray(request.dbAssertions) && request.dbAssertions.length > 0)
             notes.push("DB assertions (desktop only)");
-        if (request.kafka && (request.kafka.enabled || request.kafka.prePublish?.enabled || request.kafka.postPublish?.enabled))
-            notes.push("Kafka steps");
         if (typeof request.id === "string" && notes.length > 0)
             skipped.set(request.id, notes);
     }
@@ -112,6 +111,7 @@ const prepareRun = async (ctx, ws, collectionId, environmentRef) => {
         skipped: skippedSteps,
     };
 };
+exports.prepareRun = prepareRun;
 // Warnings for the requests actually run.
 const skippedWarnings = (prepared, ids) => {
     const out = [];
@@ -141,7 +141,7 @@ const registerRunTools = (server, ctx) => {
         const { ws, value, note } = await (0, lookups_js_1.findRequest)(ctx, workspace, request, collection);
         const { request: found } = value;
         const annotation = [value.annotation, note].filter(Boolean).join("; ") || undefined;
-        const prepared = await prepareRun(ctx, ws.id, found.collectionId, environment);
+        const prepared = await (0, exports.prepareRun)(ctx, ws.id, found.collectionId, environment);
         const runnable = prepared.collection.requests.find((entry) => entry.id === found.id);
         if (!runnable)
             throw new errors_js_1.ToolInputError("REQUEST_NOT_IN_BUNDLE", "The request is not part of the collection bundle (was it just deleted?).");
@@ -161,7 +161,17 @@ const registerRunTools = (server, ctx) => {
                     query: redactor.query(Object.fromEntries(Object.entries(runnable.query ?? {}).map(([key, value]) => [key, resolveTemplate(value, env)]))),
                     body: redactor.value(runnable.body ?? null),
                     hasPreRequestScript: Boolean(runnable.preRequestScript),
-                    hasTests: Boolean(runnable.tests),
+                    hasTests: Boolean(runnable.tests || runnable.postResponseScript),
+                    // Collection / folder scripts that run around this request.
+                    inheritedScripts: (0, callman_core_1.buildScriptLayers)({
+                        collection: {
+                            ...(prepared.collection.id ? { id: prepared.collection.id } : {}),
+                            name: prepared.collection.name,
+                            scripts: prepared.collection.scripts ?? null,
+                        },
+                        folders: prepared.collection.folders ?? [],
+                        folderId: runnable.folderId ?? null,
+                    }).map(callman_core_1.describeScriptLayer),
                 },
                 environment: prepared.environment,
                 availableVariableKeys: Object.keys(env),
@@ -203,7 +213,7 @@ const registerRunTools = (server, ctx) => {
         annotations: shared_js_1.RUN,
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, folder, only, environment, bail, maxBodyBytes }) => {
         const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
-        const prepared = await prepareRun(ctx, ws.id, resolved.item.id, environment);
+        const prepared = await (0, exports.prepareRun)(ctx, ws.id, resolved.item.id, environment);
         let selection = null;
         if (folder) {
             const target = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, resolved.item.id, folder);