@apicircle/mcp-server 1.0.8 → 1.0.9

package/dist/bin/mcp-server.cjs

@@ -36,7 +36,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@apicircle/mcp-server",
-      version: "1.0.8",
+      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.",
@@ -2205,12 +2205,146 @@ var init_prompt = __esm({
   }
 });
 
+// src/tools/globalAssets.ts
+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 import_zod10, import_shared4, globalAssetsFilesListTool, globalAssetsFilesCreateTool, globalAssetsFilesUpdateTool, globalAssetsFilesDeleteTool;
+var init_globalAssets = __esm({
+  "src/tools/globalAssets.ts"() {
+    "use strict";
+    import_zod10 = require("zod");
+    import_shared4 = require("@apicircle/shared");
+    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 };
+      }
+    };
+    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 };
+      }
+    };
+    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 };
+      }
+    };
+    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
 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,
@@ -2231,16 +2365,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 }
@@ -2267,20 +2401,20 @@ function patchEndpoint2(mock, endpointId, patcher) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-var import_zod10, import_shared4, import_mock_server_core2, mockCreateFromOpenApiTool, mockCreateFromPostmanTool, mockCreateFromInsomniaTool, mockImportPostmanMockCollectionTool, mockListTool, mockStartTool, mockStopTool, mockDeleteTool, HTTP_METHOD3, mockCreateManualTool, mockListEndpointsTool, ENDPOINT_RESPONSE2, mockAddEndpointTool, mockUpdateEndpointTool, mockDeleteEndpointTool, VALIDATION_RULE, CONDITION_CLAUSE, RESPONSE_RULE, MULTIPLIER, mockSetValidationRulesTool, mockSetResponseRulesTool, mockSetMultipliersTool;
+var import_zod11, import_shared5, import_mock_server_core2, mockCreateFromOpenApiTool, mockCreateFromPostmanTool, mockCreateFromInsomniaTool, mockImportPostmanMockCollectionTool, mockListTool, mockStartTool, mockStopTool, mockDeleteTool, HTTP_METHOD3, mockCreateManualTool, mockListEndpointsTool, ENDPOINT_RESPONSE2, mockAddEndpointTool, mockUpdateEndpointTool, mockDeleteEndpointTool, VALIDATION_RULE, CONDITION_CLAUSE, RESPONSE_RULE, MULTIPLIER, mockSetValidationRulesTool, mockSetResponseRulesTool, mockSetMultipliersTool;
 var init_mocks = __esm({
   "src/tools/mocks.ts"() {
     "use strict";
-    import_zod10 = require("zod");
-    import_shared4 = require("@apicircle/shared");
+    import_zod11 = require("zod");
+    import_shared5 = require("@apicircle/shared");
     import_mock_server_core2 = require("@apicircle/mock-server-core");
     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(
@@ -2299,7 +2433,7 @@ var init_mocks = __esm({
     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 },
@@ -2317,7 +2451,7 @@ var init_mocks = __esm({
     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 },
@@ -2335,7 +2469,7 @@ var init_mocks = __esm({
     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 },
@@ -2353,7 +2487,7 @@ var init_mocks = __esm({
     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();
@@ -2375,9 +2509,9 @@ var init_mocks = __esm({
     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();
@@ -2394,7 +2528,7 @@ var init_mocks = __esm({
     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);
@@ -2407,7 +2541,7 @@ var init_mocks = __esm({
     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);
@@ -2417,18 +2551,18 @@ var init_mocks = __esm({
         return { ok: true, changedIds: out.changedIds };
       }
     };
-    HTTP_METHOD3 = import_zod10.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+    HTTP_METHOD3 = import_zod11.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
     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: [],
@@ -2446,7 +2580,7 @@ var init_mocks = __esm({
     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];
@@ -2465,20 +2599,20 @@ var init_mocks = __esm({
         };
       }
     };
-    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")
+    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")
     });
     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) {
@@ -2501,13 +2635,13 @@ var init_mocks = __esm({
     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) {
@@ -2548,7 +2682,7 @@ var init_mocks = __esm({
     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];
@@ -2568,9 +2702,9 @@ var init_mocks = __esm({
         return { ok: true, changedIds: out.changedIds };
       }
     };
-    VALIDATION_RULE = import_zod10.z.object({
-      id: import_zod10.z.string().optional(),
-      kind: import_zod10.z.enum([
+    VALIDATION_RULE = import_zod11.z.object({
+      id: import_zod11.z.string().optional(),
+      kind: import_zod11.z.enum([
         "header-required",
         "header-equals",
         "header-matches",
@@ -2581,51 +2715,51 @@ var init_mocks = __esm({
         "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({})
     });
-    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()
+    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()
     });
-    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("{}")
+    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({})
     });
-    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()
+    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()
     });
     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();
@@ -2635,7 +2769,7 @@ var init_mocks = __esm({
         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,
@@ -2652,10 +2786,10 @@ var init_mocks = __esm({
     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();
@@ -2665,11 +2799,11 @@ var init_mocks = __esm({
         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,
@@ -2686,10 +2820,10 @@ var init_mocks = __esm({
     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();
@@ -2701,7 +2835,7 @@ var init_mocks = __esm({
           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,
@@ -2735,6 +2869,7 @@ var init_registry = __esm({
     init_history();
     init_codebase();
     init_prompt();
+    init_globalAssets();
     init_mocks();
     TOOL_REGISTRY = [
       importCurlTool,
@@ -2795,6 +2930,10 @@ var init_registry = __esm({
       promptSetEndpointValidationRulesTool,
       promptSetEndpointResponseRulesTool,
       promptSetEndpointMultipliersTool,
+      globalAssetsFilesListTool,
+      globalAssetsFilesCreateTool,
+      globalAssetsFilesUpdateTool,
+      globalAssetsFilesDeleteTool,
       mockCreateFromOpenApiTool,
       mockCreateFromPostmanTool,
       mockCreateFromInsomniaTool,