callman-mcp 0.1.1 → 0.2.0

package/dist-cjs/tools/lookups.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sameName = exports.connectionResolverFor = exports.loadConnections = exports.resolveDiagram = exports.loadDiagrams = exports.resolveScenarioFolder = exports.resolveScenario = exports.loadScenarioCatalog = exports.resolveEnvironment = exports.loadEnvironments = exports.resolveRequest = exports.searchRequests = exports.requestIdsInFolder = exports.resolveFolder = exports.loadTree = exports.resolveCollection = exports.loadCollections = void 0;
+exports.sameName = exports.connectionResolverFor = exports.loadConnections = exports.resolveDiagram = exports.loadDiagrams = exports.resolveScenarioFolder = exports.resolveScenario = exports.loadScenarioCatalog = exports.resolveEnvironment = exports.loadEnvironments = exports.resolveRequest = exports.searchRequests = exports.requestIdsInFolder = exports.resolveFolder = exports.loadTree = exports.resolveCollection = exports.findEnvironment = exports.findRequest = exports.findCollection = exports.findInWorkspaces = exports.workspaceTag = exports.workspacesForListing = exports.isAllWorkspaces = exports.loadCollections = void 0;
+const errors_js_1 = require("../client/errors.js");
 const requestIntegrations_js_1 = require("../domain/requestIntegrations.js");
 const resolve_js_1 = require("../domain/resolve.js");
 const ids_js_1 = require("../lib/ids.js");
@@ -10,6 +11,105 @@ const truncate_js_1 = require("../lib/truncate.js");
 // prefixes it touches so the next read is fresh.
 const loadCollections = (ctx, ws) => ctx.cache.getOrSet(`collections:${ws}`, () => ctx.api.listAllCollections(ws));
 exports.loadCollections = loadCollections;
+// ── across workspaces ──────────────────────────────────────────────────
+// A personal token acts in EVERY workspace the user belongs to. Reads span
+// all of them; the session default only orders them and wins ties.
+// `workspace: "all"` (or "*") asks a listing for every workspace explicitly.
+const isAllWorkspaces = (ref) => Boolean(ref && ["all", "*", "any"].includes(ref.trim().toLowerCase()));
+exports.isAllWorkspaces = isAllWorkspaces;
+const workspacesForListing = async (ctx, explicit) => {
+    if (explicit && explicit.trim() && !(0, exports.isAllWorkspaces)(explicit))
+        return [await ctx.resolveWorkspace(explicit)];
+    const workspaces = await ctx.listWorkspaces();
+    const preferred = ctx.getDefaultWorkspaceId();
+    return [...workspaces].sort((a, b) => Number(b.id === preferred) - Number(a.id === preferred));
+};
+exports.workspacesForListing = workspacesForListing;
+const workspaceTag = (ws) => ({ id: ws.id, name: ws.name });
+exports.workspaceTag = workspaceTag;
+// Find something the model named (a collection, request, environment…).
+// `workspace` given → only there. Otherwise the default workspace first — an
+// exact or id match there wins at once; then every other workspace: a unique
+// match anywhere is used, the same name in several workspaces comes back as
+// candidates tagged with their workspace. A workspace where the thing is
+// missing (404 / REF_NOT_FOUND) is simply skipped.
+const findInWorkspaces = async (ctx, explicit, kind, ref, find, options = {}) => {
+    if (explicit && explicit.trim() && !(0, exports.isAllWorkspaces)(explicit)) {
+        const ws = await ctx.resolveWorkspace(explicit);
+        return { ws, value: await find(ws) };
+    }
+    const order = await (0, exports.workspacesForListing)(ctx, null);
+    if (order.length === 0)
+        throw new errors_js_1.ToolInputError("WORKSPACE_NONE", "You are not a member of any workspace.");
+    const preferred = ctx.getDefaultWorkspaceId();
+    const hits = [];
+    const ambiguous = [];
+    for (const ws of order) {
+        let value;
+        try {
+            value = await find(ws);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.ToolInputError && error.code === "REF_NOT_FOUND")
+                continue;
+            if (error instanceof errors_js_1.ToolInputError && error.code === "REF_AMBIGUOUS") {
+                ambiguous.push({ ws, error });
+                continue;
+            }
+            if (error instanceof errors_js_1.CallmanApiError && (error.status === 404 || error.status === 403))
+                continue;
+            throw error;
+        }
+        const matched = options.matchOf?.(value);
+        if (matched === "id" || (ws.id === preferred && matched !== "partial")) {
+            return { ws, value, ...(ws.id !== preferred && order.length > 1 ? { note: `found in workspace "${ws.name}"` } : {}) };
+        }
+        hits.push({ ws, value, matched });
+    }
+    const exact = hits.filter((hit) => hit.matched !== "partial");
+    const pool = exact.length > 0 ? exact : hits;
+    // Ambiguous inside ONE workspace and nothing elsewhere: that workspace's
+    // own candidate list, tagged with where it is.
+    if (pool.length === 0 && ambiguous.length === 1) {
+        const [{ ws, error }] = ambiguous;
+        throw new errors_js_1.ToolInputError(error.code, order.length > 1 ? `${error.message} (in workspace "${ws.name}")` : error.message, { ...(error.data ?? {}), workspace: (0, exports.workspaceTag)(ws) });
+    }
+    if (pool.length === 1 && ambiguous.length === 0) {
+        const [hit] = pool;
+        return { ws: hit.ws, value: hit.value, ...(hit.ws.id !== preferred && order.length > 1 ? { note: `found in workspace "${hit.ws.name}"` } : {}) };
+    }
+    if (pool.length > 1 || ambiguous.length > 0) {
+        throw new errors_js_1.ToolInputError("REF_AMBIGUOUS", `"${ref}" matches ${kind}s in several places — pass \`workspace\` (name or id), or use the id.`, {
+            kind,
+            ref,
+            candidates: [
+                ...pool.map((hit) => ({ workspace: (0, exports.workspaceTag)(hit.ws), ...(options.describe?.(hit.value) ?? {}) })),
+                ...ambiguous.map((entry) => ({ workspace: (0, exports.workspaceTag)(entry.ws), candidates: entry.error.data?.candidates })),
+            ],
+        });
+    }
+    throw new errors_js_1.ToolInputError("REF_NOT_FOUND", `No ${kind} matches "${ref}" in ${order.length === 1 ? "your workspace" : `any of your ${order.length} workspaces`}.`, {
+        kind,
+        ref,
+        searchedWorkspaces: order.map(exports.workspaceTag),
+    });
+};
+exports.findInWorkspaces = findInWorkspaces;
+const findCollection = (ctx, workspace, ref, options = {}) => (0, exports.findInWorkspaces)(ctx, workspace, "collection", ref, (ws) => (0, exports.resolveCollection)(ctx, ws.id, ref, options), {
+    matchOf: (resolved) => resolved.matched,
+    describe: (resolved) => ({ id: resolved.item.id, name: resolved.item.name }),
+});
+exports.findCollection = findCollection;
+const findRequest = (ctx, workspace, ref, collectionRef, options = {}) => (0, exports.findInWorkspaces)(ctx, workspace, "request", ref, (ws) => (0, exports.resolveRequest)(ctx, ws.id, ref, collectionRef, options), {
+    matchOf: (resolved) => resolved.matched,
+    describe: (resolved) => ({ id: resolved.request.id, name: resolved.request.name, method: resolved.request.method, url: resolved.request.url }),
+});
+exports.findRequest = findRequest;
+const findEnvironment = (ctx, workspace, ref, options = {}) => (0, exports.findInWorkspaces)(ctx, workspace, "environment", ref, (ws) => (0, exports.resolveEnvironment)(ctx, ws.id, ref, options), {
+    matchOf: (resolved) => resolved.matched,
+    describe: (resolved) => ({ id: resolved.item.id, name: resolved.item.name }),
+});
+exports.findEnvironment = findEnvironment;
 const resolveCollection = async (ctx, ws, ref, options = {}) => {
     const collections = await (0, exports.loadCollections)(ctx, ws);
     if ((0, ids_js_1.isObjectId)(ref) && !collections.some((collection) => collection.id === ref)) {
@@ -89,7 +189,7 @@ exports.searchRequests = searchRequests;
 // given collection, or across the workspace when no collection is given.
 const resolveRequest = async (ctx, ws, ref, collectionRef, options = {}) => {
     if ((0, ids_js_1.isObjectId)(ref)) {
-        return { request: await ctx.api.getRequest(ws, ref) };
+        return { request: await ctx.api.getRequest(ws, ref), matched: "id" };
     }
     const collectionId = collectionRef ? (await (0, exports.resolveCollection)(ctx, ws, collectionRef)).item.id : null;
     const collections = await (0, exports.loadCollections)(ctx, ws);
@@ -105,7 +205,7 @@ const resolveRequest = async (ctx, ws, ref, collectionRef, options = {}) => {
         aliases: (request) => [`${request.method} ${request.url}`, request.url],
         exact: options.exact,
     });
-    return { request: await ctx.api.getRequest(ws, resolved.item.id), annotation: resolved.annotation };
+    return { request: await ctx.api.getRequest(ws, resolved.item.id), annotation: resolved.annotation, matched: resolved.matched };
 };
 exports.resolveRequest = resolveRequest;
 const loadEnvironments = (ctx, ws) => ctx.cache.getOrSet(`environments:${ws}`, () => ctx.api.listAllEnvironments(ws));

package/dist-cjs/tools/meta.js

@@ -46,8 +46,9 @@ const registerMetaTools = (server, ctx) => {
         const me = meResult.value;
         const workspaces = workspacesResult.status === "fulfilled" ? workspacesResult.value : [];
         const features = featuresResult.status === "fulfilled" ? featuresResult.value.features : {};
-        const defaultWorkspace = ctx.config.defaultWorkspaceId
-            ? (workspaces.find((workspace) => workspace.id === ctx.config.defaultWorkspaceId) ?? null)
+        const preferred = ctx.getDefaultWorkspaceId();
+        const defaultWorkspace = preferred
+            ? (workspaces.find((workspace) => workspace.id === preferred) ?? null)
             : workspaces.length === 1
                 ? workspaces[0]
                 : null;
@@ -69,8 +70,12 @@ const registerMetaTools = (server, ctx) => {
                 isDefault: workspace.id === defaultWorkspace?.id,
             })),
             defaultWorkspaceId: defaultWorkspace?.id ?? null,
-            ...(workspaces.length > 1 && !defaultWorkspace
-                ? { note: "Several workspaces and no default: pass `workspace` to tools or set CALLMAN_WORKSPACE_ID." }
+            ...(workspaces.length > 1
+                ? {
+                    workspaceScope: `This token works in all ${workspaces.length} of your workspaces. Lists and searches cover every workspace unless you pass \`workspace\`; a name is looked up in the default workspace first, then in all others. ${defaultWorkspace
+                        ? `The default ("${defaultWorkspace.name}") only decides where NEW things go and wins a name that exists in several workspaces`
+                        : "There is no default, so creating something needs `workspace`"} — change it for this session with use_workspace.`,
+                }
                 : {}),
             features,
             localRun: ctx.config.allowLocalRun,

package/dist-cjs/tools/requests.js

@@ -15,7 +15,7 @@ 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.",
+        description: "Find saved requests by words in their name, method or URL (all words must match) — across ALL your workspaces, one `workspace`, or inside one collection. Returns up to 50 matches (each with its collection and workspace) 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\""),
@@ -24,14 +24,23 @@ const registerRequestTools = (server, ctx) => {
         },
         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);
+        const max = limit ?? truncate_js_1.LIMITS.SEARCH_RESULTS;
+        const scoped = collection ? await (0, lookups_js_1.findCollection)(ctx, workspace, collection) : null;
+        const workspaces = scoped ? [scoped.ws] : await (0, lookups_js_1.workspacesForListing)(ctx, workspace);
+        const matches = [];
+        for (const ws of workspaces) {
+            if (matches.length >= max)
+                break;
+            for (const match of await (0, lookups_js_1.searchRequests)(ctx, ws.id, query, scoped?.value.item.id ?? null, max - matches.length))
+                matches.push({ ...match, ws });
+        }
+        const scope = scoped?.value ?? null;
         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 } : {}),
+            ...(workspaces.length > 1 ? { searchedWorkspaces: workspaces.length } : { workspace: (0, lookups_js_1.workspaceTag)(workspaces[0]) }),
+            matches: matches.map((request) => ({ ...(0, requestShape_js_1.requestSummaryView)(request), collection: request.collectionName, ...(workspaces.length > 1 ? { workspace: (0, lookups_js_1.workspaceTag)(request.ws) } : {}) })),
+            ...(matches.length >= max ? { truncated: true } : {}),
         });
     }));
     server.registerTool("get_request", {
@@ -46,9 +55,13 @@ const registerRequestTools = (server, ctx) => {
         },
         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 }] } : {}) });
+        const { ws, value, note } = await (0, lookups_js_1.findRequest)(ctx, workspace, request, collection);
+        const { request: found, annotation } = value;
+        return (0, shared_js_1.ok)({
+            request: (0, requestShape_js_1.compactRequestView)(found, { full, reveal }),
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
+            ...(annotation || note ? { resolved: [{ input: request, matched: found.name, id: found.id, note: [annotation, note].filter(Boolean).join("; ") }] } : {}),
+        });
     }));
     server.registerTool("create_request", {
         title: "Create a request",
@@ -56,8 +69,7 @@ const registerRequestTools = (server, ctx) => {
         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 { ws, value: resolved, note } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
         const folder = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, resolved.item.id, item.folder);
         const input = (0, requestShape_js_1.resolveMaskedValues)(item);
         const resolve = await (0, lookups_js_1.connectionResolverFor)(ctx, ws.id, (0, requestIntegrations_js_1.hasIntegrations)(input));
@@ -70,9 +82,10 @@ const registerRequestTools = (server, ctx) => {
         return (0, shared_js_1.ok)({
             request: { ...(0, requestShape_js_1.requestSummaryView)(created), isEnabledInRunner: created.isEnabledInRunner !== false },
             collection: { id: resolved.item.id, name: resolved.item.name },
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
             ...(folder ? { folder: { id: folder.item.id, path: folder.item.path } } : {}),
             ...(warnings.length > 0 ? { warnings } : {}),
-            resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved), ...(folder && item.folder ? [(0, resolve_js_1.resolvedSummary)(item.folder, folder)] : [])],
+            resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved), ...(note ? [{ input: collection, note }] : []), ...(folder && item.folder ? [(0, resolve_js_1.resolvedSummary)(item.folder, folder)] : [])],
         });
     }));
     server.registerTool("create_requests_bulk", {
@@ -99,7 +112,9 @@ const registerRequestTools = (server, ctx) => {
         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);
+        // An existing collection decides the workspace; a new one needs a target.
+        const target = collection ? await (0, lookups_js_1.findCollection)(ctx, workspace, collection) : null;
+        const ws = target ? target.ws : await ctx.resolveWorkspace(workspace);
         const folderKeys = new Set((folders ?? []).map((folder) => folder.key));
         for (const folder of folders ?? []) {
             if (folder.parentKey && !folderKeys.has(folder.parentKey)) {
@@ -163,13 +178,14 @@ const registerRequestTools = (server, ctx) => {
             }
             return (0, shared_js_1.ok)({
                 collection: { id: result.collection.id, name: result.collection.name },
+                workspace: (0, lookups_js_1.workspaceTag)(ws),
                 created: result.importedCounts,
                 ...(runnerOff.length > 0 ? { disabledInRunner: runnerOff } : {}),
                 ...(runnerWarnings.length > 0 ? { warnings: runnerWarnings } : {}),
                 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 resolved = target.value;
         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();
@@ -215,7 +231,8 @@ const registerRequestTools = (server, ctx) => {
             requests: created,
             ...(warnings.length > 0 ? { warnings } : {}),
             ...(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)],
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
+            resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved), ...(target?.note ? [{ input: collection, note: target.note }] : [])],
         });
     }));
     server.registerTool("update_request", {
@@ -228,8 +245,8 @@ const registerRequestTools = (server, ctx) => {
         },
         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 { ws, value, note } = await (0, lookups_js_1.findRequest)(ctx, workspace, request, collection);
+        const { request: found, annotation } = value;
         const input = (0, requestShape_js_1.resolveMaskedValues)(changes, found);
         const folder = input.folder !== undefined ? await (0, lookups_js_1.resolveFolder)(ctx, ws.id, found.collectionId, input.folder) : undefined;
         const resolve = await (0, lookups_js_1.connectionResolverFor)(ctx, ws.id, (0, requestIntegrations_js_1.hasIntegrations)(input));
@@ -245,12 +262,13 @@ const registerRequestTools = (server, ctx) => {
             request: (0, requestShape_js_1.compactRequestView)(updated),
             changed: [...Object.keys(payload), ...(toggle ? ["isEnabledInRunner"] : [])],
             ...(warnings.length > 0 ? { warnings } : {}),
-            ...(annotation ? { resolved: [{ input: request, matched: found.name, id: found.id, note: annotation }] } : {}),
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
+            ...(annotation || note ? { resolved: [{ input: request, matched: found.name, id: found.id, note: [annotation, note].filter(Boolean).join("; ") }] } : {}),
         });
     }));
     server.registerTool("move_requests", {
         title: "Move requests",
-        description: "Move up to 200 requests (ids or unique names) into a collection and optional folder.",
+        description: "Move up to 200 requests (ids or unique names) into a collection and optional folder of the same workspace (the target collection's).",
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             requests: zod_1.z.array(zod_1.z.string().min(1).max(500)).min(1).max(MOVE_MAX),
@@ -260,8 +278,8 @@ const registerRequestTools = (server, ctx) => {
         },
         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);
+        // Requests move within one workspace — the target collection's.
+        const { ws, value: target } = await (0, lookups_js_1.findCollection)(ctx, workspace, targetCollection);
         const folder = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, target.item.id, targetFolder);
         const moved = [];
         const failed = [];
@@ -294,24 +312,26 @@ const registerRequestTools = (server, ctx) => {
         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, { exact: true });
+                const { ws, value } = await (0, lookups_js_1.findRequest)(ctx, workspace, ref, collection, { exact: true });
+                const { request } = value;
                 await ctx.api.deleteRequest(ws.id, request.id);
-                touched.add(request.collectionId);
-                deleted.push({ id: request.id, name: request.name });
+                touched.add(`${ws.id}:${request.collectionId}`);
+                deleted.push({ id: request.id, name: request.name, workspace: (0, lookups_js_1.workspaceTag)(ws) });
             }
             catch (error) {
                 failed.push({ request: ref, error: (0, shared_js_1.failureOf)(error) });
             }
         }
-        for (const collectionId of touched)
-            ctx.invalidate(`tree:${ws.id}:${collectionId}`);
-        ctx.invalidate(`collections:${ws.id}`);
+        for (const key of touched) {
+            const [wsId, collectionId] = key.split(":");
+            ctx.invalidate(`tree:${wsId}:${collectionId}`);
+            ctx.invalidate(`collections:${wsId}`);
+        }
         return (0, shared_js_1.ok)({ deleted, failed });
     }));
 };

package/dist-cjs/tools/run.js

@@ -131,14 +131,16 @@ const registerRunTools = (server, ctx) => {
             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"),
+            environment: zod_1.z.string().max(200).optional().describe("Environment name or id from the request's own workspace; 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);
+        // The request decides the workspace; the environment must be one of its.
+        const { ws, value, note } = await (0, lookups_js_1.findRequest)(ctx, workspace, request, collection);
+        const { request: found } = value;
+        const annotation = [value.annotation, note].filter(Boolean).join("; ") || undefined;
         const prepared = await prepareRun(ctx, ws.id, found.collectionId, environment);
         const runnable = prepared.collection.requests.find((entry) => entry.id === found.id);
         if (!runnable)
@@ -179,6 +181,7 @@ const registerRunTools = (server, ctx) => {
         }));
         const summary = (0, summarize_js_1.summarizeRun)(outcome, maxBodyBytes ?? ctx.config.maxBodyBytes, {
             collection: { id: found.collectionId },
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
             environment: prepared.environment,
             warnings: [...prepared.warnings, ...skippedWarnings(prepared, [found.id])],
             ...(annotation ? { resolved: [{ input: request, matched: found.name, id: found.id, note: annotation }] } : {}),
@@ -199,8 +202,7 @@ const registerRunTools = (server, ctx) => {
         },
         annotations: shared_js_1.RUN,
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, folder, only, environment, bail, maxBodyBytes }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection);
+        const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
         const prepared = await prepareRun(ctx, ws.id, resolved.item.id, environment);
         let selection = null;
         if (folder) {
@@ -229,6 +231,7 @@ const registerRunTools = (server, ctx) => {
         }));
         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 },
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
             environment: prepared.environment,
             warnings: [...prepared.warnings, ...skippedWarnings(prepared, outcome.results.map((result) => result.requestId))],
             resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved)],

package/dist-cjs/tools/scenarios.js

@@ -47,15 +47,17 @@ const latestScenario = async (ctx, ws, id) => ctx.api.getScenario(ws, id);
 const registerScenarioTools = (server, ctx) => {
     server.registerTool("list_scenarios", {
         title: "List scenarios",
-        description: "List API test scenarios (multi-step flows) with their folder, review status and version, plus the scenario folders and (on-prem) the groups you can create scenarios in. `query` filters by name. Scenarios are scoped by edition (on-prem: your groups), not strictly by workspace.",
+        description: "List API test scenarios (multi-step flows) you can access — regardless of workspace (on-prem: your groups) — with their folder, workspace, review status and version, plus the scenario folders and (on-prem) the groups you can create scenarios in. `query` filters by name.",
         inputSchema: { workspace: shared_js_1.workspaceArg, query: zod_1.z.string().max(200).optional(), folder: zod_1.z.string().max(200).optional(), ...shared_js_1.cursorArgs },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace, query, folder, cursor, limit }) => {
         const ws = await ctx.resolveWorkspaceOrNull(workspace);
-        const [{ scenarios, folders }, groups] = await Promise.all([
+        const [{ scenarios, folders }, groups, workspaces] = await Promise.all([
             (0, lookups_js_1.loadScenarioCatalog)(ctx, ws?.id ?? null),
             ctx.api.listMyScenarioGroups(ws?.id ?? null).catch(() => ({ items: [] })),
+            ctx.listWorkspaces(),
         ]);
+        const workspaceName = new Map(workspaces.map((entry) => [entry.id, entry.name]));
         const folderName = new Map(folders.map((entry) => [entry.id, entry.name]));
         const scope = folder ? await (0, lookups_js_1.resolveScenarioFolder)(ctx, ws?.id ?? null, folder) : null;
         const needle = query?.trim().toLowerCase();
@@ -67,7 +69,10 @@ const registerScenarioTools = (server, ctx) => {
             ...(ws ? { workspace: { id: ws.id, name: ws.name } } : {}),
             folders: folders.map((entry) => ({ id: entry.id, name: entry.name })),
             ...(groups.items.length > 0 ? { groups: groups.items.map((group) => ({ id: group.id, name: group.name, role: group.role })) } : {}),
-            scenarios: page.items.map((scenario) => (0, summarize_js_1.scenarioSummaryView)(scenario, scenario.folderId ? (folderName.get(scenario.folderId) ?? null) : null)),
+            scenarios: page.items.map((scenario) => ({
+                ...(0, summarize_js_1.scenarioSummaryView)(scenario, scenario.folderId ? (folderName.get(scenario.folderId) ?? null) : null),
+                ...(workspaces.length > 1 && scenario.workspaceId ? { workspace: { id: scenario.workspaceId, name: workspaceName.get(scenario.workspaceId) ?? null } } : {}),
+            })),
             total: page.total,
             nextCursor: page.nextCursor,
         });

package/dist-cjs/tools/shared.js

@@ -71,7 +71,7 @@ exports.workspaceArg = zod_1.z
     .string()
     .max(200)
     .optional()
-    .describe("Workspace id or name. Defaults to CALLMAN_WORKSPACE_ID, or the only workspace you have; call list_workspaces to see them.");
+    .describe('Workspace id or name to narrow to. Omit it: lists/searches cover ALL your workspaces and names are found in whichever workspace has them; creating uses the session default (use_workspace). "all" = every workspace.');
 const refArg = (what, extra = "") => zod_1.z.string().min(1).max(500).describe(`${what} id or name${extra ? ` ${extra}` : ""}`);
 exports.refArg = refArg;
 exports.cursorArgs = {

package/dist-cjs/tools/workspaces.js

@@ -9,7 +9,7 @@ const shared_js_1 = require("./shared.js");
 const registerWorkspaceTools = (server, ctx) => {
     server.registerTool("list_workspaces", {
         title: "List workspaces",
-        description: "List the workspaces you belong to, with your role in each (owner / editor / viewer). A token keeps your role: writes are refused where you are a viewer.",
+        description: "List the workspaces you belong to, with your role in each (owner / editor / viewer) and which one is the session default. The token works in all of them; a token keeps your role: writes are refused where you are a viewer.",
         inputSchema: {},
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async () => {
@@ -20,10 +20,26 @@ const registerWorkspaceTools = (server, ctx) => {
                 name: workspace.name,
                 role: workspace.role,
                 memberCount: workspace.memberCount ?? null,
-                isDefault: workspace.id === ctx.config.defaultWorkspaceId,
+                isDefault: workspace.id === ctx.getDefaultWorkspaceId(),
             })),
         });
     }));
+    server.registerTool("use_workspace", {
+        title: "Set the default workspace for this session",
+        description: "Pick the workspace new things go to for the rest of this session (collections, environments, scenarios, imports — anything created without `workspace`), and the one that wins when a name exists in several workspaces. It never hides the others: lists and searches still cover every workspace. `workspace: null` clears the default. Lasts until the MCP server restarts; CALLMAN_WORKSPACE_ID sets it at start.",
+        inputSchema: { workspace: zod_1.z.string().max(200).nullable().describe("Workspace name or id; null = no default") },
+        annotations: shared_js_1.IDEMPOTENT_WRITE,
+    }, (0, shared_js_1.guarded)(async ({ workspace }) => {
+        const previous = ctx.getDefaultWorkspaceId();
+        if (workspace === null || !workspace.trim()) {
+            ctx.setDefaultWorkspaceId(null);
+            return (0, shared_js_1.ok)({ defaultWorkspace: null, previousDefaultId: previous, note: "No default workspace: creating something now needs `workspace`; reads still cover all workspaces." });
+        }
+        const target = await ctx.resolveWorkspace(workspace);
+        ctx.setDefaultWorkspaceId(target.id);
+        ctx.invalidate();
+        return (0, shared_js_1.ok)({ defaultWorkspace: { id: target.id, name: target.name, role: target.role }, previousDefaultId: previous });
+    }));
     server.registerTool("list_workspace_members", {
         title: "List workspace members",
         description: "List the members of a workspace with their role and status (active / invited).",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "callman-mcp",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "MCP server for Callman: lets Claude Code, Claude Desktop, Cursor, Codex and Gemini CLI manage collections, requests, environments, test scenarios and system-design diagrams in your Callman workspace — cloud or on-prem.",
   "keywords": [
     "callman",