nvidia-nat 1.2.0__py3-none-any.whl

nat/tool/datetime_tools.py

@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from nat.builder.builder import Builder
+from nat.builder.function_info import FunctionInfo
+from nat.cli.register_workflow import register_function
+from nat.data_models.function import FunctionBaseConfig
+
+
+class CurrentTimeToolConfig(FunctionBaseConfig, name="current_datetime"):
+    """
+    Simple tool which returns the current date and time in human readable format.
+    """
+    pass
+
+
+@register_function(config_type=CurrentTimeToolConfig)
+async def current_datetime(config: CurrentTimeToolConfig, builder: Builder):
+
+    import datetime
+
+    async def _get_current_time(unused: str) -> str:
+
+        now = datetime.datetime.now()  # Get current time
+        now_human_readable = now.strftime(("%Y-%m-%d %H:%M:%S"))
+
+        return f"The current time of day is {now_human_readable}"  # Format time in H:MM AM/PM format
+
+    yield FunctionInfo.from_fn(_get_current_time,
+                               description="Returns the current date and time in human readable format.")

nat/tool/document_search.py

@@ -0,0 +1,141 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import logging
+
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.builder.function_info import FunctionInfo
+from nat.cli.register_workflow import register_function
+from nat.data_models.component_ref import LLMRef
+from nat.data_models.function import FunctionBaseConfig
+
+logger = logging.getLogger(__name__)
+
+
+class MilvusDocumentSearchToolConfig(FunctionBaseConfig, name="milvus_document_search"):
+    """
+    This tool retrieves relevant documents for a given user query. The input query is mapped to the most appropriate
+    Milvus collection database. This will return relevant documents from the selected collection.
+    """
+    base_url: str = Field(description="The base url used to connect to the milvus database.")
+    top_k: int = Field(default=4, description="The number of results to return from the milvus database.")
+    timeout: int = Field(default=60, description="The timeout configuration to use when sending requests.")
+    llm_name: LLMRef = Field(description=("The name of the llm client to instantiate to determine most appropriate "
+                                          "milvus collection."))
+    collection_names: list = Field(default=["nvidia_api_catalog"],
+                                   description="The list of available collection names.")
+    collection_descriptions: list = Field(default=["Documents about NVIDIA's product catalog"],
+                                          description=("Collection descriptions that map to collection names by "
+                                                       "index position."))
+
+
+@register_function(config_type=MilvusDocumentSearchToolConfig)
+async def document_search(config: MilvusDocumentSearchToolConfig, builder: Builder):
+    from typing import Literal
+
+    import httpx
+    from langchain_core.messages import HumanMessage
+    from langchain_core.messages import SystemMessage
+    from langchain_core.pydantic_v1 import BaseModel
+    from langchain_core.pydantic_v1 import Field  # pylint: disable=redefined-outer-name, reimported
+
+    # define collection store
+    # create a list of tuples using enumerate()
+    tuples = [(key, value)
+              for i, (key, value) in enumerate(zip(config.collection_names, config.collection_descriptions))]
+
+    # convert list of tuples to dictionary using dict()
+    collection_store = dict(tuples)
+
+    # define collection class and force it to accept only valid collection names
+    class CollectionName(BaseModel):
+        collection_name: Literal[tuple(
+            config.collection_names)] = Field(description="The appropriate milvus collection name for the question.")
+
+    class DocumentSearchOutput(BaseModel):
+        collection_name: str
+        documents: str
+
+    # define prompt template
+    prompt_template = f"""You are an agent that helps users find the right Milvus collection based on the question.
+Here are the available list of collections (formatted as collection_name: collection_description): \n
+({collection_store})
+\nFirst, analyze the available collections and their descriptions.
+Then, select the most appropriate collection for the user's query.
+Return only the name of the predicted collection."""
+
+    async with httpx.AsyncClient(headers={
+            "accept": "application/json", "Content-Type": "application/json"
+    },
+                                 timeout=config.timeout) as client:
+
+        async def _document_search(query: str) -> DocumentSearchOutput:
+            """
+            This tool retrieve relevant context for the given question
+            Args:
+                query (str): The question for which we need to search milvus collections.
+            """
+            # log query
+            logger.debug("Q: %s", query)
+
+            # Set Template
+            sys_message = SystemMessage(content=prompt_template)
+
+            # define LLM and generate response
+            llm = await builder.get_llm(llm_name=config.llm_name, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+            structured_llm = llm.with_structured_output(CollectionName)
+            query_string = f"Get relevant chunks for this query: {query}"
+            llm_pred = await structured_llm.ainvoke([sys_message] + [HumanMessage(content=query_string)])
+
+            logger.info("Predicted LLM Collection: %s", llm_pred)
+
+            # configure params for RAG endpoint and doc search
+            url = f"{config.base_url}/search"
+            payload = {"query": query, "top_k": config.top_k, "collection_name": llm_pred.collection_name}
+
+            # send configured payload to running chain server
+            logger.debug("Sending request to the RAG endpoint %s", url)
+            response = await client.post(url, content=json.dumps(payload))
+
+            response.raise_for_status()
+            results = response.json()
+
+            if len(results["chunks"]) == 0:
+                return DocumentSearchOutput(collection_name=llm_pred.collection_name, documents="")
+
+            # parse docs from Langchain Document object to string
+            parsed_docs = []
+
+            # iterate over results and store parsed content
+            for doc in results["chunks"]:
+                source = doc["filename"]
+                page = doc.get("page", "")
+                page_content = doc["content"]
+                parsed_document = f'<Document source="{source}" page="{page}"/>\n{page_content}\n</Document>'
+                parsed_docs.append(parsed_document)
+
+            # combine parsed documents into a single string
+            internal_search_docs = "\n\n---\n\n".join(parsed_docs)
+            return DocumentSearchOutput(collection_name=llm_pred.collection_name, documents=internal_search_docs)
+
+        yield FunctionInfo.from_fn(
+            _document_search,
+            description=("This tool retrieves relevant documents for a given user query."
+                         "The input query is mapped to the most appropriate Milvus collection database"
+                         "This will return relevant documents from the selected collection."))

nat/tool/github_tools/create_github_commit.py

@@ -0,0 +1,133 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pydantic import BaseModel
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.function_info import FunctionInfo
+from nat.cli.register_workflow import register_function
+from nat.data_models.function import FunctionBaseConfig
+
+
+class GithubCommitCodeModel(BaseModel):
+    branch: str = Field(description="The branch of the remote repo to which the code will be committed")
+    commit_msg: str = Field(description="Message with which the code will be committed to the remote repo")
+    local_path: str = Field(description="Local filepath of the file that has been updated and "
+                            "needs to be committed to the remote repo")
+    remote_path: str = Field(description="Remote filepath of the updated file in GitHub. Path is relative to "
+                             "root of current repository")
+
+
+class GithubCommitCodeModelList(BaseModel):
+    updated_files: list[GithubCommitCodeModel] = Field(description=("A list of local filepaths and commit messages"))
+
+
+class GithubCommitCodeConfig(FunctionBaseConfig, name="github_commit_code_tool"):
+    """
+    Tool that commits and pushes modified code to a remote GitHub repository asynchronously.
+    """
+    repo_name: str = Field(description="The repository name in the format 'owner/repo'")
+    local_repo_dir: str = Field(description="Absolute path to the root of the repo, cloned locally")
+    timeout: int = Field(default=300, description="The timeout configuration to use when sending requests.")
+
+
+@register_function(config_type=GithubCommitCodeConfig)
+async def commit_code_async(config: GithubCommitCodeConfig, builder: Builder):
+    """
+    Commits and pushes modified code to a remote GitHub repository asynchronously.
+
+    """
+    import json
+    import os
+
+    import httpx
+
+    github_pat = os.getenv("GITHUB_PAT")
+    if not github_pat:
+        raise ValueError("GITHUB_PAT environment variable must be set")
+
+    # define the headers for the payload request
+    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
+
+    async def _github_commit_code(updated_files) -> list:
+        results = []
+        async with httpx.AsyncClient(timeout=config.timeout) as client:
+            for file_ in updated_files:
+                branch = file_.branch
+                commit_msg = file_.commit_msg
+                local_path = file_.local_path
+                remote_path = file_.remote_path
+
+                # Read content from the local file
+                local_path = os.path.join(config.local_repo_dir, local_path)
+                with open(local_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+
+                # Step 1. Create a blob with the updated contents of the file
+                blob_url = f'https://api.github.com/repos/{config.repo_name}/git/blobs'
+                blob_data = {'content': content, 'encoding': 'utf-8'}
+                blob_response = await client.request("POST", blob_url, json=blob_data, headers=headers)
+                blob_response.raise_for_status()
+                blob_sha = blob_response.json()['sha']
+
+                # Step 2: Get the base tree SHA. The commit will be pushed to this ref node in the Git graph
+                ref_url = f'https://api.github.com/repos/{config.repo_name}/git/refs/heads/{branch}'
+                ref_response = await client.request("GET", ref_url, headers=headers)
+                ref_response.raise_for_status()
+                base_tree_sha = ref_response.json()['object']['sha']
+
+                # Step 3. Create an updated tree (Git graph) with the new blob
+                tree_url = f'https://api.github.com/repos/{config.repo_name}/git/trees'
+                tree_data = {
+                    'base_tree': base_tree_sha,
+                    'tree': [{
+                        'path': remote_path, 'mode': '100644', 'type': 'blob', 'sha': blob_sha
+                    }]
+                }
+                tree_response = await client.request("POST", tree_url, json=tree_data, headers=headers)
+                tree_response.raise_for_status()
+                tree_sha = tree_response.json()['sha']
+
+                # Step 4: Create a commit
+                commit_url = f'https://api.github.com/repos/{config.repo_name}/git/commits'
+                commit_data = {'message': commit_msg, 'tree': tree_sha, 'parents': [base_tree_sha]}
+                commit_response = await client.request("POST", commit_url, json=commit_data, headers=headers)
+                commit_response.raise_for_status()
+                commit_sha = commit_response.json()['sha']
+
+                # Step 5: Update the reference in the Git graph
+                update_ref_url = f'https://api.github.com/repos/{config.repo_name}/git/refs/heads/{branch}'
+                update_ref_data = {'sha': commit_sha}
+                update_ref_response = await client.request("PATCH",
+                                                           update_ref_url,
+                                                           json=update_ref_data,
+                                                           headers=headers)
+                update_ref_response.raise_for_status()
+
+                payload_responses = {
+                    'blob_resp': blob_response.json(),
+                    'original_tree_ref': tree_response.json(),
+                    'commit_resp': commit_response.json(),
+                    'updated_tree_ref_resp': update_ref_response.json()
+                }
+                results.append(payload_responses)
+
+        return json.dumps(results)
+
+    yield FunctionInfo.from_fn(_github_commit_code,
+                               description=(f"Commits and pushes modified code to a "
+                                            f"GitHub repository in the repo named {config.repo_name}"),
+                               input_schema=GithubCommitCodeModelList)

nat/tool/github_tools/create_github_issue.py

@@ -0,0 +1,87 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pydantic import BaseModel
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.function_info import FunctionInfo
+from nat.cli.register_workflow import register_function
+from nat.data_models.function import FunctionBaseConfig
+
+
+class GithubCreateIssueModel(BaseModel):
+    title: str = Field(description="The title of the GitHub Issue")
+    body: str = Field(description="The body of the GitHub Issue")
+
+
+class GithubCreateIssueModelList(BaseModel):
+    issues: list[GithubCreateIssueModel] = Field(description=("A list of GitHub issues, "
+                                                              "each with a title and a body"))
+
+
+class GithubCreateIssueToolConfig(FunctionBaseConfig, name="github_create_issue_tool"):
+    """
+    Tool that creates an issue in a GitHub repository asynchronously.
+    """
+    repo_name: str = Field(description="The repository name in the format 'owner/repo'")
+    timeout: int = Field(default=300, description="The timeout configuration to use when sending requests.")
+
+
+@register_function(config_type=GithubCreateIssueToolConfig)
+async def create_github_issue_async(config: GithubCreateIssueToolConfig, builder: Builder):
+    """
+    Creates an issue in a GitHub repository asynchronously.
+    """
+    import json
+    import os
+
+    import httpx
+
+    github_pat = os.getenv("GITHUB_PAT")
+    if not github_pat:
+        raise ValueError("GITHUB_PAT environment variable must be set")
+
+    url = f"https://api.github.com/repos/{config.repo_name}/issues"
+
+    # define the headers for the payload request
+    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
+
+    async def _github_post_issue(issues) -> list:
+        results = []
+        async with httpx.AsyncClient(timeout=config.timeout) as client:
+            for issue in issues:
+                # define the payload body
+                payload = issue.dict(exclude_unset=True)
+
+                response = await client.request("POST", url, json=payload, headers=headers)
+
+                # Raise an exception for HTTP errors
+                response.raise_for_status()
+
+                # Parse and return the response JSON
+                try:
+                    result = response.json()
+                    results.append(result)
+
+                except ValueError as e:
+                    raise ValueError("The API response is not valid JSON.") from e
+
+        return json.dumps(results)
+
+    yield FunctionInfo.from_fn(_github_post_issue,
+                               description=(f"Creates a GitHub issue in the "
+                                            f"repo named {config.repo_name}"),
+                               input_schema=GithubCreateIssueModelList)

nat/tool/github_tools/create_github_pr.py

@@ -0,0 +1,106 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pydantic import BaseModel
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.function_info import FunctionInfo
+from nat.cli.register_workflow import register_function
+from nat.data_models.function import FunctionBaseConfig
+
+
+class GithubCreatePullModel(BaseModel):
+    title: str = Field(description="Title of the pull request")
+    body: str = Field(description="Description of the pull request")
+    source_branch: str = Field(description="The name of the branch containing your changes")
+    target_branch: str = Field(description="The name of the branch you want to merge into")
+    assignees: list[str] | None = Field([],
+                                        description="List of GitHub usernames to assign to the PR. "
+                                        "Always the current user")
+    reviewers: list[str] | None = Field([], description="List of GitHub usernames to request review from")
+
+
+class GithubCreatePullList(BaseModel):
+    pull_details: GithubCreatePullModel = Field(description=("A list of params used for creating the PR in GitHub"))
+
+
+class GithubCreatePullConfig(FunctionBaseConfig, name="github_create_pull_tool"):
+    """
+    Tool that creates a pull request in a GitHub repository asynchronously with assignees and reviewers.
+    """
+    repo_name: str = Field(description="The repository name in the format 'owner/repo'")
+    timeout: int = Field(default=300, description="The timeout configuration to use when sending requests.")
+
+
+@register_function(config_type=GithubCreatePullConfig)
+async def create_pull_request_async(config: GithubCreatePullConfig, builder: Builder):
+    """
+    Creates a pull request in a GitHub repository asynchronously with assignees and reviewers.
+
+    """
+    import json
+    import os
+
+    import httpx
+
+    github_pat = os.getenv("GITHUB_PAT")
+    if not github_pat:
+        raise ValueError("GITHUB_PAT environment variable must be set")
+
+    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
+
+    async def _github_create_pull(pull_details: GithubCreatePullList) -> str:
+        results = []
+        async with httpx.AsyncClient(timeout=config.timeout) as client:
+            # Create pull request
+            pr_url = f'https://api.github.com/repos/{config.repo_name}/pulls'
+            pr_data = {
+                'title': pull_details.title,
+                'body': pull_details.body,
+                'head': pull_details.source_branch,
+                'base': pull_details.target_branch
+            }
+
+            pr_response = await client.request("POST", pr_url, json=pr_data, headers=headers)
+            pr_response.raise_for_status()
+            pr_number = pr_response.json()['number']
+
+            # Add assignees if provided
+            if pull_details.assignees:
+                assignees_url = f'https://api.github.com/repos/{config.repo_name}/issues/{pr_number}/assignees'
+                assignees_data = {'assignees': pull_details.assignees}
+                assignees_response = await client.request("POST", assignees_url, json=assignees_data, headers=headers)
+                assignees_response.raise_for_status()
+
+            # Request reviewers if provided
+            if pull_details.reviewers:
+                reviewers_url = f'https://api.github.com/repos/{config.repo_name}/pulls/{pr_number}/requested_reviewers'
+                reviewers_data = {'reviewers': pull_details.reviewers}
+                reviewers_response = await client.request("POST", reviewers_url, json=reviewers_data, headers=headers)
+                reviewers_response.raise_for_status()
+
+            results.append({
+                'pull_request': pr_response.json(),
+                'assignees': assignees_response.json() if pull_details.assignees else None,
+                'reviewers': reviewers_response.json() if pull_details.reviewers else None
+            })
+
+        return json.dumps(results)
+
+    yield FunctionInfo.from_fn(_github_create_pull,
+                               description=(f"Creates a pull request with assignees and reviewers in the "
+                                            f"GitHub repository named {config.repo_name}"),
+                               input_schema=GithubCreatePullList)

nat/tool/github_tools/get_github_file.py

@@ -0,0 +1,106 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from nat.builder.builder import Builder
+from nat.builder.function_info import FunctionInfo
+from nat.cli.register_workflow import register_function
+from nat.data_models.function import FunctionBaseConfig
+
+
+class GithubGetFileToolConfig(FunctionBaseConfig, name="github_getfile"):
+    """
+    Tool that returns the text of a github file using a github url starting with https://github.com and ending
+    with a specific file.
+    """
+    pass
+
+
+@register_function(config_type=GithubGetFileToolConfig)
+async def github_text_from_url(config: GithubGetFileToolConfig, builder: Builder):
+
+    import re
+
+    import requests
+
+    async def _github_text_from_url(url_text: str) -> str:
+
+        # Extract sections of the base github path
+        pattern = r"https://github.com/(.*)/blob/(.*)"
+        matches = re.findall(pattern, url_text)
+
+        if (len(matches) == 0):
+            return ("Invalid github url. Please provide a valid github url. "
+                    "Example: 'https://github.com/my_repository/blob/main/file.txt'")
+
+        # Construct raw content path
+        raw_url = f"https://raw.githubusercontent.com/{matches[0][0]}/refs/heads/{matches[0][1]}"
+        # Grab raw text from github
+        try:
+            response = requests.get(raw_url, timeout=60)
+        except requests.exceptions.Timeout:
+            return f"Timeout encountered when retrieving resource: {raw_url}"
+
+        return f"```python\n{response.text}\n```"
+
+    yield FunctionInfo.from_fn(_github_text_from_url,
+                               description=("Returns the text of a github file using a github url starting with"
+                                            "https://github.com and ending with a specific file."))
+
+
+class GithubGetFileLinesToolConfig(FunctionBaseConfig, name="github_getfilelines"):
+    """
+    Tool that returns the text lines of a github file using a github url starting with
+    https://github.com and ending with a specific file line references. Examples of line references are
+    #L409-L417 and #L166-L171.
+    """
+    pass
+
+
+@register_function(config_type=GithubGetFileLinesToolConfig)
+async def github_text_lines_from_url(config: GithubGetFileLinesToolConfig, builder: Builder):
+
+    import re
+
+    async def _github_text_lines_from_url(url_text: str) -> str:
+
+        import requests
+
+        # Extract sections of the base github path
+        pattern = r"https://github.com/(.*)/blob/(.*)(#L(\d+)-L(\d+))"
+        matches = re.findall(pattern, url_text)
+
+        if (len(matches) == 0):
+            return ("Invalid github url. Please provide a valid github url with line information. "
+                    "Example: 'https://github.com/my_repository/blob/main/file.txt#L409-L417'")
+
+        start_line, end_line = int(matches[0][3]), int(matches[0][4])
+        # Construct raw content path
+        raw_url = f"https://raw.githubusercontent.com/{matches[0][0]}/refs/heads/{matches[0][1]}"
+        # Grab raw text from github
+        try:
+            response = requests.get(raw_url, timeout=60)
+        except requests.exceptions.Timeout:
+            return f"Timeout encountered when retrieving resource: {raw_url}"
+        # Extract the specified lines
+        file_lines = response.text.splitlines()
+        selected_lines = file_lines[start_line:end_line]
+        joined_selected_lines = "\n".join(selected_lines)
+
+        return f"```python\n{joined_selected_lines}\n```"
+
+    yield FunctionInfo.from_fn(_github_text_lines_from_url,
+                               description=("Returns the text lines of a github file using a github url starting with"
+                                            "https://github.com and ending with a specific file line references. "
+                                            "Examples of line references are #L409-L417 and #L166-L171."))