callman-mcp 0.1.0

package/dist-cjs/domain/requestShape.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestSummaryView = exports.compactRequestView = exports.toUpdateRequestPayload = exports.updateRequestInputSchema = exports.toFlatImportRequest = exports.toCreateRequestPayload = exports.toBodyPayload = exports.toAuthPayload = exports.toRows = exports.requestInputSchema = exports.authInputSchema = exports.bodyInputSchema = exports.kvSchema = exports.HTTP_METHODS = void 0;
+const callman_core_1 = require("callman-core");
+const zod_1 = require("zod");
+const mask_js_1 = require("../lib/mask.js");
+const truncate_js_1 = require("../lib/truncate.js");
+// The COMPACT request form a model writes (name/method/url, key-value lists,
+// a body that may be a JSON value, a string or a mode object, a small auth
+// object) and its translation into the backend's `POST /requests` payload —
+// the same document the desktop editor saves, produced by the same core
+// serialisation (`toPersistedRequestBody`) so an imported request opens in
+// the editor exactly like a hand-made one.
+exports.HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "TRACE"];
+exports.kvSchema = zod_1.z.object({
+    key: zod_1.z.string().max(100),
+    value: zod_1.z.string().max(5000).default(""),
+    enabled: zod_1.z.boolean().optional(),
+    description: zod_1.z.string().max(500).optional(),
+});
+exports.bodyInputSchema = zod_1.z.union([
+    zod_1.z.object({
+        mode: zod_1.z.literal("raw"),
+        raw: zod_1.z.string().max(2_000_000),
+        language: zod_1.z.enum(["json", "xml", "text", "html"]).optional(),
+    }),
+    zod_1.z.object({
+        mode: zod_1.z.enum(["formdata", "urlencoded"]),
+        entries: zod_1.z.array(exports.kvSchema).max(200),
+    }),
+    zod_1.z.object({ mode: zod_1.z.literal("none") }),
+    zod_1.z.unknown(),
+]);
+exports.authInputSchema = zod_1.z.discriminatedUnion("type", [
+    zod_1.z.object({ type: zod_1.z.literal("none") }),
+    zod_1.z.object({ type: zod_1.z.literal("bearer"), token: zod_1.z.string().max(10_000) }),
+    zod_1.z.object({ type: zod_1.z.literal("basic"), username: zod_1.z.string().max(5000), password: zod_1.z.string().max(5000).default("") }),
+    zod_1.z.object({
+        type: zod_1.z.literal("apiKey"),
+        key: zod_1.z.string().max(5000),
+        value: zod_1.z.string().max(10_000),
+        location: zod_1.z.enum(["header", "query"]).default("header"),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("oauth2"),
+        grantType: zod_1.z.enum(["client_credentials", "password", "refresh_token"]).default("client_credentials"),
+        tokenUrl: zod_1.z.string().max(4096),
+        clientId: zod_1.z.string().max(5000).default(""),
+        clientSecret: zod_1.z.string().max(10_000).default(""),
+        scope: zod_1.z.string().max(5000).default(""),
+        username: zod_1.z.string().max(5000).default(""),
+        password: zod_1.z.string().max(5000).default(""),
+        refreshToken: zod_1.z.string().max(10_000).default(""),
+        clientAuth: zod_1.z.enum(["basic", "body"]).default("body"),
+        audience: zod_1.z.string().max(4096).default(""),
+    }),
+]);
+exports.requestInputSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).max(truncate_js_1.LIMITS.NAME).describe("Display name, e.g. \"GET /users\" or \"Login\""),
+    method: zod_1.z.enum(exports.HTTP_METHODS),
+    url: zod_1.z
+        .string()
+        .min(1)
+        .max(4096)
+        .describe("Full URL; use {{variable}} for hosts/tokens (e.g. {{baseUrl}}/users/:id) and :name for path variables"),
+    headers: zod_1.z.array(exports.kvSchema).max(200).optional(),
+    query: zod_1.z.array(exports.kvSchema).max(200).optional(),
+    pathVariables: zod_1.z.array(exports.kvSchema).max(200).optional().describe("Values for :name segments in the URL"),
+    body: exports.bodyInputSchema
+        .optional()
+        .describe("A JSON value (stored as JSON), a string (JSON is parsed, otherwise raw text/xml/html by sniffing), or { mode: \"raw\" | \"formdata\" | \"urlencoded\" | \"none\", … }"),
+    auth: exports.authInputSchema.optional(),
+    preRequestScript: zod_1.z.string().max(100_000).optional(),
+    postResponseScript: zod_1.z.string().max(100_000).optional().describe("pm.* script run after the response (tests, pm.environment.set …)"),
+    testsScript: zod_1.z.string().max(100_000).optional(),
+    folder: zod_1.z.string().max(200).optional().describe("Folder id, name or path (\"Auth/Login\") inside the collection"),
+    folderKey: zod_1.z.string().max(120).optional().describe("Bulk create only: key of a folder declared in `folders`"),
+    isEnabledInRunner: zod_1.z.boolean().optional(),
+});
+const toRows = (entries) => (entries ?? [])
+    .filter((entry) => entry.key.trim().length > 0)
+    .map((entry) => ({ key: entry.key.trim(), value: entry.value ?? "", enabled: entry.enabled ?? true }))
+    .slice(0, 200);
+exports.toRows = toRows;
+const EMPTY_AUTH = {
+    type: "none",
+    bearerToken: "",
+    basicUsername: "",
+    basicPassword: "",
+    apiKeyKey: "",
+    apiKeyValue: "",
+    apiKeyLocation: "header",
+};
+const toAuthPayload = (auth) => {
+    if (!auth)
+        return { ...EMPTY_AUTH };
+    switch (auth.type) {
+        case "bearer":
+            return { ...EMPTY_AUTH, type: "bearer", bearerToken: auth.token };
+        case "basic":
+            return { ...EMPTY_AUTH, type: "basic", basicUsername: auth.username, basicPassword: auth.password };
+        case "apiKey":
+            return { ...EMPTY_AUTH, type: "apikey", apiKeyKey: auth.key, apiKeyValue: auth.value, apiKeyLocation: auth.location };
+        case "oauth2": {
+            const { type: _type, ...oauth2 } = auth;
+            return { ...EMPTY_AUTH, type: "oauth2", oauth2 };
+        }
+        default:
+            return { ...EMPTY_AUTH };
+    }
+};
+exports.toAuthPayload = toAuthPayload;
+const isModeObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.mode === "string";
+// Persisted body — the exact rules of the desktop editor's serializeBodyState
+// (guarded in the desktop by persistedBody.drift.test.ts): JSON stays a bare
+// JSON value; raw xml/text/html persists as { mode, raw, rawLanguage };
+// form bodies keep their entries; empty → null.
+const toBodyPayload = (body, headers) => {
+    if (body === undefined || body === null)
+        return null;
+    if (typeof body === "string") {
+        return (0, callman_core_1.toPersistedRequestBody)((0, callman_core_1.inferBodyStateFromRaw)(body, headers));
+    }
+    if (isModeObject(body)) {
+        const record = body;
+        if (record.mode === "none")
+            return null;
+        if (record.mode === "raw") {
+            const raw = typeof record.raw === "string" ? record.raw : "";
+            const language = record.language;
+            if (language) {
+                return (0, callman_core_1.toPersistedRequestBody)({ mode: "raw", raw, rawLanguage: language, formEntries: [] });
+            }
+            return (0, callman_core_1.toPersistedRequestBody)((0, callman_core_1.inferBodyStateFromRaw)(raw, headers));
+        }
+        if (record.mode === "formdata" || record.mode === "urlencoded") {
+            const entries = Array.isArray(record.entries) ? record.entries : [];
+            return (0, callman_core_1.toPersistedRequestBody)({ mode: record.mode, raw: "", formEntries: (0, exports.toRows)(entries) });
+        }
+    }
+    // Any other JSON value is stored as-is (the editor shows it on the JSON tab).
+    return body;
+};
+exports.toBodyPayload = toBodyPayload;
+const toCreateRequestPayload = (item, target) => {
+    const headers = (0, exports.toRows)(item.headers);
+    return {
+        name: item.name.trim().slice(0, truncate_js_1.LIMITS.NAME),
+        method: item.method,
+        url: item.url.trim(),
+        headers,
+        query: (0, exports.toRows)(item.query),
+        pathVariables: (item.pathVariables ?? [])
+            .filter((entry) => entry.key.trim())
+            .map((entry) => ({ key: entry.key.trim(), value: entry.value ?? "", description: entry.description ?? "" })),
+        body: (0, exports.toBodyPayload)(item.body, headers),
+        auth: (0, exports.toAuthPayload)(item.auth),
+        preRequestScript: item.preRequestScript ?? "",
+        postResponseScript: item.postResponseScript ?? "",
+        testsScript: item.testsScript ?? "",
+        collectionId: target.collectionId,
+        folderId: target.folderId,
+    };
+};
+exports.toCreateRequestPayload = toCreateRequestPayload;
+// `format: "requests"` bulk import row — same document minus the ids the
+// server assigns, plus the payload-local folderKey.
+const toFlatImportRequest = (item) => {
+    const { collectionId: _c, folderId: _f, ...payload } = (0, exports.toCreateRequestPayload)(item, { collectionId: "", folderId: null });
+    return { ...payload, ...(item.folderKey ? { folderKey: item.folderKey } : {}) };
+};
+exports.toFlatImportRequest = toFlatImportRequest;
+exports.updateRequestInputSchema = exports.requestInputSchema
+    .partial()
+    .omit({ folderKey: true })
+    .extend({ collection: zod_1.z.string().max(200).optional() });
+const toUpdateRequestPayload = (item, target) => {
+    const out = {};
+    if (item.name !== undefined)
+        out.name = item.name.trim().slice(0, truncate_js_1.LIMITS.NAME);
+    if (item.method !== undefined)
+        out.method = item.method;
+    if (item.url !== undefined)
+        out.url = item.url.trim();
+    if (item.headers !== undefined)
+        out.headers = (0, exports.toRows)(item.headers);
+    if (item.query !== undefined)
+        out.query = (0, exports.toRows)(item.query);
+    if (item.pathVariables !== undefined) {
+        out.pathVariables = item.pathVariables
+            .filter((entry) => entry.key.trim())
+            .map((entry) => ({ key: entry.key.trim(), value: entry.value ?? "", description: entry.description ?? "" }));
+    }
+    if (item.body !== undefined)
+        out.body = (0, exports.toBodyPayload)(item.body, (0, exports.toRows)(item.headers));
+    if (item.auth !== undefined)
+        out.auth = (0, exports.toAuthPayload)(item.auth);
+    if (item.preRequestScript !== undefined)
+        out.preRequestScript = item.preRequestScript;
+    if (item.postResponseScript !== undefined)
+        out.postResponseScript = item.postResponseScript;
+    if (item.testsScript !== undefined)
+        out.testsScript = item.testsScript;
+    if (item.isEnabledInRunner !== undefined)
+        out.isEnabledInRunner = item.isEnabledInRunner;
+    if (target.collectionId !== undefined)
+        out.collectionId = target.collectionId;
+    if (target.folderId !== undefined)
+        out.folderId = target.folderId;
+    return out;
+};
+exports.toUpdateRequestPayload = toUpdateRequestPayload;
+// ── outbound views ─────────────────────────────────────────────────────
+const kvView = (rows, maskHeaders) => (rows ?? []).map((row) => ({
+    key: row.key,
+    value: maskHeaders ? (0, mask_js_1.maskHeaderValue)(row.key, row.value) : row.value,
+    ...(row.enabled === false ? { enabled: false } : {}),
+}));
+const compactRequestView = (request, options = {}) => {
+    const bodyText = request.body == null ? null : (0, truncate_js_1.safeStringify)(request.body);
+    const bodyTruncated = bodyText !== null && !options.full && bodyText.length > truncate_js_1.LIMITS.BODY_PREVIEW;
+    return {
+        id: request.id,
+        name: request.name,
+        method: request.method,
+        url: options.full ? request.url : (0, truncate_js_1.clip)(request.url, 2048),
+        collectionId: request.collectionId,
+        folderId: request.folderId,
+        headers: kvView(request.headers, !options.reveal),
+        query: kvView(request.query, false),
+        ...(request.pathVariables && request.pathVariables.length > 0
+            ? { pathVariables: request.pathVariables.map((entry) => ({ key: entry.key, value: entry.value ?? "" })) }
+            : {}),
+        body: options.full ? request.body : (0, truncate_js_1.jsonPreview)(request.body),
+        ...(bodyTruncated ? { bodyTruncated: true } : {}),
+        auth: options.reveal ? (request.auth ?? { type: "none" }) : (0, mask_js_1.maskAuth)(request.auth),
+        scripts: {
+            preRequest: scriptView(request.preRequestScript, options.full),
+            postResponse: scriptView(request.postResponseScript, options.full),
+            tests: scriptView(request.testsScript, options.full),
+        },
+        isEnabledInRunner: request.isEnabledInRunner !== false,
+        updatedAt: request.updatedAt ?? null,
+    };
+};
+exports.compactRequestView = compactRequestView;
+const scriptView = (script, full) => {
+    if (!script)
+        return null;
+    return full ? script : (0, truncate_js_1.clip)(script, truncate_js_1.LIMITS.BODY_PREVIEW);
+};
+const requestSummaryView = (request) => ({
+    id: request.id,
+    name: request.name,
+    method: request.method,
+    url: (0, truncate_js_1.clip)(request.url, truncate_js_1.LIMITS.URL),
+    folderId: request.folderId,
+    ...(request.collectionId ? { collectionId: request.collectionId } : {}),
+});
+exports.requestSummaryView = requestSummaryView;

package/dist-cjs/domain/resolve.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFolderRef = exports.flattenFolderTree = exports.resolvedSummary = exports.resolveRefs = exports.resolveRef = void 0;
+const errors_js_1 = require("../client/errors.js");
+const ids_js_1 = require("../lib/ids.js");
+const candidatesOf = (items, options) => items.slice(0, 12).map((item) => ({ id: item.id, name: item.name, ...(options?.describe?.(item) ?? {}) }));
+const resolveRef = (kind, ref, items, options) => {
+    const reference = (ref ?? "").trim();
+    if (!reference) {
+        throw new errors_js_1.ToolInputError("REF_REQUIRED", `A ${kind} reference (id or name) is required.`, {
+            kind,
+            candidates: candidatesOf(items, options),
+        });
+    }
+    const byId = items.find((item) => item.id === reference);
+    if (byId)
+        return { item: byId, matched: "id" };
+    const needle = (0, ids_js_1.normalizeName)(reference);
+    const names = (item) => [item.name, ...(options?.aliases?.(item) ?? [])].map(ids_js_1.normalizeName);
+    const exact = items.filter((item) => names(item).some((name) => name === needle));
+    if (exact.length === 1) {
+        return { item: exact[0], matched: "name", annotation: `matched "${reference}" → ${exact[0].name}` };
+    }
+    if (exact.length > 1) {
+        throw new errors_js_1.ToolInputError("REF_AMBIGUOUS", `${exact.length} ${kind}s are named "${reference}" — use the id.`, { kind, ref: reference, candidates: candidatesOf(exact, options) });
+    }
+    const partial = items.filter((item) => names(item).some((name) => name.includes(needle)));
+    if (partial.length === 1) {
+        return { item: partial[0], matched: "partial", annotation: `matched "${reference}" → ${partial[0].name}` };
+    }
+    throw new errors_js_1.ToolInputError(partial.length > 1 ? "REF_AMBIGUOUS" : "REF_NOT_FOUND", partial.length > 1
+        ? `Several ${kind}s match "${reference}" — pick one by id.`
+        : `No ${kind} matches "${reference}".`, { kind, ref: reference, candidates: candidatesOf(partial.length > 0 ? partial : items, options) });
+};
+exports.resolveRef = resolveRef;
+const resolveRefs = (kind, refs, items, options) => refs.map((ref) => (0, exports.resolveRef)(kind, ref, items, options));
+exports.resolveRefs = resolveRefs;
+// A resolution summary for tool output (`resolved: [{ input, matched, id }]`).
+const resolvedSummary = (input, resolved) => ({
+    input,
+    matched: resolved.item.name,
+    id: resolved.item.id,
+    ...(resolved.annotation ? { note: resolved.annotation } : {}),
+});
+exports.resolvedSummary = resolvedSummary;
+const flattenFolderTree = (tree) => {
+    const out = [];
+    const walk = (nodes, prefix, depth) => {
+        for (const node of nodes) {
+            const path = prefix ? `${prefix}/${node.name}` : node.name;
+            out.push({ id: node.id, name: node.name, parentId: node.parentId, path, depth });
+            walk(node.children ?? [], path, depth + 1);
+        }
+    };
+    walk(tree, "", 0);
+    return out;
+};
+exports.flattenFolderTree = flattenFolderTree;
+const resolveFolderRef = (ref, folders) => (0, exports.resolveRef)("folder", ref, folders, {
+    describe: (folder) => ({ path: folder.path }),
+    aliases: (folder) => [folder.path],
+});
+exports.resolveFolderRef = resolveFolderRef;

package/dist-cjs/domain/scenario/build.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScenarioCreateBody = exports.buildScenarioGraph = exports.deepMerge = exports.scenarioInputSchema = exports.scenarioEnvironmentInputSchema = exports.scenarioEdgeInputSchema = exports.scenarioNodeInputSchema = exports.SCENARIO_NODE_TYPES = void 0;
+const callman_core_1 = require("callman-core");
+const zod_1 = require("zod");
+const errors_js_1 = require("../../client/errors.js");
+const ids_js_1 = require("../../lib/ids.js");
+const requestShape_js_1 = require("../requestShape.js");
+// From the COMPACT scenario a model writes to the backend's `POST /scenarios`
+// body. Node configs are deep-merged over core's canonical defaults for the
+// node type (the same defaults the builder and the AI assistant use), so a
+// partial config (`{ url, method }`) becomes a complete, runnable node; ids
+// are short and stable; missing positions are laid out in layers so the
+// graph opens tidy in the builder. The backend's zod schema stays the
+// arbiter of node config validity.
+exports.SCENARIO_NODE_TYPES = [...callman_core_1.SCENARIO_AI_REFERENCE_TYPES, "subscenario"];
+exports.scenarioNodeInputSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1).max(64).optional(),
+    type: zod_1.z.string().min(1).max(40).describe(`Node type: ${exports.SCENARIO_NODE_TYPES.join(", ")} (see callman://docs/scenario-nodes)`),
+    label: zod_1.z.string().max(200).optional(),
+    config: zod_1.z.record(zod_1.z.unknown()).optional().describe("Type-specific config; merged over the node type's defaults"),
+    position: zod_1.z.object({ x: zod_1.z.number(), y: zod_1.z.number() }).optional(),
+});
+exports.scenarioEdgeInputSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1).max(64).optional(),
+    source: zod_1.z.string().min(1).max(64),
+    target: zod_1.z.string().min(1).max(64),
+    type: zod_1.z.enum(["default", "yes", "no", "error"]).optional().describe("yes/no for condition branches, error for failure paths"),
+});
+exports.scenarioEnvironmentInputSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1).max(64).optional(),
+    name: zod_1.z.string().min(1).max(200),
+    variables: zod_1.z.array(requestShape_js_1.kvSchema).max(500).default([]),
+});
+exports.scenarioInputSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).max(200),
+    description: zod_1.z.string().max(5000).optional(),
+    priority: zod_1.z.enum(["critical", "high", "medium", "low"]).optional(),
+    nodes: zod_1.z.array(exports.scenarioNodeInputSchema).min(1).max(1000),
+    edges: zod_1.z.array(exports.scenarioEdgeInputSchema).max(2000).default([]),
+    environments: zod_1.z.array(exports.scenarioEnvironmentInputSchema).max(20).optional(),
+});
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+// Objects merge key by key; arrays and scalars from the override win whole.
+const deepMerge = (base, override) => {
+    if (!isRecord(base) || !isRecord(override))
+        return override === undefined ? base : override;
+    const out = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        out[key] = key in base ? (0, exports.deepMerge)(base[key], value) : value;
+    }
+    return out;
+};
+exports.deepMerge = deepMerge;
+const buildScenarioGraph = (nodesInput, edgesInput) => {
+    const nextNodeId = (0, ids_js_1.sequentialIds)("n", nodesInput.map((node) => node.id).filter((id) => Boolean(id)));
+    const nextEdgeId = (0, ids_js_1.sequentialIds)("e", edgesInput.map((edge) => edge.id).filter((id) => Boolean(id)));
+    const ids = nodesInput.map((node) => node.id ?? nextNodeId());
+    const duplicate = ids.find((id, index) => ids.indexOf(id) !== index);
+    if (duplicate)
+        throw new errors_js_1.ToolInputError("SCENARIO_DUPLICATE_NODE_ID", `Duplicate node id "${duplicate}".`);
+    const idSet = new Set(ids);
+    const nodes = nodesInput.map((node, index) => {
+        const type = node.type.trim();
+        if (!exports.SCENARIO_NODE_TYPES.includes(type)) {
+            throw new errors_js_1.ToolInputError("SCENARIO_UNKNOWN_NODE_TYPE", `Unknown scenario node type "${type}". Known: ${exports.SCENARIO_NODE_TYPES.join(", ")}.`);
+        }
+        const defaults = (0, callman_core_1.defaultScenarioNodeConfig)(type);
+        const config = (0, exports.deepMerge)(defaults ?? {}, node.config ?? {});
+        return {
+            id: ids[index],
+            type,
+            position: node.position ?? { x: 0, y: 0 },
+            data: { ...(node.label ? { label: node.label } : {}), config },
+            _positioned: Boolean(node.position),
+        };
+    });
+    const edges = edgesInput.map((edge) => {
+        for (const endpoint of [edge.source, edge.target]) {
+            if (!idSet.has(endpoint))
+                throw new errors_js_1.ToolInputError("SCENARIO_EDGE_ENDPOINT_NOT_FOUND", `Edge references "${endpoint}" which is not a node id.`);
+        }
+        return { id: edge.id ?? nextEdgeId(), source: edge.source, target: edge.target, ...(edge.type ? { type: edge.type } : {}) };
+    });
+    // Layered positions for the nodes that have none: BFS from the sources.
+    const incoming = new Map(ids.map((id) => [id, 0]));
+    const outgoing = new Map(ids.map((id) => [id, []]));
+    for (const edge of edges) {
+        incoming.set(edge.target, (incoming.get(edge.target) ?? 0) + 1);
+        outgoing.get(edge.source)?.push(edge.target);
+    }
+    const level = new Map();
+    const queue = ids.filter((id) => (incoming.get(id) ?? 0) === 0);
+    for (const id of queue)
+        level.set(id, 0);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const next of outgoing.get(current) ?? []) {
+            if (!level.has(next)) {
+                level.set(next, (level.get(current) ?? 0) + 1);
+                queue.push(next);
+            }
+        }
+    }
+    const rowCounter = new Map();
+    const positioned = nodes.map((node) => {
+        if (node._positioned)
+            return node;
+        const layer = level.get(node.id) ?? 0;
+        const row = rowCounter.get(layer) ?? 0;
+        rowCounter.set(layer, row + 1);
+        return { ...node, position: { x: 80 + layer * 320, y: 80 + row * 170 } };
+    });
+    return {
+        nodes: positioned.map(({ _positioned, ...node }) => node),
+        edges,
+    };
+};
+exports.buildScenarioGraph = buildScenarioGraph;
+const buildScenarioCreateBody = (input, folderId) => {
+    const graph = (0, exports.buildScenarioGraph)(input.nodes, input.edges);
+    const nextEnvId = (0, ids_js_1.sequentialIds)("env");
+    return {
+        name: input.name.trim(),
+        ...(input.description ? { description: input.description } : {}),
+        ...(input.priority ? { priority: input.priority } : {}),
+        folderId,
+        nodes: graph.nodes,
+        edges: graph.edges,
+        environments: (input.environments ?? []).map((environment) => {
+            const nextVarId = (0, ids_js_1.sequentialIds)("v");
+            return {
+                id: environment.id ?? nextEnvId(),
+                name: environment.name,
+                variables: (0, requestShape_js_1.toRows)(environment.variables).map((row) => ({ id: nextVarId(), key: row.key, value: row.value, enabled: row.enabled ?? true })),
+            };
+        }),
+    };
+};
+exports.buildScenarioCreateBody = buildScenarioCreateBody;

package/dist-cjs/domain/scenario/summarize.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactReportView = exports.scenarioFullView = exports.scenarioGraphView = exports.scenarioSummaryView = void 0;
+const mask_js_1 = require("../../lib/mask.js");
+const truncate_js_1 = require("../../lib/truncate.js");
+const scenarioSummaryView = (scenario, folderName) => ({
+    id: scenario.id,
+    name: scenario.name,
+    description: scenario.description ? (0, truncate_js_1.clip)(scenario.description, 300) : null,
+    priority: scenario.priority,
+    folderId: scenario.folderId,
+    ...(folderName !== undefined ? { folder: folderName } : {}),
+    reviewStatus: scenario.reviewStatus,
+    version: scenario.version,
+    nodeCount: scenario.nodes.length,
+    edgeCount: scenario.edges.length,
+    environments: (scenario.environments ?? []).map((environment) => ({ id: environment.id, name: environment.name })),
+    ...(scenario.groupName ? { group: scenario.groupName } : {}),
+    ...(scenario.permissions ? { permissions: scenario.permissions } : {}),
+    updatedAt: scenario.updatedAt ?? null,
+});
+exports.scenarioSummaryView = scenarioSummaryView;
+const scenarioGraphView = (scenario) => ({
+    ...(0, exports.scenarioSummaryView)(scenario),
+    nodes: scenario.nodes.map((node) => ({
+        id: node.id,
+        type: node.type,
+        label: node.data?.label ?? null,
+        ...nodeHint(node.type, node.data?.config ?? {}),
+    })),
+    edges: scenario.edges.map((edge) => ({ id: edge.id, source: edge.source, target: edge.target, ...(edge.type && edge.type !== "default" ? { type: edge.type } : {}) })),
+    startNodeIds: scenario.graph?.startNodeIds ?? [],
+    warnings: scenario.graph?.warnings ?? [],
+});
+exports.scenarioGraphView = scenarioGraphView;
+const nodeHint = (type, config) => {
+    switch (type) {
+        case "request":
+            return { method: config.method ?? null, url: typeof config.url === "string" ? (0, truncate_js_1.clip)(config.url, truncate_js_1.LIMITS.URL) : null };
+        case "db":
+            return { query: typeof config.query === "string" ? (0, truncate_js_1.clip)(config.query, 120) : null };
+        case "wait":
+            return { durationMs: config.durationMs ?? null };
+        case "subscenario":
+            return { scenarioId: config.scenarioId ?? null };
+        default:
+            return {};
+    }
+};
+const maskConfig = (config, reveal) => {
+    if (reveal)
+        return config;
+    const out = { ...config };
+    if (out.auth && typeof out.auth === "object")
+        out.auth = (0, mask_js_1.maskAuth)(out.auth);
+    for (const key of ["password", "clientSecret", "token", "apiKey", "secret"]) {
+        if (typeof out[key] === "string" && out[key])
+            out[key] = (0, mask_js_1.maskSecret)(out[key]);
+    }
+    return out;
+};
+const scenarioFullView = (scenario, options = {}) => {
+    const nodes = scenario.nodes.map((node) => {
+        const config = maskConfig(node.data?.config ?? {}, options.reveal ?? false);
+        const text = (0, truncate_js_1.safeStringify)(config);
+        return {
+            id: node.id,
+            type: node.type,
+            label: node.data?.label ?? null,
+            position: node.position,
+            config: text.length > truncate_js_1.LIMITS.BODY_PREVIEW ? { _truncated: true, preview: (0, truncate_js_1.clip)(text, truncate_js_1.LIMITS.BODY_PREVIEW) } : config,
+        };
+    });
+    const view = {
+        ...(0, exports.scenarioSummaryView)(scenario),
+        nodes,
+        edges: scenario.edges,
+        environments: (scenario.environments ?? []).map((environment) => ({
+            id: environment.id,
+            name: environment.name,
+            variables: environment.variables.map((variable) => ({
+                key: variable.key,
+                value: variable.valueMasked || options.reveal ? variable.value : (0, mask_js_1.maskSecret)(variable.value),
+                enabled: variable.enabled,
+            })),
+        })),
+        dataset: scenario.dataset ?? null,
+    };
+    const bytes = (0, truncate_js_1.byteLength)(view);
+    if (bytes > truncate_js_1.LIMITS.SCENARIO_FULL) {
+        return { ...(0, exports.scenarioGraphView)(scenario), truncated: true, bytes, note: `Full view is ${bytes} bytes (limit ${truncate_js_1.LIMITS.SCENARIO_FULL}); graph view returned instead.` };
+    }
+    return view;
+};
+exports.scenarioFullView = scenarioFullView;
+// ── reports ───────────────────────────────────────────────────────────
+const testCounts = (results) => {
+    const passed = (results ?? []).filter((result) => result.status === "PASS").length;
+    const total = (results ?? []).length;
+    return { passed, failed: total - passed };
+};
+const nodeRow = (node) => ({
+    nodeId: node.nodeId,
+    label: node.label,
+    type: node.type,
+    status: node.status,
+    durationMs: node.durationMs,
+    ...(node.statusCode !== undefined && node.statusCode !== null ? { statusCode: node.statusCode } : {}),
+    ...(node.retryCount ? { retries: node.retryCount } : {}),
+    ...(node.error?.message ? { error: (0, truncate_js_1.clip)(node.error.message, 500) } : {}),
+    tests: testCounts(node.scriptResults),
+    contracts: testCounts(node.contractResults),
+    ...(node.conditionResult !== undefined && node.conditionResult !== null ? { conditionResult: node.conditionResult } : {}),
+});
+const FAILED_STATUSES = new Set(["failed", "error", "timeout"]);
+const compactReportView = (report) => {
+    const nodes = report.nodeResults ?? [];
+    const failed = nodes.find((node) => FAILED_STATUSES.has(String(node.status)));
+    return {
+        reportId: report.id,
+        scenarioId: report.scenarioId,
+        scenarioName: report.scenarioName,
+        scenarioVersion: report.scenarioVersion,
+        status: report.status,
+        triggerType: report.triggerType,
+        startedAt: report.startedAt,
+        endedAt: report.endedAt,
+        durationMs: report.durationMs,
+        summary: report.summary,
+        nodes: nodes.map(nodeRow),
+        ...(failed
+            ? {
+                failedNodeDetail: {
+                    ...nodeRow(failed),
+                    failedTests: (failed.scriptResults ?? []).filter((result) => result.status === "FAIL").map((result) => ({ name: result.name, message: result.message ?? null })),
+                    response: (0, truncate_js_1.jsonPreview)(failed.response ?? failed.outputSnapshot),
+                    logs: (failed.logs ?? []).slice(-10).map((entry) => (0, truncate_js_1.clip)(String(entry.message ?? ""), 300)),
+                },
+            }
+            : {}),
+        ...(report.iterations && report.iterations.length > 0 ? { iterations: report.iterations.length } : {}),
+    };
+};
+exports.compactReportView = compactReportView;

package/dist-cjs/lib/cache.js

@@ -0,0 +1,43 @@
+"use strict";
+// Tiny TTL cache for hot reads (workspaces, collection trees) so a chain of
+// tool calls in one turn does not hammer the API. Writes call `clear()`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TtlCache = void 0;
+class TtlCache {
+    ttlMs;
+    now;
+    entries = new Map();
+    constructor(ttlMs, now = Date.now) {
+        this.ttlMs = ttlMs;
+        this.now = now;
+    }
+    get(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return undefined;
+        if (entry.expiresAt <= this.now()) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        this.entries.set(key, { value, expiresAt: this.now() + this.ttlMs });
+        return value;
+    }
+    async getOrSet(key, loader) {
+        const hit = this.get(key);
+        if (hit !== undefined)
+            return hit;
+        return this.set(key, await loader());
+    }
+    delete(prefix) {
+        for (const key of [...this.entries.keys()])
+            if (key.startsWith(prefix))
+                this.entries.delete(key);
+    }
+    clear() {
+        this.entries.clear();
+    }
+}
+exports.TtlCache = TtlCache;