@bryan-thompson/inspector-assessment-client 1.13.0 → 1.14.0

package/dist/assets/{OAuthCallback-D8KW6pFf.js → OAuthCallback-DaKwjxdn.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-cVkEgqCc.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-BAJG90Yd.js";
 const OAuthCallback = ({ onConnect }) => {
   const { toast } = useToast();
   const hasProcessedRef = reactExports.useRef(false);

package/dist/assets/{OAuthDebugCallback-D15nNAOl.js → OAuthDebugCallback-HiI2IPgB.js}

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

package/dist/assets/{index-cVkEgqCc.js → index-BAJG90Yd.js}

@@ -16320,7 +16320,7 @@ object({
   token_type_hint: string().optional()
 }).strip();
 const name = "@bryan-thompson/inspector-assessment-client";
-const version$1 = "1.13.0";
+const version$1 = "1.14.0";
 const packageJson = {
   name,
   version: version$1
@@ -48863,7 +48863,7 @@ const useTheme = () => {
     [theme, setThemeWithSideEffect]
   );
 };
-const version = "1.13.0";
+const version = "1.14.0";
 var [createTooltipContext] = createContextScope("Tooltip", [
   createPopperScope
 ]);
@@ -51555,7 +51555,9 @@ const DEFAULT_ASSESSMENT_CONFIG = {
     toolAnnotations: false,
     prohibitedLibraries: false,
     manifestValidation: false,
-    portability: false
+    portability: false,
+    externalAPIScanner: false,
+    authentication: false
   }
 };
 const REVIEWER_MODE_CONFIG = {
@@ -51594,7 +51596,9 @@ const REVIEWER_MODE_CONFIG = {
     toolAnnotations: false,
     prohibitedLibraries: false,
     manifestValidation: false,
-    portability: false
+    portability: false,
+    externalAPIScanner: false,
+    authentication: false
   }
 };
 const DEVELOPER_MODE_CONFIG = {
@@ -51630,7 +51634,9 @@ const DEVELOPER_MODE_CONFIG = {
     toolAnnotations: true,
     prohibitedLibraries: true,
     manifestValidation: true,
-    portability: true
+    portability: true,
+    externalAPIScanner: true,
+    authentication: true
   }
 };
 class BaseAssessor {
@@ -54774,6 +54780,11 @@ class FunctionalityAssessor extends BaseAssessor {
       workingTools,
       brokenTools
     );
+    const tools = context.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema
+    }));
     return {
       totalTools,
       testedTools,
@@ -54782,7 +54793,8 @@ class FunctionalityAssessor extends BaseAssessor {
       coveragePercentage,
       status,
       explanation,
-      toolResults
+      toolResults,
+      tools
     };
   }
   async testTool(tool, callTool) {
@@ -61865,13 +61877,13 @@ const App = () => {
   ) });
   if (window.location.pathname === "/oauth/callback") {
     const OAuthCallback = React.lazy(
-      () => __vitePreload(() => import("./OAuthCallback-D8KW6pFf.js"), true ? [] : void 0)
+      () => __vitePreload(() => import("./OAuthCallback-DaKwjxdn.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-D15nNAOl.js"), true ? [] : void 0)
+      () => __vitePreload(() => import("./OAuthDebugCallback-HiI2IPgB.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/dist/assets/{index-Cuc9GxjD.css → index-BdXNC65t.css}

@@ -1841,6 +1841,9 @@ video {
 .lowercase {
   text-transform: lowercase;
 }
+.capitalize {
+  text-transform: capitalize;
+}
 .italic {
   font-style: italic;
 }

package/dist/index.html

@@ -5,8 +5,8 @@
     <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-cVkEgqCc.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Cuc9GxjD.css">
+    <script type="module" crossorigin src="/assets/index-BAJG90Yd.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BdXNC65t.css">
   </head>
   <body>
     <div id="root" class="w-full"></div>

package/lib/lib/assessmentDiffer.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Assessment Differ
+ * Compares two assessment runs to detect regressions or improvements.
+ *
+ * Use Cases:
+ * - Compare bundle v1.0 vs v1.1
+ * - Track assessment changes over time
+ * - CI/CD regression detection
+ */
+import type { MCPDirectoryAssessment, AssessmentStatus } from "./assessmentTypes.js";
+/**
+ * Change direction for a metric
+ */
+export type ChangeDirection = "improved" | "regressed" | "unchanged";
+/**
+ * Detailed change information for a single module
+ */
+export interface ModuleChange {
+    module: string;
+    baselineStatus: AssessmentStatus;
+    currentStatus: AssessmentStatus;
+    baselineScore?: number;
+    currentScore?: number;
+    change: ChangeDirection;
+    details: string;
+}
+/**
+ * Security-specific delta tracking
+ */
+export interface SecurityDelta {
+    newVulnerabilities: string[];
+    fixedVulnerabilities: string[];
+    netChange: number;
+    baselineCount: number;
+    currentCount: number;
+}
+/**
+ * Functionality-specific delta tracking
+ */
+export interface FunctionalityDelta {
+    newBrokenTools: string[];
+    fixedTools: string[];
+    netChange: number;
+    baselineWorking: number;
+    currentWorking: number;
+}
+/**
+ * Full assessment comparison result
+ */
+export interface AssessmentDiff {
+    serverName: string;
+    baseline: {
+        version?: string;
+        date: string;
+        assessorVersion: string;
+    };
+    current: {
+        version?: string;
+        date: string;
+        assessorVersion: string;
+    };
+    summary: {
+        overallChange: ChangeDirection;
+        baselineStatus: AssessmentStatus;
+        currentStatus: AssessmentStatus;
+        modulesImproved: number;
+        modulesRegressed: number;
+        modulesUnchanged: number;
+    };
+    moduleChanges: ModuleChange[];
+    securityDelta: SecurityDelta;
+    functionalityDelta: FunctionalityDelta;
+    recommendations: string[];
+}
+/**
+ * Compare two assessment runs
+ */
+export declare function compareAssessments(baseline: MCPDirectoryAssessment, current: MCPDirectoryAssessment): AssessmentDiff;
+//# sourceMappingURL=assessmentDiffer.d.ts.map

package/lib/lib/assessmentDiffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assessmentDiffer.d.ts","sourceRoot":"","sources":["../../src/lib/assessmentDiffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAE3B;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,gBAAgB,CAAC;IACjC,aAAa,EAAE,gBAAgB,CAAC;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE;QACR,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,OAAO,EAAE;QACP,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,OAAO,EAAE;QACP,aAAa,EAAE,eAAe,CAAC;QAC/B,cAAc,EAAE,gBAAgB,CAAC;QACjC,aAAa,EAAE,gBAAgB,CAAC;QAChC,eAAe,EAAE,MAAM,CAAC;QACxB,gBAAgB,EAAE,MAAM,CAAC;QACzB,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,aAAa,EAAE,aAAa,CAAC;IAC7B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,sBAAsB,EAChC,OAAO,EAAE,sBAAsB,GAC9B,cAAc,CA4DhB"}

package/lib/lib/assessmentDiffer.js

@@ -0,0 +1,289 @@
+/**
+ * Assessment Differ
+ * Compares two assessment runs to detect regressions or improvements.
+ *
+ * Use Cases:
+ * - Compare bundle v1.0 vs v1.1
+ * - Track assessment changes over time
+ * - CI/CD regression detection
+ */
+/**
+ * Compare two assessment runs
+ */
+export function compareAssessments(baseline, current) {
+    const moduleChanges = compareModules(baseline, current);
+    const securityDelta = compareSecurityResults(baseline, current);
+    const functionalityDelta = compareFunctionalityResults(baseline, current);
+    const improved = moduleChanges.filter((m) => m.change === "improved").length;
+    const regressed = moduleChanges.filter((m) => m.change === "regressed").length;
+    const unchanged = moduleChanges.filter((m) => m.change === "unchanged").length;
+    // Determine overall change
+    let overallChange = "unchanged";
+    if (regressed > 0 ||
+        securityDelta.netChange > 0 ||
+        functionalityDelta.netChange < 0) {
+        overallChange = "regressed";
+    }
+    else if (improved > 0 ||
+        securityDelta.netChange < 0 ||
+        functionalityDelta.netChange > 0) {
+        overallChange = "improved";
+    }
+    const recommendations = generateDiffRecommendations(moduleChanges, securityDelta, functionalityDelta);
+    return {
+        serverName: current.serverName,
+        baseline: {
+            version: extractVersion(baseline),
+            date: baseline.assessmentDate,
+            assessorVersion: baseline.assessorVersion,
+        },
+        current: {
+            version: extractVersion(current),
+            date: current.assessmentDate,
+            assessorVersion: current.assessorVersion,
+        },
+        summary: {
+            overallChange,
+            baselineStatus: baseline.overallStatus,
+            currentStatus: current.overallStatus,
+            modulesImproved: improved,
+            modulesRegressed: regressed,
+            modulesUnchanged: unchanged,
+        },
+        moduleChanges,
+        securityDelta,
+        functionalityDelta,
+        recommendations,
+    };
+}
+/**
+ * Compare individual module results
+ */
+function compareModules(baseline, current) {
+    const changes = [];
+    // Compare core modules
+    const modules = [
+        {
+            name: "functionality",
+            getStatus: (a) => a.functionality?.status,
+            getScore: (a) => a.functionality
+                ? (a.functionality.workingTools / a.functionality.totalTools) * 100
+                : undefined,
+        },
+        {
+            name: "security",
+            getStatus: (a) => a.security?.status,
+            getScore: (a) => a.security
+                ? 100 -
+                    (a.security.vulnerabilities.length /
+                        Math.max(a.security.promptInjectionTests.length, 1)) *
+                        100
+                : undefined,
+        },
+        {
+            name: "documentation",
+            getStatus: (a) => a.documentation?.status,
+        },
+        {
+            name: "errorHandling",
+            getStatus: (a) => a.errorHandling?.status,
+            getScore: (a) => a.errorHandling?.metrics?.mcpComplianceScore,
+        },
+        {
+            name: "usability",
+            getStatus: (a) => a.usability?.status,
+        },
+        {
+            name: "mcpSpecCompliance",
+            getStatus: (a) => a.mcpSpecCompliance?.status,
+            getScore: (a) => a.mcpSpecCompliance?.complianceScore,
+        },
+        {
+            name: "aupCompliance",
+            getStatus: (a) => a.aupCompliance?.status,
+        },
+        {
+            name: "toolAnnotations",
+            getStatus: (a) => a.toolAnnotations?.status,
+        },
+        {
+            name: "manifestValidation",
+            getStatus: (a) => a.manifestValidation?.status,
+        },
+        {
+            name: "portability",
+            getStatus: (a) => a.portability?.status,
+        },
+    ];
+    for (const mod of modules) {
+        const baselineStatus = mod.getStatus(baseline);
+        const currentStatus = mod.getStatus(current);
+        // Skip if module wasn't run in either assessment
+        if (!baselineStatus && !currentStatus)
+            continue;
+        const baselineScore = mod.getScore?.(baseline);
+        const currentScore = mod.getScore?.(current);
+        const change = determineChange(baselineStatus || "NEED_MORE_INFO", currentStatus || "NEED_MORE_INFO", baselineScore, currentScore);
+        changes.push({
+            module: mod.name,
+            baselineStatus: baselineStatus || "NEED_MORE_INFO",
+            currentStatus: currentStatus || "NEED_MORE_INFO",
+            baselineScore,
+            currentScore,
+            change,
+            details: generateModuleDetails(mod.name, baselineStatus, currentStatus, baselineScore, currentScore),
+        });
+    }
+    return changes;
+}
+/**
+ * Determine if a module improved, regressed, or stayed the same
+ */
+function determineChange(baselineStatus, currentStatus, baselineScore, currentScore) {
+    // Status-based change
+    const statusOrder = {
+        FAIL: 0,
+        NEED_MORE_INFO: 1,
+        PASS: 2,
+    };
+    const baselineRank = statusOrder[baselineStatus];
+    const currentRank = statusOrder[currentStatus];
+    if (currentRank > baselineRank)
+        return "improved";
+    if (currentRank < baselineRank)
+        return "regressed";
+    // Score-based change (if statuses are equal)
+    if (baselineScore !== undefined && currentScore !== undefined) {
+        const scoreDiff = currentScore - baselineScore;
+        if (scoreDiff > 5)
+            return "improved"; // 5% threshold
+        if (scoreDiff < -5)
+            return "regressed";
+    }
+    return "unchanged";
+}
+/**
+ * Generate human-readable details for a module change
+ */
+function generateModuleDetails(_moduleName, baselineStatus, currentStatus, baselineScore, currentScore) {
+    const parts = [];
+    if (baselineStatus !== currentStatus) {
+        parts.push(`${baselineStatus || "N/A"} → ${currentStatus || "N/A"}`);
+    }
+    if (baselineScore !== undefined && currentScore !== undefined) {
+        const diff = currentScore - baselineScore;
+        const sign = diff > 0 ? "+" : "";
+        parts.push(`Score: ${baselineScore.toFixed(1)}% → ${currentScore.toFixed(1)}% (${sign}${diff.toFixed(1)}%)`);
+    }
+    if (parts.length === 0) {
+        return "No change";
+    }
+    return parts.join(", ");
+}
+/**
+ * Compare security results between assessments
+ */
+function compareSecurityResults(baseline, current) {
+    const baselineVulns = new Set(baseline.security?.vulnerabilities || []);
+    const currentVulns = new Set(current.security?.vulnerabilities || []);
+    const newVulnerabilities = [];
+    const fixedVulnerabilities = [];
+    for (const vuln of currentVulns) {
+        if (!baselineVulns.has(vuln)) {
+            newVulnerabilities.push(vuln);
+        }
+    }
+    for (const vuln of baselineVulns) {
+        if (!currentVulns.has(vuln)) {
+            fixedVulnerabilities.push(vuln);
+        }
+    }
+    return {
+        newVulnerabilities,
+        fixedVulnerabilities,
+        netChange: newVulnerabilities.length - fixedVulnerabilities.length,
+        baselineCount: baselineVulns.size,
+        currentCount: currentVulns.size,
+    };
+}
+/**
+ * Compare functionality results between assessments
+ */
+function compareFunctionalityResults(baseline, current) {
+    const baselineBroken = new Set(baseline.functionality?.brokenTools || []);
+    const currentBroken = new Set(current.functionality?.brokenTools || []);
+    const newBrokenTools = [];
+    const fixedTools = [];
+    for (const tool of currentBroken) {
+        if (!baselineBroken.has(tool)) {
+            newBrokenTools.push(tool);
+        }
+    }
+    for (const tool of baselineBroken) {
+        if (!currentBroken.has(tool)) {
+            fixedTools.push(tool);
+        }
+    }
+    const baselineWorking = baseline.functionality?.workingTools || 0;
+    const currentWorking = current.functionality?.workingTools || 0;
+    return {
+        newBrokenTools,
+        fixedTools,
+        netChange: currentWorking - baselineWorking,
+        baselineWorking,
+        currentWorking,
+    };
+}
+/**
+ * Generate recommendations based on the diff
+ */
+function generateDiffRecommendations(moduleChanges, securityDelta, functionalityDelta) {
+    const recommendations = [];
+    // Security regressions are critical
+    if (securityDelta.newVulnerabilities.length > 0) {
+        recommendations.push(`CRITICAL: ${securityDelta.newVulnerabilities.length} new security vulnerabilities detected`);
+        for (const vuln of securityDelta.newVulnerabilities.slice(0, 3)) {
+            recommendations.push(`  - ${vuln}`);
+        }
+    }
+    // Functionality regressions
+    if (functionalityDelta.newBrokenTools.length > 0) {
+        recommendations.push(`WARNING: ${functionalityDelta.newBrokenTools.length} tool(s) now broken`);
+        for (const tool of functionalityDelta.newBrokenTools.slice(0, 3)) {
+            recommendations.push(`  - ${tool}`);
+        }
+    }
+    // Module regressions
+    const regressions = moduleChanges.filter((m) => m.change === "regressed");
+    if (regressions.length > 0) {
+        recommendations.push(`WARNING: ${regressions.length} module(s) regressed`);
+        for (const reg of regressions) {
+            recommendations.push(`  - ${reg.module}: ${reg.details}`);
+        }
+    }
+    // Positive changes
+    if (securityDelta.fixedVulnerabilities.length > 0) {
+        recommendations.push(`IMPROVED: ${securityDelta.fixedVulnerabilities.length} vulnerabilities fixed`);
+    }
+    if (functionalityDelta.fixedTools.length > 0) {
+        recommendations.push(`IMPROVED: ${functionalityDelta.fixedTools.length} tool(s) now working`);
+    }
+    const improvements = moduleChanges.filter((m) => m.change === "improved");
+    if (improvements.length > 0) {
+        recommendations.push(`IMPROVED: ${improvements.length} module(s) improved`);
+    }
+    if (recommendations.length === 0) {
+        recommendations.push("No significant changes detected between versions");
+    }
+    return recommendations;
+}
+/**
+ * Extract version from assessment (if available from manifest)
+ */
+function extractVersion(assessment) {
+    // Try to get version from manifest validation
+    if (assessment.manifestValidation?.manifestVersion) {
+        return assessment.manifestValidation.manifestVersion;
+    }
+    return undefined;
+}

package/lib/lib/assessmentTypes.d.ts

@@ -241,6 +241,16 @@ export interface UsabilityMetrics {
         overallScore: number;
     };
 }
+/** Tool definition with schema from MCP tools/list response */
+export interface DiscoveredTool {
+    name: string;
+    description?: string;
+    inputSchema?: {
+        type: string;
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+}
 export interface FunctionalityAssessment {
     totalTools: number;
     testedTools: number;
@@ -250,6 +260,8 @@ export interface FunctionalityAssessment {
     status: AssessmentStatus;
     explanation: string;
     toolResults: ToolTestResult[];
+    /** Raw tool definitions with inputSchema from MCP server */
+    tools?: DiscoveredTool[];
 }
 export interface SecurityAssessment {
     promptInjectionTests: SecurityTestResult[];
@@ -476,6 +488,8 @@ export interface MCPDirectoryAssessment {
     prohibitedLibraries?: ProhibitedLibrariesAssessment;
     manifestValidation?: ManifestValidationAssessment;
     portability?: PortabilityAssessment;
+    externalAPIScanner?: ExternalAPIScannerAssessment;
+    authentication?: AuthenticationAssessment;
     overallStatus: AssessmentStatus;
     summary: string;
     recommendations: string[];
@@ -634,6 +648,18 @@ export interface ManifestJsonSchema {
     icon?: string;
     homepage?: string;
     keywords?: string[];
+    privacy_policies?: string[];
+}
+/**
+ * Privacy Policy URL Validation Result
+ * Validates that privacy_policies URLs are accessible
+ */
+export interface PrivacyPolicyValidation {
+    url: string;
+    accessible: boolean;
+    statusCode?: number;
+    contentType?: string;
+    error?: string;
 }
 export interface ManifestValidationResult {
     field: string;
@@ -650,6 +676,12 @@ export interface ManifestValidationAssessment {
     hasIcon: boolean;
     hasRequiredFields: boolean;
     missingFields: string[];
+    /** Privacy policy URL validation results */
+    privacyPolicies?: {
+        declared: string[];
+        validationResults: PrivacyPolicyValidation[];
+        allAccessible: boolean;
+    };
     status: AssessmentStatus;
     explanation: string;
     recommendations: string[];
@@ -677,6 +709,41 @@ export interface PortabilityAssessment {
     explanation: string;
     recommendations: string[];
 }
+export interface DetectedAPI {
+    url: string;
+    service: string;
+    filePath: string;
+}
+export interface ExternalAPIScannerAssessment {
+    detectedAPIs: DetectedAPI[];
+    uniqueServices: string[];
+    affiliationWarning?: string;
+    scannedFiles: number;
+    status: AssessmentStatus;
+    explanation: string;
+    recommendations: string[];
+}
+export type AuthMethod = "oauth" | "api_key" | "none" | "unknown";
+export interface AuthAppropriateness {
+    isAppropriate: boolean;
+    concerns: string[];
+    explanation: string;
+}
+export interface AuthenticationAssessment {
+    authMethod: AuthMethod;
+    hasLocalDependencies: boolean;
+    transportType: string;
+    appropriateness: AuthAppropriateness;
+    recommendation: string;
+    detectedPatterns: {
+        oauthIndicators: string[];
+        localResourceIndicators: string[];
+        apiKeyIndicators: string[];
+    };
+    status: AssessmentStatus;
+    explanation: string;
+    recommendations: string[];
+}
 export declare const PROMPT_INJECTION_TESTS: Omit<SecurityTestResult, "vulnerable" | "evidence">[];
 /**
  * Claude Code Bridge Configuration
@@ -723,6 +790,8 @@ export interface AssessmentConfiguration {
         prohibitedLibraries?: boolean;
         manifestValidation?: boolean;
         portability?: boolean;
+        externalAPIScanner?: boolean;
+        authentication?: boolean;
     };
 }
 /**