@apicircle/mcp-server 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -24,7 +24,10 @@ __export(index_exports, {
   InMemoryWorkspaceProvider: () => InMemoryWorkspaceProvider,
   InProcessMockController: () => InProcessMockController,
   McpHost: () => McpHost,
+  MultiWorkspaceProvider: () => MultiWorkspaceProvider,
+  SingleWorkspaceAdapter: () => SingleWorkspaceAdapter,
   TOOL_REGISTRY: () => TOOL_REGISTRY,
+  WorkspaceNotFoundError: () => WorkspaceNotFoundError,
   createMcpServer: () => createMcpServer,
   getTool: () => getTool
 });
@@ -462,18 +465,37 @@ function renderRust(req) {
   return lines.join("\n");
 }
 
-// src/tools/crud.ts
+// src/tools/workspaceList.ts
 var import_zod4 = require("zod");
+var workspaceListTool = {
+  name: "workspace.list",
+  description: "List every workspace registered with this server, including which one is currently active. Returns id, display name, last-opened timestamp, and a per-workspace summary (request count, environment count, mock-server count, plan count). Use this BEFORE drilling into a specific workspace via other tools \u2014 pass the resulting `id` as `workspaceId` to `workspace.read` or related reads when you want to scope to a non-active workspace.",
+  inputSchema: import_zod4.z.object({}),
+  async handler(_input, ctx) {
+    const summaries = await ctx.workspaces.list();
+    return {
+      activeWorkspaceId: ctx.workspaces.activeId(),
+      workspaceCount: summaries.length,
+      workspaces: summaries,
+      // Plain-text hint the AI surfaces when telling the user. Cheap to
+      // generate here and saves round-trips on disambiguation prompts.
+      hint: summaries.length === 0 ? "No workspaces are registered yet. The user should open the desktop app once or run `apicircle workspaces create <name>` from the terminal." : summaries.length === 1 ? `Only one workspace ("${summaries[0].name}") is registered \u2014 most tools will default to it without a workspaceId.` : `Multiple workspaces are registered. Pass the desired \`id\` as \`workspaceId\` to other tools to scope reads/writes to that workspace; the active one ("${summaries.find((w) => w.isActive)?.name ?? "(none)"}") is used by default.`
+    };
+  }
+};
+
+// src/tools/crud.ts
+var import_zod5 = require("zod");
 var import_shared2 = require("@apicircle/shared");
-var HTTP_METHOD = import_zod4.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var HTTP_METHOD = import_zod5.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var requestCreateTool = {
   name: "request.create",
   description: "Create a new request from explicit fields and persist it.",
-  inputSchema: import_zod4.z.object({
-    name: import_zod4.z.string().default("New request"),
+  inputSchema: import_zod5.z.object({
+    name: import_zod5.z.string().default("New request"),
     method: HTTP_METHOD.default("GET"),
-    url: import_zod4.z.string().default(""),
-    folderId: import_zod4.z.string().nullable().optional()
+    url: import_zod5.z.string().default(""),
+    folderId: import_zod5.z.string().nullable().optional()
   }),
   async handler(input, ctx) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -502,7 +524,7 @@ var requestCreateTool = {
 var requestReadTool = {
   name: "request.read",
   description: "Read a request by id, or list summaries (id, name, method, url) when no id is provided.",
-  inputSchema: import_zod4.z.object({ id: import_zod4.z.string().optional() }),
+  inputSchema: import_zod5.z.object({ id: import_zod5.z.string().optional() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     if (input.id) {
@@ -523,13 +545,13 @@ var requestReadTool = {
 var requestUpdateTool = {
   name: "request.update",
   description: "Patch fields on an existing request.",
-  inputSchema: import_zod4.z.object({
-    id: import_zod4.z.string(),
-    patch: import_zod4.z.object({
-      name: import_zod4.z.string().optional(),
+  inputSchema: import_zod5.z.object({
+    id: import_zod5.z.string(),
+    patch: import_zod5.z.object({
+      name: import_zod5.z.string().optional(),
       method: HTTP_METHOD.optional(),
-      url: import_zod4.z.string().optional(),
-      folderId: import_zod4.z.string().nullable().optional()
+      url: import_zod5.z.string().optional(),
+      folderId: import_zod5.z.string().nullable().optional()
     }).strict()
   }),
   async handler(input, ctx) {
@@ -544,7 +566,7 @@ var requestUpdateTool = {
 var requestDeleteTool = {
   name: "request.delete",
   description: "Delete a request by id.",
-  inputSchema: import_zod4.z.object({ id: import_zod4.z.string() }),
+  inputSchema: import_zod5.z.object({ id: import_zod5.z.string() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({ kind: "request.delete", id: input.id });
     return { changedIds: out.changedIds };
@@ -553,9 +575,9 @@ var requestDeleteTool = {
 var folderCreateTool = {
   name: "folder.create",
   description: "Create a folder under an optional parent folder.",
-  inputSchema: import_zod4.z.object({
-    name: import_zod4.z.string().default("New folder"),
-    parentId: import_zod4.z.string().nullable().optional()
+  inputSchema: import_zod5.z.object({
+    name: import_zod5.z.string().default("New folder"),
+    parentId: import_zod5.z.string().nullable().optional()
   }),
   async handler(input, ctx) {
     const folder = {
@@ -570,7 +592,7 @@ var folderCreateTool = {
 var folderReadTool = {
   name: "folder.read",
   description: "Read a folder by id, or list all folders when no id is provided.",
-  inputSchema: import_zod4.z.object({ id: import_zod4.z.string().optional() }),
+  inputSchema: import_zod5.z.object({ id: import_zod5.z.string().optional() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     if (input.id) {
@@ -586,9 +608,9 @@ var folderReadTool = {
 var folderUpdateTool = {
   name: "folder.update",
   description: "Move a folder to a new parent (or to root with parentId: null).",
-  inputSchema: import_zod4.z.object({
-    id: import_zod4.z.string(),
-    parentId: import_zod4.z.string().nullable()
+  inputSchema: import_zod5.z.object({
+    id: import_zod5.z.string(),
+    parentId: import_zod5.z.string().nullable()
   }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({
@@ -602,23 +624,23 @@ var folderUpdateTool = {
 var folderDeleteTool = {
   name: "folder.delete",
   description: "Delete a folder. Direct children (sub-folders + requests) are reparented to the deleted folder's parent.",
-  inputSchema: import_zod4.z.object({ id: import_zod4.z.string() }),
+  inputSchema: import_zod5.z.object({ id: import_zod5.z.string() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({ kind: "folder.delete", id: input.id });
     return { changedIds: out.changedIds };
   }
 };
-var VARIABLE = import_zod4.z.object({
-  key: import_zod4.z.string(),
-  value: import_zod4.z.string(),
-  encrypted: import_zod4.z.boolean().default(false)
+var VARIABLE = import_zod5.z.object({
+  key: import_zod5.z.string(),
+  value: import_zod5.z.string(),
+  encrypted: import_zod5.z.boolean().default(false)
 });
 var environmentCreateTool = {
   name: "environment.create",
   description: "Create a new environment (or upsert one with the same name).",
-  inputSchema: import_zod4.z.object({
-    name: import_zod4.z.string(),
-    variables: import_zod4.z.array(VARIABLE).default([])
+  inputSchema: import_zod5.z.object({
+    name: import_zod5.z.string(),
+    variables: import_zod5.z.array(VARIABLE).default([])
   }),
   async handler(input, ctx) {
     const env = { name: input.name, variables: input.variables };
@@ -629,7 +651,7 @@ var environmentCreateTool = {
 var environmentReadTool = {
   name: "environment.read",
   description: "Read environments \u2014 pass `name` for one, or omit for the full list.",
-  inputSchema: import_zod4.z.object({ name: import_zod4.z.string().optional() }),
+  inputSchema: import_zod5.z.object({ name: import_zod5.z.string().optional() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     if (input.name) {
@@ -646,9 +668,9 @@ var environmentReadTool = {
 var environmentUpdateTool = {
   name: "environment.update",
   description: "Replace the variables list of an environment.",
-  inputSchema: import_zod4.z.object({
-    name: import_zod4.z.string(),
-    variables: import_zod4.z.array(VARIABLE)
+  inputSchema: import_zod5.z.object({
+    name: import_zod5.z.string(),
+    variables: import_zod5.z.array(VARIABLE)
   }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({
@@ -661,7 +683,7 @@ var environmentUpdateTool = {
 var environmentDeleteTool = {
   name: "environment.delete",
   description: "Delete an environment by name.",
-  inputSchema: import_zod4.z.object({ name: import_zod4.z.string() }),
+  inputSchema: import_zod5.z.object({ name: import_zod5.z.string() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({ kind: "environment.delete", name: input.name });
     return { changedIds: out.changedIds };
@@ -670,7 +692,7 @@ var environmentDeleteTool = {
 var environmentSetActiveTool = {
   name: "environment.set_active",
   description: "Set (or clear) the active environment. Pass `name: null` to deactivate the current environment.",
-  inputSchema: import_zod4.z.object({ name: import_zod4.z.string().nullable() }),
+  inputSchema: import_zod5.z.object({ name: import_zod5.z.string().nullable() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({
       kind: "environment.setActive",
@@ -682,18 +704,18 @@ var environmentSetActiveTool = {
 var environmentSetPriorityTool = {
   name: "environment.set_priority",
   description: 'Replace the global environment priority order (highest priority first). Strings are interpreted as local env names. To target a linked env, pass `{ kind: "linked", linkedWorkspaceId, envName }` instead.',
-  inputSchema: import_zod4.z.object({
-    order: import_zod4.z.array(
-      import_zod4.z.union([
-        import_zod4.z.string(),
-        import_zod4.z.object({
-          kind: import_zod4.z.literal("local"),
-          name: import_zod4.z.string()
+  inputSchema: import_zod5.z.object({
+    order: import_zod5.z.array(
+      import_zod5.z.union([
+        import_zod5.z.string(),
+        import_zod5.z.object({
+          kind: import_zod5.z.literal("local"),
+          name: import_zod5.z.string()
         }),
-        import_zod4.z.object({
-          kind: import_zod4.z.literal("linked"),
-          linkedWorkspaceId: import_zod4.z.string(),
-          envName: import_zod4.z.string()
+        import_zod5.z.object({
+          kind: import_zod5.z.literal("linked"),
+          linkedWorkspaceId: import_zod5.z.string(),
+          envName: import_zod5.z.string()
         })
       ])
     )
@@ -710,7 +732,7 @@ var environmentSetPriorityTool = {
 var environmentExportTool = {
   name: "environment.export",
   description: "Serialize an environment to a portable JSON string. Encrypted variables drop their value (only `secretKeyId` survives) so the export can be safely pasted elsewhere \u2014 re-attach secrets locally on the receiving side.",
-  inputSchema: import_zod4.z.object({ name: import_zod4.z.string() }),
+  inputSchema: import_zod5.z.object({ name: import_zod5.z.string() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     const env = state.synced.environments.items[input.name];
@@ -728,9 +750,9 @@ var environmentExportTool = {
 var environmentImportTool = {
   name: "environment.import",
   description: "Import an environment from the JSON shape produced by `environment.export`. When a target with the same name exists, pass `overwrite: true` to replace it, otherwise the import is rejected.",
-  inputSchema: import_zod4.z.object({
-    json: import_zod4.z.string().min(1),
-    overwrite: import_zod4.z.boolean().default(false)
+  inputSchema: import_zod5.z.object({
+    json: import_zod5.z.string().min(1),
+    overwrite: import_zod5.z.boolean().default(false)
   }),
   async handler(input, ctx) {
     let parsed;
@@ -760,17 +782,17 @@ var environmentImportTool = {
     return { ok: true, name: env.name, changedIds: out.changedIds };
   }
 };
-var PLAN_STEP = import_zod4.z.object({
-  requestId: import_zod4.z.string(),
-  linkedWorkspaceId: import_zod4.z.string().optional()
+var PLAN_STEP = import_zod5.z.object({
+  requestId: import_zod5.z.string(),
+  linkedWorkspaceId: import_zod5.z.string().optional()
 });
 var planCreateTool = {
   name: "plan.create",
   description: "Create a new execution plan (sequence of request steps).",
-  inputSchema: import_zod4.z.object({
-    name: import_zod4.z.string().default("New plan"),
-    steps: import_zod4.z.array(PLAN_STEP).default([]),
-    envPriorityOrder: import_zod4.z.array(import_zod4.z.string()).default([])
+  inputSchema: import_zod5.z.object({
+    name: import_zod5.z.string().default("New plan"),
+    steps: import_zod5.z.array(PLAN_STEP).default([]),
+    envPriorityOrder: import_zod5.z.array(import_zod5.z.string()).default([])
   }),
   async handler(input, ctx) {
     const id = (0, import_shared2.generateId)();
@@ -790,7 +812,7 @@ var planCreateTool = {
 var planReadTool = {
   name: "plan.read",
   description: "Read a plan by id, or list all plans when no id is provided.",
-  inputSchema: import_zod4.z.object({ id: import_zod4.z.string().optional() }),
+  inputSchema: import_zod5.z.object({ id: import_zod5.z.string().optional() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     if (input.id) {
@@ -806,12 +828,12 @@ var planReadTool = {
 var planUpdateTool = {
   name: "plan.update",
   description: "Patch fields on an existing plan.",
-  inputSchema: import_zod4.z.object({
-    id: import_zod4.z.string(),
-    patch: import_zod4.z.object({
-      name: import_zod4.z.string().optional(),
-      steps: import_zod4.z.array(PLAN_STEP).optional(),
-      envPriorityOrder: import_zod4.z.array(import_zod4.z.string()).optional()
+  inputSchema: import_zod5.z.object({
+    id: import_zod5.z.string(),
+    patch: import_zod5.z.object({
+      name: import_zod5.z.string().optional(),
+      steps: import_zod5.z.array(PLAN_STEP).optional(),
+      envPriorityOrder: import_zod5.z.array(import_zod5.z.string()).optional()
     }).strict()
   }),
   async handler(input, ctx) {
@@ -832,7 +854,7 @@ var planUpdateTool = {
 var planDeleteTool = {
   name: "plan.delete",
   description: "Delete a plan by id. Drops history rows referencing this plan.",
-  inputSchema: import_zod4.z.object({ id: import_zod4.z.string() }),
+  inputSchema: import_zod5.z.object({ id: import_zod5.z.string() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({ kind: "plan.delete", id: input.id });
     return { changedIds: out.changedIds };
@@ -841,11 +863,11 @@ var planDeleteTool = {
 var planAddStepTool = {
   name: "plan.add_step",
   description: "Append a step to an execution plan. Optional `position` (0-based) inserts at that index instead.",
-  inputSchema: import_zod4.z.object({
-    planId: import_zod4.z.string(),
-    requestId: import_zod4.z.string(),
-    linkedWorkspaceId: import_zod4.z.string().optional(),
-    position: import_zod4.z.number().int().nonnegative().optional()
+  inputSchema: import_zod5.z.object({
+    planId: import_zod5.z.string(),
+    requestId: import_zod5.z.string(),
+    linkedWorkspaceId: import_zod5.z.string().optional(),
+    position: import_zod5.z.number().int().nonnegative().optional()
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -871,9 +893,9 @@ var planAddStepTool = {
 var planRemoveStepTool = {
   name: "plan.remove_step",
   description: "Remove a step from a plan by 0-based index.",
-  inputSchema: import_zod4.z.object({
-    planId: import_zod4.z.string(),
-    index: import_zod4.z.number().int().nonnegative()
+  inputSchema: import_zod5.z.object({
+    planId: import_zod5.z.string(),
+    index: import_zod5.z.number().int().nonnegative()
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -893,9 +915,9 @@ var planRemoveStepTool = {
 var planReorderStepsTool = {
   name: "plan.reorder_steps",
   description: "Replace the plan steps with a new permutation. The supplied indices must reference valid current step indices.",
-  inputSchema: import_zod4.z.object({
-    planId: import_zod4.z.string(),
-    order: import_zod4.z.array(import_zod4.z.number().int().nonnegative())
+  inputSchema: import_zod5.z.object({
+    planId: import_zod5.z.string(),
+    order: import_zod5.z.array(import_zod5.z.number().int().nonnegative())
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -917,13 +939,13 @@ var planReorderStepsTool = {
     return { ok: true, changedIds: out.changedIds };
   }
 };
-var PLAN_VARIABLE = import_zod4.z.object({ key: import_zod4.z.string(), value: import_zod4.z.string() });
+var PLAN_VARIABLE = import_zod5.z.object({ key: import_zod5.z.string(), value: import_zod5.z.string() });
 var planSetVariablesTool = {
   name: "plan.set_variables",
   description: "Replace the plan-scoped variables. These live highest-priority during plan runs (above environment vars, below context vars).",
-  inputSchema: import_zod4.z.object({
-    planId: import_zod4.z.string(),
-    variables: import_zod4.z.array(PLAN_VARIABLE)
+  inputSchema: import_zod5.z.object({
+    planId: import_zod5.z.string(),
+    variables: import_zod5.z.array(PLAN_VARIABLE)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -939,9 +961,9 @@ var planSetVariablesTool = {
 var planRunTool = {
   name: "plan.run",
   description: "Run a plan headlessly (server-side). Currently returns a not-implemented marker \u2014 full execution requires the Desktop or browser runtime which the MCP host does not own. The Desktop integration overrides this tool with a real runner.",
-  inputSchema: import_zod4.z.object({
-    id: import_zod4.z.string(),
-    withAssertions: import_zod4.z.boolean().default(true)
+  inputSchema: import_zod5.z.object({
+    id: import_zod5.z.string(),
+    withAssertions: import_zod5.z.boolean().default(true)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -955,18 +977,18 @@ var planRunTool = {
     };
   }
 };
-var ASSERTION = import_zod4.z.object({
-  id: import_zod4.z.string().optional(),
-  kind: import_zod4.z.enum(["status", "header", "json-path", "duration"]),
-  op: import_zod4.z.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
-  target: import_zod4.z.string().optional(),
-  expected: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()])
+var ASSERTION = import_zod5.z.object({
+  id: import_zod5.z.string().optional(),
+  kind: import_zod5.z.enum(["status", "header", "json-path", "duration"]),
+  op: import_zod5.z.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
+  target: import_zod5.z.string().optional(),
+  expected: import_zod5.z.union([import_zod5.z.string(), import_zod5.z.number()])
 });
 var assertionCreateTool = {
   name: "assertion.create",
   description: "Add an assertion to a request.",
-  inputSchema: import_zod4.z.object({
-    requestId: import_zod4.z.string(),
+  inputSchema: import_zod5.z.object({
+    requestId: import_zod5.z.string(),
     assertion: ASSERTION
   }),
   async handler(input, ctx) {
@@ -985,9 +1007,9 @@ var assertionCreateTool = {
 var assertionReadTool = {
   name: "assertion.read",
   description: "List assertions for a request, or fetch a single assertion by id.",
-  inputSchema: import_zod4.z.object({
-    requestId: import_zod4.z.string(),
-    assertionId: import_zod4.z.string().optional()
+  inputSchema: import_zod5.z.object({
+    requestId: import_zod5.z.string(),
+    assertionId: import_zod5.z.string().optional()
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1003,8 +1025,8 @@ var assertionReadTool = {
 var assertionUpdateTool = {
   name: "assertion.update",
   description: "Replace an existing assertion (matched by `assertion.id`).",
-  inputSchema: import_zod4.z.object({
-    requestId: import_zod4.z.string(),
+  inputSchema: import_zod5.z.object({
+    requestId: import_zod5.z.string(),
     assertion: ASSERTION.required({ id: true })
   }),
   async handler(input, ctx) {
@@ -1019,9 +1041,9 @@ var assertionUpdateTool = {
 var assertionDeleteTool = {
   name: "assertion.delete",
   description: "Remove an assertion from a request.",
-  inputSchema: import_zod4.z.object({
-    requestId: import_zod4.z.string(),
-    assertionId: import_zod4.z.string()
+  inputSchema: import_zod5.z.object({
+    requestId: import_zod5.z.string(),
+    assertionId: import_zod5.z.string()
   }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({
@@ -1034,21 +1056,53 @@ var assertionDeleteTool = {
 };
 var workspaceReadTool = {
   name: "workspace.read",
-  description: "Return the full `{ synced, local }` workspace pair. Use sparingly \u2014 entity-specific tools are more efficient for small reads.",
-  inputSchema: import_zod4.z.object({}),
-  async handler(_input, ctx) {
-    return await ctx.workspace.read();
+  description: 'Return the full `{ synced, local }` workspace pair. Pass `workspaceId` to scope to a specific workspace when multiple are registered (call `workspace.list` first to discover ids). When omitted and multiple workspaces exist, the response is a structured "multiple workspaces found" envelope listing each summary so the AI can clarify before drilling in. Use sparingly \u2014 entity-specific tools are more efficient for small reads.',
+  inputSchema: import_zod5.z.object({
+    workspaceId: import_zod5.z.string().min(1).max(256).optional().describe(
+      'Optional workspace id (from `workspace.list`). Omit to read the active workspace; the tool will switch to the "multiple workspaces" envelope when ambiguous.'
+    )
+  }),
+  async handler(input, ctx) {
+    if (input.workspaceId) {
+      const provider = ctx.workspaces.for(input.workspaceId);
+      const state2 = await provider.read();
+      return {
+        kind: "single",
+        workspaceId: state2.synced.workspaceId,
+        synced: state2.synced,
+        local: state2.local
+      };
+    }
+    const summaries = await ctx.workspaces.list();
+    if (summaries.length > 1) {
+      return {
+        kind: "multiple-workspaces",
+        activeWorkspaceId: ctx.workspaces.activeId(),
+        workspaceCount: summaries.length,
+        workspaces: summaries,
+        hint: `Found ${summaries.length} workspaces. Re-call \`workspace.read\` with \`workspaceId\` set to the desired entry, or call entity-specific tools (which default to the active workspace) when scoping to one workspace is acceptable.`
+      };
+    }
+    const state = await ctx.workspace.read();
+    return {
+      kind: "single",
+      workspaceId: state.synced.workspaceId,
+      synced: state.synced,
+      local: state.local
+    };
   }
 };
 var workspaceWriteTool = {
   name: "workspace.write",
-  description: "Bulk-replace the workspace. Pass `synced` and/or `local` to overwrite either side. Mutating tools are preferred \u2014 this is for full-doc imports/exports.",
-  inputSchema: import_zod4.z.object({
-    synced: import_zod4.z.unknown().optional(),
-    local: import_zod4.z.unknown().optional()
+  description: "Bulk-replace the workspace. Pass `synced` and/or `local` to overwrite either side. Use `workspaceId` to target a non-active workspace (omit to write the active one). Mutating tools are preferred \u2014 this is for full-doc imports/exports.",
+  inputSchema: import_zod5.z.object({
+    workspaceId: import_zod5.z.string().min(1).max(256).optional().describe("Optional workspace id; omit to write the active workspace."),
+    synced: import_zod5.z.unknown().optional(),
+    local: import_zod5.z.unknown().optional()
   }),
   async handler(input, ctx) {
-    const next = await ctx.workspace.write({
+    const provider = input.workspaceId ? ctx.workspaces.for(input.workspaceId) : ctx.workspace;
+    const next = await provider.write({
       synced: input.synced,
       local: input.local
     });
@@ -1057,16 +1111,16 @@ var workspaceWriteTool = {
 };
 
 // src/tools/history.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var historyListRunsTool = {
   name: "history.list_runs",
   description: "List request-run history rows in reverse-chronological order. Filter by `requestId`, `ok` (success/failure), or `since`/`until` ISO timestamps. `limit` caps the result set; default 100.",
-  inputSchema: import_zod5.z.object({
-    requestId: import_zod5.z.string().optional(),
-    ok: import_zod5.z.boolean().optional(),
-    since: import_zod5.z.string().optional(),
-    until: import_zod5.z.string().optional(),
-    limit: import_zod5.z.number().int().positive().max(500).default(100)
+  inputSchema: import_zod6.z.object({
+    requestId: import_zod6.z.string().optional(),
+    ok: import_zod6.z.boolean().optional(),
+    since: import_zod6.z.string().optional(),
+    until: import_zod6.z.string().optional(),
+    limit: import_zod6.z.number().int().positive().max(500).default(100)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1100,7 +1154,7 @@ var historyListRunsTool = {
 var historyGetRunTool = {
   name: "history.get_run",
   description: "Fetch a single history row in full (headers, body preview, assertion results).",
-  inputSchema: import_zod5.z.object({ id: import_zod5.z.string() }),
+  inputSchema: import_zod6.z.object({ id: import_zod6.z.string() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     const run = state.local.history.requestRuns.find((r) => r.id === input.id);
@@ -1111,7 +1165,7 @@ var historyGetRunTool = {
 var historyDeleteRunTool = {
   name: "history.delete_run",
   description: "Delete a single request-run row by id.",
-  inputSchema: import_zod5.z.object({ id: import_zod5.z.string() }),
+  inputSchema: import_zod6.z.object({ id: import_zod6.z.string() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({ kind: "history.delete_run", runId: input.id });
     return { deleted: out.changedIds.length, changedIds: out.changedIds };
@@ -1120,8 +1174,8 @@ var historyDeleteRunTool = {
 var historyPurgeTool = {
   name: "history.purge_by_age",
   description: "Drop every request-run + plan-run older than `olderThanDays` days. Pass 0 to clear all history.",
-  inputSchema: import_zod5.z.object({
-    olderThanDays: import_zod5.z.number().nonnegative()
+  inputSchema: import_zod6.z.object({
+    olderThanDays: import_zod6.z.number().nonnegative()
   }),
   async handler(input, ctx) {
     const olderThanMs = input.olderThanDays * 24 * 60 * 60 * 1e3;
@@ -1131,15 +1185,15 @@ var historyPurgeTool = {
 };
 
 // src/tools/codebase.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "options", "head"];
 var codebaseExtractCollectionTool = {
   name: "codebase.extract_collection",
   description: "Scan source code for HTTP route definitions (Express, FastAPI, NestJS, Spring) and return candidate requests for the user to confirm before import.",
-  inputSchema: import_zod6.z.object({
-    source: import_zod6.z.string().min(1),
+  inputSchema: import_zod7.z.object({
+    source: import_zod7.z.string().min(1),
     /** Hint to limit which framework patterns to apply. Empty = try all. */
-    frameworks: import_zod6.z.array(import_zod6.z.enum(["express", "fastapi", "nest", "spring"])).default([])
+    frameworks: import_zod7.z.array(import_zod7.z.enum(["express", "fastapi", "nest", "spring"])).default([])
   }),
   async handler(input) {
     const enabled = new Set(
@@ -1220,18 +1274,18 @@ var codebaseExtractCollectionTool = {
 };
 
 // src/tools/prompt.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var import_shared3 = require("@apicircle/shared");
 var promptCreateEnvironmentTool = {
   name: "prompt.create_environment",
   description: "Create a new environment from an LLM-shaped JSON envelope. The model produces { name, variables: [{ key, value, encrypted }] }; this tool validates and persists it.",
-  inputSchema: import_zod7.z.object({
-    name: import_zod7.z.string(),
-    variables: import_zod7.z.array(
-      import_zod7.z.object({
-        key: import_zod7.z.string(),
-        value: import_zod7.z.string(),
-        encrypted: import_zod7.z.boolean().default(false)
+  inputSchema: import_zod8.z.object({
+    name: import_zod8.z.string(),
+    variables: import_zod8.z.array(
+      import_zod8.z.object({
+        key: import_zod8.z.string(),
+        value: import_zod8.z.string(),
+        encrypted: import_zod8.z.boolean().default(false)
       })
     )
   }),
@@ -1244,13 +1298,13 @@ var promptCreateEnvironmentTool = {
 var promptCreateAssertionTool = {
   name: "prompt.create_assertion",
   description: 'Add an assertion to a request from an LLM-shaped JSON envelope. Useful when the user asks "assert that the response status is 200 and body.id matches".',
-  inputSchema: import_zod7.z.object({
-    requestId: import_zod7.z.string(),
-    assertion: import_zod7.z.object({
-      kind: import_zod7.z.enum(["status", "header", "json-path", "duration"]),
-      op: import_zod7.z.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
-      target: import_zod7.z.string().optional(),
-      expected: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()])
+  inputSchema: import_zod8.z.object({
+    requestId: import_zod8.z.string(),
+    assertion: import_zod8.z.object({
+      kind: import_zod8.z.enum(["status", "header", "json-path", "duration"]),
+      op: import_zod8.z.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
+      target: import_zod8.z.string().optional(),
+      expected: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()])
     })
   }),
   async handler(input, ctx) {
@@ -1269,10 +1323,10 @@ var promptCreateAssertionTool = {
 var promptCreatePlanTool = {
   name: "prompt.create_plan",
   description: "Create an execution plan from an LLM-shaped JSON envelope. The model produces { name, stepRequestIds: [...] } and the tool validates that each id exists in the workspace before persisting.",
-  inputSchema: import_zod7.z.object({
-    name: import_zod7.z.string(),
-    stepRequestIds: import_zod7.z.array(import_zod7.z.string()).default([]),
-    envPriorityOrder: import_zod7.z.array(import_zod7.z.string()).default([])
+  inputSchema: import_zod8.z.object({
+    name: import_zod8.z.string(),
+    stepRequestIds: import_zod8.z.array(import_zod8.z.string()).default([]),
+    envPriorityOrder: import_zod8.z.array(import_zod8.z.string()).default([])
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1301,51 +1355,51 @@ var promptCreatePlanTool = {
     return { ok: true, id, changedIds: out.changedIds };
   }
 };
-var HTTP_METHOD2 = import_zod7.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
-var HEADER_OR_QUERY = import_zod7.z.object({
-  key: import_zod7.z.string(),
-  value: import_zod7.z.string(),
-  enabled: import_zod7.z.boolean().default(true)
+var HTTP_METHOD2 = import_zod8.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var HEADER_OR_QUERY = import_zod8.z.object({
+  key: import_zod8.z.string(),
+  value: import_zod8.z.string(),
+  enabled: import_zod8.z.boolean().default(true)
 });
-var REQUEST_BODY = import_zod7.z.object({
-  type: import_zod7.z.enum(["none", "json", "text", "xml", "graphql", "urlencoded"]).default("none"),
-  content: import_zod7.z.string().default(""),
-  variables: import_zod7.z.string().optional()
+var REQUEST_BODY = import_zod8.z.object({
+  type: import_zod8.z.enum(["none", "json", "text", "xml", "graphql", "urlencoded"]).default("none"),
+  content: import_zod8.z.string().default(""),
+  variables: import_zod8.z.string().optional()
 });
-var PROMPT_AUTH = import_zod7.z.discriminatedUnion("type", [
-  import_zod7.z.object({ type: import_zod7.z.literal("none") }),
-  import_zod7.z.object({ type: import_zod7.z.literal("inherit") }),
-  import_zod7.z.object({ type: import_zod7.z.literal("bearer"), token: import_zod7.z.string().default("") }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("basic"),
-    username: import_zod7.z.string().default(""),
-    password: import_zod7.z.string().default("")
+var PROMPT_AUTH = import_zod8.z.discriminatedUnion("type", [
+  import_zod8.z.object({ type: import_zod8.z.literal("none") }),
+  import_zod8.z.object({ type: import_zod8.z.literal("inherit") }),
+  import_zod8.z.object({ type: import_zod8.z.literal("bearer"), token: import_zod8.z.string().default("") }),
+  import_zod8.z.object({
+    type: import_zod8.z.literal("basic"),
+    username: import_zod8.z.string().default(""),
+    password: import_zod8.z.string().default("")
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("api-key"),
-    key: import_zod7.z.string().default(""),
-    value: import_zod7.z.string().default(""),
-    addTo: import_zod7.z.enum(["header", "query", "cookie"]).default("header")
+  import_zod8.z.object({
+    type: import_zod8.z.literal("api-key"),
+    key: import_zod8.z.string().default(""),
+    value: import_zod8.z.string().default(""),
+    addTo: import_zod8.z.enum(["header", "query", "cookie"]).default("header")
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("custom-header"),
-    key: import_zod7.z.string().default(""),
-    value: import_zod7.z.string().default("")
+  import_zod8.z.object({
+    type: import_zod8.z.literal("custom-header"),
+    key: import_zod8.z.string().default(""),
+    value: import_zod8.z.string().default("")
   })
 ]);
-var PROMPT_ASSERTION = import_zod7.z.object({
-  kind: import_zod7.z.enum(["status", "header", "json-path", "duration"]),
-  op: import_zod7.z.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
-  target: import_zod7.z.string().optional(),
-  expected: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()])
+var PROMPT_ASSERTION = import_zod8.z.object({
+  kind: import_zod8.z.enum(["status", "header", "json-path", "duration"]),
+  op: import_zod8.z.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
+  target: import_zod8.z.string().optional(),
+  expected: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()])
 });
-var ENDPOINT_RESPONSE = import_zod7.z.object({
-  status: import_zod7.z.number().int().min(100).max(599).default(200),
-  jsonBody: import_zod7.z.string().default("{}"),
-  contentType: import_zod7.z.string().default("application/json")
+var ENDPOINT_RESPONSE = import_zod8.z.object({
+  status: import_zod8.z.number().int().min(100).max(599).default(200),
+  jsonBody: import_zod8.z.string().default("{}"),
+  contentType: import_zod8.z.string().default("application/json")
 });
-var VALIDATION_RULE_NL = import_zod7.z.object({
-  kind: import_zod7.z.enum([
+var VALIDATION_RULE_NL = import_zod8.z.object({
+  kind: import_zod8.z.enum([
     "header-required",
     "header-equals",
     "header-matches",
@@ -1356,50 +1410,50 @@ var VALIDATION_RULE_NL = import_zod7.z.object({
     "body-required",
     "content-type-equals"
   ]),
-  target: import_zod7.z.string().default(""),
-  expected: import_zod7.z.string().optional(),
-  message: import_zod7.z.string().optional(),
-  enabled: import_zod7.z.boolean().default(true),
-  failResponse: import_zod7.z.object({
-    status: import_zod7.z.number().int().min(100).max(599).default(400),
-    jsonBody: import_zod7.z.string().default('{"error":"validation failed"}')
+  target: import_zod8.z.string().default(""),
+  expected: import_zod8.z.string().optional(),
+  message: import_zod8.z.string().optional(),
+  enabled: import_zod8.z.boolean().default(true),
+  failResponse: import_zod8.z.object({
+    status: import_zod8.z.number().int().min(100).max(599).default(400),
+    jsonBody: import_zod8.z.string().default('{"error":"validation failed"}')
   }).default({})
 });
-var CONDITION_CLAUSE_NL = import_zod7.z.object({
-  scope: import_zod7.z.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
-  target: import_zod7.z.string(),
-  op: import_zod7.z.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
-  value: import_zod7.z.string().optional()
+var CONDITION_CLAUSE_NL = import_zod8.z.object({
+  scope: import_zod8.z.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
+  target: import_zod8.z.string(),
+  op: import_zod8.z.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
+  value: import_zod8.z.string().optional()
 });
-var RESPONSE_RULE_NL = import_zod7.z.object({
-  name: import_zod7.z.string(),
-  enabled: import_zod7.z.boolean().default(true),
-  when: import_zod7.z.array(CONDITION_CLAUSE_NL).default([]),
-  response: import_zod7.z.object({
-    status: import_zod7.z.number().int().min(100).max(599).default(200),
-    jsonBody: import_zod7.z.string().default("{}")
+var RESPONSE_RULE_NL = import_zod8.z.object({
+  name: import_zod8.z.string(),
+  enabled: import_zod8.z.boolean().default(true),
+  when: import_zod8.z.array(CONDITION_CLAUSE_NL).default([]),
+  response: import_zod8.z.object({
+    status: import_zod8.z.number().int().min(100).max(599).default(200),
+    jsonBody: import_zod8.z.string().default("{}")
   }).default({})
 });
-var MULTIPLIER_NL = import_zod7.z.object({
-  name: import_zod7.z.string().optional(),
-  source: import_zod7.z.object({
-    kind: import_zod7.z.enum(["query", "pathParam", "header", "body-json-path"]),
-    key: import_zod7.z.string()
+var MULTIPLIER_NL = import_zod8.z.object({
+  name: import_zod8.z.string().optional(),
+  source: import_zod8.z.object({
+    kind: import_zod8.z.enum(["query", "pathParam", "header", "body-json-path"]),
+    key: import_zod8.z.string()
   }),
-  targetJsonPath: import_zod7.z.string(),
-  defaultCount: import_zod7.z.number().int().nonnegative().default(0),
-  min: import_zod7.z.number().int().nonnegative().optional(),
-  max: import_zod7.z.number().int().nonnegative().optional()
+  targetJsonPath: import_zod8.z.string(),
+  defaultCount: import_zod8.z.number().int().nonnegative().default(0),
+  min: import_zod8.z.number().int().nonnegative().optional(),
+  max: import_zod8.z.number().int().nonnegative().optional()
 });
-var ENDPOINT_INPUT = import_zod7.z.object({
+var ENDPOINT_INPUT = import_zod8.z.object({
   method: HTTP_METHOD2,
-  pathPattern: import_zod7.z.string().min(1),
-  name: import_zod7.z.string().optional(),
-  description: import_zod7.z.string().optional(),
+  pathPattern: import_zod8.z.string().min(1),
+  name: import_zod8.z.string().optional(),
+  description: import_zod8.z.string().optional(),
   response: ENDPOINT_RESPONSE.optional(),
-  validationRules: import_zod7.z.array(VALIDATION_RULE_NL).default([]),
-  responseRules: import_zod7.z.array(RESPONSE_RULE_NL).default([]),
-  multipliers: import_zod7.z.array(MULTIPLIER_NL).default([])
+  validationRules: import_zod8.z.array(VALIDATION_RULE_NL).default([]),
+  responseRules: import_zod8.z.array(RESPONSE_RULE_NL).default([]),
+  multipliers: import_zod8.z.array(MULTIPLIER_NL).default([])
 });
 function buildRequestBody(input) {
   if (!input) return { type: "none", content: "" };
@@ -1492,17 +1546,17 @@ function patchEndpoint(mock, endpointId, patcher) {
 var promptCreateRequestTool = {
   name: "prompt.create_request",
   description: "Create a fully-shaped request from an LLM-shaped JSON envelope: method, url, headers, query params, body, auth, and inline assertions. The model produces a flat object; this tool generates the request id, normalizes auth (defaults to `inherit` so folder auth wins), and persists.",
-  inputSchema: import_zod7.z.object({
-    name: import_zod7.z.string().default("New request"),
+  inputSchema: import_zod8.z.object({
+    name: import_zod8.z.string().default("New request"),
     method: HTTP_METHOD2.default("GET"),
-    url: import_zod7.z.string().default(""),
-    folderId: import_zod7.z.string().nullable().optional(),
-    headers: import_zod7.z.array(HEADER_OR_QUERY).default([]),
-    queryParams: import_zod7.z.array(HEADER_OR_QUERY).default([]),
-    pathParams: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional(),
+    url: import_zod8.z.string().default(""),
+    folderId: import_zod8.z.string().nullable().optional(),
+    headers: import_zod8.z.array(HEADER_OR_QUERY).default([]),
+    queryParams: import_zod8.z.array(HEADER_OR_QUERY).default([]),
+    pathParams: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional(),
     body: REQUEST_BODY.optional(),
     auth: PROMPT_AUTH.optional(),
-    assertions: import_zod7.z.array(PROMPT_ASSERTION).default([])
+    assertions: import_zod8.z.array(PROMPT_ASSERTION).default([])
   }),
   async handler(input, ctx) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1532,19 +1586,19 @@ var promptCreateRequestTool = {
 var promptUpdateRequestTool = {
   name: "prompt.update_request",
   description: "Patch an existing request from an LLM-shaped JSON envelope. Provided fields replace the existing values; omitted fields are left untouched. Arrays (headers, queryParams, assertions) are full replacements when supplied. Returns `{ ok: false, error }` when the id does not resolve.",
-  inputSchema: import_zod7.z.object({
-    id: import_zod7.z.string(),
-    patch: import_zod7.z.object({
-      name: import_zod7.z.string().optional(),
+  inputSchema: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    patch: import_zod8.z.object({
+      name: import_zod8.z.string().optional(),
       method: HTTP_METHOD2.optional(),
-      url: import_zod7.z.string().optional(),
-      folderId: import_zod7.z.string().nullable().optional(),
-      headers: import_zod7.z.array(HEADER_OR_QUERY).optional(),
-      queryParams: import_zod7.z.array(HEADER_OR_QUERY).optional(),
-      pathParams: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional(),
+      url: import_zod8.z.string().optional(),
+      folderId: import_zod8.z.string().nullable().optional(),
+      headers: import_zod8.z.array(HEADER_OR_QUERY).optional(),
+      queryParams: import_zod8.z.array(HEADER_OR_QUERY).optional(),
+      pathParams: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional(),
       body: REQUEST_BODY.optional(),
       auth: PROMPT_AUTH.optional(),
-      assertions: import_zod7.z.array(PROMPT_ASSERTION).optional()
+      assertions: import_zod8.z.array(PROMPT_ASSERTION).optional()
     }).strict()
   }),
   async handler(input, ctx) {
@@ -1572,17 +1626,17 @@ var promptUpdateRequestTool = {
     return { ok: true, changedIds: out.changedIds };
   }
 };
-var FOLDER_TREE_NODE = import_zod7.z.lazy(
-  () => import_zod7.z.object({
-    name: import_zod7.z.string(),
-    children: import_zod7.z.array(FOLDER_TREE_NODE).optional()
+var FOLDER_TREE_NODE = import_zod8.z.lazy(
+  () => import_zod8.z.object({
+    name: import_zod8.z.string(),
+    children: import_zod8.z.array(FOLDER_TREE_NODE).optional()
   })
 );
 var promptCreateFolderTreeTool = {
   name: "prompt.create_folder_tree",
   description: "Create a recursive folder hierarchy from an LLM-shaped JSON envelope. The model produces `{ parentId?, tree: { name, children?: [...] } }` and this tool walks the tree, generating ids and persisting one folder per node. Returns the list of created ids in pre-order.",
-  inputSchema: import_zod7.z.object({
-    parentId: import_zod7.z.string().nullable().optional(),
+  inputSchema: import_zod8.z.object({
+    parentId: import_zod8.z.string().nullable().optional(),
     tree: FOLDER_TREE_NODE
   }),
   async handler(input, ctx) {
@@ -1608,9 +1662,9 @@ var promptCreateFolderTreeTool = {
 var promptAddPlanStepsTool = {
   name: "prompt.add_plan_steps",
   description: "Append one or more steps to an existing execution plan from an LLM-shaped JSON envelope. The model produces `{ planId, requestIds: [...] }`; each id is validated against the workspace before any step is appended. Order in the input list is preserved.",
-  inputSchema: import_zod7.z.object({
-    planId: import_zod7.z.string(),
-    requestIds: import_zod7.z.array(import_zod7.z.string()).min(1)
+  inputSchema: import_zod8.z.object({
+    planId: import_zod8.z.string(),
+    requestIds: import_zod8.z.array(import_zod8.z.string()).min(1)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1640,9 +1694,9 @@ var promptAddPlanStepsTool = {
 var promptSetPlanVariablesTool = {
   name: "prompt.set_plan_variables",
   description: "Replace the plan-scoped variables on an execution plan from an LLM-shaped JSON envelope. The model produces `{ planId, variables: [{ key, value }] }`. Empty array clears all plan variables.",
-  inputSchema: import_zod7.z.object({
-    planId: import_zod7.z.string(),
-    variables: import_zod7.z.array(import_zod7.z.object({ key: import_zod7.z.string(), value: import_zod7.z.string() }))
+  inputSchema: import_zod8.z.object({
+    planId: import_zod8.z.string(),
+    variables: import_zod8.z.array(import_zod8.z.object({ key: import_zod8.z.string(), value: import_zod8.z.string() }))
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1658,10 +1712,10 @@ var promptSetPlanVariablesTool = {
 var promptCreateMockServerTool = {
   name: "prompt.create_mock_server",
   description: "Create a manual-mode mock server with optional inline endpoints from an LLM-shaped JSON envelope. The model produces `{ name, defaultPort?, endpoints: [{ method, pathPattern, name?, response?, validationRules?, responseRules?, multipliers? }] }`; this tool generates ids for the server and every endpoint / rule, then persists in one shot.",
-  inputSchema: import_zod7.z.object({
-    name: import_zod7.z.string().min(1),
-    defaultPort: import_zod7.z.number().int().positive().nullable().optional(),
-    endpoints: import_zod7.z.array(ENDPOINT_INPUT).default([])
+  inputSchema: import_zod8.z.object({
+    name: import_zod8.z.string().min(1),
+    defaultPort: import_zod8.z.number().int().positive().nullable().optional(),
+    endpoints: import_zod8.z.array(ENDPOINT_INPUT).default([])
   }),
   async handler(input, ctx) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1688,16 +1742,16 @@ var promptCreateMockServerTool = {
 var promptAddMockEndpointTool = {
   name: "prompt.add_mock_endpoint",
   description: "Append a new endpoint (with optional inline validation rules, response rules, and multipliers) to an existing mock server from an LLM-shaped JSON envelope. All ids are auto-generated; the existing endpoints stay in place.",
-  inputSchema: import_zod7.z.object({
-    mockId: import_zod7.z.string(),
+  inputSchema: import_zod8.z.object({
+    mockId: import_zod8.z.string(),
     method: HTTP_METHOD2,
-    pathPattern: import_zod7.z.string().min(1),
-    name: import_zod7.z.string().optional(),
-    description: import_zod7.z.string().optional(),
+    pathPattern: import_zod8.z.string().min(1),
+    name: import_zod8.z.string().optional(),
+    description: import_zod8.z.string().optional(),
     response: ENDPOINT_RESPONSE.optional(),
-    validationRules: import_zod7.z.array(VALIDATION_RULE_NL).default([]),
-    responseRules: import_zod7.z.array(RESPONSE_RULE_NL).default([]),
-    multipliers: import_zod7.z.array(MULTIPLIER_NL).default([])
+    validationRules: import_zod8.z.array(VALIDATION_RULE_NL).default([]),
+    responseRules: import_zod8.z.array(RESPONSE_RULE_NL).default([]),
+    multipliers: import_zod8.z.array(MULTIPLIER_NL).default([])
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1719,10 +1773,10 @@ var promptAddMockEndpointTool = {
 var promptSetEndpointValidationRulesTool = {
   name: "prompt.set_endpoint_validation_rules",
   description: "Replace an endpoint's validation rules with an LLM-shaped list. Every rule gets a fresh id; the existing rules are dropped. Empty array clears all validation rules.",
-  inputSchema: import_zod7.z.object({
-    mockId: import_zod7.z.string(),
-    endpointId: import_zod7.z.string(),
-    rules: import_zod7.z.array(VALIDATION_RULE_NL)
+  inputSchema: import_zod8.z.object({
+    mockId: import_zod8.z.string(),
+    endpointId: import_zod8.z.string(),
+    rules: import_zod8.z.array(VALIDATION_RULE_NL)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1753,10 +1807,10 @@ var promptSetEndpointValidationRulesTool = {
 var promptSetEndpointResponseRulesTool = {
   name: "prompt.set_endpoint_response_rules",
   description: "Replace an endpoint's conditional response rules with an LLM-shaped list. Rules fire in order, first match wins. Every rule + clause gets a fresh id. Empty array falls back to defaultResponse.",
-  inputSchema: import_zod7.z.object({
-    mockId: import_zod7.z.string(),
-    endpointId: import_zod7.z.string(),
-    rules: import_zod7.z.array(RESPONSE_RULE_NL)
+  inputSchema: import_zod8.z.object({
+    mockId: import_zod8.z.string(),
+    endpointId: import_zod8.z.string(),
+    rules: import_zod8.z.array(RESPONSE_RULE_NL)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1791,10 +1845,10 @@ var promptSetEndpointResponseRulesTool = {
 var promptSetEndpointMultipliersTool = {
   name: "prompt.set_endpoint_multipliers",
   description: "Replace the response multipliers on an endpoint's defaultResponse with an LLM-shaped list. Multipliers expand an array at `targetJsonPath` to a count derived from a request value. Every multiplier gets a fresh id. Empty array clears all multipliers.",
-  inputSchema: import_zod7.z.object({
-    mockId: import_zod7.z.string(),
-    endpointId: import_zod7.z.string(),
-    multipliers: import_zod7.z.array(MULTIPLIER_NL)
+  inputSchema: import_zod8.z.object({
+    mockId: import_zod8.z.string(),
+    endpointId: import_zod8.z.string(),
+    multipliers: import_zod8.z.array(MULTIPLIER_NL)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1823,7 +1877,7 @@ var promptSetEndpointMultipliersTool = {
 };
 
 // src/tools/mocks.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var import_shared4 = require("@apicircle/shared");
 var import_mock_server_core2 = require("@apicircle/mock-server-core");
 async function ingestSource(source, name) {
@@ -1846,10 +1900,10 @@ async function ingestSource(source, name) {
 var mockCreateFromOpenApiTool = {
   name: "mock.create_from_openapi",
   description: "Create a mock server from an OpenAPI / Swagger spec (YAML or JSON).",
-  inputSchema: import_zod8.z.object({
-    name: import_zod8.z.string(),
-    spec: import_zod8.z.string().min(1),
-    format: import_zod8.z.enum(["json", "yaml"]).default("json")
+  inputSchema: import_zod9.z.object({
+    name: import_zod9.z.string(),
+    spec: import_zod9.z.string().min(1),
+    format: import_zod9.z.enum(["json", "yaml"]).default("json")
   }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
@@ -1868,7 +1922,7 @@ var mockCreateFromOpenApiTool = {
 var mockCreateFromPostmanTool = {
   name: "mock.create_from_postman",
   description: "Create a mock server from a Postman v2/v2.1 collection.",
-  inputSchema: import_zod8.z.object({ name: import_zod8.z.string(), collection: import_zod8.z.string().min(1) }),
+  inputSchema: import_zod9.z.object({ name: import_zod9.z.string(), collection: import_zod9.z.string().min(1) }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
       { kind: "postman", collection: input.collection },
@@ -1886,7 +1940,7 @@ var mockCreateFromPostmanTool = {
 var mockCreateFromInsomniaTool = {
   name: "mock.create_from_insomnia",
   description: "Create a mock server from an Insomnia v4 export.",
-  inputSchema: import_zod8.z.object({ name: import_zod8.z.string(), export: import_zod8.z.string().min(1) }),
+  inputSchema: import_zod9.z.object({ name: import_zod9.z.string(), export: import_zod9.z.string().min(1) }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
       { kind: "insomnia", export: input.export },
@@ -1904,7 +1958,7 @@ var mockCreateFromInsomniaTool = {
 var mockImportPostmanMockCollectionTool = {
   name: "mock.import_postman_mock_collection",
   description: "Import a Postman Mock Collection (collections previously hosted on Postman's mock service). Same parser as a regular Postman collection but marked as a mock import.",
-  inputSchema: import_zod8.z.object({ name: import_zod8.z.string(), collection: import_zod8.z.string().min(1) }),
+  inputSchema: import_zod9.z.object({ name: import_zod9.z.string(), collection: import_zod9.z.string().min(1) }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
       { kind: "postman", collection: input.collection },
@@ -1922,7 +1976,7 @@ var mockImportPostmanMockCollectionTool = {
 var mockListTool = {
   name: "mock.list",
   description: "List all mock servers in the workspace plus their runtime status (running / stopped, port).",
-  inputSchema: import_zod8.z.object({}),
+  inputSchema: import_zod9.z.object({}),
   async handler(_input, ctx) {
     const state = await ctx.workspace.read();
     const running = await ctx.mock.list();
@@ -1944,9 +1998,9 @@ var mockListTool = {
 var mockStartTool = {
   name: "mock.start",
   description: "Start a mock server by id. Returns the bound port. Errors if the mock is already running or the requested port is in use.",
-  inputSchema: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    port: import_zod8.z.number().int().positive().optional()
+  inputSchema: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    port: import_zod9.z.number().int().positive().optional()
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1963,7 +2017,7 @@ var mockStartTool = {
 var mockStopTool = {
   name: "mock.stop",
   description: "Stop a running mock server by id (no-op if not running).",
-  inputSchema: import_zod8.z.object({ id: import_zod8.z.string() }),
+  inputSchema: import_zod9.z.object({ id: import_zod9.z.string() }),
   async handler(input, ctx) {
     try {
       await ctx.mock.stop(input.id);
@@ -1976,7 +2030,7 @@ var mockStopTool = {
 var mockDeleteTool = {
   name: "mock.delete",
   description: "Delete a mock server definition. Stops it first if it's running.",
-  inputSchema: import_zod8.z.object({ id: import_zod8.z.string() }),
+  inputSchema: import_zod9.z.object({ id: import_zod9.z.string() }),
   async handler(input, ctx) {
     try {
       await ctx.mock.stop(input.id);
@@ -1986,13 +2040,13 @@ var mockDeleteTool = {
     return { ok: true, changedIds: out.changedIds };
   }
 };
-var HTTP_METHOD3 = import_zod8.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var HTTP_METHOD3 = import_zod9.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var mockCreateManualTool = {
   name: "mock.create_manual",
   description: "Create an empty manual-mode mock server. Use `mock.add_endpoint` afterward to populate it. CORS defaults to off (same-origin only); enable + list explicit origins via `mock.update_cors` if cross-origin access is needed.",
-  inputSchema: import_zod8.z.object({
-    name: import_zod8.z.string().min(1),
-    defaultPort: import_zod8.z.number().int().positive().nullable().optional()
+  inputSchema: import_zod9.z.object({
+    name: import_zod9.z.string().min(1),
+    defaultPort: import_zod9.z.number().int().positive().nullable().optional()
   }),
   async handler(input, ctx) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -2015,7 +2069,7 @@ var mockCreateManualTool = {
 var mockListEndpointsTool = {
   name: "mock.list_endpoints",
   description: "List endpoints for a mock server (id, method, path, name).",
-  inputSchema: import_zod8.z.object({ mockId: import_zod8.z.string() }),
+  inputSchema: import_zod9.z.object({ mockId: import_zod9.z.string() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     const mock = state.synced.mockServers[input.mockId];
@@ -2034,10 +2088,10 @@ var mockListEndpointsTool = {
     };
   }
 };
-var ENDPOINT_RESPONSE2 = import_zod8.z.object({
-  status: import_zod8.z.number().int().min(100).max(599).default(200),
-  jsonBody: import_zod8.z.string().default("{}"),
-  contentType: import_zod8.z.string().default("application/json")
+var ENDPOINT_RESPONSE2 = import_zod9.z.object({
+  status: import_zod9.z.number().int().min(100).max(599).default(200),
+  jsonBody: import_zod9.z.string().default("{}"),
+  contentType: import_zod9.z.string().default("application/json")
 });
 function buildDefaultEndpoint(args) {
   const response = args.response ?? {
@@ -2066,12 +2120,12 @@ function buildDefaultEndpoint(args) {
 var mockAddEndpointTool = {
   name: "mock.add_endpoint",
   description: "Append a new endpoint to a mock server. Defaults to a 200 JSON response of `{}`. Returns the new endpoint id.",
-  inputSchema: import_zod8.z.object({
-    mockId: import_zod8.z.string(),
+  inputSchema: import_zod9.z.object({
+    mockId: import_zod9.z.string(),
     method: HTTP_METHOD3,
-    pathPattern: import_zod8.z.string().min(1),
-    name: import_zod8.z.string().optional(),
-    description: import_zod8.z.string().optional(),
+    pathPattern: import_zod9.z.string().min(1),
+    name: import_zod9.z.string().optional(),
+    description: import_zod9.z.string().optional(),
     response: ENDPOINT_RESPONSE2.optional()
   }),
   async handler(input, ctx) {
@@ -2094,13 +2148,13 @@ var mockAddEndpointTool = {
 var mockUpdateEndpointTool = {
   name: "mock.update_endpoint",
   description: "Patch fields on a single mock endpoint (method, pathPattern, name, description, defaultResponse status / contentType / json body). Pass only the fields you want to change.",
-  inputSchema: import_zod8.z.object({
-    mockId: import_zod8.z.string(),
-    endpointId: import_zod8.z.string(),
+  inputSchema: import_zod9.z.object({
+    mockId: import_zod9.z.string(),
+    endpointId: import_zod9.z.string(),
     method: HTTP_METHOD3.optional(),
-    pathPattern: import_zod8.z.string().optional(),
-    name: import_zod8.z.string().optional(),
-    description: import_zod8.z.string().optional(),
+    pathPattern: import_zod9.z.string().optional(),
+    name: import_zod9.z.string().optional(),
+    description: import_zod9.z.string().optional(),
     response: ENDPOINT_RESPONSE2.partial().optional()
   }),
   async handler(input, ctx) {
@@ -2141,7 +2195,7 @@ var mockUpdateEndpointTool = {
 var mockDeleteEndpointTool = {
   name: "mock.delete_endpoint",
   description: "Remove an endpoint from a mock server.",
-  inputSchema: import_zod8.z.object({ mockId: import_zod8.z.string(), endpointId: import_zod8.z.string() }),
+  inputSchema: import_zod9.z.object({ mockId: import_zod9.z.string(), endpointId: import_zod9.z.string() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     const mock = state.synced.mockServers[input.mockId];
@@ -2161,9 +2215,9 @@ var mockDeleteEndpointTool = {
     return { ok: true, changedIds: out.changedIds };
   }
 };
-var VALIDATION_RULE = import_zod8.z.object({
-  id: import_zod8.z.string().optional(),
-  kind: import_zod8.z.enum([
+var VALIDATION_RULE = import_zod9.z.object({
+  id: import_zod9.z.string().optional(),
+  kind: import_zod9.z.enum([
     "header-required",
     "header-equals",
     "header-matches",
@@ -2174,43 +2228,43 @@ var VALIDATION_RULE = import_zod8.z.object({
     "body-required",
     "content-type-equals"
   ]),
-  target: import_zod8.z.string().default(""),
-  expected: import_zod8.z.string().optional(),
-  message: import_zod8.z.string().optional(),
-  enabled: import_zod8.z.boolean().default(true),
-  failResponse: import_zod8.z.object({
-    status: import_zod8.z.number().int().min(100).max(599).default(400),
-    jsonBody: import_zod8.z.string().default('{"error":"validation failed"}')
+  target: import_zod9.z.string().default(""),
+  expected: import_zod9.z.string().optional(),
+  message: import_zod9.z.string().optional(),
+  enabled: import_zod9.z.boolean().default(true),
+  failResponse: import_zod9.z.object({
+    status: import_zod9.z.number().int().min(100).max(599).default(400),
+    jsonBody: import_zod9.z.string().default('{"error":"validation failed"}')
   }).default({})
 });
-var CONDITION_CLAUSE = import_zod8.z.object({
-  id: import_zod8.z.string().optional(),
-  scope: import_zod8.z.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
-  target: import_zod8.z.string(),
-  op: import_zod8.z.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
-  value: import_zod8.z.string().optional()
+var CONDITION_CLAUSE = import_zod9.z.object({
+  id: import_zod9.z.string().optional(),
+  scope: import_zod9.z.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
+  target: import_zod9.z.string(),
+  op: import_zod9.z.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
+  value: import_zod9.z.string().optional()
 });
-var RESPONSE_RULE = import_zod8.z.object({
-  id: import_zod8.z.string().optional(),
-  name: import_zod8.z.string(),
-  enabled: import_zod8.z.boolean().default(true),
-  when: import_zod8.z.array(CONDITION_CLAUSE).default([]),
-  response: import_zod8.z.object({
-    status: import_zod8.z.number().int().min(100).max(599).default(200),
-    jsonBody: import_zod8.z.string().default("{}")
+var RESPONSE_RULE = import_zod9.z.object({
+  id: import_zod9.z.string().optional(),
+  name: import_zod9.z.string(),
+  enabled: import_zod9.z.boolean().default(true),
+  when: import_zod9.z.array(CONDITION_CLAUSE).default([]),
+  response: import_zod9.z.object({
+    status: import_zod9.z.number().int().min(100).max(599).default(200),
+    jsonBody: import_zod9.z.string().default("{}")
   }).default({})
 });
-var MULTIPLIER = import_zod8.z.object({
-  id: import_zod8.z.string().optional(),
-  name: import_zod8.z.string().optional(),
-  source: import_zod8.z.object({
-    kind: import_zod8.z.enum(["query", "pathParam", "header", "body-json-path"]),
-    key: import_zod8.z.string()
+var MULTIPLIER = import_zod9.z.object({
+  id: import_zod9.z.string().optional(),
+  name: import_zod9.z.string().optional(),
+  source: import_zod9.z.object({
+    kind: import_zod9.z.enum(["query", "pathParam", "header", "body-json-path"]),
+    key: import_zod9.z.string()
   }),
-  targetJsonPath: import_zod8.z.string(),
-  defaultCount: import_zod8.z.number().int().nonnegative().default(0),
-  min: import_zod8.z.number().int().nonnegative().optional(),
-  max: import_zod8.z.number().int().nonnegative().optional()
+  targetJsonPath: import_zod9.z.string(),
+  defaultCount: import_zod9.z.number().int().nonnegative().default(0),
+  min: import_zod9.z.number().int().nonnegative().optional(),
+  max: import_zod9.z.number().int().nonnegative().optional()
 });
 function defaultJsonResponseConfig(args) {
   return {
@@ -2235,10 +2289,10 @@ function patchEndpoint2(mock, endpointId, patcher) {
 var mockSetValidationRulesTool = {
   name: "mock.set_validation_rules",
   description: "Replace an endpoint's validation rules. Rules without an `id` get a fresh one; existing rules can keep theirs to preserve client-side selection state. Empty array clears all rules.",
-  inputSchema: import_zod8.z.object({
-    mockId: import_zod8.z.string(),
-    endpointId: import_zod8.z.string(),
-    rules: import_zod8.z.array(VALIDATION_RULE)
+  inputSchema: import_zod9.z.object({
+    mockId: import_zod9.z.string(),
+    endpointId: import_zod9.z.string(),
+    rules: import_zod9.z.array(VALIDATION_RULE)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -2265,10 +2319,10 @@ var mockSetValidationRulesTool = {
 var mockSetResponseRulesTool = {
   name: "mock.set_response_rules",
   description: "Replace an endpoint's conditional response rules. Rules fire in order; the first whose every clause matches wins. Disabled rules are skipped. Empty array falls back to defaultResponse.",
-  inputSchema: import_zod8.z.object({
-    mockId: import_zod8.z.string(),
-    endpointId: import_zod8.z.string(),
-    rules: import_zod8.z.array(RESPONSE_RULE)
+  inputSchema: import_zod9.z.object({
+    mockId: import_zod9.z.string(),
+    endpointId: import_zod9.z.string(),
+    rules: import_zod9.z.array(RESPONSE_RULE)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -2299,10 +2353,10 @@ var mockSetResponseRulesTool = {
 var mockSetMultipliersTool = {
   name: "mock.set_multipliers",
   description: "Replace the response multipliers on an endpoint's defaultResponse. Multipliers expand an array at `targetJsonPath` to a count derived from a request value. Empty array clears all multipliers.",
-  inputSchema: import_zod8.z.object({
-    mockId: import_zod8.z.string(),
-    endpointId: import_zod8.z.string(),
-    multipliers: import_zod8.z.array(MULTIPLIER)
+  inputSchema: import_zod9.z.object({
+    mockId: import_zod9.z.string(),
+    endpointId: import_zod9.z.string(),
+    multipliers: import_zod9.z.array(MULTIPLIER)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -2338,6 +2392,7 @@ var TOOL_REGISTRY = [
   importInsomniaTool,
   importHarTool,
   generateCodeTool,
+  workspaceListTool,
   workspaceReadTool,
   workspaceWriteTool,
   requestCreateTool,
@@ -2408,6 +2463,63 @@ function getTool(name) {
   return TOOL_REGISTRY.find((t) => t.name === name);
 }
 
+// src/providers/Workspaces.ts
+var SingleWorkspaceAdapter = class {
+  constructor(provider, workspaceId, displayName = "Workspace") {
+    this.provider = provider;
+    this.workspaceId = workspaceId;
+    this.displayName = displayName;
+  }
+  provider;
+  workspaceId;
+  displayName;
+  async list() {
+    const state = await this.provider.read();
+    const id = state.synced.workspaceId;
+    this.workspaceId = id;
+    return [
+      {
+        id,
+        name: this.displayName,
+        isActive: true,
+        createdAt: state.synced.meta.createdAt,
+        lastOpenedAt: state.synced.meta.updatedAt,
+        counts: {
+          requests: Object.keys(state.synced.collections.requests).length,
+          folders: Object.keys(state.synced.collections.folders).length,
+          environments: Object.keys(state.synced.environments.items).length,
+          mockServers: Object.keys(state.synced.mockServers ?? {}).length,
+          plans: Object.keys(state.synced.executionPlans ?? {}).length
+        }
+      }
+    ];
+  }
+  for(workspaceId) {
+    if (this.workspaceId && workspaceId !== this.workspaceId) {
+      throw new WorkspaceNotFoundError(workspaceId);
+    }
+    return this.provider;
+  }
+  activeId() {
+    return this.workspaceId;
+  }
+  setActive(workspaceId) {
+    if (this.workspaceId && workspaceId !== this.workspaceId) {
+      throw new WorkspaceNotFoundError(workspaceId);
+    }
+    return Promise.resolve();
+  }
+};
+var WorkspaceNotFoundError = class extends Error {
+  code = "workspace-not-found";
+  workspaceId;
+  constructor(workspaceId) {
+    super(`No workspace with id "${workspaceId}" is available on this server.`);
+    this.name = "WorkspaceNotFoundError";
+    this.workspaceId = workspaceId;
+  }
+};
+
 // src/providers/InMemoryWorkspaceProvider.ts
 var import_core2 = require("@apicircle/core");
 var InMemoryWorkspaceProvider = class {
@@ -2468,6 +2580,109 @@ var FileBackedWorkspaceProvider = class {
   }
 };
 
+// src/providers/MultiWorkspaceProvider.ts
+var import_registry = require("@apicircle/core/workspace/registry");
+var MultiWorkspaceProvider = class {
+  constructor(registryRoot) {
+    this.registryRoot = registryRoot;
+  }
+  registryRoot;
+  active = null;
+  activeWorkspaceId = null;
+  /**
+   * Hydrate the active provider from disk. Must be called once before the
+   * MCP host boots so `ctx.workspace.read()` doesn't race the first
+   * registry-load. Returns the registry the boot can log.
+   */
+  async init() {
+    const registry = await (0, import_registry.loadRegistry)(this.registryRoot) ?? {
+      schemaVersion: 1,
+      activeWorkspaceId: null,
+      workspaces: []
+    };
+    if (registry.activeWorkspaceId) {
+      this.activeWorkspaceId = registry.activeWorkspaceId;
+      this.active = new FileBackedWorkspaceProvider(
+        (0, import_registry.workspaceDirFor)(this.registryRoot, registry.activeWorkspaceId)
+      );
+    }
+    return registry;
+  }
+  /** The provider tool handlers see as `ctx.workspace`. */
+  activeProvider() {
+    if (!this.active) {
+      throw new Error(
+        "No active workspace. Open the desktop app at least once, or run `apicircle workspaces create <name>`."
+      );
+    }
+    return this.active;
+  }
+  // ─── Workspaces interface ──────────────────────────────────────────────────
+  async list() {
+    const registry = await (0, import_registry.loadRegistry)(this.registryRoot) ?? {
+      schemaVersion: 1,
+      activeWorkspaceId: null,
+      workspaces: []
+    };
+    const out = [];
+    for (const entry of registry.workspaces) {
+      let counts = null;
+      try {
+        const state = await (0, import_registry.loadWorkspaceById)(this.registryRoot, entry.id);
+        if (state) {
+          counts = {
+            requests: Object.keys(state.synced.collections.requests).length,
+            folders: Object.keys(state.synced.collections.folders).length,
+            environments: Object.keys(state.synced.environments.items).length,
+            mockServers: Object.keys(state.synced.mockServers ?? {}).length,
+            plans: Object.keys(state.synced.executionPlans ?? {}).length
+          };
+        }
+      } catch {
+        counts = null;
+      }
+      out.push({
+        id: entry.id,
+        name: entry.name,
+        isActive: entry.id === registry.activeWorkspaceId,
+        createdAt: entry.createdAt,
+        lastOpenedAt: entry.lastOpenedAt,
+        counts
+      });
+    }
+    return out;
+  }
+  for(workspaceId) {
+    return new FileBackedWorkspaceProvider((0, import_registry.workspaceDirFor)(this.registryRoot, workspaceId));
+  }
+  activeId() {
+    return this.activeWorkspaceId;
+  }
+  async setActive(workspaceId) {
+    const registry = await (0, import_registry.loadRegistry)(this.registryRoot);
+    if (!registry || !registry.workspaces.some((w) => w.id === workspaceId)) {
+      throw new WorkspaceNotFoundError(workspaceId);
+    }
+    const next = await (0, import_registry.setActiveWorkspace)(this.registryRoot, workspaceId);
+    void next;
+    this.activeWorkspaceId = workspaceId;
+    this.active = new FileBackedWorkspaceProvider((0, import_registry.workspaceDirFor)(this.registryRoot, workspaceId));
+  }
+  /**
+   * Idempotent registry write — used by tests / tools that need to
+   * persist registry updates that didn't go through `setActive`.
+   */
+  async writeRegistry(registry) {
+    await (0, import_registry.saveRegistry)(this.registryRoot, registry);
+    this.activeWorkspaceId = registry.activeWorkspaceId;
+    if (registry.activeWorkspaceId) {
+      this.active = new FileBackedWorkspaceProvider(
+        (0, import_registry.workspaceDirFor)(this.registryRoot, registry.activeWorkspaceId)
+      );
+    }
+  }
+};
+
 // src/providers/InProcessMockController.ts
 var import_mock_server_core3 = require("@apicircle/mock-server-core");
 var InProcessMockController = class {
@@ -2508,10 +2723,19 @@ var InProcessMockController = class {
 
 // src/index.ts
 function createMcpServer(options) {
+  const workspaces = options.workspaces ?? new SingleWorkspaceAdapter(
+    options.workspace,
+    null
+    /* discovered on first list() */
+  );
   return new McpHost({
     serverInfo: options.serverInfo,
     tools: options.tools ?? TOOL_REGISTRY,
-    context: { workspace: options.workspace, mock: options.mock }
+    context: {
+      workspace: options.workspace,
+      workspaces,
+      mock: options.mock
+    }
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -2520,7 +2744,10 @@ function createMcpServer(options) {
   InMemoryWorkspaceProvider,
   InProcessMockController,
   McpHost,
+  MultiWorkspaceProvider,
+  SingleWorkspaceAdapter,
   TOOL_REGISTRY,
+  WorkspaceNotFoundError,
   createMcpServer,
   getTool
 });