@apicircle/mcp-server 1.0.1 → 1.0.2

package/dist/index.js

@@ -434,18 +434,37 @@ function renderRust(req) {
   return lines.join("\n");
 }
 
-// src/tools/crud.ts
+// src/tools/workspaceList.ts
 import { z as z4 } from "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: z4.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
+import { z as z5 } from "zod";
 import { generateId as generateId2 } from "@apicircle/shared";
-var HTTP_METHOD = z4.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var HTTP_METHOD = z5.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: z4.object({
-    name: z4.string().default("New request"),
+  inputSchema: z5.object({
+    name: z5.string().default("New request"),
     method: HTTP_METHOD.default("GET"),
-    url: z4.string().default(""),
-    folderId: z4.string().nullable().optional()
+    url: z5.string().default(""),
+    folderId: z5.string().nullable().optional()
   }),
   async handler(input, ctx) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -474,7 +493,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: z4.object({ id: z4.string().optional() }),
+  inputSchema: z5.object({ id: z5.string().optional() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     if (input.id) {
@@ -495,13 +514,13 @@ var requestReadTool = {
 var requestUpdateTool = {
   name: "request.update",
   description: "Patch fields on an existing request.",
-  inputSchema: z4.object({
-    id: z4.string(),
-    patch: z4.object({
-      name: z4.string().optional(),
+  inputSchema: z5.object({
+    id: z5.string(),
+    patch: z5.object({
+      name: z5.string().optional(),
       method: HTTP_METHOD.optional(),
-      url: z4.string().optional(),
-      folderId: z4.string().nullable().optional()
+      url: z5.string().optional(),
+      folderId: z5.string().nullable().optional()
     }).strict()
   }),
   async handler(input, ctx) {
@@ -516,7 +535,7 @@ var requestUpdateTool = {
 var requestDeleteTool = {
   name: "request.delete",
   description: "Delete a request by id.",
-  inputSchema: z4.object({ id: z4.string() }),
+  inputSchema: z5.object({ id: z5.string() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({ kind: "request.delete", id: input.id });
     return { changedIds: out.changedIds };
@@ -525,9 +544,9 @@ var requestDeleteTool = {
 var folderCreateTool = {
   name: "folder.create",
   description: "Create a folder under an optional parent folder.",
-  inputSchema: z4.object({
-    name: z4.string().default("New folder"),
-    parentId: z4.string().nullable().optional()
+  inputSchema: z5.object({
+    name: z5.string().default("New folder"),
+    parentId: z5.string().nullable().optional()
   }),
   async handler(input, ctx) {
     const folder = {
@@ -542,7 +561,7 @@ var folderCreateTool = {
 var folderReadTool = {
   name: "folder.read",
   description: "Read a folder by id, or list all folders when no id is provided.",
-  inputSchema: z4.object({ id: z4.string().optional() }),
+  inputSchema: z5.object({ id: z5.string().optional() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     if (input.id) {
@@ -558,9 +577,9 @@ var folderReadTool = {
 var folderUpdateTool = {
   name: "folder.update",
   description: "Move a folder to a new parent (or to root with parentId: null).",
-  inputSchema: z4.object({
-    id: z4.string(),
-    parentId: z4.string().nullable()
+  inputSchema: z5.object({
+    id: z5.string(),
+    parentId: z5.string().nullable()
   }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({
@@ -574,23 +593,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: z4.object({ id: z4.string() }),
+  inputSchema: z5.object({ id: z5.string() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({ kind: "folder.delete", id: input.id });
     return { changedIds: out.changedIds };
   }
 };
-var VARIABLE = z4.object({
-  key: z4.string(),
-  value: z4.string(),
-  encrypted: z4.boolean().default(false)
+var VARIABLE = z5.object({
+  key: z5.string(),
+  value: z5.string(),
+  encrypted: z5.boolean().default(false)
 });
 var environmentCreateTool = {
   name: "environment.create",
   description: "Create a new environment (or upsert one with the same name).",
-  inputSchema: z4.object({
-    name: z4.string(),
-    variables: z4.array(VARIABLE).default([])
+  inputSchema: z5.object({
+    name: z5.string(),
+    variables: z5.array(VARIABLE).default([])
   }),
   async handler(input, ctx) {
     const env = { name: input.name, variables: input.variables };
@@ -601,7 +620,7 @@ var environmentCreateTool = {
 var environmentReadTool = {
   name: "environment.read",
   description: "Read environments \u2014 pass `name` for one, or omit for the full list.",
-  inputSchema: z4.object({ name: z4.string().optional() }),
+  inputSchema: z5.object({ name: z5.string().optional() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     if (input.name) {
@@ -618,9 +637,9 @@ var environmentReadTool = {
 var environmentUpdateTool = {
   name: "environment.update",
   description: "Replace the variables list of an environment.",
-  inputSchema: z4.object({
-    name: z4.string(),
-    variables: z4.array(VARIABLE)
+  inputSchema: z5.object({
+    name: z5.string(),
+    variables: z5.array(VARIABLE)
   }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({
@@ -633,7 +652,7 @@ var environmentUpdateTool = {
 var environmentDeleteTool = {
   name: "environment.delete",
   description: "Delete an environment by name.",
-  inputSchema: z4.object({ name: z4.string() }),
+  inputSchema: z5.object({ name: z5.string() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({ kind: "environment.delete", name: input.name });
     return { changedIds: out.changedIds };
@@ -642,7 +661,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: z4.object({ name: z4.string().nullable() }),
+  inputSchema: z5.object({ name: z5.string().nullable() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({
       kind: "environment.setActive",
@@ -654,18 +673,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: z4.object({
-    order: z4.array(
-      z4.union([
-        z4.string(),
-        z4.object({
-          kind: z4.literal("local"),
-          name: z4.string()
+  inputSchema: z5.object({
+    order: z5.array(
+      z5.union([
+        z5.string(),
+        z5.object({
+          kind: z5.literal("local"),
+          name: z5.string()
         }),
-        z4.object({
-          kind: z4.literal("linked"),
-          linkedWorkspaceId: z4.string(),
-          envName: z4.string()
+        z5.object({
+          kind: z5.literal("linked"),
+          linkedWorkspaceId: z5.string(),
+          envName: z5.string()
         })
       ])
     )
@@ -682,7 +701,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: z4.object({ name: z4.string() }),
+  inputSchema: z5.object({ name: z5.string() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     const env = state.synced.environments.items[input.name];
@@ -700,9 +719,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: z4.object({
-    json: z4.string().min(1),
-    overwrite: z4.boolean().default(false)
+  inputSchema: z5.object({
+    json: z5.string().min(1),
+    overwrite: z5.boolean().default(false)
   }),
   async handler(input, ctx) {
     let parsed;
@@ -732,17 +751,17 @@ var environmentImportTool = {
     return { ok: true, name: env.name, changedIds: out.changedIds };
   }
 };
-var PLAN_STEP = z4.object({
-  requestId: z4.string(),
-  linkedWorkspaceId: z4.string().optional()
+var PLAN_STEP = z5.object({
+  requestId: z5.string(),
+  linkedWorkspaceId: z5.string().optional()
 });
 var planCreateTool = {
   name: "plan.create",
   description: "Create a new execution plan (sequence of request steps).",
-  inputSchema: z4.object({
-    name: z4.string().default("New plan"),
-    steps: z4.array(PLAN_STEP).default([]),
-    envPriorityOrder: z4.array(z4.string()).default([])
+  inputSchema: z5.object({
+    name: z5.string().default("New plan"),
+    steps: z5.array(PLAN_STEP).default([]),
+    envPriorityOrder: z5.array(z5.string()).default([])
   }),
   async handler(input, ctx) {
     const id = generateId2();
@@ -762,7 +781,7 @@ var planCreateTool = {
 var planReadTool = {
   name: "plan.read",
   description: "Read a plan by id, or list all plans when no id is provided.",
-  inputSchema: z4.object({ id: z4.string().optional() }),
+  inputSchema: z5.object({ id: z5.string().optional() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     if (input.id) {
@@ -778,12 +797,12 @@ var planReadTool = {
 var planUpdateTool = {
   name: "plan.update",
   description: "Patch fields on an existing plan.",
-  inputSchema: z4.object({
-    id: z4.string(),
-    patch: z4.object({
-      name: z4.string().optional(),
-      steps: z4.array(PLAN_STEP).optional(),
-      envPriorityOrder: z4.array(z4.string()).optional()
+  inputSchema: z5.object({
+    id: z5.string(),
+    patch: z5.object({
+      name: z5.string().optional(),
+      steps: z5.array(PLAN_STEP).optional(),
+      envPriorityOrder: z5.array(z5.string()).optional()
     }).strict()
   }),
   async handler(input, ctx) {
@@ -804,7 +823,7 @@ var planUpdateTool = {
 var planDeleteTool = {
   name: "plan.delete",
   description: "Delete a plan by id. Drops history rows referencing this plan.",
-  inputSchema: z4.object({ id: z4.string() }),
+  inputSchema: z5.object({ id: z5.string() }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({ kind: "plan.delete", id: input.id });
     return { changedIds: out.changedIds };
@@ -813,11 +832,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: z4.object({
-    planId: z4.string(),
-    requestId: z4.string(),
-    linkedWorkspaceId: z4.string().optional(),
-    position: z4.number().int().nonnegative().optional()
+  inputSchema: z5.object({
+    planId: z5.string(),
+    requestId: z5.string(),
+    linkedWorkspaceId: z5.string().optional(),
+    position: z5.number().int().nonnegative().optional()
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -843,9 +862,9 @@ var planAddStepTool = {
 var planRemoveStepTool = {
   name: "plan.remove_step",
   description: "Remove a step from a plan by 0-based index.",
-  inputSchema: z4.object({
-    planId: z4.string(),
-    index: z4.number().int().nonnegative()
+  inputSchema: z5.object({
+    planId: z5.string(),
+    index: z5.number().int().nonnegative()
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -865,9 +884,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: z4.object({
-    planId: z4.string(),
-    order: z4.array(z4.number().int().nonnegative())
+  inputSchema: z5.object({
+    planId: z5.string(),
+    order: z5.array(z5.number().int().nonnegative())
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -889,13 +908,13 @@ var planReorderStepsTool = {
     return { ok: true, changedIds: out.changedIds };
   }
 };
-var PLAN_VARIABLE = z4.object({ key: z4.string(), value: z4.string() });
+var PLAN_VARIABLE = z5.object({ key: z5.string(), value: z5.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: z4.object({
-    planId: z4.string(),
-    variables: z4.array(PLAN_VARIABLE)
+  inputSchema: z5.object({
+    planId: z5.string(),
+    variables: z5.array(PLAN_VARIABLE)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -911,9 +930,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: z4.object({
-    id: z4.string(),
-    withAssertions: z4.boolean().default(true)
+  inputSchema: z5.object({
+    id: z5.string(),
+    withAssertions: z5.boolean().default(true)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -927,18 +946,18 @@ var planRunTool = {
     };
   }
 };
-var ASSERTION = z4.object({
-  id: z4.string().optional(),
-  kind: z4.enum(["status", "header", "json-path", "duration"]),
-  op: z4.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
-  target: z4.string().optional(),
-  expected: z4.union([z4.string(), z4.number()])
+var ASSERTION = z5.object({
+  id: z5.string().optional(),
+  kind: z5.enum(["status", "header", "json-path", "duration"]),
+  op: z5.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
+  target: z5.string().optional(),
+  expected: z5.union([z5.string(), z5.number()])
 });
 var assertionCreateTool = {
   name: "assertion.create",
   description: "Add an assertion to a request.",
-  inputSchema: z4.object({
-    requestId: z4.string(),
+  inputSchema: z5.object({
+    requestId: z5.string(),
     assertion: ASSERTION
   }),
   async handler(input, ctx) {
@@ -957,9 +976,9 @@ var assertionCreateTool = {
 var assertionReadTool = {
   name: "assertion.read",
   description: "List assertions for a request, or fetch a single assertion by id.",
-  inputSchema: z4.object({
-    requestId: z4.string(),
-    assertionId: z4.string().optional()
+  inputSchema: z5.object({
+    requestId: z5.string(),
+    assertionId: z5.string().optional()
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -975,8 +994,8 @@ var assertionReadTool = {
 var assertionUpdateTool = {
   name: "assertion.update",
   description: "Replace an existing assertion (matched by `assertion.id`).",
-  inputSchema: z4.object({
-    requestId: z4.string(),
+  inputSchema: z5.object({
+    requestId: z5.string(),
     assertion: ASSERTION.required({ id: true })
   }),
   async handler(input, ctx) {
@@ -991,9 +1010,9 @@ var assertionUpdateTool = {
 var assertionDeleteTool = {
   name: "assertion.delete",
   description: "Remove an assertion from a request.",
-  inputSchema: z4.object({
-    requestId: z4.string(),
-    assertionId: z4.string()
+  inputSchema: z5.object({
+    requestId: z5.string(),
+    assertionId: z5.string()
   }),
   async handler(input, ctx) {
     const out = await ctx.workspace.apply({
@@ -1006,21 +1025,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: z4.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: z5.object({
+    workspaceId: z5.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: z4.object({
-    synced: z4.unknown().optional(),
-    local: z4.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: z5.object({
+    workspaceId: z5.string().min(1).max(256).optional().describe("Optional workspace id; omit to write the active workspace."),
+    synced: z5.unknown().optional(),
+    local: z5.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
     });
@@ -1029,16 +1080,16 @@ var workspaceWriteTool = {
 };
 
 // src/tools/history.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "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: z5.object({
-    requestId: z5.string().optional(),
-    ok: z5.boolean().optional(),
-    since: z5.string().optional(),
-    until: z5.string().optional(),
-    limit: z5.number().int().positive().max(500).default(100)
+  inputSchema: z6.object({
+    requestId: z6.string().optional(),
+    ok: z6.boolean().optional(),
+    since: z6.string().optional(),
+    until: z6.string().optional(),
+    limit: z6.number().int().positive().max(500).default(100)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1072,7 +1123,7 @@ var historyListRunsTool = {
 var historyGetRunTool = {
   name: "history.get_run",
   description: "Fetch a single history row in full (headers, body preview, assertion results).",
-  inputSchema: z5.object({ id: z5.string() }),
+  inputSchema: z6.object({ id: z6.string() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     const run = state.local.history.requestRuns.find((r) => r.id === input.id);
@@ -1083,7 +1134,7 @@ var historyGetRunTool = {
 var historyDeleteRunTool = {
   name: "history.delete_run",
   description: "Delete a single request-run row by id.",
-  inputSchema: z5.object({ id: z5.string() }),
+  inputSchema: z6.object({ id: z6.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 };
@@ -1092,8 +1143,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: z5.object({
-    olderThanDays: z5.number().nonnegative()
+  inputSchema: z6.object({
+    olderThanDays: z6.number().nonnegative()
   }),
   async handler(input, ctx) {
     const olderThanMs = input.olderThanDays * 24 * 60 * 60 * 1e3;
@@ -1103,15 +1154,15 @@ var historyPurgeTool = {
 };
 
 // src/tools/codebase.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "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: z6.object({
-    source: z6.string().min(1),
+  inputSchema: z7.object({
+    source: z7.string().min(1),
     /** Hint to limit which framework patterns to apply. Empty = try all. */
-    frameworks: z6.array(z6.enum(["express", "fastapi", "nest", "spring"])).default([])
+    frameworks: z7.array(z7.enum(["express", "fastapi", "nest", "spring"])).default([])
   }),
   async handler(input) {
     const enabled = new Set(
@@ -1192,18 +1243,18 @@ var codebaseExtractCollectionTool = {
 };
 
 // src/tools/prompt.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 import { generateId as generateId3, makeDefaultMockResponse, makeDefaultRequestSchema } from "@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: z7.object({
-    name: z7.string(),
-    variables: z7.array(
-      z7.object({
-        key: z7.string(),
-        value: z7.string(),
-        encrypted: z7.boolean().default(false)
+  inputSchema: z8.object({
+    name: z8.string(),
+    variables: z8.array(
+      z8.object({
+        key: z8.string(),
+        value: z8.string(),
+        encrypted: z8.boolean().default(false)
       })
     )
   }),
@@ -1216,13 +1267,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: z7.object({
-    requestId: z7.string(),
-    assertion: z7.object({
-      kind: z7.enum(["status", "header", "json-path", "duration"]),
-      op: z7.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
-      target: z7.string().optional(),
-      expected: z7.union([z7.string(), z7.number()])
+  inputSchema: z8.object({
+    requestId: z8.string(),
+    assertion: z8.object({
+      kind: z8.enum(["status", "header", "json-path", "duration"]),
+      op: z8.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
+      target: z8.string().optional(),
+      expected: z8.union([z8.string(), z8.number()])
     })
   }),
   async handler(input, ctx) {
@@ -1241,10 +1292,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: z7.object({
-    name: z7.string(),
-    stepRequestIds: z7.array(z7.string()).default([]),
-    envPriorityOrder: z7.array(z7.string()).default([])
+  inputSchema: z8.object({
+    name: z8.string(),
+    stepRequestIds: z8.array(z8.string()).default([]),
+    envPriorityOrder: z8.array(z8.string()).default([])
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1273,51 +1324,51 @@ var promptCreatePlanTool = {
     return { ok: true, id, changedIds: out.changedIds };
   }
 };
-var HTTP_METHOD2 = z7.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
-var HEADER_OR_QUERY = z7.object({
-  key: z7.string(),
-  value: z7.string(),
-  enabled: z7.boolean().default(true)
+var HTTP_METHOD2 = z8.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var HEADER_OR_QUERY = z8.object({
+  key: z8.string(),
+  value: z8.string(),
+  enabled: z8.boolean().default(true)
 });
-var REQUEST_BODY = z7.object({
-  type: z7.enum(["none", "json", "text", "xml", "graphql", "urlencoded"]).default("none"),
-  content: z7.string().default(""),
-  variables: z7.string().optional()
+var REQUEST_BODY = z8.object({
+  type: z8.enum(["none", "json", "text", "xml", "graphql", "urlencoded"]).default("none"),
+  content: z8.string().default(""),
+  variables: z8.string().optional()
 });
-var PROMPT_AUTH = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("none") }),
-  z7.object({ type: z7.literal("inherit") }),
-  z7.object({ type: z7.literal("bearer"), token: z7.string().default("") }),
-  z7.object({
-    type: z7.literal("basic"),
-    username: z7.string().default(""),
-    password: z7.string().default("")
+var PROMPT_AUTH = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("none") }),
+  z8.object({ type: z8.literal("inherit") }),
+  z8.object({ type: z8.literal("bearer"), token: z8.string().default("") }),
+  z8.object({
+    type: z8.literal("basic"),
+    username: z8.string().default(""),
+    password: z8.string().default("")
   }),
-  z7.object({
-    type: z7.literal("api-key"),
-    key: z7.string().default(""),
-    value: z7.string().default(""),
-    addTo: z7.enum(["header", "query", "cookie"]).default("header")
+  z8.object({
+    type: z8.literal("api-key"),
+    key: z8.string().default(""),
+    value: z8.string().default(""),
+    addTo: z8.enum(["header", "query", "cookie"]).default("header")
   }),
-  z7.object({
-    type: z7.literal("custom-header"),
-    key: z7.string().default(""),
-    value: z7.string().default("")
+  z8.object({
+    type: z8.literal("custom-header"),
+    key: z8.string().default(""),
+    value: z8.string().default("")
   })
 ]);
-var PROMPT_ASSERTION = z7.object({
-  kind: z7.enum(["status", "header", "json-path", "duration"]),
-  op: z7.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
-  target: z7.string().optional(),
-  expected: z7.union([z7.string(), z7.number()])
+var PROMPT_ASSERTION = z8.object({
+  kind: z8.enum(["status", "header", "json-path", "duration"]),
+  op: z8.enum(["equals", "not-equals", "contains", "lt", "gt", "matches"]),
+  target: z8.string().optional(),
+  expected: z8.union([z8.string(), z8.number()])
 });
-var ENDPOINT_RESPONSE = z7.object({
-  status: z7.number().int().min(100).max(599).default(200),
-  jsonBody: z7.string().default("{}"),
-  contentType: z7.string().default("application/json")
+var ENDPOINT_RESPONSE = z8.object({
+  status: z8.number().int().min(100).max(599).default(200),
+  jsonBody: z8.string().default("{}"),
+  contentType: z8.string().default("application/json")
 });
-var VALIDATION_RULE_NL = z7.object({
-  kind: z7.enum([
+var VALIDATION_RULE_NL = z8.object({
+  kind: z8.enum([
     "header-required",
     "header-equals",
     "header-matches",
@@ -1328,50 +1379,50 @@ var VALIDATION_RULE_NL = z7.object({
     "body-required",
     "content-type-equals"
   ]),
-  target: z7.string().default(""),
-  expected: z7.string().optional(),
-  message: z7.string().optional(),
-  enabled: z7.boolean().default(true),
-  failResponse: z7.object({
-    status: z7.number().int().min(100).max(599).default(400),
-    jsonBody: z7.string().default('{"error":"validation failed"}')
+  target: z8.string().default(""),
+  expected: z8.string().optional(),
+  message: z8.string().optional(),
+  enabled: z8.boolean().default(true),
+  failResponse: z8.object({
+    status: z8.number().int().min(100).max(599).default(400),
+    jsonBody: z8.string().default('{"error":"validation failed"}')
   }).default({})
 });
-var CONDITION_CLAUSE_NL = z7.object({
-  scope: z7.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
-  target: z7.string(),
-  op: z7.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
-  value: z7.string().optional()
+var CONDITION_CLAUSE_NL = z8.object({
+  scope: z8.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
+  target: z8.string(),
+  op: z8.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
+  value: z8.string().optional()
 });
-var RESPONSE_RULE_NL = z7.object({
-  name: z7.string(),
-  enabled: z7.boolean().default(true),
-  when: z7.array(CONDITION_CLAUSE_NL).default([]),
-  response: z7.object({
-    status: z7.number().int().min(100).max(599).default(200),
-    jsonBody: z7.string().default("{}")
+var RESPONSE_RULE_NL = z8.object({
+  name: z8.string(),
+  enabled: z8.boolean().default(true),
+  when: z8.array(CONDITION_CLAUSE_NL).default([]),
+  response: z8.object({
+    status: z8.number().int().min(100).max(599).default(200),
+    jsonBody: z8.string().default("{}")
   }).default({})
 });
-var MULTIPLIER_NL = z7.object({
-  name: z7.string().optional(),
-  source: z7.object({
-    kind: z7.enum(["query", "pathParam", "header", "body-json-path"]),
-    key: z7.string()
+var MULTIPLIER_NL = z8.object({
+  name: z8.string().optional(),
+  source: z8.object({
+    kind: z8.enum(["query", "pathParam", "header", "body-json-path"]),
+    key: z8.string()
   }),
-  targetJsonPath: z7.string(),
-  defaultCount: z7.number().int().nonnegative().default(0),
-  min: z7.number().int().nonnegative().optional(),
-  max: z7.number().int().nonnegative().optional()
+  targetJsonPath: z8.string(),
+  defaultCount: z8.number().int().nonnegative().default(0),
+  min: z8.number().int().nonnegative().optional(),
+  max: z8.number().int().nonnegative().optional()
 });
-var ENDPOINT_INPUT = z7.object({
+var ENDPOINT_INPUT = z8.object({
   method: HTTP_METHOD2,
-  pathPattern: z7.string().min(1),
-  name: z7.string().optional(),
-  description: z7.string().optional(),
+  pathPattern: z8.string().min(1),
+  name: z8.string().optional(),
+  description: z8.string().optional(),
   response: ENDPOINT_RESPONSE.optional(),
-  validationRules: z7.array(VALIDATION_RULE_NL).default([]),
-  responseRules: z7.array(RESPONSE_RULE_NL).default([]),
-  multipliers: z7.array(MULTIPLIER_NL).default([])
+  validationRules: z8.array(VALIDATION_RULE_NL).default([]),
+  responseRules: z8.array(RESPONSE_RULE_NL).default([]),
+  multipliers: z8.array(MULTIPLIER_NL).default([])
 });
 function buildRequestBody(input) {
   if (!input) return { type: "none", content: "" };
@@ -1464,17 +1515,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: z7.object({
-    name: z7.string().default("New request"),
+  inputSchema: z8.object({
+    name: z8.string().default("New request"),
     method: HTTP_METHOD2.default("GET"),
-    url: z7.string().default(""),
-    folderId: z7.string().nullable().optional(),
-    headers: z7.array(HEADER_OR_QUERY).default([]),
-    queryParams: z7.array(HEADER_OR_QUERY).default([]),
-    pathParams: z7.record(z7.string(), z7.string()).optional(),
+    url: z8.string().default(""),
+    folderId: z8.string().nullable().optional(),
+    headers: z8.array(HEADER_OR_QUERY).default([]),
+    queryParams: z8.array(HEADER_OR_QUERY).default([]),
+    pathParams: z8.record(z8.string(), z8.string()).optional(),
     body: REQUEST_BODY.optional(),
     auth: PROMPT_AUTH.optional(),
-    assertions: z7.array(PROMPT_ASSERTION).default([])
+    assertions: z8.array(PROMPT_ASSERTION).default([])
   }),
   async handler(input, ctx) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1504,19 +1555,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: z7.object({
-    id: z7.string(),
-    patch: z7.object({
-      name: z7.string().optional(),
+  inputSchema: z8.object({
+    id: z8.string(),
+    patch: z8.object({
+      name: z8.string().optional(),
       method: HTTP_METHOD2.optional(),
-      url: z7.string().optional(),
-      folderId: z7.string().nullable().optional(),
-      headers: z7.array(HEADER_OR_QUERY).optional(),
-      queryParams: z7.array(HEADER_OR_QUERY).optional(),
-      pathParams: z7.record(z7.string(), z7.string()).optional(),
+      url: z8.string().optional(),
+      folderId: z8.string().nullable().optional(),
+      headers: z8.array(HEADER_OR_QUERY).optional(),
+      queryParams: z8.array(HEADER_OR_QUERY).optional(),
+      pathParams: z8.record(z8.string(), z8.string()).optional(),
       body: REQUEST_BODY.optional(),
       auth: PROMPT_AUTH.optional(),
-      assertions: z7.array(PROMPT_ASSERTION).optional()
+      assertions: z8.array(PROMPT_ASSERTION).optional()
     }).strict()
   }),
   async handler(input, ctx) {
@@ -1544,17 +1595,17 @@ var promptUpdateRequestTool = {
     return { ok: true, changedIds: out.changedIds };
   }
 };
-var FOLDER_TREE_NODE = z7.lazy(
-  () => z7.object({
-    name: z7.string(),
-    children: z7.array(FOLDER_TREE_NODE).optional()
+var FOLDER_TREE_NODE = z8.lazy(
+  () => z8.object({
+    name: z8.string(),
+    children: z8.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: z7.object({
-    parentId: z7.string().nullable().optional(),
+  inputSchema: z8.object({
+    parentId: z8.string().nullable().optional(),
     tree: FOLDER_TREE_NODE
   }),
   async handler(input, ctx) {
@@ -1580,9 +1631,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: z7.object({
-    planId: z7.string(),
-    requestIds: z7.array(z7.string()).min(1)
+  inputSchema: z8.object({
+    planId: z8.string(),
+    requestIds: z8.array(z8.string()).min(1)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1612,9 +1663,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: z7.object({
-    planId: z7.string(),
-    variables: z7.array(z7.object({ key: z7.string(), value: z7.string() }))
+  inputSchema: z8.object({
+    planId: z8.string(),
+    variables: z8.array(z8.object({ key: z8.string(), value: z8.string() }))
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1630,10 +1681,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: z7.object({
-    name: z7.string().min(1),
-    defaultPort: z7.number().int().positive().nullable().optional(),
-    endpoints: z7.array(ENDPOINT_INPUT).default([])
+  inputSchema: z8.object({
+    name: z8.string().min(1),
+    defaultPort: z8.number().int().positive().nullable().optional(),
+    endpoints: z8.array(ENDPOINT_INPUT).default([])
   }),
   async handler(input, ctx) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1660,16 +1711,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: z7.object({
-    mockId: z7.string(),
+  inputSchema: z8.object({
+    mockId: z8.string(),
     method: HTTP_METHOD2,
-    pathPattern: z7.string().min(1),
-    name: z7.string().optional(),
-    description: z7.string().optional(),
+    pathPattern: z8.string().min(1),
+    name: z8.string().optional(),
+    description: z8.string().optional(),
     response: ENDPOINT_RESPONSE.optional(),
-    validationRules: z7.array(VALIDATION_RULE_NL).default([]),
-    responseRules: z7.array(RESPONSE_RULE_NL).default([]),
-    multipliers: z7.array(MULTIPLIER_NL).default([])
+    validationRules: z8.array(VALIDATION_RULE_NL).default([]),
+    responseRules: z8.array(RESPONSE_RULE_NL).default([]),
+    multipliers: z8.array(MULTIPLIER_NL).default([])
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1691,10 +1742,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: z7.object({
-    mockId: z7.string(),
-    endpointId: z7.string(),
-    rules: z7.array(VALIDATION_RULE_NL)
+  inputSchema: z8.object({
+    mockId: z8.string(),
+    endpointId: z8.string(),
+    rules: z8.array(VALIDATION_RULE_NL)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1725,10 +1776,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: z7.object({
-    mockId: z7.string(),
-    endpointId: z7.string(),
-    rules: z7.array(RESPONSE_RULE_NL)
+  inputSchema: z8.object({
+    mockId: z8.string(),
+    endpointId: z8.string(),
+    rules: z8.array(RESPONSE_RULE_NL)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1763,10 +1814,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: z7.object({
-    mockId: z7.string(),
-    endpointId: z7.string(),
-    multipliers: z7.array(MULTIPLIER_NL)
+  inputSchema: z8.object({
+    mockId: z8.string(),
+    endpointId: z8.string(),
+    multipliers: z8.array(MULTIPLIER_NL)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1795,7 +1846,7 @@ var promptSetEndpointMultipliersTool = {
 };
 
 // src/tools/mocks.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 import { generateId as generateId4, makeDefaultMockResponse as makeDefaultMockResponse2, makeDefaultRequestSchema as makeDefaultRequestSchema2 } from "@apicircle/shared";
 import { parseSourceToEndpoints } from "@apicircle/mock-server-core";
 async function ingestSource(source, name) {
@@ -1818,10 +1869,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: z8.object({
-    name: z8.string(),
-    spec: z8.string().min(1),
-    format: z8.enum(["json", "yaml"]).default("json")
+  inputSchema: z9.object({
+    name: z9.string(),
+    spec: z9.string().min(1),
+    format: z9.enum(["json", "yaml"]).default("json")
   }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
@@ -1840,7 +1891,7 @@ var mockCreateFromOpenApiTool = {
 var mockCreateFromPostmanTool = {
   name: "mock.create_from_postman",
   description: "Create a mock server from a Postman v2/v2.1 collection.",
-  inputSchema: z8.object({ name: z8.string(), collection: z8.string().min(1) }),
+  inputSchema: z9.object({ name: z9.string(), collection: z9.string().min(1) }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
       { kind: "postman", collection: input.collection },
@@ -1858,7 +1909,7 @@ var mockCreateFromPostmanTool = {
 var mockCreateFromInsomniaTool = {
   name: "mock.create_from_insomnia",
   description: "Create a mock server from an Insomnia v4 export.",
-  inputSchema: z8.object({ name: z8.string(), export: z8.string().min(1) }),
+  inputSchema: z9.object({ name: z9.string(), export: z9.string().min(1) }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
       { kind: "insomnia", export: input.export },
@@ -1876,7 +1927,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: z8.object({ name: z8.string(), collection: z8.string().min(1) }),
+  inputSchema: z9.object({ name: z9.string(), collection: z9.string().min(1) }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
       { kind: "postman", collection: input.collection },
@@ -1894,7 +1945,7 @@ var mockImportPostmanMockCollectionTool = {
 var mockListTool = {
   name: "mock.list",
   description: "List all mock servers in the workspace plus their runtime status (running / stopped, port).",
-  inputSchema: z8.object({}),
+  inputSchema: z9.object({}),
   async handler(_input, ctx) {
     const state = await ctx.workspace.read();
     const running = await ctx.mock.list();
@@ -1916,9 +1967,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: z8.object({
-    id: z8.string(),
-    port: z8.number().int().positive().optional()
+  inputSchema: z9.object({
+    id: z9.string(),
+    port: z9.number().int().positive().optional()
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -1935,7 +1986,7 @@ var mockStartTool = {
 var mockStopTool = {
   name: "mock.stop",
   description: "Stop a running mock server by id (no-op if not running).",
-  inputSchema: z8.object({ id: z8.string() }),
+  inputSchema: z9.object({ id: z9.string() }),
   async handler(input, ctx) {
     try {
       await ctx.mock.stop(input.id);
@@ -1948,7 +1999,7 @@ var mockStopTool = {
 var mockDeleteTool = {
   name: "mock.delete",
   description: "Delete a mock server definition. Stops it first if it's running.",
-  inputSchema: z8.object({ id: z8.string() }),
+  inputSchema: z9.object({ id: z9.string() }),
   async handler(input, ctx) {
     try {
       await ctx.mock.stop(input.id);
@@ -1958,13 +2009,13 @@ var mockDeleteTool = {
     return { ok: true, changedIds: out.changedIds };
   }
 };
-var HTTP_METHOD3 = z8.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var HTTP_METHOD3 = z9.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: z8.object({
-    name: z8.string().min(1),
-    defaultPort: z8.number().int().positive().nullable().optional()
+  inputSchema: z9.object({
+    name: z9.string().min(1),
+    defaultPort: z9.number().int().positive().nullable().optional()
   }),
   async handler(input, ctx) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1987,7 +2038,7 @@ var mockCreateManualTool = {
 var mockListEndpointsTool = {
   name: "mock.list_endpoints",
   description: "List endpoints for a mock server (id, method, path, name).",
-  inputSchema: z8.object({ mockId: z8.string() }),
+  inputSchema: z9.object({ mockId: z9.string() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     const mock = state.synced.mockServers[input.mockId];
@@ -2006,10 +2057,10 @@ var mockListEndpointsTool = {
     };
   }
 };
-var ENDPOINT_RESPONSE2 = z8.object({
-  status: z8.number().int().min(100).max(599).default(200),
-  jsonBody: z8.string().default("{}"),
-  contentType: z8.string().default("application/json")
+var ENDPOINT_RESPONSE2 = z9.object({
+  status: z9.number().int().min(100).max(599).default(200),
+  jsonBody: z9.string().default("{}"),
+  contentType: z9.string().default("application/json")
 });
 function buildDefaultEndpoint(args) {
   const response = args.response ?? {
@@ -2038,12 +2089,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: z8.object({
-    mockId: z8.string(),
+  inputSchema: z9.object({
+    mockId: z9.string(),
     method: HTTP_METHOD3,
-    pathPattern: z8.string().min(1),
-    name: z8.string().optional(),
-    description: z8.string().optional(),
+    pathPattern: z9.string().min(1),
+    name: z9.string().optional(),
+    description: z9.string().optional(),
     response: ENDPOINT_RESPONSE2.optional()
   }),
   async handler(input, ctx) {
@@ -2066,13 +2117,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: z8.object({
-    mockId: z8.string(),
-    endpointId: z8.string(),
+  inputSchema: z9.object({
+    mockId: z9.string(),
+    endpointId: z9.string(),
     method: HTTP_METHOD3.optional(),
-    pathPattern: z8.string().optional(),
-    name: z8.string().optional(),
-    description: z8.string().optional(),
+    pathPattern: z9.string().optional(),
+    name: z9.string().optional(),
+    description: z9.string().optional(),
     response: ENDPOINT_RESPONSE2.partial().optional()
   }),
   async handler(input, ctx) {
@@ -2113,7 +2164,7 @@ var mockUpdateEndpointTool = {
 var mockDeleteEndpointTool = {
   name: "mock.delete_endpoint",
   description: "Remove an endpoint from a mock server.",
-  inputSchema: z8.object({ mockId: z8.string(), endpointId: z8.string() }),
+  inputSchema: z9.object({ mockId: z9.string(), endpointId: z9.string() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     const mock = state.synced.mockServers[input.mockId];
@@ -2133,9 +2184,9 @@ var mockDeleteEndpointTool = {
     return { ok: true, changedIds: out.changedIds };
   }
 };
-var VALIDATION_RULE = z8.object({
-  id: z8.string().optional(),
-  kind: z8.enum([
+var VALIDATION_RULE = z9.object({
+  id: z9.string().optional(),
+  kind: z9.enum([
     "header-required",
     "header-equals",
     "header-matches",
@@ -2146,43 +2197,43 @@ var VALIDATION_RULE = z8.object({
     "body-required",
     "content-type-equals"
   ]),
-  target: z8.string().default(""),
-  expected: z8.string().optional(),
-  message: z8.string().optional(),
-  enabled: z8.boolean().default(true),
-  failResponse: z8.object({
-    status: z8.number().int().min(100).max(599).default(400),
-    jsonBody: z8.string().default('{"error":"validation failed"}')
+  target: z9.string().default(""),
+  expected: z9.string().optional(),
+  message: z9.string().optional(),
+  enabled: z9.boolean().default(true),
+  failResponse: z9.object({
+    status: z9.number().int().min(100).max(599).default(400),
+    jsonBody: z9.string().default('{"error":"validation failed"}')
   }).default({})
 });
-var CONDITION_CLAUSE = z8.object({
-  id: z8.string().optional(),
-  scope: z8.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
-  target: z8.string(),
-  op: z8.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
-  value: z8.string().optional()
+var CONDITION_CLAUSE = z9.object({
+  id: z9.string().optional(),
+  scope: z9.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
+  target: z9.string(),
+  op: z9.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
+  value: z9.string().optional()
 });
-var RESPONSE_RULE = z8.object({
-  id: z8.string().optional(),
-  name: z8.string(),
-  enabled: z8.boolean().default(true),
-  when: z8.array(CONDITION_CLAUSE).default([]),
-  response: z8.object({
-    status: z8.number().int().min(100).max(599).default(200),
-    jsonBody: z8.string().default("{}")
+var RESPONSE_RULE = z9.object({
+  id: z9.string().optional(),
+  name: z9.string(),
+  enabled: z9.boolean().default(true),
+  when: z9.array(CONDITION_CLAUSE).default([]),
+  response: z9.object({
+    status: z9.number().int().min(100).max(599).default(200),
+    jsonBody: z9.string().default("{}")
   }).default({})
 });
-var MULTIPLIER = z8.object({
-  id: z8.string().optional(),
-  name: z8.string().optional(),
-  source: z8.object({
-    kind: z8.enum(["query", "pathParam", "header", "body-json-path"]),
-    key: z8.string()
+var MULTIPLIER = z9.object({
+  id: z9.string().optional(),
+  name: z9.string().optional(),
+  source: z9.object({
+    kind: z9.enum(["query", "pathParam", "header", "body-json-path"]),
+    key: z9.string()
   }),
-  targetJsonPath: z8.string(),
-  defaultCount: z8.number().int().nonnegative().default(0),
-  min: z8.number().int().nonnegative().optional(),
-  max: z8.number().int().nonnegative().optional()
+  targetJsonPath: z9.string(),
+  defaultCount: z9.number().int().nonnegative().default(0),
+  min: z9.number().int().nonnegative().optional(),
+  max: z9.number().int().nonnegative().optional()
 });
 function defaultJsonResponseConfig(args) {
   return {
@@ -2207,10 +2258,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: z8.object({
-    mockId: z8.string(),
-    endpointId: z8.string(),
-    rules: z8.array(VALIDATION_RULE)
+  inputSchema: z9.object({
+    mockId: z9.string(),
+    endpointId: z9.string(),
+    rules: z9.array(VALIDATION_RULE)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -2237,10 +2288,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: z8.object({
-    mockId: z8.string(),
-    endpointId: z8.string(),
-    rules: z8.array(RESPONSE_RULE)
+  inputSchema: z9.object({
+    mockId: z9.string(),
+    endpointId: z9.string(),
+    rules: z9.array(RESPONSE_RULE)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -2271,10 +2322,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: z8.object({
-    mockId: z8.string(),
-    endpointId: z8.string(),
-    multipliers: z8.array(MULTIPLIER)
+  inputSchema: z9.object({
+    mockId: z9.string(),
+    endpointId: z9.string(),
+    multipliers: z9.array(MULTIPLIER)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -2310,6 +2361,7 @@ var TOOL_REGISTRY = [
   importInsomniaTool,
   importHarTool,
   generateCodeTool,
+  workspaceListTool,
   workspaceReadTool,
   workspaceWriteTool,
   requestCreateTool,
@@ -2380,6 +2432,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
 import { applyMutation } from "@apicircle/core";
 var InMemoryWorkspaceProvider = class {
@@ -2440,6 +2549,115 @@ var FileBackedWorkspaceProvider = class {
   }
 };
 
+// src/providers/MultiWorkspaceProvider.ts
+import {
+  loadRegistry,
+  loadWorkspaceById,
+  saveRegistry,
+  setActiveWorkspace as setActiveWorkspaceOnDisk,
+  workspaceDirFor
+} from "@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 loadRegistry(this.registryRoot) ?? {
+      schemaVersion: 1,
+      activeWorkspaceId: null,
+      workspaces: []
+    };
+    if (registry.activeWorkspaceId) {
+      this.activeWorkspaceId = registry.activeWorkspaceId;
+      this.active = new FileBackedWorkspaceProvider(
+        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 loadRegistry(this.registryRoot) ?? {
+      schemaVersion: 1,
+      activeWorkspaceId: null,
+      workspaces: []
+    };
+    const out = [];
+    for (const entry of registry.workspaces) {
+      let counts = null;
+      try {
+        const state = await 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(workspaceDirFor(this.registryRoot, workspaceId));
+  }
+  activeId() {
+    return this.activeWorkspaceId;
+  }
+  async setActive(workspaceId) {
+    const registry = await loadRegistry(this.registryRoot);
+    if (!registry || !registry.workspaces.some((w) => w.id === workspaceId)) {
+      throw new WorkspaceNotFoundError(workspaceId);
+    }
+    const next = await setActiveWorkspaceOnDisk(this.registryRoot, workspaceId);
+    void next;
+    this.activeWorkspaceId = workspaceId;
+    this.active = new FileBackedWorkspaceProvider(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 saveRegistry(this.registryRoot, registry);
+    this.activeWorkspaceId = registry.activeWorkspaceId;
+    if (registry.activeWorkspaceId) {
+      this.active = new FileBackedWorkspaceProvider(
+        workspaceDirFor(this.registryRoot, registry.activeWorkspaceId)
+      );
+    }
+  }
+};
+
 // src/providers/InProcessMockController.ts
 import {
   startMockServer,
@@ -2483,10 +2701,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
+    }
   });
 }
 export {
@@ -2494,7 +2721,10 @@ export {
   InMemoryWorkspaceProvider,
   InProcessMockController,
   McpHost,
+  MultiWorkspaceProvider,
+  SingleWorkspaceAdapter,
   TOOL_REGISTRY,
+  WorkspaceNotFoundError,
   createMcpServer,
   getTool
 };