@bryan-thompson/inspector-assessment-client 1.15.1 → 1.16.1

package/lib/services/assessment/ResponseValidator.js

@@ -2,7 +2,75 @@
  * Response Validator for MCP Tool Testing
  * Validates that tool responses are actually functional, not just present
  */
+import { validateToolOutput, hasOutputSchema } from "../../utils/schemaUtils.js";
 export class ResponseValidator {
+    /**
+     * Extract response metadata including content types, structuredContent, and _meta
+     */
+    static extractResponseMetadata(context) {
+        const content = context.response.content;
+        const response = context.response;
+        // Track content types present
+        const contentTypes = [];
+        let textBlockCount = 0;
+        let imageCount = 0;
+        let resourceCount = 0;
+        if (Array.isArray(content)) {
+            for (const item of content) {
+                const type = item.type;
+                if (!contentTypes.includes(type)) {
+                    contentTypes.push(type);
+                }
+                // Count by type
+                switch (type) {
+                    case "text":
+                        textBlockCount++;
+                        break;
+                    case "image":
+                        imageCount++;
+                        break;
+                    case "resource":
+                    case "resource_link":
+                        resourceCount++;
+                        break;
+                }
+            }
+        }
+        // Check for structuredContent property (MCP 2024-11-05+)
+        const hasStructuredContent = "structuredContent" in response &&
+            response.structuredContent !== undefined;
+        // Check for _meta property
+        const hasMeta = "_meta" in response && response._meta !== undefined;
+        // Output schema validation
+        let outputSchemaValidation;
+        const toolHasOutputSchema = hasOutputSchema(context.tool.name);
+        if (toolHasOutputSchema) {
+            if (!hasStructuredContent) {
+                outputSchemaValidation = {
+                    hasOutputSchema: true,
+                    isValid: false,
+                    error: "Tool has output schema but did not return structuredContent",
+                };
+            }
+            else {
+                const validation = validateToolOutput(context.tool.name, response.structuredContent);
+                outputSchemaValidation = {
+                    hasOutputSchema: true,
+                    isValid: validation.isValid,
+                    error: validation.error,
+                };
+            }
+        }
+        return {
+            contentTypes,
+            hasStructuredContent,
+            hasMeta,
+            textBlockCount,
+            imageCount,
+            resourceCount,
+            outputSchemaValidation,
+        };
+    }
     /**
      * Validate a tool response comprehensively
      */
@@ -15,6 +83,9 @@ export class ResponseValidator {
             evidence: [],
             classification: "broken",
         };
+        // Extract response metadata for content type tracking
+        const responseMetadata = this.extractResponseMetadata(context);
+        result.responseMetadata = responseMetadata;
         // Check if response indicates an error
         if (context.response.isError) {
             result.isError = true;
@@ -48,19 +119,40 @@ export class ResponseValidator {
             result.confidence = 0;
             return result;
         }
-        // Tool responded successfully - it's functional!
+        // Tool responded successfully - start with fully_working
         result.isValid = true;
         result.classification = "fully_working";
         result.confidence = 100;
         result.evidence.push("Tool responded successfully with content");
-        // Add details about response type for debugging
-        const hasText = content.some((item) => item.type === "text");
-        const hasResource = content.some((item) => item.type === "resource");
-        if (hasText) {
-            result.evidence.push("Response includes text content");
+        // Add details about content types for debugging
+        if (responseMetadata.textBlockCount > 0) {
+            result.evidence.push(`Response includes ${responseMetadata.textBlockCount} text block(s)`);
         }
-        if (hasResource) {
-            result.evidence.push("Response includes resource content");
+        if (responseMetadata.imageCount > 0) {
+            result.evidence.push(`Response includes ${responseMetadata.imageCount} image(s)`);
+        }
+        if (responseMetadata.resourceCount > 0) {
+            result.evidence.push(`Response includes ${responseMetadata.resourceCount} resource(s)`);
+        }
+        if (responseMetadata.hasStructuredContent) {
+            result.evidence.push("Response includes structuredContent");
+        }
+        if (responseMetadata.hasMeta) {
+            result.evidence.push("Response includes _meta field");
+        }
+        // Check output schema validation (P0 enhancement)
+        if (responseMetadata.outputSchemaValidation) {
+            const { hasOutputSchema: hasSchema, isValid, error, } = responseMetadata.outputSchemaValidation;
+            if (hasSchema && !isValid) {
+                // Downgrade classification if output schema validation fails
+                result.classification = "partially_working";
+                result.confidence = 70;
+                result.issues.push(error || "Output schema validation failed");
+                result.evidence.push("Tool has output schema but response does not conform");
+            }
+            else if (hasSchema && isValid) {
+                result.evidence.push("Output schema validation passed");
+            }
         }
         return result;
     }
@@ -317,702 +409,6 @@ export class ResponseValidator {
                 : 0.5;
         return confidence >= confidenceThreshold;
     }
-    /**
-     * Validate error responses are proper and informative
-     * NOTE: Currently unused - kept for potential future use
-     */
-    // @ts-ignore - Unused method kept for potential future use
-    static validateErrorResponse(context, result) {
-        const content = context.response.content;
-        const errorText = content?.[0]?.type === "text" && content[0].text
-            ? content[0].text
-            : JSON.stringify(context.response.content);
-        // Check for proper error structure
-        let hasProperError = false;
-        // Check for MCP standard error codes
-        if (errorText.includes("-32602") || errorText.includes("Invalid params")) {
-            result.evidence.push("Proper MCP error code for invalid parameters");
-            hasProperError = true;
-        }
-        // Check for descriptive error messages
-        if (errorText.length > 20 &&
-            (errorText.toLowerCase().includes("invalid") ||
-                errorText.toLowerCase().includes("required") ||
-                errorText.toLowerCase().includes("type") ||
-                errorText.toLowerCase().includes("validation"))) {
-            result.evidence.push("Descriptive error message provided");
-            hasProperError = true;
-        }
-        if (!hasProperError) {
-            result.issues.push("Error response lacks proper error codes or descriptive messages");
-        }
-        return hasProperError;
-    }
-    /**
-     * Validate response structure matches expectations
-     * NOTE: Currently unused - kept for potential future use
-     */
-    // @ts-ignore - Unused method kept for potential future use
-    static validateResponseStructure(context, result) {
-        // Check if response has content
-        if (!context.response.content) {
-            result.issues.push("Response has no content");
-            return false;
-        }
-        // Check content structure
-        const content = context.response.content;
-        if (!Array.isArray(content) || content.length === 0) {
-            result.issues.push("Response content is empty or not an array");
-            return false;
-        }
-        // Check for expected content type
-        const hasTextContent = content.some((item) => item.type === "text" && item.text);
-        const hasResourceContent = content.some((item) => item.type === "resource");
-        if (!hasTextContent && !hasResourceContent) {
-            result.issues.push("Response lacks text or resource content");
-            return false;
-        }
-        result.evidence.push("Response has valid structure");
-        return true;
-    }
-    /**
-     * Validate response content is meaningful
-     * NOTE: Currently unused - kept for potential future use
-     */
-    // @ts-ignore - Unused method kept for potential future use
-    static validateResponseContent(context, result) {
-        const content = context.response.content;
-        const textContent = content.find((item) => item.type === "text")?.text || "";
-        // Check if response is just echoing input (bad)
-        const inputStr = JSON.stringify(context.input);
-        if (textContent === inputStr || textContent === "test_value") {
-            result.issues.push("Response appears to just echo input");
-            return false;
-        }
-        // Check for minimal content length
-        // But allow short responses for mutation tools (create/update/delete) that might return simple "Success"
-        const toolName = context.tool.name.toLowerCase();
-        const isMutationTool = toolName.includes("create") ||
-            toolName.includes("update") ||
-            toolName.includes("delete") ||
-            toolName.includes("add") ||
-            toolName.includes("remove") ||
-            toolName.includes("insert");
-        if (textContent.length < 10 && !isMutationTool) {
-            result.issues.push("Response content is too short to be meaningful");
-            return false;
-        }
-        // For mutation tools, accept common success indicators even if short
-        if (isMutationTool && textContent.length < 10) {
-            const successIndicators = [
-                "success",
-                "ok",
-                "done",
-                "created",
-                "updated",
-                "deleted",
-                "added",
-                "removed",
-            ];
-            const hasSuccessIndicator = successIndicators.some((indicator) => textContent.toLowerCase().includes(indicator));
-            if (!hasSuccessIndicator) {
-                result.issues.push("Short response lacks success confirmation for mutation operation");
-                return false;
-            }
-            // Short success message is acceptable
-            result.evidence.push("Mutation operation confirmed with short response");
-            return true;
-        }
-        // MCP 2025-06-18: Check structuredContent first (modern MCP tools)
-        // Modern tools provide structuredContent even without outputSchema
-        const response = context.response;
-        if (response.structuredContent) {
-            const structured = response.structuredContent;
-            // Handle structured array responses
-            if (Array.isArray(structured)) {
-                if (structured.length === 0) {
-                    // Empty array is valid - tool processed request successfully but had no data
-                    // Example: create_relations returns [] when referenced entities don't exist
-                    result.evidence.push("Tool returned empty array (processed successfully, no matching data)");
-                    return true;
-                }
-                // For mutation tools, check for IDs
-                if (isMutationTool) {
-                    const hasIds = structured.some((item) => item &&
-                        typeof item === "object" &&
-                        ("id" in item || "_id" in item || "ID" in item));
-                    if (hasIds) {
-                        result.evidence.push(`Mutation operation returned ${structured.length} item(s) with IDs in structuredContent`);
-                        return true;
-                    }
-                }
-                result.evidence.push(`Response has structuredContent array with ${structured.length} item(s)`);
-                return true;
-            }
-            // Handle structured object responses
-            if (typeof structured === "object" && structured !== null) {
-                const keys = Object.keys(structured);
-                if (keys.length === 0) {
-                    result.issues.push("structuredContent object is empty");
-                    return false;
-                }
-                const hasNonNullValues = keys.some((key) => structured[key] !== null && structured[key] !== undefined);
-                if (!hasNonNullValues) {
-                    result.issues.push("structuredContent contains only null/undefined values");
-                    return false;
-                }
-                result.evidence.push(`Response has structuredContent with ${keys.length} data fields`);
-                return true;
-            }
-        }
-        // Fallback: Check for actual data/information in content.text
-        try {
-            const parsed = JSON.parse(textContent);
-            // Handle JSON array responses (common for batch operations)
-            if (Array.isArray(parsed)) {
-                if (parsed.length === 0) {
-                    // Empty array is valid - tool processed request successfully but had no data
-                    result.evidence.push("Tool returned empty array (processed successfully, no matching data)");
-                    return true;
-                }
-                // For mutation tools, check if array items have IDs (indicates successful creation)
-                if (isMutationTool && parsed.length > 0) {
-                    const hasIds = parsed.some((item) => typeof item === "object" &&
-                        item !== null &&
-                        ("id" in item || "_id" in item || "ID" in item));
-                    if (hasIds) {
-                        result.evidence.push(`Mutation operation returned ${parsed.length} item(s) with IDs`);
-                        return true;
-                    }
-                }
-                result.evidence.push(`Response is array with ${parsed.length} item(s)`);
-                return true;
-            }
-            // Handle JSON object responses
-            if (typeof parsed === "object" && parsed !== null) {
-                const keys = Object.keys(parsed);
-                if (keys.length === 0) {
-                    result.issues.push("Response object is empty");
-                    return false;
-                }
-                // Check for null/undefined values
-                const hasNonNullValues = keys.some((key) => parsed[key] !== null && parsed[key] !== undefined);
-                if (!hasNonNullValues) {
-                    result.issues.push("Response contains only null/undefined values");
-                    return false;
-                }
-                result.evidence.push(`Response contains ${keys.length} data fields`);
-                return true;
-            }
-        }
-        catch {
-            // Not JSON, check as plain text
-            if (textContent.includes("error") || textContent.includes("Error")) {
-                // If it contains error but isError is false, that's suspicious
-                if (!context.response.isError) {
-                    result.issues.push("Response contains error text but isError flag is false");
-                    return false;
-                }
-            }
-        }
-        result.evidence.push("Response contains meaningful content");
-        return true;
-    }
-    /**
-     * Validate semantic correctness based on input/output relationship
-     * NOTE: Currently unused - kept for potential future use
-     */
-    // @ts-ignore - Unused method kept for potential future use
-    static validateSemanticCorrectness(context, result) {
-        const toolName = context.tool.name.toLowerCase();
-        const content = context.response.content;
-        const textContent = content.find((item) => item.type === "text")?.text || "";
-        // Tool-specific semantic validation
-        if (toolName.includes("search") ||
-            toolName.includes("find") ||
-            toolName.includes("get")) {
-            // MCP 2025-06-18: Check structuredContent first
-            const response = context.response;
-            if (response.structuredContent) {
-                const structured = response.structuredContent;
-                // Check for array results
-                if (Array.isArray(structured)) {
-                    result.evidence.push(`Search returned ${structured.length} result(s) in structuredContent (empty results are valid)`);
-                    return true;
-                }
-                // Check for object with search result structure
-                if (typeof structured === "object" && structured !== null) {
-                    const hasSearchStructure = "entities" in structured ||
-                        "relations" in structured ||
-                        "results" in structured ||
-                        "items" in structured ||
-                        "data" in structured ||
-                        "matches" in structured;
-                    if (hasSearchStructure) {
-                        result.evidence.push("Search response has proper result structure in structuredContent");
-                        return true;
-                    }
-                    // Single result object
-                    if (Object.keys(structured).length > 0) {
-                        result.evidence.push("Search returned single result object in structuredContent");
-                        return true;
-                    }
-                }
-            }
-            // Fallback: Search tools should return results structure (even if empty)
-            try {
-                const parsed = JSON.parse(textContent);
-                // Check for common search response structures
-                if (Array.isArray(parsed)) {
-                    // Array of results (even empty is valid - means no matches)
-                    result.evidence.push(`Search returned ${parsed.length} result(s) (empty results are valid)`);
-                    return true;
-                }
-                if (typeof parsed === "object" && parsed !== null) {
-                    // Check for common search result object structures
-                    const hasSearchStructure = "entities" in parsed ||
-                        "relations" in parsed ||
-                        "results" in parsed ||
-                        "items" in parsed ||
-                        "data" in parsed ||
-                        "matches" in parsed;
-                    if (hasSearchStructure) {
-                        result.evidence.push("Search response has proper result structure");
-                        return true;
-                    }
-                    // Single result object (e.g., get by ID)
-                    if (Object.keys(parsed).length > 0) {
-                        result.evidence.push("Search returned single result object");
-                        return true;
-                    }
-                }
-            }
-            catch {
-                // Not JSON, check text patterns
-            }
-            // Fallback to text-based validation
-            const query = this.findQueryParameter(context.input);
-            if (query && typeof query === "string") {
-                // Very basic check - response should reference the query somehow
-                if (!textContent.toLowerCase().includes(query.toLowerCase()) &&
-                    !textContent.includes("results") &&
-                    !textContent.includes("found")) {
-                    result.issues.push("Search response doesn't seem related to query");
-                    return false;
-                }
-                result.evidence.push("Search response appears related to query");
-                return true;
-            }
-            // If no query parameter, just check for search-related keywords
-            if (textContent.includes("result") ||
-                textContent.includes("found") ||
-                textContent.includes("match") ||
-                textContent.includes("entity") ||
-                textContent.includes("entities")) {
-                result.evidence.push("Search response contains search-related data");
-                return true;
-            }
-        }
-        if (toolName.includes("create") ||
-            toolName.includes("add") ||
-            toolName.includes("insert")) {
-            // MCP 2025-06-18: Check structuredContent first
-            const response = context.response;
-            if (response.structuredContent) {
-                const structured = response.structuredContent;
-                // Check if response is array with IDs
-                if (Array.isArray(structured)) {
-                    const hasIds = structured.some((item) => item &&
-                        typeof item === "object" &&
-                        ("id" in item || "_id" in item || "ID" in item));
-                    if (hasIds) {
-                        result.evidence.push(`Creation response includes ${structured.length} item(s) with IDs in structuredContent`);
-                        return true;
-                    }
-                    // Even without IDs, array response indicates success
-                    if (structured.length > 0) {
-                        result.evidence.push("Creation response includes created items in structuredContent");
-                        return true;
-                    }
-                }
-                // Check if response is object with ID
-                if (typeof structured === "object" && structured !== null) {
-                    if ("id" in structured || "_id" in structured || "ID" in structured) {
-                        result.evidence.push("Creation response includes resource ID in structuredContent");
-                        return true;
-                    }
-                    // Check for entity/relation structures
-                    if ("entities" in structured ||
-                        "relations" in structured ||
-                        "observations" in structured) {
-                        result.evidence.push("Creation response includes entity/relation data in structuredContent");
-                        return true;
-                    }
-                }
-            }
-            // Fallback: Creation tools should return created resource or ID
-            // Try to parse as JSON first to check for structured data with IDs
-            try {
-                const parsed = JSON.parse(textContent);
-                // Check if response is array with IDs (common for batch creation)
-                if (Array.isArray(parsed)) {
-                    const hasIds = parsed.some((item) => typeof item === "object" &&
-                        item !== null &&
-                        ("id" in item || "_id" in item || "ID" in item));
-                    if (hasIds) {
-                        result.evidence.push(`Creation response includes ${parsed.length} item(s) with IDs`);
-                        return true;
-                    }
-                }
-                // Check if response is object with ID
-                if (typeof parsed === "object" && parsed !== null) {
-                    if ("id" in parsed || "_id" in parsed || "ID" in parsed) {
-                        result.evidence.push("Creation response includes resource ID");
-                        return true;
-                    }
-                }
-            }
-            catch {
-                // Not JSON, check text patterns
-            }
-            // Fallback to text-based validation
-            if (!textContent.includes("id") &&
-                !textContent.includes("created") &&
-                !textContent.includes("success")) {
-                result.issues.push("Creation response lacks confirmation or resource ID");
-                return false;
-            }
-            result.evidence.push("Creation response includes confirmation");
-            return true;
-        }
-        if (toolName.includes("delete") || toolName.includes("remove")) {
-            // Deletion tools should confirm deletion
-            if (!textContent.includes("deleted") &&
-                !textContent.includes("removed") &&
-                !textContent.includes("success")) {
-                result.issues.push("Deletion response lacks confirmation");
-                return false;
-            }
-            result.evidence.push("Deletion response confirms action");
-            return true;
-        }
-        if (toolName.includes("update") ||
-            toolName.includes("modify") ||
-            toolName.includes("edit")) {
-            // Update tools should confirm update
-            if (!textContent.includes("updated") &&
-                !textContent.includes("modified") &&
-                !textContent.includes("changed") &&
-                !textContent.includes("success")) {
-                result.issues.push("Update response lacks confirmation");
-                return false;
-            }
-            result.evidence.push("Update response confirms changes");
-            return true;
-        }
-        if (toolName.includes("list") || toolName.includes("all")) {
-            // List tools should return array or multiple items
-            try {
-                const parsed = JSON.parse(textContent);
-                if (Array.isArray(parsed) ||
-                    (parsed &&
-                        typeof parsed === "object" &&
-                        ("items" in parsed || "results" in parsed))) {
-                    result.evidence.push("List response contains array or collection");
-                    return true;
-                }
-            }
-            catch {
-                // Check for list-like text response
-                if (textContent.includes(",") || textContent.includes("\n")) {
-                    result.evidence.push("Response appears to contain multiple items");
-                    return true;
-                }
-            }
-            result.issues.push("List response doesn't contain collection");
-            return false;
-        }
-        // Default validation - response should be different from input
-        const inputStr = JSON.stringify(context.input);
-        if (textContent !== inputStr &&
-            textContent.length > inputStr.length * 0.5) {
-            result.evidence.push("Response is substantively different from input");
-            return true;
-        }
-        result.issues.push("Response doesn't demonstrate clear functionality");
-        return false;
-    }
-    /**
-     * Validate tool-specific logic and patterns
-     * NOTE: Currently unused - kept for potential future use
-     */
-    // @ts-ignore - Unused method kept for potential future use
-    static validateToolSpecificLogic(context, result) {
-        const toolName = context.tool.name.toLowerCase();
-        const content = context.response.content;
-        const textContent = content.find((item) => item.type === "text")?.text || "";
-        // Creation/mutation tools (entities, relations, observations, etc.)
-        if (toolName.includes("create") ||
-            toolName.includes("add") ||
-            toolName.includes("insert") ||
-            toolName.includes("entity") ||
-            toolName.includes("entities") ||
-            toolName.includes("relation") ||
-            toolName.includes("observation")) {
-            // MCP 2025-06-18: Check structuredContent first (CRITICAL FIX)
-            const response = context.response;
-            if (response.structuredContent) {
-                const structured = response.structuredContent;
-                // Check for array responses with IDs
-                if (Array.isArray(structured)) {
-                    const hasIds = structured.some((item) => item &&
-                        typeof item === "object" &&
-                        ("id" in item || "_id" in item || "ID" in item));
-                    if (hasIds) {
-                        result.evidence.push(`Creation tool returned ${structured.length} entity/entities with IDs in structuredContent`);
-                        return true;
-                    }
-                    // Check for entity-like objects even without IDs
-                    const hasEntityStructure = structured.some((item) => item &&
-                        typeof item === "object" &&
-                        ("name" in item ||
-                            "entityType" in item ||
-                            "from" in item ||
-                            "to" in item));
-                    if (hasEntityStructure) {
-                        result.evidence.push("Creation tool returned entity-like objects in structuredContent");
-                        return true;
-                    }
-                }
-                // Check for object with ID
-                if (structured &&
-                    typeof structured === "object" &&
-                    ("id" in structured || "_id" in structured || "ID" in structured)) {
-                    result.evidence.push("Creation tool returned entity with ID in structuredContent");
-                    return true;
-                }
-                // Check for entity/relation structure
-                if (structured &&
-                    typeof structured === "object" &&
-                    ("name" in structured ||
-                        "entityType" in structured ||
-                        "from" in structured ||
-                        "to" in structured ||
-                        "entities" in structured ||
-                        "relations" in structured ||
-                        "observations" in structured)) {
-                    result.evidence.push("Creation tool returned entity/relation structure in structuredContent");
-                    return true;
-                }
-            }
-            // Fallback: Try parsing content.text as JSON
-            try {
-                const parsed = JSON.parse(textContent);
-                // Check for array responses with IDs (common for batch operations)
-                if (Array.isArray(parsed)) {
-                    const hasIds = parsed.some((item) => item &&
-                        typeof item === "object" &&
-                        ("id" in item || "_id" in item || "ID" in item));
-                    if (hasIds) {
-                        result.evidence.push(`Creation tool returned ${parsed.length} entity/entities with IDs`);
-                        return true;
-                    }
-                    // Even without IDs, if array has entity-like objects, it's valid
-                    const hasEntityStructure = parsed.some((item) => item &&
-                        typeof item === "object" &&
-                        ("name" in item ||
-                            "entityType" in item ||
-                            "from" in item ||
-                            "to" in item));
-                    if (hasEntityStructure) {
-                        result.evidence.push("Creation tool returned entity-like objects");
-                        return true;
-                    }
-                }
-                // Check for object with ID
-                if (parsed &&
-                    typeof parsed === "object" &&
-                    ("id" in parsed || "_id" in parsed || "ID" in parsed)) {
-                    result.evidence.push("Creation tool returned entity with ID");
-                    return true;
-                }
-                // Check for entity structure
-                if (parsed &&
-                    typeof parsed === "object" &&
-                    ("name" in parsed ||
-                        "entityType" in parsed ||
-                        "from" in parsed ||
-                        "to" in parsed ||
-                        "entities" in parsed ||
-                        "relations" in parsed)) {
-                    result.evidence.push("Creation tool returned entity/relation structure");
-                    return true;
-                }
-            }
-            catch {
-                // Not JSON, check text patterns
-            }
-            // Fallback: check for success indicators in text
-            if (textContent.includes("id") ||
-                textContent.includes("created") ||
-                textContent.includes("entity") ||
-                textContent.includes("entities") ||
-                textContent.includes("relation") ||
-                textContent.includes("observation")) {
-                result.evidence.push("Creation tool response contains entity/relation indicators");
-                return true;
-            }
-        }
-        // Database/store tools
-        if (toolName.includes("database") ||
-            toolName.includes("store") ||
-            toolName.includes("db")) {
-            if (textContent.includes("connection") &&
-                textContent.includes("failed")) {
-                result.issues.push("Database connection failure");
-                return false;
-            }
-            // Should have some indication of data operation
-            if (textContent.includes("rows") ||
-                textContent.includes("records") ||
-                textContent.includes("documents") ||
-                textContent.includes("query")) {
-                result.evidence.push("Response indicates database operation");
-                return true;
-            }
-        }
-        // File system tools
-        if (toolName.includes("file") ||
-            toolName.includes("read") ||
-            toolName.includes("write")) {
-            if (textContent.includes("permission") &&
-                textContent.includes("denied")) {
-                result.issues.push("File permission error");
-                return false;
-            }
-            if (textContent.includes("not found") &&
-                context.scenarioCategory !== "error_case") {
-                result.issues.push("File not found error");
-                return false;
-            }
-            // Should have file operation indication
-            if (textContent.includes("bytes") ||
-                textContent.includes("content") ||
-                textContent.includes("saved") ||
-                textContent.includes("written")) {
-                result.evidence.push("Response indicates file operation");
-                return true;
-            }
-        }
-        // API/HTTP tools
-        if (toolName.includes("http") ||
-            toolName.includes("api") ||
-            toolName.includes("fetch")) {
-            // Check for HTTP status codes
-            if (textContent.includes("200") ||
-                textContent.includes("201") ||
-                textContent.includes("success")) {
-                result.evidence.push("Response indicates successful HTTP operation");
-                return true;
-            }
-            if (textContent.includes("404") ||
-                textContent.includes("500") ||
-                textContent.includes("error")) {
-                result.issues.push("HTTP error in response");
-                return false;
-            }
-        }
-        // Computation/calculation tools
-        if (toolName.includes("calc") ||
-            toolName.includes("compute") ||
-            toolName.includes("math")) {
-            // Should return numeric result
-            try {
-                const parsed = JSON.parse(textContent);
-                if (typeof parsed === "number" ||
-                    (parsed && "result" in parsed && typeof parsed.result === "number")) {
-                    result.evidence.push("Response contains numeric computation result");
-                    return true;
-                }
-            }
-            catch {
-                // Check for number in text
-                if (/\d+/.test(textContent)) {
-                    result.evidence.push("Response contains numeric value");
-                    return true;
-                }
-            }
-            result.issues.push("Computation tool didn't return numeric result");
-            return false;
-        }
-        // Default - tool responded with non-empty content
-        if (textContent.length > 20) {
-            result.evidence.push("Tool provided substantive response");
-            return true;
-        }
-        result.issues.push("Response lacks tool-specific indicators");
-        return false;
-    }
-    /**
-     * Find query-like parameter in input
-     */
-    static findQueryParameter(input) {
-        const queryKeys = [
-            "query",
-            "q",
-            "search",
-            "term",
-            "keyword",
-            "filter",
-            "name",
-            "id",
-        ];
-        for (const key of queryKeys) {
-            if (key in input) {
-                return input[key];
-            }
-        }
-        // Return first string parameter as fallback
-        for (const value of Object.values(input)) {
-            if (typeof value === "string") {
-                return value;
-            }
-        }
-        return null;
-    }
-    /**
-     * Validate structured output against outputSchema (MCP 2025-06-18 feature)
-     * NOTE: Currently unused - kept for potential future use
-     */
-    // @ts-ignore - Unused method kept for potential future use
-    static validateStructuredOutput(context, result) {
-        // Check if tool has outputSchema defined
-        const tool = context.tool; // Cast to any to access potential outputSchema property
-        if (!tool.outputSchema) {
-            // Tool doesn't define outputSchema, this validation is not applicable
-            result.evidence.push("Tool does not define outputSchema (optional MCP 2025-06-18 feature)");
-            return true; // Not a failure if not using structured output
-        }
-        // Check if response contains structuredContent
-        const response = context.response;
-        if (response.structuredContent) {
-            // Tool provides structuredContent - this is the modern MCP 2025-06-18 pattern
-            // outputSchema validation is optional and rarely used, so we accept any structuredContent
-            result.evidence.push("Tool provides structuredContent (MCP 2025-06-18 modern response format)");
-            return true;
-        }
-        // Check if response contains resource URIs (another MCP 2025-06-18 feature)
-        const content = context.response.content;
-        const hasResourceUris = content.some((item) => item.type === "resource" && item.uri);
-        if (hasResourceUris) {
-            result.evidence.push("Response uses resource URIs for external content (MCP 2025-06-18 feature)");
-            return true;
-        }
-        // Tool has outputSchema but didn't provide structuredContent
-        // This is okay - tools can provide both text and structured output
-        result.evidence.push("Tool has outputSchema but provided text response (backward compatibility)");
-        return true;
-    }
     /**
      * Calculate confidence score for a set of validation results
      */