fix: make tools converted from resources return array content

also add test case for handling undefined text content returned by resource callback

Author: Mubashwer

src/helpers/registerGitMobResourceAsTool.test.ts

@@ -15,9 +15,7 @@ import type {
 } from "@modelcontextprotocol/sdk/types.js";
 
 describe("[helpers] registerGtMobResourceAsTool", () => {
-  const RESOURCE_CALLBACK_CONTENT = "hello world";
-
-  const arrangeMockServerAndTestResource = () => {
+  const arrangeMockServerAndTestResource = (textContents: string[]) => {
     const mockServer = {
       registerTool: jest.fn(),
     } as Partial<McpServer> as McpServer;
@@ -32,12 +30,10 @@ describe("[helpers] registerGtMobResourceAsTool", () => {
     };
     const readCallback: ReadResourceTemplateCallback = async (uri) => {
       return {
-        contents: [
-          {
-            uri: uri.href,
-            text: RESOURCE_CALLBACK_CONTENT,
-          },
-        ],
+        contents: textContents.map((text) => ({
+          uri: uri.href,
+          text,
+        })),
       };
     };
     const testResource: GitMobResource = {
@@ -50,7 +46,9 @@ describe("[helpers] registerGtMobResourceAsTool", () => {
   };
 
   it("should register a resource as a tool with the given server", async () => {
-    const { mockServer, testResource } = arrangeMockServerAndTestResource();
+    const { mockServer, testResource } = arrangeMockServerAndTestResource([
+      "foo",
+    ]);
 
     registerGtMobResourceAsTool(mockServer, testResource);
 
@@ -71,23 +69,53 @@ describe("[helpers] registerGtMobResourceAsTool", () => {
     );
   });
 
-  it("should have registered tool callback return the resource callback content when invoked", async () => {
-    const { mockServer, testResource } = arrangeMockServerAndTestResource();
-    const readCallBackSpy = jest.spyOn(testResource, "readCallback");
+  describe("tool callback", () => {
+    it("should return the resource callback content", async () => {
+      const { mockServer, testResource } = arrangeMockServerAndTestResource([
+        "foo",
+        "bar",
+      ]);
+      const readCallBackSpy = jest.spyOn(testResource, "readCallback");
 
-    registerGtMobResourceAsTool(mockServer, testResource);
+      registerGtMobResourceAsTool(mockServer, testResource);
 
-    const toolCallback = (mockServer.registerTool as jest.Mock).mock
-      .calls[0][2] as ToolCallback<Record<string, never>>;
+      const toolCallback = (mockServer.registerTool as jest.Mock).mock
+        .calls[0][2] as ToolCallback<Record<string, never>>;
 
-    const result = await toolCallback(
-      {},
-      {} as RequestHandlerExtra<ServerRequest, ServerNotification>,
-    );
+      const result = await toolCallback(
+        {},
+        {} as RequestHandlerExtra<ServerRequest, ServerNotification>,
+      );
+
+      expect(readCallBackSpy).toHaveBeenCalled();
+      expect(result).toEqual({
+        content: [
+          { type: "text", text: "foo" },
+          { type: "text", text: "bar" },
+        ],
+      });
+    });
+
+    it("should handle undefined text content in resource callback", async () => {
+      const { mockServer, testResource } = arrangeMockServerAndTestResource([
+        // @ts-expect-error testing for undefined text content
+        undefined,
+        "bar",
+      ]);
+
+      registerGtMobResourceAsTool(mockServer, testResource);
+
+      const toolCallback = (mockServer.registerTool as jest.Mock).mock
+        .calls[0][2] as ToolCallback<Record<string, never>>;
+
+      const result = await toolCallback(
+        {},
+        {} as RequestHandlerExtra<ServerRequest, ServerNotification>,
+      );
 
-    expect(readCallBackSpy).toHaveBeenCalled();
-    expect(result).toEqual({
-      content: [{ type: "text", text: RESOURCE_CALLBACK_CONTENT }],
+      expect(result).toEqual({
+        content: [{ type: "text", text: "bar" }],
+      });
     });
   });
 });

src/helpers/registerGitMobResourceAsTool.ts

@@ -2,6 +2,7 @@ import type {
   ServerNotification,
   ServerRequest,
   ToolAnnotations,
+  CallToolResult,
 } from "@modelcontextprotocol/sdk/types";
 import type { GitMobResource } from "../types/GitMobResource";
 import type {
@@ -32,15 +33,21 @@ export const registerGtMobResourceAsTool = (
     args: Variables,
     extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
   ) => {
-    const result = await readCallback(
+    const resourceResult = await readCallback(
       new URL(template.uriTemplate),
       args,
       extra,
     );
-    const text = result.contents
-      .map((content) => (typeof content.text === "string" ? content.text : ""))
-      .join("\n");
-    return { content: [{ type: "text", text }] };
+    const toolResult: CallToolResult = {
+      content: resourceResult.contents
+        .filter((content) => typeof content.text === "string")
+        .map((content) => ({
+          type: "text",
+          text: content.text as string,
+        })),
+    };
+
+    return toolResult;
   };
 
   server.registerTool(