feat(vscode): add language model tool to get the library and resource imports from a robot file

d-biehl · d-biehl · commit e5631f042e42 · 2025-05-31T22:29:35.000+02:00
diff --git a/package.json b/package.json
@@ -1941,16 +1941,14 @@
         ]
       }
     ],
-    "chatParticipants":[
-
-    ],
+    "chatParticipants": [],
     "languageModelTools": [
       {
-        "name": "robot-get_library_doc",
+        "name": "robot-get_library_documentation",
         "displayName": "Get Library Documentation",
-        "toolReferenceName": "robotGetLibraryDoc",
-        "modelDescription": "Gets the library documentation for the given library name. This includes keywords, documentation, and other information about the library.",
-        "userDescription": "Gets documentation for the given library.",
+        "toolReferenceName": "robotGetLibraryDocumentation",
+        "modelDescription": "Retrieves comprehensive documentation for Robot Framework libraries. Returns the library's description, initialization parameters with their types and default values, complete list of available keywords with their signatures (including arguments, types, and return values). Use this tool when you need to understand what keywords are available in a library, how to initialize it, or get detailed parameter information. Do not use for getting documentation of specific keywords (use robot-get_keyword_documentation instead) or for analyzing test files. Limitations: Only works with libraries that are properly installed and importable in the current Python environment, may not work with dynamic libraries that change behavior based on runtime conditions, and requires the specified library to be accessible from the workspace's Robot Framework configuration.",
+        "userDescription": "Gets Documentation and keyword list for a Robot Framework library.",
         "canBeReferencedInPrompt": true,
         "tags": [
           "robot",
@@ -1977,11 +1975,75 @@
           }
         }
       },
+      {
+        "name": "robot-get_keyword_documentation",
+        "displayName": "Get Keyword Documentation",
+        "toolReferenceName": "robotGetKeywordDoc",
+        "modelDescription": "Retrieves detailed documentation for a specific Robot Framework keyword. Returns the keyword's complete signature with parameter names, types, default values, and detailed descriptions, along with return value information and usage examples. Use this tool when you need specific information about how to use a particular keyword, its parameters, or expected behavior. Do not use for getting a list of all keywords in a library (use robot-get_library_documentation instead) or for analyzing test file content. Limitations: Requires both the keyword name and library name to be specified accurately, only works with keywords from libraries that are properly installed and importable in the current Python environment, may not work with dynamic keywords that change behavior based on runtime conditions, and requires the specified library to be accessible from the workspace's Robot Framework configuration.",
+        "userDescription": "Gets detailed documentation for a specific Robot Framework keyword.",
+        "canBeReferencedInPrompt": true,
+        "tags": [
+          "robot",
+          "robotframework",
+          "robotframework-keyword",
+          "robotcode"
+        ],
+        "icon": "$(robotcode-robot)",
+        "inputSchema": {
+          "type": "object",
+          "required": [
+            "keywordName",
+            "libraryName"
+          ],
+          "properties": {
+            "keywordName": {
+              "type": "string",
+              "description": "The name of the keyword."
+            },
+            "libraryName": {
+              "type": "string",
+              "description": "The name of the library containing the keyword."
+            },
+            "resourcePath": {
+              "type": "string",
+              "description": "The path to the robot framework file or workspace."
+            }
+          }
+        }
+      },
+      {
+        "name": "robot-get_document_imports",
+        "displayName": "Get Document Imports",
+        "toolReferenceName": "robotGetDocumentImports",
+        "modelDescription": "Retrieves a list of all imported libraries and resource files for a specific Robot Framework document. Returns the names and paths of all libraries imported in the specified Robot Framework file. Use this tool when you need to analyze the dependencies of a Robot Framework document or understand its library and resource usage. Limitations: Only works with Robot Framework files, may not detect dynamic imports or libraries loaded at runtime, and requires the specified file to be accessible from the workspace's Robot Framework configuration.",
+        "userDescription": "Gets a list of all imported libraries and resources for a specific Robot Framework document.",
+        "canBeReferencedInPrompt": true,
+        "tags": [
+          "robot",
+          "robotframework",
+          "robotframework-library",
+          "robotframework-resource",
+          "robotcode"
+        ],
+        "icon": "$(robotcode-robot)",
+        "inputSchema": {
+          "type": "object",
+          "required": [
+            "resourcePath"
+          ],
+          "properties": {
+            "resourcePath": {
+              "type": "string",
+              "description": "The path to a robot framework file."
+            }
+          }
+        }
+      },
       {
         "name": "robot-get_environment_details",
         "displayName": "Get Robot Framework Environment Informations",
         "toolReferenceName": "robotGetEnvironmentInfo",
-        "modelDescription": "This tool will retrieve the details of the Robot Framework Environment for the specified file or workspace. This includes informations about the python interpreter, like the version and the executable path, and the versions of robot framework, RobotCode, robocop and robotidy if installed.",
+        "modelDescription": "Retrieves detailed environment information for Robot Framework workspaces or files. Returns comprehensive details about the Python interpreter (version, executable path), installed Robot Framework version, RobotCode extension version, and optional tool versions (robocop, robotidy) if available. Use this tool when you need to diagnose environment issues, verify installations, check version compatibility, or troubleshoot Robot Framework setup problems. Limitations: Only provides information about the currently configured Python environment for the workspace, may not detect tools installed in different Python environments, requires proper workspace configuration to access environment details, and information accuracy depends on the current RobotCode language server connection.",
         "userDescription": "Gets informations about the Robot Framework Environment.",
         "canBeReferencedInPrompt": true,
         "tags": [
diff --git a/packages/language_server/src/robotcode/language_server/robotframework/parts/keywords_treeview.py b/packages/language_server/src/robotcode/language_server/robotframework/parts/keywords_treeview.py
@@ -17,6 +17,13 @@
 @dataclass(repr=False)
 class GetDocumentImportsParams(CamelSnakeMixin):
     text_document: TextDocumentIdentifier
+    no_documentation: Optional[bool] = None
+
+
+@dataclass(repr=False)
+class GetDocumentKeywordsParams(CamelSnakeMixin):
+    text_document: TextDocumentIdentifier
+    no_documentation: Optional[bool] = None
 
 
 @dataclass(repr=False)
@@ -25,6 +32,13 @@ class GetLibraryDocumentationParams(CamelSnakeMixin):
     library_name: str
 
 
+@dataclass(repr=False)
+class GetKeywordDocumentationParams(CamelSnakeMixin):
+    workspace_folder_uri: str
+    library_name: str
+    keyword_name: str
+
+
 @dataclass(repr=False)
 class Keyword(CamelSnakeMixin):
     name: str
@@ -69,6 +83,7 @@ def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
     def _get_document_imports(
         self,
         text_document: TextDocumentIdentifier,
+        no_documentation: Optional[bool] = None,
         *args: Any,
         **kwargs: Any,
     ) -> Optional[List[DocumentImport]]:
@@ -87,16 +102,18 @@ def _get_document_imports(
                     alias=v.alias,
                     id=str(hash(v)),
                     type="library",
-                    documentation=v.library_doc.to_markdown(add_signature=False),
+                    documentation=v.library_doc.to_markdown(add_signature=False) if not no_documentation else None,
                     keywords=[
                         Keyword(
                             l.name,
                             str(hash(l)),
                             l.parameter_signature(),
-                            l.to_markdown(add_signature=False),
+                            l.to_markdown(add_signature=False) if not no_documentation else None,
                         )
                         for l in v.library_doc.keywords.values()
-                    ],
+                    ]
+                    if not no_documentation
+                    else None,
                 )
             )
         for _k, v in namespace.get_resources().items():
@@ -106,21 +123,29 @@ def _get_document_imports(
                     alias=None,
                     id=str(hash(v)),
                     type="resource",
-                    documentation=v.library_doc.to_markdown(add_signature=False),
+                    documentation=v.library_doc.to_markdown(add_signature=False) if not no_documentation else None,
                     keywords=[
-                        Keyword(l.name, str(hash(l)), l.parameter_signature(), l.to_markdown(add_signature=False))
+                        Keyword(
+                            l.name,
+                            str(hash(l)),
+                            l.parameter_signature(),
+                            l.to_markdown(add_signature=False) if not no_documentation else None,
+                        )
                         for l in v.library_doc.keywords.values()
-                    ],
+                    ]
+                    if not no_documentation
+                    else None,
                 )
             )
 
         return result
 
-    @rpc_method(name="robot/keywordsview/getDocumentKeywords", param_type=GetDocumentImportsParams, threaded=True)
+    @rpc_method(name="robot/keywordsview/getDocumentKeywords", param_type=GetDocumentKeywordsParams, threaded=True)
     @_logger.call
     def _get_document_keywords(
         self,
         text_document: TextDocumentIdentifier,
+        no_documentation: Optional[bool] = None,
         *args: Any,
         **kwargs: Any,
     ) -> Optional[List[Keyword]]:
@@ -131,7 +156,12 @@ def _get_document_keywords(
         namespace = self.parent.documents_cache.get_namespace(document)
 
         return [
-            Keyword(l.name, str(hash(l)), l.parameter_signature(), l.to_markdown(add_signature=False))
+            Keyword(
+                l.name,
+                str(hash(l)),
+                l.parameter_signature(),
+                l.to_markdown(add_signature=False) if not no_documentation else None,
+            )
             for l in namespace.get_library_doc().keywords.values()
         ]
 
@@ -220,3 +250,32 @@ def _get_library_documentation(
                 for s in libdoc.inits.values()
             ],
         )
+
+    @rpc_method(
+        name="robot/keywordsview/getKeywordDocumentation", param_type=GetKeywordDocumentationParams, threaded=True
+    )
+    @_logger.call
+    def _get_keyword_documentation(
+        self,
+        workspace_folder_uri: str,
+        library_name: str,
+        keyword_name: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[Keyword]:
+        imports_manager = self.parent.documents_cache.get_imports_manager_for_uri(Uri(workspace_folder_uri))
+
+        libdoc = imports_manager.get_libdoc_for_library_import(library_name, (), ".")
+        if libdoc.errors:
+            raise ValueError(f"Errors while loading library documentation: {libdoc.errors}")
+
+        kw = libdoc.keywords.get(keyword_name, None)
+        if kw is None:
+            raise ValueError(f"Keyword '{keyword_name}' not found in library '{library_name}'.")
+
+        return Keyword(
+            name=kw.name,
+            id=str(hash(kw)),
+            signature=kw.parameter_signature(),
+            documentation=kw.to_markdown(),
+        )
diff --git a/vscode-client/extension/index.ts b/vscode-client/extension/index.ts
@@ -7,7 +7,7 @@ import { KeywordsTreeViewProvider } from "./keywordsTreeViewProvider";
 import { LanguageToolsManager } from "./languageToolsManager";
 import { NotebookManager } from "./notebook";
 import path from "path";
-import { GetEnvironmentDetails, GetLibDocTool } from "./lmTools";
+import { GetDocumentImportsTool, GetEnvironmentDetails, GetKeywordInfoTool, GetLibraryInfoTool } from "./lmTools";
 
 class TerminalLink extends vscode.TerminalLink {
   constructor(
@@ -154,7 +154,18 @@ export async function activateAsync(context: vscode.ExtensionContext): Promise<v
         }, 1000);
       }
     }),
-    vscode.lm.registerTool("robot-get_library_doc", new GetLibDocTool(context, languageClientManger, outputChannel)),
+    vscode.lm.registerTool(
+      "robot-get_library_documentation",
+      new GetLibraryInfoTool(context, languageClientManger, outputChannel),
+    ),
+    vscode.lm.registerTool(
+      "robot-get_keyword_documentation",
+      new GetKeywordInfoTool(context, languageClientManger, outputChannel),
+    ),
+    vscode.lm.registerTool(
+      "robot-get_document_imports",
+      new GetDocumentImportsTool(context, languageClientManger, outputChannel),
+    ),
     vscode.lm.registerTool(
       "robot-get_environment_details",
       new GetEnvironmentDetails(context, languageClientManger, outputChannel),
diff --git a/vscode-client/extension/keywordsTreeViewProvider.ts b/vscode-client/extension/keywordsTreeViewProvider.ts
@@ -196,7 +196,7 @@ export class KeywordsTreeViewProvider
           const currentDoc = document; // needed for the closure
 
           this._currentDocumentData.imports = (
-            await this.languageClientsManager.getDocumentImports(document, this._cancelationSource.token)
+            await this.languageClientsManager.getDocumentImports(document, false, this._cancelationSource.token)
           )
             .map((lib_or_res) => {
               if (this._cancelationSource?.token.isCancellationRequested) {
diff --git a/vscode-client/extension/languageclientsmanger.ts b/vscode-client/extension/languageclientsmanger.ts
@@ -47,7 +47,7 @@ export interface LibraryDocumentation {
   name: string;
   documentation?: string;
   keywords?: Keyword[];
-  initializers?: DocumentImport[];
+  initializers?: Keyword[];
 }
 
 export interface DocumentImport {
@@ -892,18 +892,27 @@ export class LanguageClientsManager {
   }
 
   public async getDocumentImports(
-    document: vscode.TextDocument,
+    document_or_uri: vscode.TextDocument | vscode.Uri | string,
+    noDocumentation?: boolean | undefined,
     token?: vscode.CancellationToken | undefined,
   ): Promise<DocumentImport[]> {
-    const client = await this.getLanguageClientForResource(document.uri);
+    const uri =
+      document_or_uri instanceof vscode.Uri
+        ? document_or_uri
+        : typeof document_or_uri === "string"
+          ? vscode.Uri.parse(document_or_uri)
+          : document_or_uri.uri;
+
+    const client = await this.getLanguageClientForResource(uri);
 
     if (!client) return [];
 
     return (
       (await client.sendRequest<DocumentImport[]>(
         "robot/keywordsview/getDocumentImports",
         {
-          textDocument: { uri: document.uri.toString() },
+          textDocument: { uri: uri.toString() },
+          noDocumentation: noDocumentation,
         },
         token ?? new vscode.CancellationTokenSource().token,
       )) ?? []
@@ -931,6 +940,29 @@ export class LanguageClientsManager {
     );
   }
 
+  public async getKeywordDocumentation(
+    workspace_folder: vscode.WorkspaceFolder,
+    libraryName: string,
+    keywordName: string,
+    token?: vscode.CancellationToken | undefined,
+  ): Promise<Keyword | undefined> {
+    const client = await this.getLanguageClientForResource(workspace_folder.uri);
+
+    if (!client) return undefined;
+
+    return (
+      (await client.sendRequest<Keyword>(
+        "robot/keywordsview/getKeywordDocumentation",
+        {
+          workspaceFolderUri: workspace_folder.uri.toString(),
+          libraryName: libraryName,
+          keywordName: keywordName,
+        },
+        token ?? new vscode.CancellationTokenSource().token,
+      )) ?? undefined
+    );
+  }
+
   public async getDocumentKeywords(
     document: vscode.TextDocument,
     token?: vscode.CancellationToken | undefined,
diff --git a/vscode-client/extension/lmTools.tsx b/vscode-client/extension/lmTools.tsx

Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,7 @@ export class KeywordsTreeViewProvider`
`196`	`196`	`const currentDoc = document; // needed for the closure`
`197`	`197`
`198`	`198`	`this._currentDocumentData.imports = (`
`199`		`- await this.languageClientsManager.getDocumentImports(document, this._cancelationSource.token)`
	`199`	`+ await this.languageClientsManager.getDocumentImports(document, false, this._cancelationSource.token)`
`200`	`200`	`)`
`201`	`201`	`.map((lib_or_res) => {`
`202`	`202`	`if (this._cancelationSource?.token.isCancellationRequested) {`