@bryan-thompson/inspector-assessment-cli 1.36.4 → 1.36.5

package/build/__tests__/assessment-runner/tools-with-hints.test.js

@@ -198,6 +198,96 @@ describe("getToolsWithPreservedHints", () => {
         const tools = await getToolsWithPreservedHints(mockClient);
         expect(tools[0].destructiveHint).toBe(true);
     });
+    // Issue #160: Non-suffixed property preservation tests
+    it("should preserve non-suffixed readOnly from annotations object (Issue #160)", async () => {
+        mockClient.listTools.mockImplementation(async () => {
+            if (mockTransport.onmessage) {
+                mockTransport.onmessage({
+                    result: {
+                        tools: [
+                            {
+                                name: "domain_search",
+                                annotations: { readOnly: true }, // Non-suffixed version
+                            },
+                        ],
+                    },
+                });
+            }
+            // SDK returns tool without annotations (stripped by Zod)
+            return { tools: [{ name: "domain_search" }] };
+        });
+        const tools = await getToolsWithPreservedHints(mockClient);
+        // Should be mapped to readOnlyHint
+        expect(tools[0].readOnlyHint).toBe(true);
+    });
+    it("should preserve all non-suffixed annotations from annotations object (Issue #160)", async () => {
+        mockClient.listTools.mockImplementation(async () => {
+            if (mockTransport.onmessage) {
+                mockTransport.onmessage({
+                    result: {
+                        tools: [
+                            {
+                                name: "full_tool",
+                                annotations: {
+                                    readOnly: true,
+                                    destructive: false,
+                                    idempotent: true,
+                                    openWorld: false,
+                                },
+                            },
+                        ],
+                    },
+                });
+            }
+            return { tools: [{ name: "full_tool" }] };
+        });
+        const tools = await getToolsWithPreservedHints(mockClient);
+        expect(tools[0].readOnlyHint).toBe(true);
+        expect(tools[0].destructiveHint).toBe(false);
+        expect(tools[0].idempotentHint).toBe(true);
+        expect(tools[0].openWorldHint).toBe(false);
+    });
+    it("should preserve non-suffixed readOnly from direct property (Issue #160)", async () => {
+        mockClient.listTools.mockImplementation(async () => {
+            if (mockTransport.onmessage) {
+                mockTransport.onmessage({
+                    result: {
+                        tools: [
+                            {
+                                name: "direct_tool",
+                                readOnly: true, // Direct non-suffixed property
+                            },
+                        ],
+                    },
+                });
+            }
+            return { tools: [{ name: "direct_tool" }] };
+        });
+        const tools = await getToolsWithPreservedHints(mockClient);
+        expect(tools[0].readOnlyHint).toBe(true);
+    });
+    it("should prioritize *Hint over non-suffixed versions (Issue #160)", async () => {
+        mockClient.listTools.mockImplementation(async () => {
+            if (mockTransport.onmessage) {
+                mockTransport.onmessage({
+                    result: {
+                        tools: [
+                            {
+                                name: "priority_tool",
+                                annotations: {
+                                    readOnlyHint: false, // *Hint should win
+                                    readOnly: true, // Should be ignored
+                                },
+                            },
+                        ],
+                    },
+                });
+            }
+            return { tools: [{ name: "priority_tool" }] };
+        });
+        const tools = await getToolsWithPreservedHints(mockClient);
+        expect(tools[0].readOnlyHint).toBe(false); // *Hint takes priority
+    });
     it("should restore original onmessage handler after call", async () => {
         const originalHandler = jest.fn();
         mockTransport.onmessage = originalHandler;

package/build/lib/assessment-runner/tools-with-hints.js

@@ -6,15 +6,33 @@
  * as a direct property on tools). This module intercepts the raw transport
  * response to preserve these properties.
  *
+ * Issue #160: Also preserves non-suffixed annotation property names (readOnly,
+ * destructive, idempotent, openWorld) for servers that use the shorter names
+ * instead of the *Hint suffix versions required by MCP spec.
+ *
  * @module cli/lib/assessment-runner/tools-with-hints
  */
-// Hint property names we want to preserve
+// Hint property names we want to preserve (*Hint suffix - MCP spec)
 const HINT_PROPERTIES = [
     "readOnlyHint",
     "destructiveHint",
     "idempotentHint",
     "openWorldHint",
 ];
+// Issue #160: Non-suffixed property names (fallback for servers using shorter names)
+const NON_SUFFIXED_PROPERTIES = [
+    "readOnly",
+    "destructive",
+    "idempotent",
+    "openWorld",
+];
+// Mapping from non-suffixed to *Hint versions
+const NON_SUFFIXED_TO_HINT = {
+    readOnly: "readOnlyHint",
+    destructive: "destructiveHint",
+    idempotent: "idempotentHint",
+    openWorld: "openWorldHint",
+};
 /**
  * Get tools from MCP server with hint properties preserved.
  *
@@ -74,23 +92,45 @@ export async function getToolsWithPreservedHints(client) {
                     continue;
                 }
                 // Check raw tool locations in priority order:
-                // 1. Direct property on raw tool
-                // 2. annotations object
-                // 3. metadata object
-                // 4. _meta object
+                // 1. Direct property on raw tool (*Hint)
+                // 2. Direct property on raw tool (non-suffixed, Issue #160)
+                // 3. annotations object (*Hint)
+                // 4. annotations object (non-suffixed, Issue #160)
+                // 5. metadata object (*Hint)
+                // 6. metadata object (non-suffixed, Issue #160)
+                // 7. _meta object (*Hint)
+                // 8. _meta object (non-suffixed, Issue #160)
                 let value;
+                // Get the non-suffixed equivalent (e.g., readOnlyHint -> readOnly)
+                const nonSuffixed = hint.replace("Hint", "");
+                // Check direct properties
                 if (typeof rawTool[hint] === "boolean") {
                     value = rawTool[hint];
                 }
+                else if (typeof rawTool[nonSuffixed] === "boolean") {
+                    value = rawTool[nonSuffixed];
+                }
+                // Check annotations object
                 else if (typeof rawTool.annotations?.[hint] === "boolean") {
                     value = rawTool.annotations[hint];
                 }
+                else if (typeof rawTool.annotations?.[nonSuffixed] === "boolean") {
+                    value = rawTool.annotations[nonSuffixed];
+                }
+                // Check metadata object
                 else if (typeof rawTool.metadata?.[hint] === "boolean") {
                     value = rawTool.metadata[hint];
                 }
+                else if (typeof rawTool.metadata?.[nonSuffixed] === "boolean") {
+                    value = rawTool.metadata[nonSuffixed];
+                }
+                // Check _meta object
                 else if (typeof rawTool._meta?.[hint] === "boolean") {
                     value = rawTool._meta[hint];
                 }
+                else if (typeof rawTool._meta?.[nonSuffixed] === "boolean") {
+                    value = rawTool._meta[nonSuffixed];
+                }
                 if (value !== undefined) {
                     enrichedTool[hint] = value;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bryan-thompson/inspector-assessment-cli",
-  "version": "1.36.4",
+  "version": "1.36.5",
   "description": "CLI for the Enhanced MCP Inspector with assessment capabilities",
   "license": "MIT",
   "author": "Bryan Thompson <bryan@triepod.ai>",