callman-mcp 0.1.0

package/dist-cjs/tools/requests.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRequestTools = void 0;
+const zod_1 = require("zod");
+const errors_js_1 = require("../client/errors.js");
+const requestShape_js_1 = require("../domain/requestShape.js");
+const resolve_js_1 = require("../domain/resolve.js");
+const truncate_js_1 = require("../lib/truncate.js");
+const lookups_js_1 = require("./lookups.js");
+const shared_js_1 = require("./shared.js");
+const BULK_MAX = 5000;
+const MOVE_MAX = 200;
+const registerRequestTools = (server, ctx) => {
+    server.registerTool("search_requests", {
+        title: "Search requests",
+        description: "Find saved requests by words in their name, method or URL (all words must match), across the workspace or inside one collection. Returns up to 50 matches with ids you can pass to get_request / run_request.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            query: zod_1.z.string().min(1).max(200).describe("e.g. \"POST login\", \"users\", \"GET /orders\""),
+            collection: zod_1.z.string().max(200).optional(),
+            limit: zod_1.z.number().int().min(1).max(truncate_js_1.LIMITS.SEARCH_RESULTS).optional(),
+        },
+        annotations: shared_js_1.READ,
+    }, (0, shared_js_1.guarded)(async ({ workspace, query, collection, limit }) => {
+        const ws = await ctx.resolveWorkspace(workspace);
+        const scope = collection ? await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection) : null;
+        const matches = await (0, lookups_js_1.searchRequests)(ctx, ws.id, query, scope?.item.id ?? null, limit ?? truncate_js_1.LIMITS.SEARCH_RESULTS);
+        return (0, shared_js_1.ok)({
+            query,
+            ...(scope ? { collection: { id: scope.item.id, name: scope.item.name } } : {}),
+            matches: matches.map((request) => ({ ...(0, requestShape_js_1.requestSummaryView)(request), collection: request.collectionName })),
+            ...(matches.length >= (limit ?? truncate_js_1.LIMITS.SEARCH_RESULTS) ? { truncated: true } : {}),
+        });
+    }));
+    server.registerTool("get_request", {
+        title: "Get a request",
+        description: "Read one saved request: url, headers, query, body, auth (secrets masked unless reveal:true and the token holds requests:read + the request's own permissions), scripts. `full: true` returns untruncated body and scripts.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            request: (0, shared_js_1.refArg)("Request", "(name, \"METHOD url\" or id)"),
+            collection: zod_1.z.string().max(200).optional().describe("Narrow a name lookup to one collection"),
+            full: zod_1.z.boolean().optional(),
+            reveal: zod_1.z.boolean().optional().describe("Return auth secrets and sensitive header values unmasked"),
+        },
+        annotations: shared_js_1.READ,
+    }, (0, shared_js_1.guarded)(async ({ workspace, request, collection, full, reveal }) => {
+        const ws = await ctx.resolveWorkspace(workspace);
+        const { request: found, annotation } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, request, collection);
+        return (0, shared_js_1.ok)({ request: (0, requestShape_js_1.compactRequestView)(found, { full, reveal }), ...(annotation ? { resolved: [{ input: request, matched: found.name, id: found.id, note: annotation }] } : {}) });
+    }));
+    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). Body may be a JSON value, a raw string, or { mode: raw|formdata|urlencoded }. Use {{variable}} for hosts and secrets and put the values in an environment. For many requests use create_requests_bulk (one call, atomic).",
+        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 }) => {
+        const ws = await ctx.resolveWorkspace(workspace);
+        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection);
+        const folder = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, resolved.item.id, item.folder);
+        const created = await ctx.api.createRequest(ws.id, (0, requestShape_js_1.toCreateRequestPayload)(item, { collectionId: resolved.item.id, folderId: folder?.item.id ?? null }));
+        ctx.invalidate(`tree:${ws.id}:${resolved.item.id}`);
+        ctx.invalidate(`collections:${ws.id}`);
+        return (0, shared_js_1.ok)({
+            request: (0, requestShape_js_1.requestSummaryView)(created),
+            collection: { id: resolved.item.id, name: resolved.item.name },
+            ...(folder ? { folder: { id: folder.item.id, path: folder.item.path } } : {}),
+            resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved), ...(folder && item.folder ? [(0, resolve_js_1.resolvedSummary)(item.folder, folder)] : [])],
+        });
+    }));
+    server.registerTool("create_requests_bulk", {
+        title: "Create many requests",
+        description: "Create many requests at once. Either `collectionName` (creates a NEW collection with an optional folder skeleton — atomic: all or nothing) or `collection` (adds to an EXISTING one; each request may name a `folder`). Requests reference folders by `folderKey` (new collection) or `folder` (existing). Use dryRun: true first for large sets.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            collectionName: zod_1.z.string().min(1).max(truncate_js_1.LIMITS.NAME).optional().describe("Create a new collection with this name"),
+            collection: zod_1.z.string().max(200).optional().describe("Add to this existing collection (id or name)"),
+            folders: zod_1.z
+                .array(zod_1.z.object({ key: zod_1.z.string().min(1).max(120), name: zod_1.z.string().min(1).max(truncate_js_1.LIMITS.NAME), parentKey: zod_1.z.string().max(120).optional() }))
+                .max(200)
+                .optional()
+                .describe("New-collection mode only: folder skeleton; requests use folderKey"),
+            requests: zod_1.z.array(requestShape_js_1.requestInputSchema).min(1).max(BULK_MAX),
+            dryRun: shared_js_1.dryRunArg,
+        },
+        annotations: shared_js_1.WRITE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, collectionName, collection, folders, requests, dryRun }) => {
+        if ((collectionName ? 1 : 0) + (collection ? 1 : 0) !== 1) {
+            throw new errors_js_1.ToolInputError("TARGET_REQUIRED", "Pass exactly one of collectionName (new collection) or collection (existing).");
+        }
+        const ws = await ctx.resolveWorkspace(workspace);
+        const folderKeys = new Set((folders ?? []).map((folder) => folder.key));
+        for (const [index, request] of requests.entries()) {
+            if (request.folderKey && !folderKeys.has(request.folderKey)) {
+                throw new errors_js_1.ToolInputError("FOLDER_KEY_UNKNOWN", `requests[${index}] references folderKey "${request.folderKey}" which is not declared in folders.`);
+            }
+        }
+        if (collectionName) {
+            const existing = (await (0, lookups_js_1.loadCollections)(ctx, ws.id)).find((entry) => (0, lookups_js_1.sameName)(entry.name, collectionName));
+            if (existing) {
+                throw new errors_js_1.ToolInputError("COLLECTION_NAME_EXISTS", `A collection named "${existing.name}" already exists (id ${existing.id}). Use collection: "${existing.id}" to add to it, or pick another name.`, {
+                    existing: { id: existing.id, name: existing.name },
+                });
+            }
+            const payload = {
+                collectionName: collectionName.trim(),
+                ...(folders && folders.length > 0 ? { folders } : {}),
+                requests: requests.map(requestShape_js_1.toFlatImportRequest),
+            };
+            if (dryRun) {
+                return (0, shared_js_1.ok)({ dryRun: true, mode: "new-collection", collectionName, folderCount: folders?.length ?? 0, requestCount: requests.length, sample: requests.slice(0, 5).map((request) => `${request.method} ${request.name}`) });
+            }
+            const result = await ctx.api.importJson(ws.id, { format: "requests", payload });
+            ctx.invalidate(`collections:${ws.id}`);
+            return (0, shared_js_1.ok)({
+                collection: { id: result.collection.id, name: result.collection.name },
+                created: result.importedCounts,
+                note: "Created atomically. Open the collection in the desktop app (it refreshes when it regains focus).",
+            });
+        }
+        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection);
+        const tree = await (0, lookups_js_1.loadTree)(ctx, ws.id, resolved.item.id);
+        // Resolve every folder reference up front so a typo fails before any write.
+        const folderIdByRef = new Map();
+        for (const request of requests) {
+            const ref = request.folder ?? "";
+            if (!folderIdByRef.has(ref)) {
+                folderIdByRef.set(ref, ref ? (await (0, lookups_js_1.resolveFolder)(ctx, ws.id, resolved.item.id, ref))?.item.id ?? null : null);
+            }
+        }
+        const duplicates = requests.filter((request) => tree.requests.some((existing) => (0, lookups_js_1.sameName)(existing.name, request.name) && existing.folderId === folderIdByRef.get(request.folder ?? "")));
+        if (dryRun) {
+            return (0, shared_js_1.ok)({
+                dryRun: true,
+                mode: "existing-collection",
+                collection: { id: resolved.item.id, name: resolved.item.name },
+                requestCount: requests.length,
+                duplicateNames: duplicates.map((request) => request.name),
+                sample: requests.slice(0, 5).map((request) => `${request.method} ${request.name}`),
+            });
+        }
+        const created = [];
+        const failed = [];
+        for (const request of requests) {
+            try {
+                const row = await ctx.api.createRequest(ws.id, (0, requestShape_js_1.toCreateRequestPayload)(request, { collectionId: resolved.item.id, folderId: folderIdByRef.get(request.folder ?? "") ?? null }));
+                created.push({ id: row.id, name: row.name, method: row.method });
+            }
+            catch (error) {
+                failed.push({ name: request.name, error: error instanceof errors_js_1.CallmanApiError ? `${error.code}: ${error.message}` : error instanceof Error ? error.message : String(error) });
+            }
+        }
+        ctx.invalidate(`tree:${ws.id}:${resolved.item.id}`);
+        ctx.invalidate(`collections:${ws.id}`);
+        return (0, shared_js_1.ok)({
+            collection: { id: resolved.item.id, name: resolved.item.name },
+            created: created.length,
+            failed,
+            requests: created,
+            ...(duplicates.length > 0 ? { note: `${duplicates.length} request name(s) already existed in the same folder and were created again: ${duplicates.map((request) => request.name).join(", ")}` } : {}),
+            resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved)],
+        });
+    }));
+    server.registerTool("update_request", {
+        title: "Update a request",
+        description: "Change fields of a saved request (only the fields you pass change). To move it, use move_requests. Sending `headers`/`query` replaces the whole list.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            request: (0, shared_js_1.refArg)("Request", "(name, \"METHOD url\" or id)"),
+            ...requestShape_js_1.updateRequestInputSchema.shape,
+        },
+        annotations: shared_js_1.IDEMPOTENT_WRITE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, request, collection, ...changes }) => {
+        const ws = await ctx.resolveWorkspace(workspace);
+        const { request: found, annotation } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, request, collection);
+        const folder = changes.folder !== undefined ? await (0, lookups_js_1.resolveFolder)(ctx, ws.id, found.collectionId, changes.folder) : undefined;
+        const payload = (0, requestShape_js_1.toUpdateRequestPayload)(changes, { ...(folder !== undefined ? { folderId: folder?.item.id ?? null } : {}) });
+        if (Object.keys(payload).length === 0)
+            throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass at least one field to change.");
+        const updated = await ctx.api.updateRequest(ws.id, found.id, payload);
+        ctx.invalidate(`tree:${ws.id}:${found.collectionId}`);
+        return (0, shared_js_1.ok)({ request: (0, requestShape_js_1.compactRequestView)(updated), changed: Object.keys(payload), ...(annotation ? { resolved: [{ input: request, matched: found.name, id: found.id, note: annotation }] } : {}) });
+    }));
+    server.registerTool("move_requests", {
+        title: "Move requests",
+        description: "Move up to 200 requests (ids or unique names) into a collection and optional folder.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            requests: zod_1.z.array(zod_1.z.string().min(1).max(500)).min(1).max(MOVE_MAX),
+            targetCollection: (0, shared_js_1.refArg)("Target collection"),
+            targetFolder: zod_1.z.string().max(300).optional().describe("Folder id, name or path in the target collection; omit for top level"),
+            sourceCollection: zod_1.z.string().max(200).optional().describe("Narrow name lookups to one collection"),
+        },
+        annotations: shared_js_1.IDEMPOTENT_WRITE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, requests, targetCollection, targetFolder, sourceCollection }) => {
+        const ws = await ctx.resolveWorkspace(workspace);
+        const target = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, targetCollection);
+        const folder = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, target.item.id, targetFolder);
+        const moved = [];
+        const failed = [];
+        const touchedCollections = new Set([target.item.id]);
+        for (const ref of requests) {
+            try {
+                const { request } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, ref, sourceCollection);
+                touchedCollections.add(request.collectionId);
+                const updated = await ctx.api.updateRequest(ws.id, request.id, { collectionId: target.item.id, folderId: folder?.item.id ?? null });
+                moved.push({ id: updated.id, name: updated.name });
+            }
+            catch (error) {
+                failed.push({ request: ref, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        for (const collectionId of touchedCollections)
+            ctx.invalidate(`tree:${ws.id}:${collectionId}`);
+        ctx.invalidate(`collections:${ws.id}`);
+        return (0, shared_js_1.ok)({ target: { collection: { id: target.item.id, name: target.item.name }, folder: folder ? { id: folder.item.id, path: folder.item.path } : null }, moved, failed });
+    }));
+    server.registerTool("delete_requests", {
+        title: "Delete requests",
+        description: "Delete up to 200 requests (ids or unique names). Permanent — confirm with the user first.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            requests: zod_1.z.array(zod_1.z.string().min(1).max(500)).min(1).max(MOVE_MAX),
+            collection: zod_1.z.string().max(200).optional().describe("Narrow name lookups to one collection"),
+            confirm: shared_js_1.confirmArg,
+        },
+        annotations: shared_js_1.DESTRUCTIVE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, requests, collection, confirm }) => {
+        (0, shared_js_1.requireConfirm)(confirm, "requests");
+        const ws = await ctx.resolveWorkspace(workspace);
+        const deleted = [];
+        const failed = [];
+        const touched = new Set();
+        for (const ref of requests) {
+            try {
+                const { request } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, ref, collection);
+                await ctx.api.deleteRequest(ws.id, request.id);
+                touched.add(request.collectionId);
+                deleted.push({ id: request.id, name: request.name });
+            }
+            catch (error) {
+                failed.push({ request: ref, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        for (const collectionId of touched)
+            ctx.invalidate(`tree:${ws.id}:${collectionId}`);
+        ctx.invalidate(`collections:${ws.id}`);
+        return (0, shared_js_1.ok)({ deleted, failed });
+    }));
+};
+exports.registerRequestTools = registerRequestTools;

package/dist-cjs/tools/run.js

@@ -0,0 +1,203 @@
+"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.registerRunTools = void 0;
+const zod_1 = require("zod");
+const errors_js_1 = require("../client/errors.js");
+const resolve_js_1 = require("../domain/resolve.js");
+const mask_js_1 = require("../lib/mask.js");
+const truncate_js_1 = require("../lib/truncate.js");
+const executeCollection_js_1 = require("../run/executeCollection.js");
+const loadBundle_js_1 = require("../run/loadBundle.js");
+const summarize_js_1 = require("../run/summarize.js");
+const lookups_js_1 = require("./lookups.js");
+const shared_js_1 = require("./shared.js");
+// Local execution — the same path as callme-cli: the pipeline bundle
+// (collection + environment values + connection configs) is fetched with the
+// token, requests run HERE through callman-core, and only the results go back
+// to the model. Variable values are never in the output. One run at a time.
+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)");
+const prepareRun = async (ctx, ws, collectionId, environmentRef) => {
+    const environment = environmentRef ? (await (0, lookups_js_1.resolveEnvironment)(ctx, ws, environmentRef)).item : null;
+    const bundle = await ctx.api.pipelineBundle(ws, collectionId, environment?.id ?? null);
+    const warnings = [];
+    // Global variables apply underneath the environment. They come back masked
+    // unless the token can reveal them — a masked value would break requests,
+    // so they are only merged when the real values are available.
+    let globals = {};
+    const scopes = await ctx.getTokenScopes();
+    if (scopes.includes("environments:reveal")) {
+        try {
+            globals = Object.fromEntries((await ctx.api.listGlobalVariables(ws, true)).map((variable) => [variable.key, variable.value]));
+        }
+        catch (error) {
+            warnings.push(`Global variables not applied: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    else {
+        warnings.push("Global variables were not applied (the token lacks environments:reveal). Environment variables are applied.");
+    }
+    const collection = (0, loadBundle_js_1.validateCollection)(bundle.collection);
+    const { map, skipped } = (0, loadBundle_js_1.buildConnectionRuntimeMap)(bundle.connections);
+    if (skipped.length > 0)
+        warnings.push(`Connections not usable in a local run: ${skipped.join(", ")}`);
+    if (collection.runnerSettings?.kafka)
+        warnings.push("Kafka steps never run from an AI tool.");
+    return {
+        collection,
+        env: { ...globals, ...(bundle.environment?.variables ?? {}) },
+        connections: map,
+        environment: bundle.environment ? { id: bundle.environment.id, name: bundle.environment.name } : null,
+        warnings,
+    };
+};
+const registerRunTools = (server, ctx) => {
+    server.registerTool("run_request", {
+        title: "Run a request locally",
+        description: "Execute one saved request from this machine with an environment's variables (like the desktop's Send / callme run): returns status, timing, response headers and a bounded body preview, plus test and contract results and the NAMES of variables the scripts changed (never values). dryRun: true shows the resolved request without sending it. Needs requests:run.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            request: (0, shared_js_1.refArg)("Request", "(name, \"METHOD url\" or id)"),
+            collection: zod_1.z.string().max(200).optional().describe("Narrow a name lookup to one collection"),
+            environment: zod_1.z.string().max(200).optional().describe("Environment name or id; omit to run without one"),
+            dryRun: zod_1.z.boolean().optional(),
+            maxBodyBytes: maxBodyArg,
+        },
+        annotations: shared_js_1.RUN,
+    }, (0, shared_js_1.guarded)(async ({ workspace, request, collection, environment, dryRun, maxBodyBytes }) => {
+        const ws = await ctx.resolveWorkspace(workspace);
+        const { request: found, annotation } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, request, collection);
+        const prepared = await 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?).");
+        if (dryRun) {
+            const { resolveTemplate } = await Promise.resolve().then(() => __importStar(require("../run/resolveTemplate.js")));
+            const env = prepared.env;
+            return (0, shared_js_1.ok)({
+                dryRun: true,
+                request: {
+                    id: runnable.id,
+                    name: runnable.name,
+                    method: runnable.method,
+                    url: resolveTemplate(runnable.url, env),
+                    headers: (0, mask_js_1.maskHeaderRecord)(Object.fromEntries(Object.entries(runnable.headers ?? {}).map(([key, value]) => [key, resolveTemplate(value, env)]))),
+                    query: Object.fromEntries(Object.entries(runnable.query ?? {}).map(([key, value]) => [key, resolveTemplate(value, env)])),
+                    body: runnable.body ?? null,
+                    hasPreRequestScript: Boolean(runnable.preRequestScript),
+                    hasTests: Boolean(runnable.tests),
+                },
+                environment: prepared.environment,
+                availableVariableKeys: Object.keys(env),
+                unresolvedVariables: unresolved([runnable.url, ...Object.values(runnable.headers ?? {}), ...Object.values(runnable.query ?? {})], env),
+                warnings: prepared.warnings,
+            });
+        }
+        const outcome = await ctx.withRunLock(() => (0, executeCollection_js_1.executeCollection)({
+            collection: prepared.collection,
+            env: prepared.env,
+            connections: prepared.connections,
+            only: [found.id],
+            deadlineMs: ctx.config.runTimeoutMs,
+        }));
+        const summary = (0, summarize_js_1.summarizeRun)(outcome, maxBodyBytes ?? ctx.config.maxBodyBytes, {
+            collection: { id: found.collectionId },
+            environment: prepared.environment,
+            warnings: prepared.warnings,
+            ...(annotation ? { resolved: [{ input: request, matched: found.name, id: found.id, note: annotation }] } : {}),
+        });
+        return (0, shared_js_1.ok)({ ...summary, result: summary.results[0] ?? null });
+    }));
+    server.registerTool("run_collection", {
+        title: "Run a collection locally",
+        description: "Run a collection (or one folder of it, or specific requests) sequentially from this machine with an environment, sharing variables between requests like the collection runner. Returns per-request results (bounded bodies), a pass/fail summary and the variable names scripts changed. `bail` stops at the first failure. 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("Run only this folder (id, name or path), subfolders included"),
+            only: zod_1.z.array(zod_1.z.string().min(1).max(500)).max(200).optional().describe("Run only these requests (ids or names)"),
+            environment: zod_1.z.string().max(200).optional(),
+            bail: zod_1.z.boolean().optional(),
+            maxBodyBytes: maxBodyArg,
+        },
+        annotations: shared_js_1.RUN,
+    }, (0, shared_js_1.guarded)(async ({ workspace, collection, folder, only, environment, bail, maxBodyBytes }) => {
+        const ws = await ctx.resolveWorkspace(workspace);
+        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection);
+        const prepared = await 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);
+            if (!target)
+                throw new errors_js_1.ToolInputError("REF_REQUIRED", "folder is required.");
+            selection = (0, lookups_js_1.requestIdsInFolder)(await (0, lookups_js_1.loadTree)(ctx, ws.id, resolved.item.id), target.item.id);
+        }
+        if (only && only.length > 0) {
+            const ids = [];
+            for (const ref of only)
+                ids.push((await (0, lookups_js_1.resolveRequest)(ctx, ws.id, ref, resolved.item.id)).request.id);
+            selection = selection ? ids.filter((id) => selection?.includes(id)) : ids;
+        }
+        if (selection && selection.length === 0)
+            throw new errors_js_1.ToolInputError("NOTHING_TO_RUN", "The selection contains no requests.");
+        const outcome = await ctx.withRunLock(() => (0, executeCollection_js_1.executeCollection)({
+            collection: prepared.collection,
+            env: prepared.env,
+            connections: prepared.connections,
+            only: selection,
+            bail: bail ?? false,
+            deadlineMs: ctx.config.runTimeoutMs,
+        }));
+        return (0, shared_js_1.ok)((0, summarize_js_1.summarizeRun)(outcome, maxBodyBytes ?? ctx.config.maxBodyBytes, {
+            collection: { id: resolved.item.id, name: resolved.item.name },
+            environment: prepared.environment,
+            warnings: prepared.warnings,
+            resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved)],
+        }));
+    }));
+};
+exports.registerRunTools = registerRunTools;
+const TEMPLATE = /\{\{\s*([^}]+?)\s*\}\}/g;
+const unresolved = (values, env) => {
+    const missing = new Set();
+    for (const value of values) {
+        for (const match of value.matchAll(TEMPLATE)) {
+            const key = match[1].trim();
+            if (!(key in env) && !key.startsWith("$") && !key.startsWith("data."))
+                missing.add(key);
+        }
+    }
+    return [...missing];
+};