@anyproto/anytype-mcp 1.0.7 → 1.0.8

package/server.json

@@ -19,7 +19,7 @@
       },
       "environment_variables": [
         {
-          "description": "JSON string of headers for Anytype API. Example: {\"Authorization\":\"Bearer <YOUR_API_KEY>\", \"Anytype-Version\":\"2025-05-20\"}",
+          "description": "JSON string of headers for Anytype API. Example: {\"Authorization\":\"Bearer <YOUR_API_KEY>\", \"Anytype-Version\":\"2025-11-08\"}",
           "is_required": true,
           "format": "string",
           "is_secret": true,

package/src/client/__tests__/http-client.test.ts

@@ -5,16 +5,19 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { HttpClient } from "../http-client";
 
 // Mock the OpenAPIClientAxios initialization
+const mockApi = {
+  getPet: vi.fn(),
+  testOperation: vi.fn(),
+  complexOperation: vi.fn(),
+};
+
 vi.mock("openapi-client-axios", () => {
-  const mockApi = {
-    getPet: vi.fn(),
-    testOperation: vi.fn(),
-    complexOperation: vi.fn(),
-  };
+  const MockOpenAPIClientAxios = vi.fn(function (this: any) {
+    this.init = vi.fn().mockResolvedValue(mockApi);
+    return this;
+  });
   return {
-    default: vi.fn().mockImplementation(() => ({
-      init: vi.fn().mockResolvedValue(mockApi),
-    })),
+    default: MockOpenAPIClientAxios,
   };
 });
 
@@ -473,12 +476,13 @@ describe("HttpClient", () => {
       testOperation: vi.fn().mockRejectedValue(errorResponse),
     };
 
-    // Mock the OpenAPIClientAxios initialization
-    const MockOpenAPIClientAxios = vi.fn().mockImplementation(() => ({
-      init: () => Promise.resolve(mockAxiosInstance),
-    }));
+    // Mock the OpenAPIClientAxios initialization - use function keyword for constructor support
+    const MockOpenAPIClientAxios = vi.fn(function (this: any) {
+      this.init = vi.fn().mockResolvedValue(mockAxiosInstance);
+      return this;
+    });
 
-    vi.mocked(OpenAPIClientAxios).mockImplementation(() => MockOpenAPIClientAxios());
+    vi.mocked(OpenAPIClientAxios).mockImplementation(MockOpenAPIClientAxios as any);
 
     const client = new HttpClient(mockConfig, mockOpenApiSpec);
     const operation = mockOpenApiSpec.paths["/test"]?.post;
@@ -510,11 +514,13 @@ describe("HttpClient", () => {
       }),
     };
 
-    const MockOpenAPIClientAxios = vi.fn().mockImplementation(() => ({
-      init: () => Promise.resolve(mockAxiosInstance),
-    }));
+    // Mock the OpenAPIClientAxios initialization - use function keyword for constructor support
+    const MockOpenAPIClientAxios = vi.fn(function (this: any) {
+      this.init = vi.fn().mockResolvedValue(mockAxiosInstance);
+      return this;
+    });
 
-    vi.mocked(OpenAPIClientAxios).mockImplementation(() => MockOpenAPIClientAxios());
+    vi.mocked(OpenAPIClientAxios).mockImplementation(MockOpenAPIClientAxios as any);
 
     const client = new HttpClient(mockConfig, mockOpenApiSpec);
     const operation = mockOpenApiSpec.paths["/test"]?.post;

package/src/openapi/__tests__/parser.test.ts

@@ -855,6 +855,142 @@ describe("OpenAPIToMCPConverter", () => {
       description: "A schema description",
     });
   });
+
+  describe("Delete Operations Support", () => {
+    const deleteSpec: OpenAPIV3.Document = {
+      openapi: "3.0.0",
+      info: {
+        title: "Delete Test API",
+        version: "1.0.0",
+      },
+      paths: {
+        "/objects/{object_id}": {
+          delete: {
+            operationId: "delete_object",
+            summary: "Delete an object",
+            parameters: [
+              {
+                name: "object_id",
+                in: "path",
+                required: true,
+                description: "The ID of the object to delete",
+                schema: {
+                  type: "string",
+                },
+              },
+            ],
+            responses: {
+              "200": {
+                description: "Object deleted successfully",
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object",
+                      properties: {
+                        id: { type: "string" },
+                        deleted: { type: "boolean" },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        "/lists/{list_id}/objects/{object_id}": {
+          delete: {
+            operationId: "remove_list_object",
+            summary: "Remove object from list",
+            parameters: [
+              {
+                name: "list_id",
+                in: "path",
+                required: true,
+                description: "The ID of the list",
+                schema: { type: "string" },
+              },
+              {
+                name: "object_id",
+                in: "path",
+                required: true,
+                description: "The ID of the object to remove",
+                schema: { type: "string" },
+              },
+            ],
+            responses: {
+              "200": {
+                description: "Object removed from list",
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object",
+                      properties: {
+                        success: { type: "boolean" },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    };
+
+    it("should include delete operations in MCP tools", () => {
+      const converter = new OpenAPIToMCPConverter(deleteSpec);
+      const { tools, openApiLookup } = converter.convertToMCPTools();
+
+      expect(tools).toHaveProperty("API");
+      expect(tools.API.methods).toHaveLength(2);
+
+      const deleteObjectMethod = tools.API.methods.find((m) => m.name === "delete-object");
+      const removeListObjectMethod = tools.API.methods.find((m) => m.name === "remove-list-object");
+
+      expect(deleteObjectMethod).toBeDefined();
+      expect(removeListObjectMethod).toBeDefined();
+
+      // Check that delete operations are in the lookup
+      expect(openApiLookup).toHaveProperty("API-delete-object");
+      expect(openApiLookup).toHaveProperty("API-remove-list-object");
+
+      // Verify delete object method parameters
+      const deleteParams = getParamsFromSchema(deleteObjectMethod!);
+      expect(deleteParams).toContainEqual({
+        name: "object_id",
+        type: "string",
+        description: "The ID of the object to delete",
+        optional: false,
+      });
+
+      // Verify remove list object method parameters
+      const removeParams = getParamsFromSchema(removeListObjectMethod!);
+      expect(removeParams).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: "list_id",
+            type: "string",
+            description: "The ID of the list",
+            optional: false,
+          }),
+          expect.objectContaining({
+            name: "object_id",
+            type: "string",
+            description: "The ID of the object to remove",
+            optional: false,
+          }),
+        ]),
+      );
+    });
+
+    it("should handle delete operations with proper error responses", () => {
+      const converter = new OpenAPIToMCPConverter(deleteSpec);
+      const { tools } = converter.convertToMCPTools();
+
+      const deleteObjectMethod = tools.API.methods.find((m) => m.name === "delete-object");
+      expect(deleteObjectMethod?.description).toContain("Delete an object");
+    });
+  });
 });
 
 // Additional complex test scenarios as a table test

package/src/openapi/parser.ts

@@ -327,13 +327,8 @@ export class OpenAPIToMCPConverter {
       if (!pathItem) continue;
 
       for (const [method, operation] of Object.entries(pathItem)) {
-        // skip "Auth" operations and delete operations, as they shouldn't be called by mcp client
-        if (
-          !this.isOperation(method, operation) ||
-          operation.tags?.includes("Auth") ||
-          method.toLowerCase() === "delete"
-        )
-          continue;
+        // skip "Auth" operations, as they shouldn't be called by mcp client
+        if (!this.isOperation(method, operation) || operation.tags?.includes("Auth")) continue;
 
         const mcpMethod = this.convertOperationToMCPMethod(operation, method, path);
         if (mcpMethod) {
@@ -360,13 +355,8 @@ export class OpenAPIToMCPConverter {
       if (!pathItem) continue;
 
       for (const [method, operation] of Object.entries(pathItem)) {
-        // skip "Auth" operations and delete operations, as they shouldn't be called by mcp client
-        if (
-          !this.isOperation(method, operation) ||
-          operation.tags?.includes("Auth") ||
-          method.toLowerCase() === "delete"
-        )
-          continue;
+        // skip "Auth" operations, as they shouldn't be called by mcp client
+        if (!this.isOperation(method, operation) || operation.tags?.includes("Auth")) continue;
 
         const parameters = this.convertOperationToJsonSchema(operation, method, path);
         const tool: ChatCompletionTool = {
@@ -394,13 +384,8 @@ export class OpenAPIToMCPConverter {
       if (!pathItem) continue;
 
       for (const [method, operation] of Object.entries(pathItem)) {
-        // skip "Auth" operations and delete operations, as they shouldn't be called by mcp client
-        if (
-          !this.isOperation(method, operation) ||
-          operation.tags?.includes("Auth") ||
-          method.toLowerCase() === "delete"
-        )
-          continue;
+        // skip "Auth" operations, as they shouldn't be called by mcp client
+        if (!this.isOperation(method, operation) || operation.tags?.includes("Auth")) continue;
 
         const parameters = this.convertOperationToJsonSchema(operation, method, path);
         const tool: Tool = {