@access-mcp/announcements 0.3.0 → 0.5.0

package/src/server.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, vi, Mock } from "vitest";
 import { AnnouncementsServer } from "./server.js";
-import { DrupalAuthProvider } from "@access-mcp/shared";
+import { DrupalAuthProvider, requestContextStorage, RequestContext } from "@access-mcp/shared";
 
 // Mock the DrupalAuthProvider
 vi.mock("@access-mcp/shared", async () => {
@@ -10,6 +10,8 @@ vi.mock("@access-mcp/shared", async () => {
     DrupalAuthProvider: vi.fn().mockImplementation(() => ({
       ensureAuthenticated: vi.fn().mockResolvedValue(undefined),
       getUserUuid: vi.fn().mockReturnValue("user-uuid-123"),
+      setActingUser: vi.fn(),
+      getActingUser: vi.fn(),
       get: vi.fn(),
       post: vi.fn(),
       patch: vi.fn(),
@@ -33,12 +35,12 @@ describe("AnnouncementsServer", () => {
 
   beforeEach(() => {
     server = new AnnouncementsServer();
-    
+
     // Mock the httpClient
     mockHttpClient = {
       get: vi.fn(),
     };
-    
+
     // Override the httpClient getter
     Object.defineProperty(server, "httpClient", {
       get: () => mockHttpClient,
@@ -59,6 +61,7 @@ describe("AnnouncementsServer", () => {
               author: "ACCESS Support",
               tags: ["maintenance", "scheduled"],
               affinity_group: ["123", "456"],
+              url: "https://support.access-ci.org/announcements/scheduled-maintenance",
             },
             {
               title: "New GPU Nodes Available",
@@ -67,6 +70,7 @@ describe("AnnouncementsServer", () => {
               author: "Resource Team",
               tags: ["gpu", "hardware"],
               affinity_group: ["789"],
+              url: "https://support.access-ci.org/announcements/new-gpu-nodes-available",
             },
           ],
         };
@@ -193,6 +197,7 @@ describe("AnnouncementsServer", () => {
               author: "Support",
               tags: ["gpu", "maintenance"],
               affinity_group: [],
+              url: "https://support.access-ci.org/announcements/gpu-maintenance",
             },
           ],
         };
@@ -230,6 +235,7 @@ describe("AnnouncementsServer", () => {
               published_date: "2024-03-14",
               tags: ["ai"],
               affinity_group: [],
+              url: "https://support.access-ci.org/announcements/update-1",
             },
           ],
         };
@@ -266,6 +272,7 @@ describe("AnnouncementsServer", () => {
               author: "Admin",
               tags: ["urgent"],
               affinity_group: [],
+              url: "https://support.access-ci.org/announcements/todays-update",
             },
           ],
         };
@@ -365,6 +372,7 @@ describe("AnnouncementsServer", () => {
             published_date: "2024-03-15",
             tags: ["tag1", "tag2", "tag3"],
             affinity_group: [],
+            url: "https://support.access-ci.org/announcements/test",
           },
         ],
       };
@@ -392,6 +400,7 @@ describe("AnnouncementsServer", () => {
             published_date: "2024-03-15",
             tags: "gpu, machine-learning, hpc",
             affinity_group: [],
+            url: "https://support.access-ci.org/announcements/test",
           },
         ],
       };
@@ -419,6 +428,7 @@ describe("AnnouncementsServer", () => {
             published_date: "2024-03-15",
             tags: "",
             affinity_group: [],
+            url: "https://support.access-ci.org/announcements/test",
           },
         ],
       };
@@ -441,10 +451,28 @@ describe("AnnouncementsServer", () => {
       const mockResponse = {
         status: 200,
         data: [
-          { title: "1", published_date: "2024-03-15", tags: ["gpu", "maintenance"], affinity_group: [] },
-          { title: "2", published_date: "2024-03-14", tags: ["gpu", "network"], affinity_group: [] },
-          { title: "3", published_date: "2024-03-13", tags: ["gpu", "storage"], affinity_group: [] },
-          { title: "4", published_date: "2024-03-12", tags: ["maintenance"], affinity_group: [] },
+          {
+            title: "1",
+            published_date: "2024-03-15",
+            tags: ["gpu", "maintenance"],
+            affinity_group: [],
+            url: "https://support.access-ci.org/announcements/1",
+          },
+          {
+            title: "2",
+            published_date: "2024-03-14",
+            tags: ["gpu", "network"],
+            affinity_group: [],
+            url: "https://support.access-ci.org/announcements/2",
+          },
+          {
+            title: "3",
+            published_date: "2024-03-13",
+            tags: ["gpu", "storage"],
+            affinity_group: [],
+            url: "https://support.access-ci.org/announcements/3",
+          },
+          { title: "4", published_date: "2024-03-12", tags: ["maintenance"], affinity_group: [], url: "https://support.access-ci.org/announcements/4" },
         ],
       };
 
@@ -472,6 +500,7 @@ describe("AnnouncementsServer", () => {
             published_date: "2024-03-15",
             tags: [],
             affinity_group: [],
+            url: "https://support.access-ci.org/announcements/test",
           },
         ],
       };
@@ -495,6 +524,8 @@ describe("AnnouncementsServer", () => {
     let mockDrupalAuth: {
       ensureAuthenticated: Mock;
       getUserUuid: Mock;
+      setActingUser: Mock;
+      getActingUser: Mock;
       get: Mock;
       post: Mock;
       patch: Mock;
@@ -506,12 +537,14 @@ describe("AnnouncementsServer", () => {
       process.env.DRUPAL_API_URL = "https://test.drupal.site";
       process.env.DRUPAL_USERNAME = "test_user";
       process.env.DRUPAL_PASSWORD = "test_password";
-      process.env.ACTING_USER_UID = "1985";
+      process.env.ACTING_USER = "testuser@access-ci.org";
 
       // Create a fresh mock for each test
       mockDrupalAuth = {
         ensureAuthenticated: vi.fn().mockResolvedValue(undefined),
         getUserUuid: vi.fn().mockReturnValue("user-uuid-123"),
+        setActingUser: vi.fn(),
+        getActingUser: vi.fn(),
         get: vi.fn(),
         post: vi.fn(),
         patch: vi.fn(),
@@ -526,16 +559,11 @@ describe("AnnouncementsServer", () => {
       delete process.env.DRUPAL_API_URL;
       delete process.env.DRUPAL_USERNAME;
       delete process.env.DRUPAL_PASSWORD;
-      delete process.env.ACTING_USER_UID;
+      delete process.env.ACTING_USER;
     });
 
     describe("create_announcement", () => {
       it("should create an announcement with required fields", async () => {
-        // Mock user UUID lookup for ACTING_USER_UID
-        mockDrupalAuth.get.mockResolvedValueOnce({
-          data: [{ id: "acting-user-uuid-123" }],
-        });
-
         mockDrupalAuth.post.mockResolvedValue({
           data: {
             id: "new-announcement-uuid",
@@ -553,15 +581,11 @@ describe("AnnouncementsServer", () => {
             arguments: {
               title: "Test Announcement",
               body: "<p>This is a test</p>",
+              summary: "Test summary",
             },
           },
         });
 
-        // Should have looked up the acting user UUID
-        expect(mockDrupalAuth.get).toHaveBeenCalledWith(
-          "/jsonapi/user/user?filter[drupal_internal__uid]=1985"
-        );
-
         expect(mockDrupalAuth.post).toHaveBeenCalledWith(
           "/jsonapi/node/access_news",
           expect.objectContaining({
@@ -573,16 +597,9 @@ describe("AnnouncementsServer", () => {
                 body: expect.objectContaining({
                   value: "<p>This is a test</p>",
                   format: "basic_html",
+                  summary: "Test summary",
                 }),
               }),
-              relationships: expect.objectContaining({
-                uid: {
-                  data: {
-                    type: "user--user",
-                    id: "acting-user-uuid-123",
-                  },
-                },
-              }),
             }),
           })
         );
@@ -593,16 +610,14 @@ describe("AnnouncementsServer", () => {
       });
 
       it("should look up tags by name when provided (with caching)", async () => {
-        // Mock user lookup first, then bulk tag fetch for cache
-        mockDrupalAuth.get
-          .mockResolvedValueOnce({ data: [{ id: "acting-user-uuid" }] }) // user lookup
-          .mockResolvedValueOnce({
-            data: [
-              { id: "tag-uuid-1", attributes: { name: "gpu" } },
-              { id: "tag-uuid-2", attributes: { name: "maintenance" } },
-              { id: "tag-uuid-3", attributes: { name: "hpc" } },
-            ]
-          }); // bulk tag cache fetch
+        mockDrupalAuth.get.mockResolvedValueOnce({
+          data: [
+            { id: "tag-uuid-1", attributes: { name: "gpu" } },
+            { id: "tag-uuid-2", attributes: { name: "maintenance" } },
+            { id: "tag-uuid-3", attributes: { name: "hpc" } },
+          ],
+          links: {},
+        });
 
         mockDrupalAuth.post.mockResolvedValue({
           data: {
@@ -618,20 +633,16 @@ describe("AnnouncementsServer", () => {
             arguments: {
               title: "Test",
               body: "Body",
+              summary: "Summary",
               tags: ["gpu", "maintenance"],
             },
           },
         });
 
-        // Should have looked up user, then fetched all tags for cache
-        expect(mockDrupalAuth.get).toHaveBeenCalledWith(
-          "/jsonapi/user/user?filter[drupal_internal__uid]=1985"
-        );
         expect(mockDrupalAuth.get).toHaveBeenCalledWith(
-          "/jsonapi/taxonomy_term/tags?page[limit]=500"
+          "/jsonapi/taxonomy_term/tags?page[limit]=50"
         );
 
-        // Should have created with the correct tag UUIDs
         expect(mockDrupalAuth.post).toHaveBeenCalledWith(
           "/jsonapi/node/access_news",
           expect.objectContaining({
@@ -667,30 +678,118 @@ describe("AnnouncementsServer", () => {
         expect(responseData.error).toContain("DRUPAL_API_URL");
       });
 
-      it("should fail without ACTING_USER_UID", async () => {
-        delete process.env.ACTING_USER_UID;
+      it("should fail without ACTING_USER", async () => {
+        delete process.env.ACTING_USER;
 
         const result = await server["handleToolCall"]({
           method: "tools/call",
           params: {
-            name: "create_announcement",
-            arguments: {
+            name: "get_my_announcements",
+            arguments: {},
+          },
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.error).toContain("No acting user specified");
+      });
+
+      it("should use actingUser from request context when env var not set", async () => {
+        delete process.env.ACTING_USER;
+
+        mockDrupalAuth.post.mockResolvedValue({
+          data: {
+            id: "new-announcement-uuid",
+            attributes: {
               title: "Test",
-              body: "Body",
+              drupal_internal__nid: 12345,
             },
           },
         });
 
+        const context: RequestContext = {
+          actingUser: "contextuser@access-ci.org",
+        };
+
+        const result = await requestContextStorage.run(context, async () => {
+          return server["handleToolCall"]({
+            method: "tools/call",
+            params: {
+              name: "create_announcement",
+              arguments: {
+                title: "Test",
+                body: "Body",
+                summary: "Summary",
+              },
+            },
+          });
+        });
+
         const responseData = JSON.parse((result.content[0] as TextContent).text);
-        expect(responseData.error).toContain("ACTING_USER_UID");
-        expect(responseData.error).toContain("No acting user specified");
+        expect(responseData.success).toBe(true);
       });
 
-      it("should create announcement with external link", async () => {
-        mockDrupalAuth.get.mockResolvedValueOnce({
-          data: [{ id: "acting-user-uuid-123" }],
+      it("should prefer request context actingUser over env var", async () => {
+        process.env.ACTING_USER = "envuser@access-ci.org";
+
+        mockDrupalAuth.post.mockResolvedValue({
+          data: {
+            id: "new-announcement-uuid",
+            attributes: { title: "Test" },
+          },
         });
 
+        const context: RequestContext = {
+          actingUser: "contextuser@access-ci.org",
+        };
+
+        await requestContextStorage.run(context, async () => {
+          return server["handleToolCall"]({
+            method: "tools/call",
+            params: {
+              name: "create_announcement",
+              arguments: {
+                title: "Test",
+                body: "Body",
+                summary: "Summary",
+              },
+            },
+          });
+        });
+
+        // Should have called setActingUser with the context value, not env var
+        expect(mockDrupalAuth.setActingUser).toHaveBeenCalledWith("contextuser@access-ci.org");
+      });
+
+      it("should set actingUser on DrupalAuth from request context", async () => {
+        const context: RequestContext = {
+          actingUser: "researcher@access-ci.org",
+        };
+
+        mockDrupalAuth.post.mockResolvedValue({
+          data: {
+            id: "new-announcement-uuid",
+            attributes: { title: "Test" },
+          },
+        });
+
+        await requestContextStorage.run(context, async () => {
+          return server["handleToolCall"]({
+            method: "tools/call",
+            params: {
+              name: "create_announcement",
+              arguments: {
+                title: "Test",
+                body: "Body",
+                summary: "Summary",
+              },
+            },
+          });
+        });
+
+        expect(mockDrupalAuth.setActingUser).toHaveBeenCalledWith("researcher@access-ci.org");
+      });
+
+      it("should create announcement with external link", async () => {
         mockDrupalAuth.post.mockResolvedValue({
           data: {
             id: "new-announcement-uuid",
@@ -733,10 +832,6 @@ describe("AnnouncementsServer", () => {
       });
 
       it("should create announcement with where_to_share", async () => {
-        mockDrupalAuth.get.mockResolvedValueOnce({
-          data: [{ id: "acting-user-uuid-123" }],
-        });
-
         mockDrupalAuth.post.mockResolvedValue({
           data: {
             id: "new-announcement-uuid",
@@ -776,10 +871,6 @@ describe("AnnouncementsServer", () => {
       });
 
       it("should fail with invalid where_to_share value", async () => {
-        mockDrupalAuth.get.mockResolvedValueOnce({
-          data: [{ id: "acting-user-uuid-123" }],
-        });
-
         const result = await server["handleToolCall"]({
           method: "tools/call",
           params: {
@@ -798,14 +889,8 @@ describe("AnnouncementsServer", () => {
       });
 
       it("should create announcement with affinity group", async () => {
-        // User lookup
-        mockDrupalAuth.get.mockResolvedValueOnce({
-          data: [{ id: "acting-user-uuid-123" }],
-        });
-        // Affinity group lookup by title
-        mockDrupalAuth.get.mockResolvedValueOnce({
-          data: [],
-        });
+        // Affinity group lookup by title (first by field_group_id returns empty, then by title)
+        mockDrupalAuth.get.mockResolvedValueOnce({ data: [] });
         mockDrupalAuth.get.mockResolvedValueOnce({
           data: [{ id: "group-uuid-456", attributes: { title: "Test Group" } }],
         });
@@ -851,9 +936,6 @@ describe("AnnouncementsServer", () => {
       });
 
       it("should fail when affinity group not found", async () => {
-        mockDrupalAuth.get.mockResolvedValueOnce({
-          data: [{ id: "acting-user-uuid-123" }],
-        });
         // Both lookups return empty
         mockDrupalAuth.get.mockResolvedValueOnce({ data: [] });
         mockDrupalAuth.get.mockResolvedValueOnce({ data: [] });
@@ -1049,23 +1131,20 @@ describe("AnnouncementsServer", () => {
     });
 
     describe("get_my_announcements", () => {
-      it("should fetch announcements for acting user", async () => {
-        // First call: user UUID lookup, Second call: announcements
-        mockDrupalAuth.get
-          .mockResolvedValueOnce({ data: [{ id: "acting-user-uuid-456" }] })
-          .mockResolvedValueOnce({
-            data: [
-              {
-                id: "announcement-1",
-                attributes: {
-                  title: "My First Announcement",
-                  status: false,
-                  created: "2024-03-15T10:00:00Z",
-                  body: { value: "<p>Content</p>", summary: "Summary" },
-                },
+      it("should fetch announcements via views endpoint without user UUID lookup", async () => {
+        mockDrupalAuth.get.mockResolvedValueOnce({
+          data: [
+            {
+              id: "announcement-1",
+              attributes: {
+                title: "My First Announcement",
+                status: false,
+                created: "2024-03-15T10:00:00Z",
+                body: { value: "<p>Content</p>", summary: "Summary" },
               },
-            ],
-          });
+            },
+          ],
+        });
 
         const result = await server["handleToolCall"]({
           method: "tools/call",
@@ -1075,13 +1154,10 @@ describe("AnnouncementsServer", () => {
           },
         });
 
-        // Should look up acting user UUID first
-        expect(mockDrupalAuth.get).toHaveBeenCalledWith(
-          "/jsonapi/user/user?filter[drupal_internal__uid]=1985"
-        );
-        // Then fetch announcements for that user
+        // Should make exactly 1 call — no user UUID lookup
+        expect(mockDrupalAuth.get).toHaveBeenCalledTimes(1);
         expect(mockDrupalAuth.get).toHaveBeenCalledWith(
-          expect.stringContaining("filter[uid.id]=acting-user-uuid-456")
+          "/jsonapi/views/mcp_my_announcements/page_1?page[limit]=10"
         );
 
         const responseData = JSON.parse((result.content[0] as TextContent).text);
@@ -1089,22 +1165,120 @@ describe("AnnouncementsServer", () => {
         expect(responseData.items[0].title).toBe("My First Announcement");
         expect(responseData.items[0].status).toBe("draft");
       });
-    });
 
-    describe("get_announcement_context", () => {
-      it("should return tags and affinity groups for coordinator", async () => {
-        // First call: get user UUID
-        mockDrupalAuth.get.mockResolvedValueOnce({
-          data: [{ id: "user-uuid-123", attributes: { name: "testuser" } }],
+      it("should use default limit of 25", async () => {
+        mockDrupalAuth.get.mockResolvedValueOnce({ data: [] });
+
+        await server["handleToolCall"]({
+          method: "tools/call",
+          params: {
+            name: "get_my_announcements",
+            arguments: {},
+          },
         });
-        // Second call: get tags (parallel)
+
+        expect(mockDrupalAuth.get).toHaveBeenCalledWith(
+          "/jsonapi/views/mcp_my_announcements/page_1?page[limit]=25"
+        );
+      });
+
+      it("should map published status and build edit_url from nid", async () => {
         mockDrupalAuth.get.mockResolvedValueOnce({
           data: [
-            { id: "tag-1", attributes: { name: "gpu" } },
-            { id: "tag-2", attributes: { name: "hpc" } },
+            {
+              id: "ann-published",
+              attributes: {
+                title: "Published One",
+                status: true,
+                drupal_internal__nid: 999,
+                created: "2024-03-15T10:00:00Z",
+                field_published_date: "2024-03-15",
+                body: { value: "<p>Body</p>", summary: "Short summary" },
+              },
+            },
+            {
+              id: "ann-draft",
+              attributes: {
+                title: "Draft One",
+                status: false,
+                drupal_internal__nid: 1000,
+                created: "2024-03-14T10:00:00Z",
+                body: { value: "<p>Draft body</p>" },
+              },
+            },
           ],
         });
-        // Third call: get affinity groups (parallel)
+
+        const result = await server["handleToolCall"]({
+          method: "tools/call",
+          params: {
+            name: "get_my_announcements",
+            arguments: {},
+          },
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.total).toBe(2);
+
+        // Published announcement
+        expect(responseData.items[0].uuid).toBe("ann-published");
+        expect(responseData.items[0].status).toBe("published");
+        expect(responseData.items[0].nid).toBe(999);
+        expect(responseData.items[0].edit_url).toBe("https://test.drupal.site/node/999/edit");
+        expect(responseData.items[0].published_date).toBe("2024-03-15");
+        expect(responseData.items[0].summary).toBe("Short summary");
+
+        // Draft announcement — summary falls back to body text
+        expect(responseData.items[1].uuid).toBe("ann-draft");
+        expect(responseData.items[1].status).toBe("draft");
+        expect(responseData.items[1].edit_url).toBe("https://test.drupal.site/node/1000/edit");
+        expect(responseData.items[1].summary).toContain("Draft body");
+      });
+
+      it("should handle empty results from views endpoint", async () => {
+        mockDrupalAuth.get.mockResolvedValueOnce({ data: [] });
+
+        const result = await server["handleToolCall"]({
+          method: "tools/call",
+          params: {
+            name: "get_my_announcements",
+            arguments: {},
+          },
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.total).toBe(0);
+        expect(responseData.items).toEqual([]);
+      });
+
+      it("should use acting user from request context", async () => {
+        delete process.env.ACTING_USER;
+
+        mockDrupalAuth.get.mockResolvedValueOnce({ data: [] });
+
+        const context: RequestContext = {
+          actingUser: "contextuser@access-ci.org",
+        };
+
+        const result = await requestContextStorage.run(context, async () => {
+          return server["handleToolCall"]({
+            method: "tools/call",
+            params: {
+              name: "get_my_announcements",
+              arguments: {},
+            },
+          });
+        });
+
+        // Should succeed — acting user comes from request context
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.total).toBe(0);
+        expect(mockDrupalAuth.get).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe("get_announcement_context", () => {
+      it("should fetch affinity groups without tags", async () => {
         mockDrupalAuth.get.mockResolvedValueOnce({
           data: [
             {
@@ -1112,8 +1286,8 @@ describe("AnnouncementsServer", () => {
               attributes: {
                 title: "Test Group",
                 field_group_id: 123,
-                field_affinity_group_category: "Research"
-              }
+                field_affinity_group_category: "Research",
+              },
             },
           ],
         });
@@ -1126,26 +1300,25 @@ describe("AnnouncementsServer", () => {
           },
         });
 
+        // Only 1 call — affinity groups view, no tags fetch
+        expect(mockDrupalAuth.get).toHaveBeenCalledTimes(1);
+        expect(mockDrupalAuth.get).toHaveBeenCalledWith(
+          "/jsonapi/views/mcp_my_affinity_groups/page_1"
+        );
+
         const responseData = JSON.parse((result.content[0] as TextContent).text);
-        expect(responseData.tags).toHaveLength(2);
-        expect(responseData.tags[0].name).toBe("gpu");
+        // Should NOT return tags
+        expect(responseData).not.toHaveProperty("tags");
         expect(responseData.affinity_groups).toHaveLength(1);
         expect(responseData.affinity_groups[0].name).toBe("Test Group");
         expect(responseData.is_coordinator).toBe(true);
         expect(responseData.affiliations).toContain("ACCESS Collaboration");
         expect(responseData.affiliations).toContain("Community");
+        expect(responseData.where_to_share_options).toHaveLength(4);
+        expect(responseData.guidance).toContain("coordinator");
       });
 
-      it("should indicate non-coordinator when user has no affinity groups", async () => {
-        // First call: get user UUID
-        mockDrupalAuth.get.mockResolvedValueOnce({
-          data: [{ id: "user-uuid-123", attributes: { name: "testuser" } }],
-        });
-        // Second call: get tags (parallel)
-        mockDrupalAuth.get.mockResolvedValueOnce({
-          data: [{ id: "tag-1", attributes: { name: "gpu" } }],
-        });
-        // Third call: get affinity groups - empty (parallel)
+      it("should indicate non-coordinator when views returns no affinity groups", async () => {
         mockDrupalAuth.get.mockResolvedValueOnce({
           data: [],
         });
@@ -1161,6 +1334,154 @@ describe("AnnouncementsServer", () => {
         const responseData = JSON.parse((result.content[0] as TextContent).text);
         expect(responseData.is_coordinator).toBe(false);
         expect(responseData.affinity_groups).toHaveLength(0);
+        expect(responseData.guidance).toContain("not a coordinator");
+      });
+
+      it("should fail without acting user", async () => {
+        delete process.env.ACTING_USER;
+
+        const result = await server["handleToolCall"]({
+          method: "tools/call",
+          params: {
+            name: "get_announcement_context",
+            arguments: {},
+          },
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.error).toContain("No acting user specified");
+        expect(mockDrupalAuth.get).not.toHaveBeenCalled();
+      });
+
+      it("should use acting user from request context", async () => {
+        delete process.env.ACTING_USER;
+
+        mockDrupalAuth.get.mockResolvedValueOnce({ data: [] });
+
+        const context: RequestContext = {
+          actingUser: "contextuser@access-ci.org",
+        };
+
+        const result = await requestContextStorage.run(context, async () => {
+          return server["handleToolCall"]({
+            method: "tools/call",
+            params: {
+              name: "get_announcement_context",
+              arguments: {},
+            },
+          });
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData).not.toHaveProperty("tags");
+        expect(responseData.is_coordinator).toBe(false);
+        expect(mockDrupalAuth.get).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe("suggest_tags", () => {
+      it("should return error when text is too short", async () => {
+        const result = await server["handleToolCall"]({
+          method: "tools/call",
+          params: {
+            name: "suggest_tags",
+            arguments: { text: "Short text" },
+          },
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.error).toContain("at least 100 characters");
+      });
+
+      it("should return error when text is empty", async () => {
+        const result = await server["handleToolCall"]({
+          method: "tools/call",
+          params: {
+            name: "suggest_tags",
+            arguments: { text: "" },
+          },
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.error).toContain("at least 100 characters");
+      });
+
+      it("should return suggested tags on success", async () => {
+        const longText = "A".repeat(150);
+        mockDrupalAuth.post.mockResolvedValueOnce({
+          tags: [
+            { tid: 1, name: "ai", uuid: "uuid-1" },
+            { tid: 2, name: "hpc", uuid: "uuid-2" },
+          ],
+        });
+
+        const result = await server["handleToolCall"]({
+          method: "tools/call",
+          params: {
+            name: "suggest_tags",
+            arguments: { text: longText },
+          },
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.suggested_tags).toEqual(["ai", "hpc"]);
+        expect(responseData.tag_details).toHaveLength(2);
+      });
+
+      it("should truncate results to the specified limit", async () => {
+        const longText = "A".repeat(150);
+        mockDrupalAuth.post.mockResolvedValueOnce({
+          tags: [
+            { tid: 1, name: "ai", uuid: "uuid-1" },
+            { tid: 2, name: "hpc", uuid: "uuid-2" },
+            { tid: 3, name: "gpu", uuid: "uuid-3" },
+          ],
+        });
+
+        const result = await server["handleToolCall"]({
+          method: "tools/call",
+          params: {
+            name: "suggest_tags",
+            arguments: { text: longText, limit: 2 },
+          },
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.suggested_tags).toHaveLength(2);
+        expect(responseData.tag_details).toHaveLength(2);
+      });
+    });
+
+    describe("suggest_summary", () => {
+      it("should return error when text is too short", async () => {
+        const result = await server["handleToolCall"]({
+          method: "tools/call",
+          params: {
+            name: "suggest_summary",
+            arguments: { text: "Short text" },
+          },
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.error).toContain("at least 100 characters");
+      });
+
+      it("should return summary on success", async () => {
+        const longText = "A".repeat(150);
+        mockDrupalAuth.post.mockResolvedValueOnce({
+          summary: "A test summary of the content.",
+        });
+
+        const result = await server["handleToolCall"]({
+          method: "tools/call",
+          params: {
+            name: "suggest_summary",
+            arguments: { text: longText },
+          },
+        });
+
+        const responseData = JSON.parse((result.content[0] as TextContent).text);
+        expect(responseData.summary).toBe("A test summary of the content.");
       });
     });
   });
@@ -1248,7 +1569,9 @@ describe("AnnouncementsServer", () => {
         },
       });
 
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK prompt message content type
       expect((result.messages[0].content as any).text).toContain("GPU availability");
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK prompt message content type
       expect((result.messages[1].content as any).text).toContain("GPU availability");
     });
 
@@ -1262,6 +1585,7 @@ describe("AnnouncementsServer", () => {
 
       expect(result.description).toBe("Guide for managing existing announcements");
       expect(result.messages).toHaveLength(2);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK prompt message content type
       expect((result.messages[1].content as any).text).toContain("get_my_announcements");
     });
 
@@ -1291,4 +1615,4 @@ describe("AnnouncementsServer", () => {
       expect(responseData.error).toContain("Unknown tool");
     });
   });
-});
+});