@bryan-thompson/inspector-assessment-client 1.10.1 → 1.11.1

package/lib/services/assessment/modules/FunctionalityAssessor.js

@@ -5,7 +5,10 @@
 import { BaseAssessor } from "./BaseAssessor.js";
 import { ResponseValidator } from "../ResponseValidator.js";
 import { createConcurrencyLimit } from "../lib/concurrencyLimit.js";
+import { ToolClassifier, ToolCategory } from "../ToolClassifier.js";
+import { TestDataGenerator } from "../TestDataGenerator.js";
 export class FunctionalityAssessor extends BaseAssessor {
+    toolClassifier = new ToolClassifier();
     /**
      * Select tools for testing based on configuration
      */
@@ -118,9 +121,9 @@ export class FunctionalityAssessor extends BaseAssessor {
     }
     async testTool(tool, callTool) {
         const startTime = Date.now();
+        // Generate minimal valid parameters with metadata
+        const { params: testParams, metadata } = this.generateMinimalParams(tool);
         try {
-            // Generate minimal valid parameters
-            const testParams = this.generateMinimalParams(tool);
             this.log(`Testing tool: ${tool.name} with params: ${JSON.stringify(testParams)}`);
             // Execute tool with timeout
             const response = await this.executeWithTimeout(callTool(tool.name, testParams), this.config.testTimeout);
@@ -145,6 +148,7 @@ export class FunctionalityAssessor extends BaseAssessor {
                         executionTime,
                         testParameters: testParams,
                         response,
+                        testInputMetadata: metadata,
                     };
                 }
                 // Real tool failure (not just validation)
@@ -156,6 +160,7 @@ export class FunctionalityAssessor extends BaseAssessor {
                     executionTime,
                     testParameters: testParams,
                     response,
+                    testInputMetadata: metadata,
                 };
             }
             return {
@@ -165,6 +170,7 @@ export class FunctionalityAssessor extends BaseAssessor {
                 executionTime,
                 testParameters: testParams,
                 response,
+                testInputMetadata: metadata,
             };
         }
         catch (error) {
@@ -174,28 +180,50 @@ export class FunctionalityAssessor extends BaseAssessor {
                 status: "broken",
                 error: this.extractErrorMessage(error),
                 executionTime: Date.now() - startTime,
+                testInputMetadata: metadata,
             };
         }
     }
     generateMinimalParams(tool) {
+        // Classify tool to get category for smart parameter generation
+        const classification = this.toolClassifier.classify(tool.name, tool.description || "");
+        const primaryCategory = classification.categories[0] || ToolCategory.GENERIC;
+        const emptyResult = {
+            params: {},
+            metadata: {
+                toolCategory: primaryCategory,
+                generationStrategy: "default",
+                fieldSources: {},
+            },
+        };
         if (!tool.inputSchema)
-            return {};
+            return emptyResult;
         const schema = typeof tool.inputSchema === "string"
             ? this.safeJsonParse(tool.inputSchema)
             : tool.inputSchema;
         if (!schema?.properties)
-            return {};
+            return emptyResult;
         const params = {};
+        const fieldSources = {};
         const required = schema.required || [];
         // For functionality testing, only generate REQUIRED parameters
         // This avoids triggering validation errors on optional parameters with complex rules
         for (const [key, prop] of Object.entries(schema.properties)) {
             // Only include required parameters for basic functionality testing
             if (required.includes(key)) {
-                params[key] = this.generateParamValue(prop, key);
+                const { value, source, reason } = this.generateSmartParamValueWithMetadata(prop, key, primaryCategory);
+                params[key] = value;
+                fieldSources[key] = { field: key, value, source, reason };
             }
         }
-        return params;
+        return {
+            params,
+            metadata: {
+                toolCategory: primaryCategory,
+                generationStrategy: this.determineStrategy(fieldSources),
+                fieldSources,
+            },
+        };
     }
     generateParamValue(prop, fieldName, includeOptional = false) {
         const type = prop.type;
@@ -269,6 +297,109 @@ export class FunctionalityAssessor extends BaseAssessor {
                 return {};
         }
     }
+    /**
+     * Field names that indicate specific data types regardless of tool category.
+     * These take precedence over category-specific generation.
+     */
+    static SPECIFIC_FIELD_PATTERNS = [
+        /url/i,
+        /endpoint/i,
+        /link/i,
+        /email/i,
+        /mail/i,
+        /path/i,
+        /file/i,
+        /directory/i,
+        /folder/i,
+        /uuid/i,
+        /page_id/i,
+        /database_id/i,
+        /user_id/i,
+        /block_id/i,
+    ];
+    /**
+     * Generate smart parameter value with metadata about how it was generated.
+     * Returns value, source type, and reason for downstream consumers.
+     */
+    generateSmartParamValueWithMetadata(prop, fieldName, category) {
+        // Handle enum first
+        if (prop.enum && prop.enum.length > 0) {
+            return {
+                value: prop.enum[0],
+                source: "enum",
+                reason: `First enum value: ${prop.enum[0]}`,
+            };
+        }
+        // Handle format (uri, email, etc.)
+        if (prop.format === "uri") {
+            return {
+                value: "https://example.com",
+                source: "format",
+                reason: "URI format detected",
+            };
+        }
+        if (prop.format === "email") {
+            return {
+                value: "test@example.com",
+                source: "format",
+                reason: "Email format detected",
+            };
+        }
+        // For non-string types, use standard generation
+        if (prop.type !== "string") {
+            const value = this.generateParamValue(prop, fieldName);
+            return {
+                value,
+                source: "default",
+                reason: `Default for type: ${prop.type}`,
+            };
+        }
+        // Specific field names (url, email, path, etc.) take precedence over category
+        // These indicate explicit data type requirements regardless of tool category
+        const isSpecificFieldName = FunctionalityAssessor.SPECIFIC_FIELD_PATTERNS.some((pattern) => pattern.test(fieldName));
+        if (isSpecificFieldName) {
+            const fieldValue = TestDataGenerator.generateSingleValue(fieldName, prop);
+            return {
+                value: fieldValue,
+                source: "field-name",
+                reason: `Field name pattern: ${fieldName}`,
+            };
+        }
+        // Check category-specific data
+        const categoryData = TestDataGenerator.TOOL_CATEGORY_DATA[category];
+        if (categoryData?.default) {
+            return {
+                value: categoryData.default[0],
+                source: "category",
+                reason: `Category ${category} default value`,
+            };
+        }
+        // Fall back to field-name detection for generic fields
+        const fieldValue = TestDataGenerator.generateSingleValue(fieldName, prop);
+        if (fieldValue !== "test") {
+            return {
+                value: fieldValue,
+                source: "field-name",
+                reason: `Field name pattern: ${fieldName}`,
+            };
+        }
+        return {
+            value: "test",
+            source: "default",
+            reason: "No specific pattern matched",
+        };
+    }
+    /**
+     * Determine overall generation strategy based on field sources
+     */
+    determineStrategy(fieldSources) {
+        const sources = Object.values(fieldSources).map((f) => f.source);
+        if (sources.includes("category"))
+            return "category-specific";
+        if (sources.includes("field-name"))
+            return "field-name-aware";
+        return "default";
+    }
     // Public method for testing purposes - allows tests to verify parameter generation logic
     // Always includes optional properties to test full schema
     generateTestInput(schema) {

package/lib/services/assessment/modules/SecurityAssessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SecurityAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/SecurityAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,kBAAkB,EAInB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAU9D,qBAAa,gBAAiB,SAAQ,YAAY;IAC1C,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAuFrE;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAkC7B;;;;OAIG;YACW,yBAAyB;IAyJvC;;;;OAIG;YACW,qBAAqB;IA6InC;;OAEG;YACW,WAAW;IA2HzB;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAkDzB;;;OAGG;IACH,OAAO,CAAC,8BAA8B;IAmDtC;;OAEG;IACH,OAAO,CAAC,aAAa;IA+BrB;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAgClC;;;OAGG;IACH,OAAO,CAAC,eAAe;IA6HvB;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IAiE7B;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;IAqC5B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAsB3B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAkC5B;;OAEG;YACW,+BAA+B;IAiC7C;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAYjC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA0B/B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAkEnC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAuI3B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAsB5B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,oBAAoB;IAiM5B;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IAiDhC;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA8BhC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAW9B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,oBAAoB;IAoE5B;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;;OAGG;IACH,OAAO,CAAC,eAAe;IASvB;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAiB9B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;CAmB3B"}
+{"version":3,"file":"SecurityAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/SecurityAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,kBAAkB,EAInB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAU9D,qBAAa,gBAAiB,SAAQ,YAAY;IAC1C,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAuFrE;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAkC7B;;;;OAIG;YACW,yBAAyB;IAuKvC;;;;OAIG;YACW,qBAAqB;IA2JnC;;OAEG;YACW,WAAW;IA2HzB;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAkDzB;;;OAGG;IACH,OAAO,CAAC,8BAA8B;IAmDtC;;OAEG;IACH,OAAO,CAAC,aAAa;IA+BrB;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAgClC;;;OAGG;IACH,OAAO,CAAC,eAAe;IA6HvB;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IAiE7B;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;IAqC5B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAsB3B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAkC5B;;OAEG;YACW,+BAA+B;IAiC7C;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAYjC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA0B/B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAkEnC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAuI3B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAsB5B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,oBAAoB;IAiM5B;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IAiDhC;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA8BhC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAW9B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,oBAAoB;IAoE5B;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;;OAGG;IACH,OAAO,CAAC,eAAe;IASvB;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAiB9B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;CAmB3B"}

package/lib/services/assessment/modules/SecurityAssessor.js

@@ -175,6 +175,19 @@ export class SecurityAssessor extends BaseAssessor {
                         toolResults.push(result);
                         if (result.vulnerable) {
                             this.log(`🚨 VULNERABILITY: ${tool.name} - ${attackPattern.attackName} (${payload.payloadType}: ${payload.description})`);
+                            // Emit real-time vulnerability_found event
+                            if (context.onProgress) {
+                                context.onProgress({
+                                    type: "vulnerability_found",
+                                    tool: tool.name,
+                                    pattern: attackPattern.attackName,
+                                    confidence: result.confidence || "medium",
+                                    evidence: result.evidence || "Vulnerability detected",
+                                    riskLevel: payload.riskLevel,
+                                    requiresReview: result.requiresManualReview || false,
+                                    payload: payload.payload,
+                                });
+                            }
                         }
                     }
                     catch (error) {
@@ -285,6 +298,19 @@ export class SecurityAssessor extends BaseAssessor {
                     results.push(result);
                     if (result.vulnerable) {
                         this.log(`🚨 VULNERABILITY: ${tool.name} - ${attackPattern.attackName}`);
+                        // Emit real-time vulnerability_found event
+                        if (context.onProgress) {
+                            context.onProgress({
+                                type: "vulnerability_found",
+                                tool: tool.name,
+                                pattern: attackPattern.attackName,
+                                confidence: result.confidence || "medium",
+                                evidence: result.evidence || "Vulnerability detected",
+                                riskLevel: payload.riskLevel,
+                                requiresReview: result.requiresManualReview || false,
+                                payload: payload.payload,
+                            });
+                        }
                     }
                 }
                 catch (error) {

package/lib/services/assessment/modules/ToolAnnotationAssessor.d.ts

@@ -76,6 +76,10 @@ export declare class ToolAnnotationAssessor extends BaseAssessor {
      * MCP SDK may have annotations in different locations
      */
     private extractAnnotations;
+    /**
+     * Extract parameters from tool input schema for event emission
+     */
+    private extractToolParams;
     /**
      * Infer expected behavior from tool name and description
      */

package/lib/services/assessment/modules/ToolAnnotationAssessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolAnnotationAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/ToolAnnotationAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EACV,wBAAwB,EACxB,oBAAoB,EAErB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,4BAA6B,SAAQ,oBAAoB;IACxE,eAAe,CAAC,EAAE;QAChB,gBAAgB,EAAE,OAAO,CAAC;QAC1B,mBAAmB,EAAE,OAAO,CAAC;QAC7B,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,oBAAoB,EAAE;YACpB,YAAY,CAAC,EAAE,OAAO,CAAC;YACvB,eAAe,CAAC,EAAE,OAAO,CAAC;YAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;SAC1B,CAAC;QACF,oBAAoB,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,MAAM,EAAE,iBAAiB,GAAG,eAAe,CAAC;KAC7C,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,gCAAiC,SAAQ,wBAAwB;IAChF,WAAW,EAAE,4BAA4B,EAAE,CAAC;IAC5C,cAAc,EAAE,OAAO,CAAC;IACxB,2BAA2B,EAAE,4BAA4B,EAAE,CAAC;CAC7D;AAwED,qBAAa,sBAAuB,SAAQ,YAAY;IACtD,OAAO,CAAC,YAAY,CAAC,CAAmB;IAExC;;OAEG;IACH,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAK/C;;OAEG;IACH,eAAe,IAAI,OAAO;IAO1B;;OAEG;IACG,MAAM,CACV,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,wBAAwB,GAAG,gCAAgC,CAAC;IAqIvE;;OAEG;YACW,0BAA0B;IA+IxC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAiCnC;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAoFvC;;OAEG;IACH,OAAO,CAAC,UAAU;IAqElB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAyC1B;;OAEG;IACH,OAAO,CAAC,aAAa;IA0ErB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAsCjC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAmC3B;;OAEG;IACH,OAAO,CAAC,uBAAuB;CA2ChC"}
+{"version":3,"file":"ToolAnnotationAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/ToolAnnotationAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EACV,wBAAwB,EACxB,oBAAoB,EAGrB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,4BAA6B,SAAQ,oBAAoB;IACxE,eAAe,CAAC,EAAE;QAChB,gBAAgB,EAAE,OAAO,CAAC;QAC1B,mBAAmB,EAAE,OAAO,CAAC;QAC7B,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,oBAAoB,EAAE;YACpB,YAAY,CAAC,EAAE,OAAO,CAAC;YACvB,eAAe,CAAC,EAAE,OAAO,CAAC;YAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;SAC1B,CAAC;QACF,oBAAoB,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,MAAM,EAAE,iBAAiB,GAAG,eAAe,CAAC;KAC7C,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,gCAAiC,SAAQ,wBAAwB;IAChF,WAAW,EAAE,4BAA4B,EAAE,CAAC;IAC5C,cAAc,EAAE,OAAO,CAAC;IACxB,2BAA2B,EAAE,4BAA4B,EAAE,CAAC;CAC7D;AAwED,qBAAa,sBAAuB,SAAQ,YAAY;IACtD,OAAO,CAAC,YAAY,CAAC,CAAmB;IAExC;;OAEG;IACH,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAK/C;;OAEG;IACH,eAAe,IAAI,OAAO;IAO1B;;OAEG;IACG,MAAM,CACV,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,wBAAwB,GAAG,gCAAgC,CAAC;IAsMvE;;OAEG;YACW,0BAA0B;IA+IxC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAiCnC;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAoFvC;;OAEG;IACH,OAAO,CAAC,UAAU;IAqElB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAyC1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAuBzB;;OAEG;IACH,OAAO,CAAC,aAAa;IA0ErB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAsCjC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAmC3B;;OAEG;IACH,OAAO,CAAC,uBAAuB;CA2ChC"}

package/lib/services/assessment/modules/ToolAnnotationAssessor.js

@@ -151,11 +151,68 @@ export class ToolAnnotationAssessor extends BaseAssessor {
                     misalignedAnnotationsCount++;
                 }
             }
-            if (toolResults[toolResults.length - 1].hasAnnotations) {
+            const latestResult = toolResults[toolResults.length - 1];
+            if (latestResult.hasAnnotations) {
                 annotatedCount++;
             }
             else {
                 missingAnnotationsCount++;
+                // Emit annotation_missing event with tool details
+                if (context.onProgress && latestResult.inferredBehavior) {
+                    const annotations = this.extractAnnotations(tool);
+                    context.onProgress({
+                        type: "annotation_missing",
+                        tool: tool.name,
+                        title: annotations.title,
+                        description: tool.description,
+                        parameters: this.extractToolParams(tool.inputSchema),
+                        inferredBehavior: {
+                            expectedReadOnly: latestResult.inferredBehavior.expectedReadOnly,
+                            expectedDestructive: latestResult.inferredBehavior.expectedDestructive,
+                            reason: latestResult.inferredBehavior.reason,
+                        },
+                    });
+                }
+            }
+            // Emit annotation_misaligned events for each misalignment
+            if (context.onProgress && latestResult.inferredBehavior) {
+                const annotations = latestResult.annotations;
+                const inferred = latestResult.inferredBehavior;
+                const confidence = latestResult.claudeInference?.confidence ?? 50;
+                const toolParams = this.extractToolParams(tool.inputSchema);
+                const toolAnnotations = this.extractAnnotations(tool);
+                // Check readOnlyHint misalignment
+                if (annotations?.readOnlyHint !== undefined &&
+                    annotations.readOnlyHint !== inferred.expectedReadOnly) {
+                    context.onProgress({
+                        type: "annotation_misaligned",
+                        tool: tool.name,
+                        title: toolAnnotations.title,
+                        description: tool.description,
+                        parameters: toolParams,
+                        field: "readOnlyHint",
+                        actual: annotations.readOnlyHint,
+                        expected: inferred.expectedReadOnly,
+                        confidence,
+                        reason: `Tool has readOnlyHint=${annotations.readOnlyHint}, but ${inferred.reason}`,
+                    });
+                }
+                // Check destructiveHint misalignment
+                if (annotations?.destructiveHint !== undefined &&
+                    annotations.destructiveHint !== inferred.expectedDestructive) {
+                    context.onProgress({
+                        type: "annotation_misaligned",
+                        tool: tool.name,
+                        title: toolAnnotations.title,
+                        description: tool.description,
+                        parameters: toolParams,
+                        field: "destructiveHint",
+                        actual: annotations.destructiveHint,
+                        expected: inferred.expectedDestructive,
+                        confidence,
+                        reason: `Tool has destructiveHint=${annotations.destructiveHint}, but ${inferred.reason}`,
+                    });
+                }
             }
         }
         const status = this.determineAnnotationStatus(toolResults, context.tools.length);
@@ -452,6 +509,29 @@ export class ToolAnnotationAssessor extends BaseAssessor {
             openWorldHint,
         };
     }
+    /**
+     * Extract parameters from tool input schema for event emission
+     */
+    extractToolParams(schema) {
+        if (!schema || typeof schema !== "object")
+            return [];
+        const s = schema;
+        if (!s.properties || typeof s.properties !== "object")
+            return [];
+        const required = new Set(Array.isArray(s.required) ? s.required : []);
+        const properties = s.properties;
+        return Object.entries(properties).map(([name, prop]) => {
+            const param = {
+                name,
+                type: prop.type || "any",
+                required: required.has(name),
+            };
+            if (prop.description) {
+                param.description = prop.description;
+            }
+            return param;
+        });
+    }
     /**
      * Infer expected behavior from tool name and description
      */

package/package.json

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