fixes root url parsing issue.

CHANGELOG.md

@@ -13,6 +13,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Fixed a when generating a plugin when only an operation is selected in the root node in the extension. [#5300](https://github.com/microsoft/kiota/issues/5300)
+
 ## [1.18.0] - 2024-09-05
 
 ### Added

src/Kiota.Builder/Plugins/PluginsGenerationService.cs

@@ -131,6 +131,9 @@ private OpenApiDocument GetDocumentWithTrimmedComponentsAndResponses(OpenApiDocu
             requestUrls[key] = path.Value.Operations.Keys.Select(static key => key.ToString().ToUpperInvariant()).ToList();
         }
 
+        if (requestUrls.Count == 0)
+            throw new InvalidOperationException("No operations found in the OpenAPI document.");
+
         var predicate = OpenApiFilterService.CreatePredicate(requestUrls: requestUrls, source: doc);
         return OpenApiFilterService.CreateFilteredDocument(doc, predicate);
     }

tests/Kiota.Builder.Tests/KiotaBuilderTests.cs

@@ -5994,6 +5994,73 @@ public void SetsReadonlyProperties(bool isReadonly)
         var nameProperty = objectClass.Properties.First(static x => "name".Equals(x.Name, StringComparison.OrdinalIgnoreCase));
         Assert.Equal(isReadonly, nameProperty.ReadOnly);
     }
+    [Theory]
+    [InlineData("#GET", 0)]
+    [InlineData("/#GET", 1)]
+    public void SupportsIncludeFilterOnRootPath(string inputPattern, int expectedPathsCount)
+    {
+        var myObjectSchema = new OpenApiSchema
+        {
+            Type = "object",
+            Properties = new Dictionary<string, OpenApiSchema> {
+                {
+                    "name", new OpenApiSchema {
+                        Type = "string",
+                    }
+                }
+            },
+            Reference = new OpenApiReference
+            {
+                Id = "myobject",
+                Type = ReferenceType.Schema
+            },
+            UnresolvedReference = false,
+        };
+        var document = new OpenApiDocument
+        {
+            Paths = new OpenApiPaths
+            {
+                ["/"] = new OpenApiPathItem
+                {
+                    Operations = {
+                        [OperationType.Get] = new OpenApiOperation
+                        {
+                            Responses = new OpenApiResponses
+                            {
+                                ["200"] = new OpenApiResponse {
+                                    Content = {
+                                        ["application/json"] = new OpenApiMediaType {
+                                            Schema = myObjectSchema
+                                        }
+                                    }
+                                },
+                            }
+                        }
+                    }
+                },
+            },
+            Components = new()
+            {
+                Schemas = new Dictionary<string, OpenApiSchema> {
+                    {
+                        "myobject", myObjectSchema
+                    }
+                }
+            }
+        };
+        var mockLogger = new Mock<ILogger<KiotaBuilder>>();
+        var builder = new KiotaBuilder(mockLogger.Object, new GenerationConfiguration
+        {
+            ClientClassName = "TestClient",
+            ClientNamespaceName = "TestSdk",
+            ApiRootUrl = "https://localhost",
+            IncludePatterns = new() {
+                inputPattern
+            }
+        }, _httpClient);
+        builder.FilterPathsByPatterns(document);
+        Assert.Equal(expectedPathsCount, document.Paths.Count);
+    }
     [Fact]
     public void SupportsIncludeFilter()
     {

vscode/microsoft-kiota/src/openApiTreeProvider.ts

@@ -267,7 +267,11 @@ export class OpenApiTreeProvider implements vscode.TreeDataProvider<OpenApiTreeN
             if ((currentNode.isOperation || false) && this.rawRootNode) {
                 const parent = this.findApiNode(getPathSegments(trimOperation(currentNode.path)), this.rawRootNode);
                 if (parent && !parent.selected) {
-                    result.push(currentNode.path.replace(/\\/g, pathSeparator));
+                    let operationPath = currentNode.path.replace(/\\/g, pathSeparator);
+                    if(operationPath.startsWith('#')) {//its a operation at the root it needs a leading slash
+                        operationPath = `${pathSeparator}${operationPath}`
+                    }
+                    result.push(operationPath);
                 }
             } else {
                 result.push(currentNode.path.replace(/\\/g, pathSeparator));