callman-mcp 0.10.2 → 0.11.0

package/dist-cjs/tools/collections.js

@@ -4,6 +4,8 @@ exports.registerCollectionTools = void 0;
 const zod_1 = require("zod");
 const errors_js_1 = require("../client/errors.js");
 const strict_js_1 = require("../lib/strict.js");
+const ids_js_1 = require("../lib/ids.js");
+const pipeline_js_1 = require("../domain/pipeline.js");
 const requestShape_js_1 = require("../domain/requestShape.js");
 const resolve_js_1 = require("../domain/resolve.js");
 const pagination_js_1 = require("../lib/pagination.js");
@@ -43,6 +45,99 @@ const variableWrites = (variables) => {
 // collection variables (older backend).
 const variablesView = (variables) => Array.isArray(variables) ? variables.map((variable) => ({ key: variable.key, value: variable.value, enabled: variable.enabled !== false })) : null;
 const UNSUPPORTED_VARIABLES_NOTE = "This server does not support collection variables yet (update the Callman backend); use an environment instead.";
+// ── Pipeline collections (on-prem) ────────────────────────────────────────
+// Changes go through review like scenarios, approved versions are kept, CI
+// runs only the active approved version and its stored pass criteria decide
+// the verdict. Approving is a person's decision in the app — tokens may
+// submit and request, never approve.
+const kindArg = zod_1.z
+    .enum(["pipeline"])
+    .optional()
+    .describe('On-prem: "pipeline" makes it a pipeline collection — reviewed like scenarios, CI runs only its approved version and its pipelineConfig decides pass/fail. Needs `group`. The way back to standard goes through review (desktop app)');
+const groupArg = zod_1.z
+    .string()
+    .max(200)
+    .optional()
+    .describe("On-prem pipeline collections: the group whose approvers review it (name or id from the groups you belong to, as list_scenarios shows them). Optional when you belong to one group; fixed once a version is approved or a review is open");
+const PIPELINE_DRAFT_NOTE = "Pipeline collection: edits change the DRAFT. CI (callme run, run_collection) keeps running the approved version until the change is submitted (submit_collection) and approved by a person in the Callman app.";
+// The reviewing group: by id or name among the groups the user belongs to.
+// Omitted → the only group the user has, when there is exactly one.
+const resolveCollectionGroup = async (ctx, ws, ref) => {
+    let items;
+    try {
+        items = (await ctx.api.listMyScenarioGroups(ws)).items;
+    }
+    catch (error) {
+        // The group list needs scenarios:read; an id can still be passed through.
+        if (ref && (0, ids_js_1.isObjectId)(ref.trim()) && error instanceof errors_js_1.CallmanApiError && error.code === "PAT_SCOPE_MISSING")
+            return { id: ref.trim() };
+        throw error;
+    }
+    if (ref) {
+        if (items.length === 0)
+            throw new errors_js_1.ToolInputError("NO_REVIEW_GROUPS", "You belong to no group that can review collections. Pipeline collections exist on Callman on-prem only, and their group is an on-prem group.");
+        return { id: (0, resolve_js_1.resolveRef)("group", ref, items).item.id };
+    }
+    if (items.length === 1)
+        return { id: items[0].id, note: `Reviewed by the group "${items[0].name}" (your only group).` };
+    if (items.length > 1) {
+        throw new errors_js_1.ToolInputError("COLLECTION_GROUP_REQUIRED", "Pass `group`: the group whose approvers review this pipeline collection.", {
+            candidates: items.map((group) => ({ id: group.id, name: group.name })),
+        });
+    }
+    return undefined;
+};
+// Critical request refs (ids or names) → ids of requests in this collection.
+const criticalRequestIds = async (ctx, ws, collectionId, refs) => {
+    if (refs.length === 0)
+        return [];
+    const tree = await (0, lookups_js_1.loadTree)(ctx, ws, collectionId);
+    return [...new Set(refs.map((ref) => (0, resolve_js_1.resolveRef)("request", ref, tree.requests, { aliases: (request) => [`${request.method} ${request.url}`] }).item.id))];
+};
+const reviewStateView = (collection) => collection.kind === "pipeline" && collection.review ? { review: collection.review } : {};
+// What a collection is, for every read: kind always (older servers: standard),
+// group / draft pass criteria / review state for pipeline collections.
+const pipelineView = (collection) => ({
+    kind: collection.kind ?? "standard",
+    ...(collection.kind === "pipeline"
+        ? {
+            groupId: collection.groupId ?? null,
+            pipelineConfig: collection.pipelineConfig ?? null,
+            ...reviewStateView(collection),
+        }
+        : {}),
+});
+const reviewSummaryView = (summary) => ({
+    status: summary.status,
+    activeVersionNumber: summary.activeVersionNumber ?? null,
+    approvedAt: summary.approvedAt ?? null,
+    approvedByLabel: summary.approvedByLabel ?? null,
+    hasUnapprovedChanges: summary.hasUnapprovedChanges,
+    group: summary.groupId ? { id: summary.groupId, name: summary.groupName ?? null } : null,
+});
+const reviewRequestView = (request) => ({
+    id: request.id,
+    action: request.action,
+    status: request.status,
+    baseVersionNumber: request.baseVersionNumber ?? null,
+    note: request.note ?? null,
+    assigneeIds: request.assigneeIds ?? [],
+    submittedAt: request.submittedAt,
+});
+const reviewNoteArg = zod_1.z.string().max(2000).optional().describe("Note for the reviewers (what changed, why)");
+const approversArg = zod_1.z.array(zod_1.z.string().max(255)).max(100).optional().describe("Approver emails; omit to notify every eligible approver of the group");
+// Approver emails → user ids among the server's candidates for the action.
+const approverIdsFor = async (ctx, ws, collectionId, action, emails) => {
+    if (!emails || emails.length === 0)
+        return undefined;
+    const candidates = await ctx.api.listCollectionApproverCandidates(ws, collectionId, action);
+    return emails.map((email) => {
+        const match = candidates.find((candidate) => candidate.email.toLowerCase() === email.trim().toLowerCase());
+        if (!match)
+            throw new errors_js_1.ToolInputError("APPROVER_NOT_ELIGIBLE", `"${email}" cannot approve this collection.`, { candidates: candidates.map((candidate) => candidate.email) });
+        return match.userId;
+    });
+};
 // ── Collection / folder detail: docs + scripts ─────────────────────────────
 const DOCS_MAX_CHARS = 500_000;
 const SCRIPT_MAX_CHARS = 100_000;
@@ -93,7 +188,7 @@ const detailView = (item) => ({
 const registerCollectionTools = (server, ctx) => {
     server.registerTool("get_collection", {
         title: "Get a collection's documentation, scripts and variables",
-        description: "A collection's details: its documentation (Markdown), its collection-level pre-request / post-response / tests scripts (they run around every request in it) and its collection variables ({ key, value, enabled }). Variable values are masked (••••ab) unless reveal: true AND the token holds environments:reveal. Use get_collection_tree for its folders and requests.",
+        description: "A collection's details: its documentation (Markdown), its collection-level pre-request / post-response / tests scripts (they run around every request in it) and its collection variables ({ key, value, enabled }). Variable values are masked (••••ab) unless reveal: true AND the token holds environments:reveal. Also its `kind`; an on-prem pipeline collection adds its group, its DRAFT pipelineConfig (pass criteria) and `review` (status, the active approved version, pending submission). Use get_collection_tree for its folders and requests.",
         inputSchema: { workspace: shared_js_1.workspaceArg, collection: (0, shared_js_1.refArg)("Collection"), reveal: zod_1.z.boolean().optional().describe("Return variable values unmasked (needs environments:reveal)") },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, reveal }) => {
@@ -107,8 +202,10 @@ const registerCollectionTools = (server, ctx) => {
                 requestCount: detail.requestCount ?? null,
                 folderCount: detail.folderCount ?? null,
                 runnerSettings: detail.runnerSettings ?? null,
+                ...pipelineView(detail),
             },
             workspace: (0, lookups_js_1.workspaceTag)(ws),
+            ...(detail.kind === "pipeline" ? { pipelineNote: PIPELINE_DRAFT_NOTE } : {}),
             ...detailView(detail),
             variables: variablesView(detail.variables),
             ...(detail.variables === undefined ? { variablesNote: UNSUPPORTED_VARIABLES_NOTE } : {}),
@@ -137,7 +234,7 @@ const registerCollectionTools = (server, ctx) => {
     }));
     server.registerTool("list_collections", {
         title: "List collections",
-        description: "List collections with request/folder counts — across ALL your workspaces unless `workspace` narrows it (the default workspace comes first; every row says its workspace). Optional `query` filters by name (substring). Use get_collection_tree to see what is inside one.",
+        description: "List collections with request/folder counts — across ALL your workspaces unless `workspace` narrows it (the default workspace comes first; every row says its workspace). Optional `query` filters by name (substring). Each row says its `kind`; on-prem pipeline collections add their review state. Use get_collection_tree to see what is inside one.",
         inputSchema: { workspace: shared_js_1.workspaceArg, query: zod_1.z.string().max(200).optional(), ...shared_js_1.cursorArgs },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace, query, cursor, limit }) => {
@@ -156,6 +253,17 @@ const registerCollectionTools = (server, ctx) => {
                 requestCount: collection.requestCount ?? null,
                 folderCount: collection.folderCount ?? null,
                 updatedAt: collection.updatedAt ?? null,
+                kind: collection.kind ?? "standard",
+                ...(collection.kind === "pipeline" && collection.review
+                    ? {
+                        review: {
+                            status: collection.review.status,
+                            activeVersionNumber: collection.review.activeVersionNumber ?? null,
+                            pendingAction: collection.review.pendingAction ?? null,
+                            hasUnapprovedChanges: collection.review.hasUnapprovedChanges,
+                        },
+                    }
+                    : {}),
             })),
             total: page.total,
             nextCursor: page.nextCursor,
@@ -195,7 +303,7 @@ const registerCollectionTools = (server, ctx) => {
     }));
     server.registerTool("create_collection", {
         title: "Create a collection",
-        description: "Create an empty collection in `workspace` (or the session default — use_workspace; with one workspace, that one), optionally with its collection variables, docs and scripts. Refuses a name that already exists in that workspace unless allowDuplicateName is true — list_collections first and reuse an existing one when it fits.",
+        description: "Create an empty collection in `workspace` (or the session default — use_workspace; with one workspace, that one), optionally with its collection variables, docs and scripts. On-prem, kind: \"pipeline\" (+ group, pipelineConfig) creates a pipeline collection: it starts as a draft, and CI runs it only after submit_collection and a person's approval. Refuses a name that already exists in that workspace unless allowDuplicateName is true — list_collections first and reuse an existing one when it fits.",
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             name: zod_1.z.string().min(1).max(truncate_js_1.LIMITS.NAME),
@@ -204,9 +312,18 @@ const registerCollectionTools = (server, ctx) => {
             variables: collectionVariablesArg,
             docs: docsArg,
             scripts: scriptsArg,
+            kind: kindArg,
+            group: groupArg,
+            pipelineConfig: pipeline_js_1.pipelineConfigArg,
         },
         annotations: shared_js_1.WRITE,
-    }, (0, shared_js_1.guarded)(async ({ workspace, name, allowDuplicateName, runnerSettings, variables, docs, scripts }) => {
+    }, (0, shared_js_1.guarded)(async ({ workspace, name, allowDuplicateName, runnerSettings, variables, docs, scripts, kind, group, pipelineConfig }) => {
+        if (kind !== "pipeline" && (group !== undefined || pipelineConfig !== undefined)) {
+            throw new errors_js_1.ToolInputError("KIND_REQUIRED", 'group and pipelineConfig belong to pipeline collections — pass kind: "pipeline" as well.');
+        }
+        if ((pipelineConfig?.passCriteria?.requiredRequests?.length ?? 0) > 0) {
+            throw new errors_js_1.ToolInputError("CRITICAL_REQUESTS_LATER", "A new collection has no requests yet. Create it, add the requests, then set passCriteria.requiredRequests with update_collection.");
+        }
         const writes = variables ? variableWrites(variables) : undefined;
         const ws = await ctx.resolveWorkspace(workspace);
         const existing = (await (0, lookups_js_1.loadCollections)(ctx, ws.id)).find((collection) => (0, lookups_js_1.sameName)(collection.name, name));
@@ -215,24 +332,39 @@ const registerCollectionTools = (server, ctx) => {
                 existing: { id: existing.id, name: existing.name },
             });
         }
+        const reviewGroup = kind === "pipeline" ? await resolveCollectionGroup(ctx, ws.id, group) : undefined;
         const created = await ctx.api.createCollection(ws.id, {
             name: name.trim(),
             ...(runnerSettings ? { runnerSettings: compactSettings(runnerSettings) } : {}),
             ...(writes && writes.length > 0 ? { variables: writes } : {}),
             ...containerWrite({ docs, scripts }),
+            ...(kind === "pipeline"
+                ? {
+                    kind,
+                    ...(reviewGroup ? { groupId: reviewGroup.id } : {}),
+                    ...(pipelineConfig ? { pipelineConfig: await (0, pipeline_js_1.mergePipelineConfig)(null, pipelineConfig, async () => []) } : {}),
+                }
+                : {}),
         });
         ctx.invalidate(`collections:${ws.id}`);
         const variablesLost = writes !== undefined && writes.length > 0 && !Array.isArray(created.variables);
         return (0, shared_js_1.ok)({
-            collection: { id: created.id, name: created.name, ...(writes && writes.length > 0 && !variablesLost ? { variableKeys: writes.map((variable) => variable.key) } : {}) },
+            collection: {
+                id: created.id,
+                name: created.name,
+                ...(writes && writes.length > 0 && !variablesLost ? { variableKeys: writes.map((variable) => variable.key) } : {}),
+                ...pipelineView(created),
+            },
             workspace: (0, lookups_js_1.workspaceTag)(ws),
-            note: "Created. Add requests with create_request / create_requests_bulk / import_content.",
+            note: created.kind === "pipeline"
+                ? `Created as a pipeline collection (draft). Add requests with create_request / create_requests_bulk / import_content, then submit_collection — CI runs it only once a person approves it.${reviewGroup?.note ? ` ${reviewGroup.note}` : ""}`
+                : "Created. Add requests with create_request / create_requests_bulk / import_content.",
             ...(variablesLost ? { warnings: [`The variables were not saved: ${UNSUPPORTED_VARIABLES_NOTE}`] } : {}),
         });
     }));
     server.registerTool("update_collection", {
         title: "Update a collection (name, runner settings, variables, docs, scripts)",
-        description: "Rename a collection, toggle its runner settings (whether collection runs execute the requests' database steps), replace its collection variables (the whole list — read it with get_collection, change it, send it back), replace its documentation (Markdown — pass expectedDocsVersion from get_collection) and/or set its collection-level scripts.",
+        description: "Rename a collection, toggle its runner settings (whether collection runs execute the requests' database steps), replace its collection variables (the whole list — read it with get_collection, change it, send it back), replace its documentation (Markdown — pass expectedDocsVersion from get_collection) and/or set its collection-level scripts. On-prem: kind: \"pipeline\" (+ group) turns a standard collection into a pipeline collection, and pipelineConfig changes its pass criteria (omitted keys keep their value). A pipeline collection's edits change its draft; CI keeps running the approved version until submit_collection + approval.",
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             collection: (0, shared_js_1.refArg)("Collection"),
@@ -242,26 +374,60 @@ const registerCollectionTools = (server, ctx) => {
             docs: docsArg,
             expectedDocsVersion: expectedDocsVersionArg,
             scripts: scriptsArg,
+            kind: kindArg,
+            group: groupArg,
+            pipelineConfig: pipeline_js_1.pipelineConfigArg,
         },
         annotations: shared_js_1.IDEMPOTENT_WRITE,
-    }, (0, shared_js_1.guarded)(async ({ workspace, collection, name, runnerSettings, variables, docs, expectedDocsVersion, scripts }) => {
-        if (name === undefined && runnerSettings === undefined && variables === undefined && docs === undefined && scripts === undefined) {
-            throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass name, runnerSettings, variables, docs and/or scripts.");
+    }, (0, shared_js_1.guarded)(async ({ workspace, collection, name, runnerSettings, variables, docs, expectedDocsVersion, scripts, kind, group, pipelineConfig }) => {
+        if (name === undefined &&
+            runnerSettings === undefined &&
+            variables === undefined &&
+            docs === undefined &&
+            scripts === undefined &&
+            kind === undefined &&
+            group === undefined &&
+            pipelineConfig === undefined) {
+            throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass name, runnerSettings, variables, docs, scripts, kind, group and/or pipelineConfig.");
         }
         requireDocsVersion(docs, expectedDocsVersion);
         const writes = variables ? variableWrites(variables) : undefined;
         const { ws, value: resolved, note } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
-        const updated = await ctx.api.updateCollection(ws.id, resolved.item.id, {
+        // Kind / group / pass criteria: the stored config is replaced whole, so
+        // the input is laid over the current draft.
+        let pipelineWrite = {};
+        let groupNote;
+        if (kind !== undefined || group !== undefined || pipelineConfig !== undefined) {
+            const current = await ctx.api.getCollection(ws.id, resolved.item.id);
+            const converting = kind === "pipeline" && current.kind !== "pipeline";
+            if (!converting && current.kind !== "pipeline" && (group !== undefined || pipelineConfig !== undefined)) {
+                throw new errors_js_1.ToolInputError("NOT_A_PIPELINE_COLLECTION", 'This is a standard collection — pass kind: "pipeline" to turn it into a pipeline collection (with group and pipelineConfig).');
+            }
+            const reviewGroup = converting || group !== undefined ? await resolveCollectionGroup(ctx, ws.id, group) : undefined;
+            groupNote = reviewGroup?.note;
+            pipelineWrite = {
+                ...(converting ? { kind } : {}),
+                ...(reviewGroup && (converting || group !== undefined) ? { groupId: reviewGroup.id } : {}),
+                ...(pipelineConfig
+                    ? { pipelineConfig: await (0, pipeline_js_1.mergePipelineConfig)(current.pipelineConfig ?? null, pipelineConfig, (refs) => criticalRequestIds(ctx, ws.id, resolved.item.id, refs)) }
+                    : {}),
+            };
+        }
+        const body = {
             ...(name !== undefined ? { name: name.trim() } : {}),
             ...(runnerSettings ? { runnerSettings: compactSettings(runnerSettings) } : {}),
             ...(writes !== undefined ? { variables: writes } : {}),
             ...containerWrite({ docs, expectedDocsVersion, scripts }),
-        });
+            ...pipelineWrite,
+        };
+        if (Object.keys(body).length === 0)
+            throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Nothing changes: it is already a pipeline collection.");
+        const updated = await ctx.api.updateCollection(ws.id, resolved.item.id, body);
         ctx.invalidate(`collections:${ws.id}`);
         // An older server drops the unknown field without an error: say so
         // instead of reporting the variables as saved.
         const variablesLost = writes !== undefined && !Array.isArray(updated.variables);
-        if (variablesLost && name === undefined && runnerSettings === undefined && docs === undefined && scripts === undefined) {
+        if (variablesLost && name === undefined && runnerSettings === undefined && docs === undefined && scripts === undefined && Object.keys(pipelineWrite).length === 0) {
             throw new errors_js_1.ToolInputError("COLLECTION_VARIABLES_UNSUPPORTED", UNSUPPORTED_VARIABLES_NOTE);
         }
         return (0, shared_js_1.ok)({
@@ -277,8 +443,10 @@ const registerCollectionTools = (server, ctx) => {
                     : {}),
                 ...(docs !== undefined ? { docsVersion: updated.docsVersion ?? null } : {}),
                 ...(scripts !== undefined ? { hasScripts: updated.hasScripts ?? null } : {}),
+                ...pipelineView(updated),
             },
             workspace: (0, lookups_js_1.workspaceTag)(ws),
+            ...(updated.kind === "pipeline" ? { pipelineNote: `${PIPELINE_DRAFT_NOTE}${groupNote ? ` ${groupNote}` : ""}` } : {}),
             resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved), ...(note ? [{ input: collection, note }] : [])],
             ...(variablesLost ? { warnings: [`The variables were not saved: ${UNSUPPORTED_VARIABLES_NOTE}`] } : {}),
         });
@@ -361,17 +529,81 @@ const registerCollectionTools = (server, ctx) => {
     }));
     server.registerTool("delete_collection", {
         title: "Delete a collection",
-        description: "Delete a collection with all its folders and requests. Permanent — confirm with the user first.",
+        description: "Delete a collection with all its folders and requests. Permanent — confirm with the user first. An on-prem pipeline collection cannot be deleted directly: use request_collection_deletion (an approver decides).",
         inputSchema: { workspace: shared_js_1.workspaceArg, collection: (0, shared_js_1.refArg)("Collection"), confirm: shared_js_1.confirmArg },
         annotations: shared_js_1.DESTRUCTIVE,
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, confirm }) => {
         (0, shared_js_1.requireConfirm)(confirm, "a collection");
         const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection, { exact: true });
-        await ctx.api.deleteCollection(ws.id, resolved.item.id);
+        try {
+            await ctx.api.deleteCollection(ws.id, resolved.item.id);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.CallmanApiError && error.code === "COLLECTION_DELETE_REQUIRES_REVIEW") {
+                throw new errors_js_1.ToolInputError("COLLECTION_DELETE_REQUIRES_REVIEW", `"${resolved.item.name}" is a pipeline collection: it is deleted through review. Call request_collection_deletion { collection: "${resolved.item.id}", confirm: true } (optionally with a note and approvers); it is deleted once an approver approves the request in the Callman app.`, { collection: { id: resolved.item.id, name: resolved.item.name }, next: "request_collection_deletion" });
+            }
+            throw error;
+        }
         ctx.invalidate(`collections:${ws.id}`);
         ctx.invalidate(`tree:${ws.id}:${resolved.item.id}`);
         return (0, shared_js_1.ok)({ deleted: { id: resolved.item.id, name: resolved.item.name }, workspace: (0, lookups_js_1.workspaceTag)(ws), resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved)] });
     }));
+    server.registerTool("submit_collection", {
+        title: "Submit a pipeline collection for review",
+        description: "On-prem pipeline collections: send the current draft (requests, folders, scripts, pass criteria) for review. CI runs only the approved version, so a new or edited pipeline collection must be approved before callme run / run_collection use the change. Optionally name approvers by email (default: every eligible approver of the collection's group is notified); replace: true swaps your own open submission for the current draft. Approval happens in the Callman app — AI tools cannot approve.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            collection: (0, shared_js_1.refArg)("Collection"),
+            note: reviewNoteArg,
+            approvers: approversArg,
+            replace: zod_1.z.boolean().optional().describe("Replace your own pending submission with the current draft"),
+        },
+        annotations: shared_js_1.WRITE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, collection, note, approvers, replace }) => {
+        const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
+        const assigneeIds = await approverIdsFor(ctx, ws.id, resolved.item.id, "update", approvers);
+        const { summary, request } = await ctx.api.submitCollectionReview(ws.id, resolved.item.id, {
+            ...(note !== undefined ? { note } : {}),
+            ...(assigneeIds ? { assigneeIds } : {}),
+            ...(replace ? { replace: true } : {}),
+        });
+        ctx.invalidate(`collections:${ws.id}`);
+        return (0, shared_js_1.ok)({
+            collection: { id: resolved.item.id, name: resolved.item.name },
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
+            review: reviewSummaryView(summary),
+            request: reviewRequestView(request),
+            note: "Submitted — an approver approves it in the Callman app. Until then CI keeps running the previous approved version (none yet: CI refuses the collection).",
+        });
+    }));
+    server.registerTool("request_collection_deletion", {
+        title: "Request deletion of a pipeline collection",
+        description: "On-prem pipeline collections are not deleted directly (delete_collection refuses them): this sends a deletion request to the group's approvers, and the collection is deleted when one approves it in the Callman app. Confirm with the user first. Optionally a note and approver emails.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            collection: (0, shared_js_1.refArg)("Collection"),
+            note: reviewNoteArg,
+            approvers: approversArg,
+            confirm: shared_js_1.confirmArg,
+        },
+        annotations: { ...shared_js_1.WRITE, destructiveHint: true },
+    }, (0, shared_js_1.guarded)(async ({ workspace, collection, note, approvers, confirm }) => {
+        (0, shared_js_1.requireConfirm)(confirm, "a pipeline collection (once approved)");
+        const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection, { exact: true });
+        const assigneeIds = await approverIdsFor(ctx, ws.id, resolved.item.id, "delete", approvers);
+        const { summary, request } = await ctx.api.requestCollectionDeletion(ws.id, resolved.item.id, {
+            ...(note !== undefined ? { note } : {}),
+            ...(assigneeIds ? { assigneeIds } : {}),
+        });
+        ctx.invalidate(`collections:${ws.id}`);
+        return (0, shared_js_1.ok)({
+            collection: { id: resolved.item.id, name: resolved.item.name },
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
+            review: reviewSummaryView(summary),
+            request: reviewRequestView(request),
+            note: "Deletion requested — the collection is deleted when an approver approves the request in the Callman app. CI keeps running it until then.",
+        });
+    }));
     server.registerTool("delete_folder", {
         title: "Delete a folder",
         description: "Delete a folder and everything inside it (subfolders and requests). Permanent — confirm with the user first.",

package/dist-cjs/tools/run.js

@@ -37,6 +37,7 @@ 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 pipeline_js_1 = require("../domain/pipeline.js");
 const resolve_js_1 = require("../domain/resolve.js");
 const redact_js_1 = require("../lib/redact.js");
 const truncate_js_1 = require("../lib/truncate.js");
@@ -103,6 +104,7 @@ const prepareRun = async (ctx, ws, collectionId, environmentRef) => {
         environment: bundle.environment ? { id: bundle.environment.id, name: bundle.environment.name } : null,
         warnings,
         redaction,
+        pipeline: bundle.pipeline ?? null,
     };
 };
 exports.prepareRun = prepareRun;
@@ -184,7 +186,7 @@ const registerRunTools = (server, ctx) => {
     }));
     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 and the collection's variables, sharing variables between requests like the collection runner. Requests switched off for the runner are skipped unless named in \`only\`; data-driven contracts run once per row. Returns per-request results (as in run_request, values shown as {{key}}, with \`failure\` / \`diagnosis\` where something broke), a pass/fail summary and the variable names scripts changed. \`bail\` stops at the first failure. ${LOCAL_RUN_LIMITS} Needs requests:run.`,
+        description: `Run a collection (or one folder of it, or specific requests) sequentially from this machine with an environment and the collection's variables, sharing variables between requests like the collection runner. Requests switched off for the runner are skipped unless named in \`only\`; data-driven contracts run once per row. Returns per-request results (as in run_request, values shown as {{key}}, with \`failure\` / \`diagnosis\` where something broke), a pass/fail summary, the variable names scripts changed and the \`verdict\` — the pass criteria callme run applies in CI: every executed request must pass, or \`passThreshold\` percent of them, and every \`criticalRequests\` entry. An on-prem pipeline collection runs its APPROVED version (not the draft) with its approved criteria (the inputs are then ignored, \`version\` says which version ran) and may refuse folder / partial runs. \`bail\` stops at the first failure (not with passThreshold). ${LOCAL_RUN_LIMITS} Needs requests:run.`,
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             collection: (0, shared_js_1.refArg)("Collection"),
@@ -192,12 +194,25 @@ const registerRunTools = (server, ctx) => {
             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(),
+            passThreshold: zod_1.z.number().int().min(1).max(100).optional().describe("The run passes when at least this percent of the executed requests passed (default: all must). Ignored for pipeline collections"),
+            criticalRequests: zod_1.z.array(zod_1.z.string().min(1).max(500)).max(200).optional().describe("Requests (ids or names) that must pass whatever the percentage. Ignored for pipeline collections"),
             maxBodyBytes: maxBodyArg,
         },
         annotations: shared_js_1.RUN,
-    }, (0, shared_js_1.guarded)(async ({ workspace, collection, folder, only, environment, bail, maxBodyBytes }) => {
+    }, (0, shared_js_1.guarded)(async ({ workspace, collection, folder, only, environment, bail, passThreshold, criticalRequests, maxBodyBytes }) => {
         const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
         const prepared = await (0, exports.prepareRun)(ctx, ws.id, resolved.item.id, environment);
+        // What decides the verdict: a pipeline collection's approved config,
+        // else the inputs. Critical requests are looked up in what runs.
+        const isPipeline = prepared.pipeline?.kind === "pipeline";
+        const criticalRequestIds = !isPipeline && criticalRequests && criticalRequests.length > 0
+            ? [...new Set(criticalRequests.map((ref) => (0, resolve_js_1.resolveRef)("request", ref, prepared.collection.requests, { aliases: (request) => [`${request.method} ${request.url}`] }).item.id))]
+            : [];
+        const runCriteria = (0, pipeline_js_1.resolveRunCriteria)(prepared.pipeline, {
+            passThreshold,
+            criticalRequestIds: isPipeline ? (criticalRequests ?? []) : criticalRequestIds,
+            bail,
+        });
         let selection = null;
         if (folder) {
             const target = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, resolved.item.id, folder);
@@ -213,6 +228,9 @@ const registerRunTools = (server, ctx) => {
         }
         if (selection && selection.length === 0)
             throw new errors_js_1.ToolInputError("NOTHING_TO_RUN", "The selection contains no requests.");
+        if (selection && !runCriteria.allowFolderRuns) {
+            throw new errors_js_1.ToolInputError("PIPELINE_FOLDER_RUN_NOT_ALLOWED", `This pipeline collection's approved config${runCriteria.version ? ` v${runCriteria.version.number}` : ""} runs the whole collection only: drop folder / only (run_request runs a single request), or allow folder runs in its pipelineConfig and get the change approved.`);
+        }
         const outcome = await ctx.withRunLock(() => (0, executeCollection_js_1.executeCollection)({
             collection: prepared.collection,
             env: prepared.env,
@@ -220,13 +238,24 @@ const registerRunTools = (server, ctx) => {
             connections: prepared.connections,
             only: selection,
             includeDisabled: Boolean(only && only.length > 0),
-            bail: bail ?? false,
+            bail: runCriteria.bail,
             deadlineMs: ctx.config.runTimeoutMs,
         }));
+        const verdict = (0, pipeline_js_1.evaluateRunVerdict)({
+            results: outcome.results,
+            criteria: runCriteria.criteria,
+            collectionName: prepared.collection.name,
+            version: runCriteria.version?.number ?? null,
+            requests: prepared.collection.requests,
+            selection,
+        });
         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 },
+            collection: { id: resolved.item.id, name: resolved.item.name, kind: runCriteria.kind },
+            ...(runCriteria.version ? { version: runCriteria.version } : {}),
             workspace: (0, lookups_js_1.workspaceTag)(ws),
             environment: prepared.environment,
+            verdict,
+            ...(runCriteria.notes.length > 0 ? { notes: runCriteria.notes } : {}),
             warnings: prepared.warnings,
             resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved)],
         }, prepared.redaction));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "callman-mcp",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "MCP server for Callman: lets Claude Code, Claude Desktop, Cursor, Codex and Gemini CLI manage collections, requests, environments, test scenarios, UI tests (web, Android, iOS) and system-design diagrams in your Callman workspace — cloud or on-prem.",
   "keywords": [
     "callman",
@@ -62,7 +62,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "callman-core": "^1.42.0",
+    "callman-core": "^1.43.0",
     "elkjs": "^0.12.0",
     "js-yaml": "^4.1.0",
     "zod": "^3.25.0"