Added structuredContent support, applied "Remove misleading structured content compatibility warning" fix (PR 1098)

Author: BobDickinson

core/__tests__/inspectorClient.test.ts

@@ -634,6 +634,38 @@ describe("InspectorClient", () => {
       expect(hasImage).toBe(true);
     });
 
+    it("should return both content and structuredContent for tool with outputSchema (get_temp)", async () => {
+      const result = await client.callTool("get_temp", {
+        city: "Seattle",
+        units: "C",
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBeDefined();
+      expect(result.result).toHaveProperty("content");
+      expect(result.result).toHaveProperty("structuredContent");
+
+      const content = result.result!.content as Array<{
+        type: string;
+        text?: string;
+      }>;
+      expect(Array.isArray(content)).toBe(true);
+      expect(content[0].type).toBe("text");
+      expect(content[0].text).toContain("Seattle");
+      expect(content[0].text).toContain("25");
+      expect(content[0].text).toContain("degrees C");
+
+      const structured = result.result!.structuredContent as Record<
+        string,
+        unknown
+      >;
+      expect(structured).toEqual({
+        temperature: 25,
+        unit: "C",
+        city: "Seattle",
+      });
+    });
+
     it("should handle tool not found", async () => {
       const result = await client.callTool("nonexistent-tool", {});
       // When tool is not found, the SDK returns an error response, not an exception

docs/inspector-client-todo.md

@@ -78,9 +78,11 @@ If we are in a container:
 Goal: Parity with v1 client
 
 - MCP apps work (remaining)
-  - Fix handler multiplexing in AppRendererClient
+  - Fix handler multiplexing in AppRendererClient (AppNotificationHandler multiplexing)
 - Update README (client->web, proxy->sandbox)
 - Review changes to Client from time of fork to present to make sure we didn't miss anything else
+  - Structured Content Compatability warning
+    - https://github.com/modelcontextprotocol/inspector/pull/1098
 
 Goal: Bring Inspector Web support to current spec
 

test/__tests__/server-composable.test.ts

@@ -29,8 +29,8 @@ describe("server-composable", () => {
 
     try {
       const { tools } = await client.listTools();
-      expect(tools).toHaveLength(1);
-      expect(tools[0].name).toBe("echo");
+      const echoTool = tools.find((t) => t.name === "echo");
+      expect(echoTool).toBeDefined();
 
       const result = await client.callTool({
         name: "echo",

test/configs/demo.json

@@ -3,7 +3,7 @@
     "name": "composable-demo",
     "version": "1.0.0"
   },
-  "tools": [{ "preset": "echo" }],
+  "tools": [{ "preset": "echo" }, { "preset": "get_temp" }],
   "transport": {
     "type": "stdio"
   }

test/src/composable-test-server.ts

@@ -49,6 +49,7 @@ import {
   type ListResourceTemplatesResult,
   type ListPromptsResult,
 } from "@modelcontextprotocol/sdk/types.js";
+import type { AnySchema } from "@modelcontextprotocol/sdk/server/zod-compat.js";
 import {
   ZodRawShapeCompat,
   getObjectShape,
@@ -98,6 +99,8 @@ export interface ToolDefinition {
   name: string;
   description: string;
   inputSchema?: ToolInputSchema;
+  /** Optional Zod object schema for tool output; when set, handler must return structuredContent. */
+  outputSchema?: unknown;
   handler: (
     params: Record<string, any>,
     context?: TestServerContext,
@@ -470,37 +473,43 @@ export function createMcpServer(config: ServerConfig): McpServer {
           {
             description: tool.description,
             inputSchema: tool.inputSchema,
+            ...(tool.outputSchema != null && {
+              outputSchema: tool.outputSchema as AnySchema,
+            }),
           },
           async (args, extra) => {
             const result = await tool.handler(
               args as Record<string, any>,
               context,
               extra,
             );
-            // Handle different return types from tool handlers
-            // If handler returns content array directly (like get-annotated-message), use it
+            const rawStructured =
+              result &&
+              typeof result === "object" &&
+              "structuredContent" in result
+                ? (result as { structuredContent?: unknown }).structuredContent
+                : undefined;
+            const structuredContent =
+              rawStructured !== undefined && rawStructured !== null
+                ? (rawStructured as Record<string, unknown>)
+                : undefined;
+            // If handler returns content array, use it; otherwise build content from message or stringify
+            let content: Array<{ type: "text"; text: string }>;
             if (result && Array.isArray(result.content)) {
-              return { content: result.content };
-            }
-            // If handler returns message (like echo), format it
-            if (result && typeof result.message === "string") {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: result.message,
-                  },
-                ],
-              };
-            }
-            // Otherwise, stringify the result
-            return {
-              content: [
+              content = result.content as Array<{ type: "text"; text: string }>;
+            } else if (result && typeof result.message === "string") {
+              content = [{ type: "text" as const, text: result.message }];
+            } else {
+              content = [
                 {
-                  type: "text",
-                  text: JSON.stringify(result),
+                  type: "text" as const,
+                  text: JSON.stringify(result ?? {}),
                 },
-              ],
+              ];
+            }
+            return {
+              content,
+              ...(structuredContent !== undefined && { structuredContent }),
             };
           },
         );

test/src/preset-registry.ts

@@ -22,6 +22,7 @@ import {
   createUrlElicitationFormTool,
   createSendNotificationTool,
   createGetAnnotatedMessageTool,
+  createGetTempTool,
   createAddResourceTool,
   createRemoveResourceTool,
   createAddToolTool,
@@ -96,6 +97,8 @@ function resolveToolPreset(
       return createSendNotificationTool();
     case "get_annotated_message":
       return createGetAnnotatedMessageTool();
+    case "get_temp":
+      return createGetTempTool();
     case "add_resource":
       return createAddResourceTool();
     case "remove_resource":

test/src/test-server-fixtures.ts

@@ -640,6 +640,40 @@ export function createGetAnnotatedMessageTool(): ToolDefinition {
   };
 }
 
+/** Output schema for get_temp: temperature, unit, city */
+const GetTempOutputSchema = z.object({
+  temperature: z.number().describe("Temperature value"),
+  unit: z.string().describe("C or F"),
+  city: z.string().describe("City name"),
+});
+
+/**
+ * Create a "get_temp" tool that returns both content (human-readable) and structuredContent (schema-validated).
+ * Takes city and units (C/F), returns mock temperature 25 and matching text + structured output.
+ */
+export function createGetTempTool(): ToolDefinition {
+  return {
+    name: "get_temp",
+    description:
+      "Get the current temperature for a city (mock; returns 25 in requested units)",
+    inputSchema: {
+      city: z.string().describe("City name"),
+      units: z.enum(["C", "F"]).describe("Temperature units"),
+    },
+    outputSchema: GetTempOutputSchema,
+    handler: async (params: Record<string, any>) => {
+      const city = (params.city as string) || "Unknown";
+      const unit = (params.units as "C" | "F") || "C";
+      const temperature = 25;
+      const text = `The temperature in ${city} is ${temperature} degrees ${unit}`;
+      return {
+        content: [{ type: "text" as const, text }],
+        structuredContent: { temperature, unit, city },
+      };
+    },
+  };
+}
+
 /**
  * Create a "simple_prompt" prompt definition
  */
@@ -1823,6 +1857,7 @@ export function getDefaultServerConfig(): ServerConfig {
       createEchoTool(),
       createGetSumTool(),
       createGetAnnotatedMessageTool(),
+      createGetTempTool(),
       createSendNotificationTool(),
       createWriteToStderrTool(),
     ],

web/src/App.tsx

@@ -1413,8 +1413,8 @@ const App = () => {
           const compatibilityResult: CompatibilityCallToolResult =
             invocation.result
               ? {
-                  content: invocation.result.content || [],
-                  isError: false,
+                  ...invocation.result,
+                  content: invocation.result.content ?? [],
                 }
               : {
                   content: [
@@ -1447,8 +1447,8 @@ const App = () => {
         const compatibilityResult: CompatibilityCallToolResult =
           invocation.result
             ? {
-                content: invocation.result.content || [],
-                isError: false,
+                ...invocation.result,
+                content: invocation.result.content ?? [],
               }
             : {
                 content: [

web/src/components/ToolResults.tsx

@@ -22,17 +22,14 @@ const checkContentCompatibility = (
     text?: string;
     [key: string]: unknown;
   }>,
-): { isCompatible: boolean; message: string } => {
+): { hasMatch: boolean; message: string } | null => {
   // Look for at least one text content block that matches the structured content
   const textBlocks = unstructuredContent.filter(
     (block) => block.type === "text",
   );
 
   if (textBlocks.length === 0) {
-    return {
-      isCompatible: false,
-      message: "No text blocks to match structured content",
-    };
+    return null;
   }
 
   // Check if any text block contains JSON that matches the structured content
@@ -49,7 +46,7 @@ const checkContentCompatibility = (
 
       if (isEqual) {
         return {
-          isCompatible: true,
+          hasMatch: true,
           message: `Structured content matches text block${textBlocks.length > 1 ? " (multiple blocks)" : ""}${unstructuredContent.length > textBlocks.length ? " + other content" : ""}`,
         };
       }
@@ -59,10 +56,7 @@ const checkContentCompatibility = (
     }
   }
 
-  return {
-    isCompatible: false,
-    message: "No text block matches structured content",
-  };
+  return null;
 };
 
 const ToolResults = ({
@@ -196,16 +190,9 @@ const ToolResults = ({
                 <h5 className="font-semibold mb-2 text-sm">
                   Unstructured Content:
                 </h5>
-                {compatibilityResult && (
-                  <div
-                    className={`mb-2 p-2 rounded text-sm ${
-                      compatibilityResult.isCompatible
-                        ? "bg-blue-100 dark:bg-blue-900 text-blue-800 dark:text-blue-200"
-                        : "bg-yellow-100 dark:bg-yellow-900 text-yellow-800 dark:text-yellow-200"
-                    }`}
-                  >
-                    {compatibilityResult.isCompatible ? "✓" : "⚠"}{" "}
-                    {compatibilityResult.message}
+                {compatibilityResult?.hasMatch && (
+                  <div className="mb-2 p-2 rounded text-sm bg-blue-100 dark:bg-blue-900 text-blue-800 dark:text-blue-200">
+                    ✓ {compatibilityResult.message}
                   </div>
                 )}
               </>

web/src/components/__tests__/ToolsTab.test.tsx

@@ -736,8 +736,13 @@ describe("ToolsTab", () => {
         toolResult: noMatchResult,
       });
 
-      // Should render without crashing - the validation logic has been updated
       expect(screen.getAllByText("weatherTool")).toHaveLength(2);
+      // No compatibility warning when content is not a JSON copy of structuredContent (PR #1098)
+      expect(
+        screen.queryByText(
+          /structured content matches|no text blocks|no.*matches/i,
+        ),
+      ).not.toBeInTheDocument();
     });
 
     it("should reject when no text blocks are present", () => {
@@ -752,8 +757,13 @@ describe("ToolsTab", () => {
         toolResult: noTextBlocksResult,
       });
 
-      // Should render without crashing - the validation logic has been updated
       expect(screen.getAllByText("weatherTool")).toHaveLength(2);
+      // No compatibility message when no text blocks (PR #1098)
+      expect(
+        screen.queryByText(
+          /structured content matches|no text blocks|no.*matches/i,
+        ),
+      ).not.toBeInTheDocument();
     });
 
     it("should not show compatibility check when tool has no output schema", () => {
@@ -774,6 +784,32 @@ describe("ToolsTab", () => {
         ),
       ).not.toBeInTheDocument();
     });
+
+    it("should not show compatibility warning when content is human-readable (not JSON copy of structuredContent)", () => {
+      const humanReadableResult = {
+        content: [
+          {
+            type: "text",
+            text: "The temperature in Seattle is 25 degrees C",
+          },
+        ],
+        structuredContent: { temperature: 25, unit: "C", city: "Seattle" },
+      };
+
+      renderToolsTab({
+        tools: [toolWithOutputSchema],
+        selectedTool: toolWithOutputSchema,
+        toolResult: humanReadableResult,
+      });
+
+      expect(screen.getByText("Structured Content:")).toBeInTheDocument();
+      // No yellow warning; MCP spec allows content to be human-readable (PR #1098)
+      expect(
+        screen.queryByText(
+          /no text blocks? to match|no text block matches structured/i,
+        ),
+      ).not.toBeInTheDocument();
+    });
   });
 
   describe("Resource Link Content Type", () => {