@bryan-thompson/inspector-assessment 1.36.3 → 1.36.4

package/cli/build/__tests__/jsonl-events.test.js

@@ -207,6 +207,105 @@ describe("JSONL Event Emission", () => {
             expect(annotations).not.toBeNull();
             expect(annotations?.readOnlyHint).toBe(false); // Should use annotations object value
         });
+        // Issue #160: Test non-suffixed annotation property detection
+        it("should detect non-suffixed readOnly from annotations object (Issue #160)", () => {
+            const tool = {
+                name: "domain_search",
+                description: "Search emails based on domain name",
+                inputSchema: { type: "object" },
+                annotations: { readOnly: true }, // Non-suffixed version
+            };
+            emitToolDiscovered(tool);
+            const annotations = emittedEvents[0].annotations;
+            expect(annotations).not.toBeNull();
+            expect(annotations?.readOnlyHint).toBe(true);
+        });
+        it("should detect all non-suffixed annotations from annotations object (Issue #160)", () => {
+            const tool = {
+                name: "full_annotations",
+                inputSchema: { type: "object" },
+                annotations: {
+                    readOnly: true,
+                    destructive: false,
+                    idempotent: true,
+                    openWorld: false,
+                },
+            };
+            emitToolDiscovered(tool);
+            const annotations = emittedEvents[0].annotations;
+            expect(annotations).not.toBeNull();
+            expect(annotations?.readOnlyHint).toBe(true);
+            expect(annotations?.destructiveHint).toBe(false);
+            expect(annotations?.idempotentHint).toBe(true);
+            expect(annotations?.openWorldHint).toBe(false);
+        });
+        it("should detect non-suffixed readOnly from direct properties (Issue #160)", () => {
+            const tool = {
+                name: "email_finder",
+                inputSchema: { type: "object" },
+                readOnly: true, // Direct non-suffixed property
+            };
+            emitToolDiscovered(tool);
+            const annotations = emittedEvents[0].annotations;
+            expect(annotations).not.toBeNull();
+            expect(annotations?.readOnlyHint).toBe(true);
+        });
+        it("should detect non-suffixed annotations from metadata object (Issue #160)", () => {
+            const tool = {
+                name: "metadata_tool",
+                inputSchema: { type: "object" },
+                metadata: {
+                    readOnly: true,
+                    destructive: false,
+                },
+            };
+            emitToolDiscovered(tool);
+            const annotations = emittedEvents[0].annotations;
+            expect(annotations).not.toBeNull();
+            expect(annotations?.readOnlyHint).toBe(true);
+            expect(annotations?.destructiveHint).toBe(false);
+        });
+        it("should detect non-suffixed annotations from _meta object (Issue #160)", () => {
+            const tool = {
+                name: "meta_tool",
+                inputSchema: { type: "object" },
+                _meta: {
+                    idempotent: true,
+                    openWorld: false,
+                },
+            };
+            emitToolDiscovered(tool);
+            const annotations = emittedEvents[0].annotations;
+            expect(annotations).not.toBeNull();
+            expect(annotations?.idempotentHint).toBe(true);
+            expect(annotations?.openWorldHint).toBe(false);
+        });
+        it("should prioritize *Hint over non-suffixed in annotations object (Issue #160)", () => {
+            const tool = {
+                name: "priority_tool",
+                inputSchema: { type: "object" },
+                annotations: {
+                    readOnlyHint: false, // *Hint version should win
+                    readOnly: true, // Should be ignored
+                },
+            };
+            emitToolDiscovered(tool);
+            const annotations = emittedEvents[0].annotations;
+            expect(annotations).not.toBeNull();
+            expect(annotations?.readOnlyHint).toBe(false); // *Hint takes priority
+        });
+        it("should prioritize *Hint over non-suffixed in direct properties (Issue #160)", () => {
+            const tool = {
+                name: "direct_priority_tool",
+                inputSchema: { type: "object" },
+                destructiveHint: true, // *Hint version should win
+                destructive: false, // Should be ignored
+            };
+            emitToolDiscovered(tool);
+            const annotations = emittedEvents[0].annotations;
+            expect(annotations).not.toBeNull();
+            expect(annotations?.destructiveHint).toBe(true);
+        });
     });
     describe("emitToolsDiscoveryComplete", () => {
         it("should emit tools_discovery_complete with count", () => {

package/cli/build/lib/jsonl-events.js

@@ -70,76 +70,150 @@ export function extractToolParams(schema) {
 export function emitToolDiscovered(tool) {
     const params = extractToolParams(tool.inputSchema);
     // Issue #155: Extract annotations from multiple sources (priority order)
-    // NOTE: This is a simplified version of AlignmentChecker.extractAnnotations()
-    // that only checks *Hint-suffixed properties (readOnlyHint, destructiveHint, etc.),
-    // not non-suffixed variants like readOnly, destructive, idempotent, openWorld.
-    // See AlignmentChecker.resolveAnnotationValue() for full implementation with fallbacks.
+    // Issue #160: Also check non-suffixed variants (readOnly, destructive, etc.)
+    // for servers that use the shorter property names instead of *Hint versions.
     const toolAny = tool;
+    const annotationsAny = tool.annotations;
     // Priority 1: Check tool.annotations object (MCP spec)
+    // Issue #160: Use nullish coalescing to fall back to non-suffixed versions
     let readOnlyHint;
     let destructiveHint;
     let idempotentHint;
     let openWorldHint;
-    if (tool.annotations) {
-        readOnlyHint = tool.annotations.readOnlyHint;
-        destructiveHint = tool.annotations.destructiveHint;
-        idempotentHint = tool.annotations.idempotentHint;
-        openWorldHint = tool.annotations.openWorldHint;
+    if (annotationsAny) {
+        // Check *Hint version first, fall back to non-suffixed (Issue #160)
+        if (typeof annotationsAny.readOnlyHint === "boolean") {
+            readOnlyHint = annotationsAny.readOnlyHint;
+        }
+        else if (typeof annotationsAny.readOnly === "boolean") {
+            readOnlyHint = annotationsAny.readOnly;
+        }
+        if (typeof annotationsAny.destructiveHint === "boolean") {
+            destructiveHint = annotationsAny.destructiveHint;
+        }
+        else if (typeof annotationsAny.destructive === "boolean") {
+            destructiveHint = annotationsAny.destructive;
+        }
+        if (typeof annotationsAny.idempotentHint === "boolean") {
+            idempotentHint = annotationsAny.idempotentHint;
+        }
+        else if (typeof annotationsAny.idempotent === "boolean") {
+            idempotentHint = annotationsAny.idempotent;
+        }
+        if (typeof annotationsAny.openWorldHint === "boolean") {
+            openWorldHint = annotationsAny.openWorldHint;
+        }
+        else if (typeof annotationsAny.openWorld === "boolean") {
+            openWorldHint = annotationsAny.openWorld;
+        }
     }
     // Priority 2: Check direct properties on tool object
     // Only use if not already found in annotations
-    if (readOnlyHint === undefined && typeof toolAny.readOnlyHint === "boolean") {
-        readOnlyHint = toolAny.readOnlyHint;
+    // Issue #160: Check both *Hint and non-suffixed versions
+    if (readOnlyHint === undefined) {
+        if (typeof toolAny.readOnlyHint === "boolean") {
+            readOnlyHint = toolAny.readOnlyHint;
+        }
+        else if (typeof toolAny.readOnly === "boolean") {
+            readOnlyHint = toolAny.readOnly;
+        }
     }
-    if (destructiveHint === undefined &&
-        typeof toolAny.destructiveHint === "boolean") {
-        destructiveHint = toolAny.destructiveHint;
+    if (destructiveHint === undefined) {
+        if (typeof toolAny.destructiveHint === "boolean") {
+            destructiveHint = toolAny.destructiveHint;
+        }
+        else if (typeof toolAny.destructive === "boolean") {
+            destructiveHint = toolAny.destructive;
+        }
     }
-    if (idempotentHint === undefined &&
-        typeof toolAny.idempotentHint === "boolean") {
-        idempotentHint = toolAny.idempotentHint;
+    if (idempotentHint === undefined) {
+        if (typeof toolAny.idempotentHint === "boolean") {
+            idempotentHint = toolAny.idempotentHint;
+        }
+        else if (typeof toolAny.idempotent === "boolean") {
+            idempotentHint = toolAny.idempotent;
+        }
     }
-    if (openWorldHint === undefined &&
-        typeof toolAny.openWorldHint === "boolean") {
-        openWorldHint = toolAny.openWorldHint;
+    if (openWorldHint === undefined) {
+        if (typeof toolAny.openWorldHint === "boolean") {
+            openWorldHint = toolAny.openWorldHint;
+        }
+        else if (typeof toolAny.openWorld === "boolean") {
+            openWorldHint = toolAny.openWorld;
+        }
     }
     // Priority 3: Check tool.metadata object
+    // Issue #160: Check both *Hint and non-suffixed versions
     const metadata = toolAny.metadata;
     if (metadata) {
-        if (readOnlyHint === undefined &&
-            typeof metadata.readOnlyHint === "boolean") {
-            readOnlyHint = metadata.readOnlyHint;
+        if (readOnlyHint === undefined) {
+            if (typeof metadata.readOnlyHint === "boolean") {
+                readOnlyHint = metadata.readOnlyHint;
+            }
+            else if (typeof metadata.readOnly === "boolean") {
+                readOnlyHint = metadata.readOnly;
+            }
         }
-        if (destructiveHint === undefined &&
-            typeof metadata.destructiveHint === "boolean") {
-            destructiveHint = metadata.destructiveHint;
+        if (destructiveHint === undefined) {
+            if (typeof metadata.destructiveHint === "boolean") {
+                destructiveHint = metadata.destructiveHint;
+            }
+            else if (typeof metadata.destructive === "boolean") {
+                destructiveHint = metadata.destructive;
+            }
         }
-        if (idempotentHint === undefined &&
-            typeof metadata.idempotentHint === "boolean") {
-            idempotentHint = metadata.idempotentHint;
+        if (idempotentHint === undefined) {
+            if (typeof metadata.idempotentHint === "boolean") {
+                idempotentHint = metadata.idempotentHint;
+            }
+            else if (typeof metadata.idempotent === "boolean") {
+                idempotentHint = metadata.idempotent;
+            }
         }
-        if (openWorldHint === undefined &&
-            typeof metadata.openWorldHint === "boolean") {
-            openWorldHint = metadata.openWorldHint;
+        if (openWorldHint === undefined) {
+            if (typeof metadata.openWorldHint === "boolean") {
+                openWorldHint = metadata.openWorldHint;
+            }
+            else if (typeof metadata.openWorld === "boolean") {
+                openWorldHint = metadata.openWorld;
+            }
         }
     }
     // Priority 4: Check tool._meta object
+    // Issue #160: Check both *Hint and non-suffixed versions
     const _meta = toolAny._meta;
     if (_meta) {
-        if (readOnlyHint === undefined && typeof _meta.readOnlyHint === "boolean") {
-            readOnlyHint = _meta.readOnlyHint;
+        if (readOnlyHint === undefined) {
+            if (typeof _meta.readOnlyHint === "boolean") {
+                readOnlyHint = _meta.readOnlyHint;
+            }
+            else if (typeof _meta.readOnly === "boolean") {
+                readOnlyHint = _meta.readOnly;
+            }
         }
-        if (destructiveHint === undefined &&
-            typeof _meta.destructiveHint === "boolean") {
-            destructiveHint = _meta.destructiveHint;
+        if (destructiveHint === undefined) {
+            if (typeof _meta.destructiveHint === "boolean") {
+                destructiveHint = _meta.destructiveHint;
+            }
+            else if (typeof _meta.destructive === "boolean") {
+                destructiveHint = _meta.destructive;
+            }
         }
-        if (idempotentHint === undefined &&
-            typeof _meta.idempotentHint === "boolean") {
-            idempotentHint = _meta.idempotentHint;
+        if (idempotentHint === undefined) {
+            if (typeof _meta.idempotentHint === "boolean") {
+                idempotentHint = _meta.idempotentHint;
+            }
+            else if (typeof _meta.idempotent === "boolean") {
+                idempotentHint = _meta.idempotent;
+            }
         }
-        if (openWorldHint === undefined &&
-            typeof _meta.openWorldHint === "boolean") {
-            openWorldHint = _meta.openWorldHint;
+        if (openWorldHint === undefined) {
+            if (typeof _meta.openWorldHint === "boolean") {
+                openWorldHint = _meta.openWorldHint;
+            }
+            else if (typeof _meta.openWorld === "boolean") {
+                openWorldHint = _meta.openWorld;
+            }
         }
     }
     // Build annotations object if any hints were found

package/cli/package.json

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

package/client/dist/assets/{OAuthCallback-RXmtS9Xr.js → OAuthCallback-pydLxj3d.js}

@@ -1,4 +1,4 @@
-import { u as useToast, r as reactExports, j as jsxRuntimeExports, p as parseOAuthCallbackParams, g as generateOAuthErrorDescription, S as SESSION_KEYS, I as InspectorOAuthClientProvider, a as auth } from "./index-0DAqp50J.js";
+import { u as useToast, r as reactExports, j as jsxRuntimeExports, p as parseOAuthCallbackParams, g as generateOAuthErrorDescription, S as SESSION_KEYS, I as InspectorOAuthClientProvider, a as auth } from "./index-CVyqQ7s8.js";
 const OAuthCallback = ({ onConnect }) => {
   const { toast } = useToast();
   const hasProcessedRef = reactExports.useRef(false);

package/client/dist/assets/{OAuthDebugCallback-BRtDZYF8.js → OAuthDebugCallback-BLEebYQf.js}

@@ -1,4 +1,4 @@
-import { r as reactExports, S as SESSION_KEYS, p as parseOAuthCallbackParams, j as jsxRuntimeExports, g as generateOAuthErrorDescription } from "./index-0DAqp50J.js";
+import { r as reactExports, S as SESSION_KEYS, p as parseOAuthCallbackParams, j as jsxRuntimeExports, g as generateOAuthErrorDescription } from "./index-CVyqQ7s8.js";
 const OAuthDebugCallback = ({ onConnect }) => {
   reactExports.useEffect(() => {
     let isProcessed = false;

package/client/dist/assets/{index-0DAqp50J.js → index-CVyqQ7s8.js}

@@ -16373,7 +16373,7 @@ object({
   token_type_hint: string().optional()
 }).strip();
 const name = "@bryan-thompson/inspector-assessment-client";
-const version$1 = "1.36.3";
+const version$1 = "1.36.4";
 const packageJson = {
   name,
   version: version$1
@@ -48920,7 +48920,7 @@ const useTheme = () => {
     [theme, setThemeWithSideEffect]
   );
 };
-const version = "1.36.3";
+const version = "1.36.4";
 var [createTooltipContext] = createContextScope("Tooltip", [
   createPopperScope
 ]);
@@ -52515,13 +52515,13 @@ const App = () => {
   ) });
   if (window.location.pathname === "/oauth/callback") {
     const OAuthCallback = React.lazy(
-      () => __vitePreload(() => import("./OAuthCallback-RXmtS9Xr.js"), true ? [] : void 0)
+      () => __vitePreload(() => import("./OAuthCallback-pydLxj3d.js"), true ? [] : void 0)
     );
     return /* @__PURE__ */ jsxRuntimeExports.jsx(reactExports.Suspense, { fallback: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: /* @__PURE__ */ jsxRuntimeExports.jsx(OAuthCallback, { onConnect: onOAuthConnect }) });
   }
   if (window.location.pathname === "/oauth/callback/debug") {
     const OAuthDebugCallback = React.lazy(
-      () => __vitePreload(() => import("./OAuthDebugCallback-BRtDZYF8.js"), true ? [] : void 0)
+      () => __vitePreload(() => import("./OAuthDebugCallback-BLEebYQf.js"), true ? [] : void 0)
     );
     return /* @__PURE__ */ jsxRuntimeExports.jsx(reactExports.Suspense, { fallback: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: /* @__PURE__ */ jsxRuntimeExports.jsx(OAuthDebugCallback, { onConnect: onOAuthDebugConnect }) });
   }

package/client/dist/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/mcp.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>MCP Inspector</title>
-    <script type="module" crossorigin src="/assets/index-0DAqp50J.js"></script>
+    <script type="module" crossorigin src="/assets/index-CVyqQ7s8.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BoUA5OL1.css">
   </head>
   <body>

package/client/package.json

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

package/package.json

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

package/server/package.json

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