@apicircle/mcp-server 1.0.7 → 1.0.9

package/dist/index.cjs

@@ -41,7 +41,7 @@ var import_zod = require("zod");
 // package.json
 var package_default = {
   name: "@apicircle/mcp-server",
-  version: "1.0.7",
+  version: "1.0.9",
   private: false,
   type: "module",
   description: "Model Context Protocol server exposing API Circle Studio's workspace as a tool catalog. Used by Claude Desktop, ChatGPT, Cursor, GitHub Copilot, and any other MCP-compatible AI client.",
@@ -2143,15 +2143,143 @@ var promptSetEndpointMultipliersTool = {
   }
 };
 
-// src/tools/mocks.ts
+// src/tools/globalAssets.ts
 var import_zod10 = require("zod");
 var import_shared4 = require("@apicircle/shared");
+function deriveState(asset, hasPendingUpload) {
+  const w = asset.workingBranchRef ?? null;
+  const b = asset.baseBranchRef ?? null;
+  if (w && b) {
+    if (w.blobSha && b.blobSha && w.blobSha !== b.blobSha) return "diverged";
+    return "merged";
+  }
+  if (w && !b) return "workingOnly";
+  if (!w && b) return "baseOnly";
+  if (hasPendingUpload) return "uploading";
+  return "missing";
+}
+var globalAssetsFilesListTool = {
+  name: "assets.list_files",
+  description: "List every Global File Asset with its provenance state and reference count. Each entry includes id, name, filename, size, mimeType, sha256, state (uploading | workingOnly | merged | baseOnly | missing | diverged), workingBranchRef, baseBranchRef, and usage { requests, mockEndpoints, total }.",
+  inputSchema: import_zod10.z.object({}).strict(),
+  async handler(_input, ctx) {
+    const state = await ctx.workspace.read();
+    const files = state.synced.globalAssets.files ?? {};
+    const pending = state.local.pendingFileUploads ?? {};
+    const usage = state.local.assetUsageIndex ?? {};
+    const items = Object.values(files).map((asset) => {
+      const hasPending = Boolean(pending[asset.id]);
+      const u = usage[asset.id] ?? { requests: [], mockEndpoints: [], total: 0 };
+      return {
+        id: asset.id,
+        name: asset.name,
+        description: asset.description ?? null,
+        filename: asset.filename,
+        size: asset.size,
+        mimeType: asset.mimeType,
+        sha256: asset.sha256 ?? null,
+        state: deriveState(asset, hasPending),
+        workingBranchRef: asset.workingBranchRef ?? null,
+        baseBranchRef: asset.baseBranchRef ?? null,
+        usage: { ...u }
+      };
+    });
+    return { count: items.length, files: items };
+  }
+};
+var globalAssetsFilesCreateTool = {
+  name: "assets.create_file",
+  description: 'Register a Global File Asset entry. Bytes are NOT carried \u2014 MCP returns the new asset id and the asset enters the "missing" state. The user fills the bytes from the Global Assets panel (a "Fill bytes" button surfaces on missing-state assets) which preserves the slot id and queues the bytes for the next push. Use this when an AI client wants to claim an asset slot for a file the user will provide later.',
+  inputSchema: import_zod10.z.object({
+    name: import_zod10.z.string().min(1, "name is required"),
+    description: import_zod10.z.string().optional(),
+    filename: import_zod10.z.string().min(1, "filename is required"),
+    size: import_zod10.z.number().int().nonnegative(),
+    mimeType: import_zod10.z.string().default("application/octet-stream"),
+    sha256: import_zod10.z.string().optional()
+  }).strict(),
+  async handler(input, ctx) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const file = {
+      id: (0, import_shared4.generateId)(),
+      name: input.name,
+      description: input.description,
+      slotId: (0, import_shared4.generateId)(),
+      filename: input.filename,
+      size: input.size,
+      mimeType: input.mimeType,
+      sha256: input.sha256,
+      createdAt: now,
+      updatedAt: now
+    };
+    const out = await ctx.workspace.apply({ kind: "globalAsset.upsertFile", file });
+    return { id: file.id, slotId: file.slotId, changedIds: out.changedIds };
+  }
+};
+var globalAssetsFilesUpdateTool = {
+  name: "assets.update_file",
+  description: "Rename or re-describe a Global File Asset. Provenance refs (workingBranchRef, baseBranchRef) and binary metadata (slotId, sha256, size, mimeType) are preserved verbatim.",
+  inputSchema: import_zod10.z.object({
+    id: import_zod10.z.string().min(1),
+    patch: import_zod10.z.object({
+      name: import_zod10.z.string().optional(),
+      description: import_zod10.z.string().nullable().optional()
+    }).strict()
+  }).strict(),
+  async handler(input, ctx) {
+    const state = await ctx.workspace.read();
+    const existing = state.synced.globalAssets.files?.[input.id];
+    if (!existing) {
+      return { found: false, changedIds: [] };
+    }
+    const next = {
+      ...existing,
+      name: input.patch.name ?? existing.name,
+      description: input.patch.description === null ? void 0 : input.patch.description ?? existing.description
+    };
+    const out = await ctx.workspace.apply({ kind: "globalAsset.upsertFile", file: next });
+    return { found: true, id: next.id, changedIds: out.changedIds };
+  }
+};
+var globalAssetsFilesDeleteTool = {
+  name: "assets.delete_file",
+  description: "Delete a Global File Asset. Cascades \u2014 every request body and mock-response body that referenced the asset is unbound in the same mutation. The result envelope includes the consumer list that was cleared so the caller can report what changed.",
+  inputSchema: import_zod10.z.object({ id: import_zod10.z.string().min(1) }).strict(),
+  async handler(input, ctx) {
+    const before = await ctx.workspace.read();
+    const usage = before.local.assetUsageIndex?.[input.id] ?? {
+      requests: [],
+      mockEndpoints: [],
+      total: 0
+    };
+    const existing = before.synced.globalAssets.files?.[input.id];
+    if (!existing) {
+      return { found: false, changedIds: [] };
+    }
+    const out = await ctx.workspace.apply({ kind: "globalAsset.removeFile", id: input.id });
+    return {
+      found: true,
+      id: input.id,
+      filename: existing.filename,
+      unbound: {
+        requests: usage.requests,
+        mockEndpoints: usage.mockEndpoints,
+        total: usage.total
+      },
+      changedIds: out.changedIds
+    };
+  }
+};
+
+// src/tools/mocks.ts
+var import_zod11 = require("zod");
+var import_shared5 = require("@apicircle/shared");
 var import_mock_server_core2 = require("@apicircle/mock-server-core");
 async function ingestSource(source, name) {
   const { endpoints, warnings } = await (0, import_mock_server_core2.parseSourceToEndpoints)(source);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const mock = {
-    id: (0, import_shared4.generateId)(),
+    id: (0, import_shared5.generateId)(),
     name,
     source,
     endpoints,
@@ -2167,10 +2295,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_zod10.z.object({
-    name: import_zod10.z.string(),
-    spec: import_zod10.z.string().min(1),
-    format: import_zod10.z.enum(["json", "yaml"]).default("json")
+  inputSchema: import_zod11.z.object({
+    name: import_zod11.z.string(),
+    spec: import_zod11.z.string().min(1),
+    format: import_zod11.z.enum(["json", "yaml"]).default("json")
   }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
@@ -2189,7 +2317,7 @@ var mockCreateFromOpenApiTool = {
 var mockCreateFromPostmanTool = {
   name: "mock.create_from_postman",
   description: "Create a mock server from a Postman v2/v2.1 collection.",
-  inputSchema: import_zod10.z.object({ name: import_zod10.z.string(), collection: import_zod10.z.string().min(1) }),
+  inputSchema: import_zod11.z.object({ name: import_zod11.z.string(), collection: import_zod11.z.string().min(1) }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
       { kind: "postman", collection: input.collection },
@@ -2207,7 +2335,7 @@ var mockCreateFromPostmanTool = {
 var mockCreateFromInsomniaTool = {
   name: "mock.create_from_insomnia",
   description: "Create a mock server from an Insomnia v4 export.",
-  inputSchema: import_zod10.z.object({ name: import_zod10.z.string(), export: import_zod10.z.string().min(1) }),
+  inputSchema: import_zod11.z.object({ name: import_zod11.z.string(), export: import_zod11.z.string().min(1) }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
       { kind: "insomnia", export: input.export },
@@ -2225,7 +2353,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_zod10.z.object({ name: import_zod10.z.string(), collection: import_zod10.z.string().min(1) }),
+  inputSchema: import_zod11.z.object({ name: import_zod11.z.string(), collection: import_zod11.z.string().min(1) }),
   async handler(input, ctx) {
     const { mock, warnings } = await ingestSource(
       { kind: "postman", collection: input.collection },
@@ -2243,7 +2371,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_zod10.z.object({}),
+  inputSchema: import_zod11.z.object({}),
   async handler(_input, ctx) {
     const state = await ctx.workspace.read();
     const running = await ctx.mock.list();
@@ -2265,9 +2393,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_zod10.z.object({
-    id: import_zod10.z.string(),
-    port: import_zod10.z.number().int().positive().optional()
+  inputSchema: import_zod11.z.object({
+    id: import_zod11.z.string(),
+    port: import_zod11.z.number().int().positive().optional()
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -2284,7 +2412,7 @@ var mockStartTool = {
 var mockStopTool = {
   name: "mock.stop",
   description: "Stop a running mock server by id (no-op if not running).",
-  inputSchema: import_zod10.z.object({ id: import_zod10.z.string() }),
+  inputSchema: import_zod11.z.object({ id: import_zod11.z.string() }),
   async handler(input, ctx) {
     try {
       await ctx.mock.stop(input.id);
@@ -2297,7 +2425,7 @@ var mockStopTool = {
 var mockDeleteTool = {
   name: "mock.delete",
   description: "Delete a mock server definition. Stops it first if it's running.",
-  inputSchema: import_zod10.z.object({ id: import_zod10.z.string() }),
+  inputSchema: import_zod11.z.object({ id: import_zod11.z.string() }),
   async handler(input, ctx) {
     try {
       await ctx.mock.stop(input.id);
@@ -2307,18 +2435,18 @@ var mockDeleteTool = {
     return { ok: true, changedIds: out.changedIds };
   }
 };
-var HTTP_METHOD3 = import_zod10.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var HTTP_METHOD3 = import_zod11.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_zod10.z.object({
-    name: import_zod10.z.string().min(1),
-    defaultPort: import_zod10.z.number().int().positive().nullable().optional()
+  inputSchema: import_zod11.z.object({
+    name: import_zod11.z.string().min(1),
+    defaultPort: import_zod11.z.number().int().positive().nullable().optional()
   }),
   async handler(input, ctx) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const mock = {
-      id: (0, import_shared4.generateId)(),
+      id: (0, import_shared5.generateId)(),
       name: input.name,
       source: { kind: "manual", endpoints: [] },
       endpoints: [],
@@ -2336,7 +2464,7 @@ var mockCreateManualTool = {
 var mockListEndpointsTool = {
   name: "mock.list_endpoints",
   description: "List endpoints for a mock server (id, method, path, name).",
-  inputSchema: import_zod10.z.object({ mockId: import_zod10.z.string() }),
+  inputSchema: import_zod11.z.object({ mockId: import_zod11.z.string() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     const mock = state.synced.mockServers[input.mockId];
@@ -2355,10 +2483,10 @@ var mockListEndpointsTool = {
     };
   }
 };
-var ENDPOINT_RESPONSE2 = import_zod10.z.object({
-  status: import_zod10.z.number().int().min(100).max(599).default(200),
-  jsonBody: import_zod10.z.string().default("{}"),
-  contentType: import_zod10.z.string().default("application/json")
+var ENDPOINT_RESPONSE2 = import_zod11.z.object({
+  status: import_zod11.z.number().int().min(100).max(599).default(200),
+  jsonBody: import_zod11.z.string().default("{}"),
+  contentType: import_zod11.z.string().default("application/json")
 });
 function buildDefaultEndpoint(args) {
   const response = args.response ?? {
@@ -2368,16 +2496,16 @@ function buildDefaultEndpoint(args) {
   };
   const headers = [{ key: "Content-Type", value: response.contentType, enabled: true }];
   return {
-    id: (0, import_shared4.generateId)(),
+    id: (0, import_shared5.generateId)(),
     name: args.name ?? `${args.method} ${args.pathPattern}`,
     method: args.method,
     pathPattern: args.pathPattern,
     description: args.description,
-    requestSchema: (0, import_shared4.makeDefaultRequestSchema)(),
+    requestSchema: (0, import_shared5.makeDefaultRequestSchema)(),
     requestValidation: [],
     responseRules: [],
     defaultResponse: {
-      ...(0, import_shared4.makeDefaultMockResponse)(),
+      ...(0, import_shared5.makeDefaultMockResponse)(),
       status: response.status,
       headers,
       body: { type: "json", content: response.jsonBody }
@@ -2387,12 +2515,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_zod10.z.object({
-    mockId: import_zod10.z.string(),
+  inputSchema: import_zod11.z.object({
+    mockId: import_zod11.z.string(),
     method: HTTP_METHOD3,
-    pathPattern: import_zod10.z.string().min(1),
-    name: import_zod10.z.string().optional(),
-    description: import_zod10.z.string().optional(),
+    pathPattern: import_zod11.z.string().min(1),
+    name: import_zod11.z.string().optional(),
+    description: import_zod11.z.string().optional(),
     response: ENDPOINT_RESPONSE2.optional()
   }),
   async handler(input, ctx) {
@@ -2415,13 +2543,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_zod10.z.object({
-    mockId: import_zod10.z.string(),
-    endpointId: import_zod10.z.string(),
+  inputSchema: import_zod11.z.object({
+    mockId: import_zod11.z.string(),
+    endpointId: import_zod11.z.string(),
     method: HTTP_METHOD3.optional(),
-    pathPattern: import_zod10.z.string().optional(),
-    name: import_zod10.z.string().optional(),
-    description: import_zod10.z.string().optional(),
+    pathPattern: import_zod11.z.string().optional(),
+    name: import_zod11.z.string().optional(),
+    description: import_zod11.z.string().optional(),
     response: ENDPOINT_RESPONSE2.partial().optional()
   }),
   async handler(input, ctx) {
@@ -2462,7 +2590,7 @@ var mockUpdateEndpointTool = {
 var mockDeleteEndpointTool = {
   name: "mock.delete_endpoint",
   description: "Remove an endpoint from a mock server.",
-  inputSchema: import_zod10.z.object({ mockId: import_zod10.z.string(), endpointId: import_zod10.z.string() }),
+  inputSchema: import_zod11.z.object({ mockId: import_zod11.z.string(), endpointId: import_zod11.z.string() }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
     const mock = state.synced.mockServers[input.mockId];
@@ -2482,9 +2610,9 @@ var mockDeleteEndpointTool = {
     return { ok: true, changedIds: out.changedIds };
   }
 };
-var VALIDATION_RULE = import_zod10.z.object({
-  id: import_zod10.z.string().optional(),
-  kind: import_zod10.z.enum([
+var VALIDATION_RULE = import_zod11.z.object({
+  id: import_zod11.z.string().optional(),
+  kind: import_zod11.z.enum([
     "header-required",
     "header-equals",
     "header-matches",
@@ -2495,43 +2623,43 @@ var VALIDATION_RULE = import_zod10.z.object({
     "body-required",
     "content-type-equals"
   ]),
-  target: import_zod10.z.string().default(""),
-  expected: import_zod10.z.string().optional(),
-  message: import_zod10.z.string().optional(),
-  enabled: import_zod10.z.boolean().default(true),
-  failResponse: import_zod10.z.object({
-    status: import_zod10.z.number().int().min(100).max(599).default(400),
-    jsonBody: import_zod10.z.string().default('{"error":"validation failed"}')
+  target: import_zod11.z.string().default(""),
+  expected: import_zod11.z.string().optional(),
+  message: import_zod11.z.string().optional(),
+  enabled: import_zod11.z.boolean().default(true),
+  failResponse: import_zod11.z.object({
+    status: import_zod11.z.number().int().min(100).max(599).default(400),
+    jsonBody: import_zod11.z.string().default('{"error":"validation failed"}')
   }).default({})
 });
-var CONDITION_CLAUSE = import_zod10.z.object({
-  id: import_zod10.z.string().optional(),
-  scope: import_zod10.z.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
-  target: import_zod10.z.string(),
-  op: import_zod10.z.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
-  value: import_zod10.z.string().optional()
+var CONDITION_CLAUSE = import_zod11.z.object({
+  id: import_zod11.z.string().optional(),
+  scope: import_zod11.z.enum(["query", "pathParam", "header", "cookie", "body-json-path"]),
+  target: import_zod11.z.string(),
+  op: import_zod11.z.enum(["equals", "not-equals", "matches", "gt", "lt", "gte", "lte", "present", "absent"]),
+  value: import_zod11.z.string().optional()
 });
-var RESPONSE_RULE = import_zod10.z.object({
-  id: import_zod10.z.string().optional(),
-  name: import_zod10.z.string(),
-  enabled: import_zod10.z.boolean().default(true),
-  when: import_zod10.z.array(CONDITION_CLAUSE).default([]),
-  response: import_zod10.z.object({
-    status: import_zod10.z.number().int().min(100).max(599).default(200),
-    jsonBody: import_zod10.z.string().default("{}")
+var RESPONSE_RULE = import_zod11.z.object({
+  id: import_zod11.z.string().optional(),
+  name: import_zod11.z.string(),
+  enabled: import_zod11.z.boolean().default(true),
+  when: import_zod11.z.array(CONDITION_CLAUSE).default([]),
+  response: import_zod11.z.object({
+    status: import_zod11.z.number().int().min(100).max(599).default(200),
+    jsonBody: import_zod11.z.string().default("{}")
   }).default({})
 });
-var MULTIPLIER = import_zod10.z.object({
-  id: import_zod10.z.string().optional(),
-  name: import_zod10.z.string().optional(),
-  source: import_zod10.z.object({
-    kind: import_zod10.z.enum(["query", "pathParam", "header", "body-json-path"]),
-    key: import_zod10.z.string()
+var MULTIPLIER = import_zod11.z.object({
+  id: import_zod11.z.string().optional(),
+  name: import_zod11.z.string().optional(),
+  source: import_zod11.z.object({
+    kind: import_zod11.z.enum(["query", "pathParam", "header", "body-json-path"]),
+    key: import_zod11.z.string()
   }),
-  targetJsonPath: import_zod10.z.string(),
-  defaultCount: import_zod10.z.number().int().nonnegative().default(0),
-  min: import_zod10.z.number().int().nonnegative().optional(),
-  max: import_zod10.z.number().int().nonnegative().optional()
+  targetJsonPath: import_zod11.z.string(),
+  defaultCount: import_zod11.z.number().int().nonnegative().default(0),
+  min: import_zod11.z.number().int().nonnegative().optional(),
+  max: import_zod11.z.number().int().nonnegative().optional()
 });
 function defaultJsonResponseConfig(args) {
   return {
@@ -2556,10 +2684,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_zod10.z.object({
-    mockId: import_zod10.z.string(),
-    endpointId: import_zod10.z.string(),
-    rules: import_zod10.z.array(VALIDATION_RULE)
+  inputSchema: import_zod11.z.object({
+    mockId: import_zod11.z.string(),
+    endpointId: import_zod11.z.string(),
+    rules: import_zod11.z.array(VALIDATION_RULE)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -2569,7 +2697,7 @@ var mockSetValidationRulesTool = {
     const next = patchEndpoint2(mock, input.endpointId, (e) => ({
       ...e,
       requestValidation: rules.map((r) => ({
-        id: r.id ?? (0, import_shared4.generateId)(),
+        id: r.id ?? (0, import_shared5.generateId)(),
         kind: r.kind,
         target: r.target,
         expected: r.expected,
@@ -2586,10 +2714,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_zod10.z.object({
-    mockId: import_zod10.z.string(),
-    endpointId: import_zod10.z.string(),
-    rules: import_zod10.z.array(RESPONSE_RULE)
+  inputSchema: import_zod11.z.object({
+    mockId: import_zod11.z.string(),
+    endpointId: import_zod11.z.string(),
+    rules: import_zod11.z.array(RESPONSE_RULE)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -2599,11 +2727,11 @@ var mockSetResponseRulesTool = {
     const next = patchEndpoint2(mock, input.endpointId, (e) => ({
       ...e,
       responseRules: rules.map((r) => ({
-        id: r.id ?? (0, import_shared4.generateId)(),
+        id: r.id ?? (0, import_shared5.generateId)(),
         name: r.name,
         enabled: r.enabled,
         when: r.when.map((c) => ({
-          id: c.id ?? (0, import_shared4.generateId)(),
+          id: c.id ?? (0, import_shared5.generateId)(),
           scope: c.scope,
           target: c.target,
           op: c.op,
@@ -2620,10 +2748,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_zod10.z.object({
-    mockId: import_zod10.z.string(),
-    endpointId: import_zod10.z.string(),
-    multipliers: import_zod10.z.array(MULTIPLIER)
+  inputSchema: import_zod11.z.object({
+    mockId: import_zod11.z.string(),
+    endpointId: import_zod11.z.string(),
+    multipliers: import_zod11.z.array(MULTIPLIER)
   }),
   async handler(input, ctx) {
     const state = await ctx.workspace.read();
@@ -2635,7 +2763,7 @@ var mockSetMultipliersTool = {
       defaultResponse: {
         ...e.defaultResponse,
         multipliers: multipliers.length === 0 ? void 0 : multipliers.map((m) => ({
-          id: m.id ?? (0, import_shared4.generateId)(),
+          id: m.id ?? (0, import_shared5.generateId)(),
           name: m.name,
           source: { kind: m.source.kind, key: m.source.key },
           targetJsonPath: m.targetJsonPath,
@@ -2711,6 +2839,10 @@ var TOOL_REGISTRY = [
   promptSetEndpointValidationRulesTool,
   promptSetEndpointResponseRulesTool,
   promptSetEndpointMultipliersTool,
+  globalAssetsFilesListTool,
+  globalAssetsFilesCreateTool,
+  globalAssetsFilesUpdateTool,
+  globalAssetsFilesDeleteTool,
   mockCreateFromOpenApiTool,
   mockCreateFromPostmanTool,
   mockCreateFromInsomniaTool,
@@ -2851,17 +2983,58 @@ var FileBackedWorkspaceProvider = class {
 
 // src/providers/MultiWorkspaceProvider.ts
 var import_registry = require("@apicircle/core/workspace/registry");
+var LazyActiveWorkspaceProvider = class {
+  constructor(registryRoot, onActiveResolved) {
+    this.registryRoot = registryRoot;
+    this.onActiveResolved = onActiveResolved;
+  }
+  registryRoot;
+  onActiveResolved;
+  async resolveActive() {
+    const registry = await (0, import_registry.loadRegistry)(this.registryRoot);
+    const activeId = registry?.activeWorkspaceId ?? null;
+    if (!activeId) {
+      throw new Error(
+        "No active workspace. Open the desktop app at least once, or run `apicircle workspaces create <name>`."
+      );
+    }
+    this.onActiveResolved(activeId);
+    return new FileBackedWorkspaceProvider((0, import_registry.workspaceDirFor)(this.registryRoot, activeId));
+  }
+  async read() {
+    const provider = await this.resolveActive();
+    return provider.read();
+  }
+  async apply(patch) {
+    const provider = await this.resolveActive();
+    return provider.apply(patch);
+  }
+  async write(next) {
+    const provider = await this.resolveActive();
+    return provider.write(next);
+  }
+};
 var MultiWorkspaceProvider = class {
   constructor(registryRoot) {
     this.registryRoot = registryRoot;
+    this.lazyProvider = new LazyActiveWorkspaceProvider(this.registryRoot, (id) => {
+      this.activeWorkspaceId = id;
+    });
   }
   registryRoot;
-  active = null;
+  /** Last-known active workspace id. Refreshed every time the lazy
+   *  provider resolves; reflects what the most recent operation saw on
+   *  disk, not a stale boot-time snapshot. */
   activeWorkspaceId = null;
+  /** The lazy provider tool handlers consume as `ctx.workspace`. Holds a
+   *  reference back to this instance so each call updates
+   *  `activeWorkspaceId` for `activeId()` callers + diagnostic logs. */
+  lazyProvider;
   /**
-   * 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.
+   * Read the registry from disk so the host can log a boot banner. Does
+   * NOT cache a per-id provider — each `activeProvider()` call re-reads
+   * the registry, so a workspace switch in the desktop is picked up by
+   * the next tool call without restarting the MCP server.
    */
   async init() {
     const registry = await (0, import_registry.loadRegistry)(this.registryRoot) ?? {
@@ -2869,22 +3042,18 @@ var MultiWorkspaceProvider = class {
       activeWorkspaceId: null,
       workspaces: []
     };
-    if (registry.activeWorkspaceId) {
-      this.activeWorkspaceId = registry.activeWorkspaceId;
-      this.active = new FileBackedWorkspaceProvider(
-        (0, import_registry.workspaceDirFor)(this.registryRoot, registry.activeWorkspaceId)
-      );
-    }
+    this.activeWorkspaceId = registry.activeWorkspaceId;
     return registry;
   }
-  /** The provider tool handlers see as `ctx.workspace`. */
+  /**
+   * The provider tool handlers see as `ctx.workspace`. Returns a lazy
+   * provider whose `read` / `apply` / `write` calls re-read
+   * `registry.json` so the right active workspace is always targeted
+   * even if the desktop switched workspaces since this MCP process
+   * started.
+   */
   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;
+    return this.lazyProvider;
   }
   // ─── Workspaces interface ──────────────────────────────────────────────────
   async list() {
@@ -2932,23 +3101,17 @@ var MultiWorkspaceProvider = class {
     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;
+    await (0, import_registry.setActiveWorkspace)(this.registryRoot, workspaceId);
     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`.
+   * persist registry updates that didn't go through `setActive`. The
+   * lazy active provider picks the new id up on its next operation.
    */
   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)
-      );
-    }
   }
 };