nvidia-nat 1.2.0rc5__py3-none-any.whl

aiq/tool/github_tools/get_github_issue.py

@@ -0,0 +1,166 @@
+# 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 datetime import datetime
+from typing import Literal
+
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import field_validator
+
+from aiq.builder.builder import Builder
+from aiq.builder.function_info import FunctionInfo
+from aiq.cli.register_workflow import register_function
+from aiq.data_models.function import FunctionBaseConfig
+
+
+class GithubListIssueModel(BaseModel):
+    state: Literal["open", "closed", "all"] | None = Field('open', description="Issue state used in issue query filter")
+    assignee: str | None = Field("*", description="Assignee name used in issue query filter")
+    creator: str | None = Field(None, description="Creator name used in issue query filter")
+    mentioned: str | None = Field(None, description="Name of person mentioned in issue")
+    labels: list[str] | None = Field(None, description="A list of labels that are assigned to the issue")
+    since: str | None = Field(None, description="Only show results that were last updated after the given time.")
+
+    @classmethod
+    @field_validator('since', mode='before')
+    def validate_since(cls, v):
+        if v is None:
+            return v
+        try:
+            # Parse the string to a datetime object
+            parsed_date = datetime.strptime(v, "%Y-%m-%dT%H:%M:%SZ")
+            # Return the formatted string
+            return parsed_date.isoformat() + 'Z'
+        except ValueError as e:
+            raise ValueError("since must be in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ") from e
+
+
+class GithubListIssueModelList(BaseModel):
+    filter_params: GithubListIssueModel = Field(description=("A list of query params when fetching issues "
+                                                             "each of type GithubListIssueModel"))
+
+
+class GithubListIssueToolConfig(FunctionBaseConfig, name="github_list_issues_tool"):
+    """
+    Configuration for the GitHub List Issues Tool.
+    """
+    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=GithubListIssueToolConfig)
+async def list_github_issue_async(config: GithubListIssueToolConfig, builder: Builder):
+    """
+    Lists GitHub Issues based on various filter parameters
+
+    """
+    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_list_issues(filter_params) -> dict:
+        async with httpx.AsyncClient(timeout=config.timeout) as client:
+
+            filter_params = filter_params.dict(exclude_unset=True)
+
+            # filter out None values that are explictly set in the request body.
+            filter_params = {k: v for k, v in filter_params.items() if v is not None}
+
+            response = await client.request("GET", url, params=filter_params, headers=headers)
+
+            # Raise an exception for HTTP errors
+            response.raise_for_status()
+
+            # Parse and return the response JSON
+            try:
+                result = response.json()
+
+            except ValueError as e:
+                raise ValueError("The API response is not valid JSON.") from e
+
+        return json.dumps(result)
+
+    yield FunctionInfo.from_fn(_github_list_issues,
+                               description=(f"Lists GitHub issues based on filter "
+                                            f"params in the repo named {config.repo_name}"),
+                               input_schema=GithubListIssueModelList)
+
+
+class GithubGetIssueModel(BaseModel):
+    issue_number: str = Field(description="The issue number that needs to be fetched")
+
+
+class GithubGetIssueToolConfig(FunctionBaseConfig, name="github_get_issue_tool"):
+    """
+    Tool that fetches a particular issue in a GitHub repository asynchronously.
+    """
+    repo_name: str = "The repository name in the format 'owner/repo'"
+    timeout: int = 300
+
+
+@register_function(config_type=GithubGetIssueToolConfig)
+async def get_github_issue_async(config: GithubGetIssueToolConfig, builder: Builder):
+    """
+    Fetches a particular 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_get_issue(issue_number) -> list:
+        async with httpx.AsyncClient(timeout=config.timeout) as client:
+            # update the url with the issue number that needs to be updated
+            issue_url = os.path.join(url, issue_number)
+
+            response = await client.request("GET", issue_url, headers=headers)
+
+            # Raise an exception for HTTP errors
+            response.raise_for_status()
+
+            # Parse and return the response JSON
+            try:
+                result = response.json()
+
+            except ValueError as e:
+                raise ValueError("The API response is not valid JSON.") from e
+
+        return json.dumps(result)
+
+    yield FunctionInfo.from_fn(_github_get_issue,
+                               description=(f"Fetches a particular GitHub issue "
+                                            f"in the repo named {config.repo_name}"),
+                               input_schema=GithubGetIssueModel)

aiq/tool/github_tools/get_github_pr.py

@@ -0,0 +1,256 @@
+# 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 typing import Literal
+
+from pydantic import BaseModel
+from pydantic import Field
+
+from aiq.builder.builder import Builder
+from aiq.builder.function_info import FunctionInfo
+from aiq.cli.register_workflow import register_function
+from aiq.data_models.function import FunctionBaseConfig
+
+
+class GithubListPullsModel(BaseModel):
+    state: Literal["open", "closed", "all"] | None = Field('open', description="Issue state used in issue query filter")
+    head: str | None = Field(None, description="Filters pulls by head user or head organization and branch name")
+    base: str | None = Field(None, description="Filters pull by branch name")
+
+
+class GithubListPullsModelList(BaseModel):
+    filter_params: GithubListPullsModel = Field(description=("A list of query params when fetching pull requests "
+                                                             "each of type GithubListPRModel"))
+
+
+class GithubListPullsToolConfig(FunctionBaseConfig, name="github_list_pulls_tool"):
+    """
+    Tool that lists GitHub Pull Requests based on various filter parameters
+    """
+    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=GithubListPullsToolConfig)
+async def list_github_pulls_async(config: GithubListPullsToolConfig, builder: Builder):
+    """
+    Lists GitHub Pull Requests based on various filter parameters
+
+    """
+    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}/pulls"
+
+    # define the headers for the payload request
+    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
+
+    async def _github_list_pulls(filter_params) -> dict:
+        async with httpx.AsyncClient(timeout=config.timeout) as client:
+
+            filter_params = filter_params.dict(exclude_unset=True)
+
+            # filter out None values that are explictly set in the request body.
+            filter_params = {k: v for k, v in filter_params.items() if v is not None}
+
+            response = await client.request("GET", url, params=filter_params, headers=headers)
+
+            # Raise an exception for HTTP errors
+            response.raise_for_status()
+
+            # Parse and return the response JSON
+            try:
+                result = response.json()
+
+            except ValueError as e:
+                raise ValueError("The API response is not valid JSON.") from e
+
+        return json.dumps(result)
+
+    yield FunctionInfo.from_fn(_github_list_pulls,
+                               description=(f"Lists GitHub PRs based on filter params "
+                                            f"in the repo named {config.repo_name}"),
+                               input_schema=GithubListPullsModelList)
+
+
+class GithubGetPullModel(BaseModel):
+    pull_number: str = Field(description="The number of the pull request that needs to be fetched")
+
+
+class GithubGetPullToolConfig(FunctionBaseConfig, name="github_get_pull_tool"):
+    """
+    Tool that fetches a particular pull request in a GitHub repository asynchronously.
+    """
+    repo_name: str = "The repository name in the format 'owner/repo'"
+    timeout: int = 300
+
+
+@register_function(config_type=GithubGetPullToolConfig)
+async def get_github_pull_async(config: GithubGetPullToolConfig, builder: Builder):
+    """
+    Fetches a particular pull request 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}/pulls"
+
+    # define the headers for the payload request
+    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
+
+    async def _github_get_pull(pull_number) -> list:
+        async with httpx.AsyncClient(timeout=config.timeout) as client:
+            # update the url with the pull number that needs to be updated
+            pull_url = os.path.join(url, pull_number)
+
+            response = await client.request("GET", pull_url, headers=headers)
+
+            # Raise an exception for HTTP errors
+            response.raise_for_status()
+
+            # Parse and return the response JSON
+            try:
+                result = response.json()
+
+            except ValueError as e:
+                raise ValueError("The API response is not valid JSON.") from e
+
+        return json.dumps(result)
+
+    yield FunctionInfo.from_fn(_github_get_pull,
+                               description=(f"Fetches a particular GitHub pull request "
+                                            f"in the repo named {config.repo_name}"),
+                               input_schema=GithubGetPullModel)
+
+
+class GithubGetPullCommitsToolConfig(FunctionBaseConfig, name="github_get_pull_commits_tool"):
+    """
+    Configuration for the GitHub Get Pull Commits Tool.
+    """
+    repo_name: str = "The repository name in the format 'owner/repo'"
+    timeout: int = 300
+
+
+@register_function(config_type=GithubGetPullCommitsToolConfig)
+async def get_github_pull_commits_async(config: GithubGetPullCommitsToolConfig, builder: Builder):
+    """
+    Fetches the commits associated with a particular pull request 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}/pulls"
+
+    # define the headers for the payload request
+    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
+
+    async def _github_get_pull(pull_number) -> list:
+        async with httpx.AsyncClient(timeout=config.timeout) as client:
+            # update the url with the pull number that needs to be updated
+            pull_url = os.path.join(url, pull_number)
+            pull_commits_url = os.path.join(pull_url, "commits")
+
+            response = await client.request("GET", pull_commits_url, headers=headers)
+
+            # Raise an exception for HTTP errors
+            response.raise_for_status()
+
+            # Parse and return the response JSON
+            try:
+                result = response.json()
+
+            except ValueError as e:
+                raise ValueError("The API response is not valid JSON.") from e
+
+        return json.dumps(result)
+
+    yield FunctionInfo.from_fn(_github_get_pull,
+                               description=("Fetches the commits for a particular GitHub pull request "
+                                            f" in the repo named {config.repo_name}"),
+                               input_schema=GithubGetPullModel)
+
+
+class GithubGetPullFilesToolConfig(FunctionBaseConfig, name="github_get_pull_files_tool"):
+    """
+    Configuration for the GitHub Get Pull Files Tool.
+    """
+    repo_name: str = "The repository name in the format 'owner/repo'"
+    timeout: int = 300
+
+
+@register_function(config_type=GithubGetPullFilesToolConfig)
+async def get_github_pull_files_async(config: GithubGetPullFilesToolConfig, builder: Builder):
+    """
+    Fetches the files associated with a particular pull request 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}/pulls"
+
+    # define the headers for the payload request
+    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
+
+    async def _github_get_pull(pull_number) -> list:
+        async with httpx.AsyncClient(timeout=config.timeout) as client:
+            # update the url with the pull number that needs to be updated
+            pull_url = os.path.join(url, pull_number)
+            pull_files_url = os.path.join(pull_url, "files")
+
+            response = await client.request("GET", pull_files_url, headers=headers)
+
+            # Raise an exception for HTTP errors
+            response.raise_for_status()
+
+            # Parse and return the response JSON
+            try:
+                result = response.json()
+
+            except ValueError as e:
+                raise ValueError("The API response is not valid JSON.") from e
+
+        return json.dumps(result)
+
+    yield FunctionInfo.from_fn(_github_get_pull,
+                               description=("Fetches the files for a particular GitHub pull request "
+                                            f" in the repo named {config.repo_name}"),
+                               input_schema=GithubGetPullModel)

aiq/tool/github_tools/update_github_issue.py

@@ -0,0 +1,100 @@
+# 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 typing import Literal
+
+from pydantic import BaseModel
+from pydantic import Field
+
+from aiq.builder.builder import Builder
+from aiq.builder.function_info import FunctionInfo
+from aiq.cli.register_workflow import register_function
+from aiq.data_models.function import FunctionBaseConfig
+
+
+class GithubUpdateIssueModel(BaseModel):
+    issue_number: str = Field(description="The issue number that will be updated")
+    title: str | None = Field(None, description="The title of the GitHub Issue")
+    body: str | None = Field(None, description="The body of the GitHub Issue")
+    state: Literal["open", "closed"] | None = Field(None, description="The new state of the issue")
+
+    state_reason: Literal["completed", "not_planned", "reopened", None] | None = Field(
+        None, description="The reason for changing the state of the issue")
+
+    labels: list[str] | None = Field(None, description="A list of labels to assign to the issue")
+    assignees: list[str] | None = Field(None, description="A list of assignees to assign to the issue")
+
+
+class GithubUpdateIssueModelList(BaseModel):
+    issues: list[GithubUpdateIssueModel] = Field(description=("A list of GitHub issues each "
+                                                              "of type GithubUpdateIssueModel"))
+
+
+class GithubUpdateIssueToolConfig(FunctionBaseConfig, name="github_update_issue_tool"):
+    """
+    Tool that updates an issue in a GitHub repository asynchronously.
+    """
+    repo_name: str = "The repository name in the format 'owner/repo'"
+    timeout: int = 300
+
+
+@register_function(config_type=GithubUpdateIssueToolConfig)
+async def update_github_issue_async(config: GithubUpdateIssueToolConfig, builder: Builder):
+    """
+    Updates 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_update_issue(issues) -> list:
+        results = []
+        async with httpx.AsyncClient(timeout=config.timeout) as client:
+            for issue in issues:
+                payload = issue.dict(exclude_unset=True)
+
+                # update the url with the issue number that needs to be updated
+                issue_number = payload.pop("issue_number")
+                issue_url = os.path.join(url, issue_number)
+
+                response = await client.request("PATCH", issue_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_update_issue,
+                               description=(f"Updates a GitHub issue in the "
+                                            f"repo named {config.repo_name}"),
+                               input_schema=GithubUpdateIssueModelList)

aiq/tool/mcp/__init__.py

@@ -0,0 +1,14 @@
+# 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.

aiq/tool/mcp/exceptions.py

@@ -0,0 +1,142 @@
+# 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 enum import Enum
+
+
+class MCPErrorCategory(str, Enum):
+    """Categories of MCP errors for structured handling."""
+    CONNECTION = "connection"
+    TIMEOUT = "timeout"
+    SSL = "ssl"
+    AUTHENTICATION = "authentication"
+    TOOL_NOT_FOUND = "tool_not_found"
+    PROTOCOL = "protocol"
+    UNKNOWN = "unknown"
+
+
+class MCPError(Exception):
+    """Base exception for MCP-related errors."""
+
+    def __init__(self,
+                 message: str,
+                 url: str,
+                 category: MCPErrorCategory = MCPErrorCategory.UNKNOWN,
+                 suggestions: list[str] | None = None,
+                 original_exception: Exception | None = None):
+        super().__init__(message)
+        self.url = url
+        self.category = category
+        self.suggestions = suggestions or []
+        self.original_exception = original_exception
+
+
+class MCPConnectionError(MCPError):
+    """Exception for MCP connection failures."""
+
+    def __init__(self, url: str, original_exception: Exception | None = None):
+        super().__init__(f"Unable to connect to MCP server at {url}",
+                         url=url,
+                         category=MCPErrorCategory.CONNECTION,
+                         suggestions=[
+                             "Please ensure the MCP server is running and accessible",
+                             "Check if the URL and port are correct"
+                         ],
+                         original_exception=original_exception)
+
+
+class MCPTimeoutError(MCPError):
+    """Exception for MCP timeout errors."""
+
+    def __init__(self, url: str, original_exception: Exception | None = None):
+        super().__init__(f"Connection timed out to MCP server at {url}",
+                         url=url,
+                         category=MCPErrorCategory.TIMEOUT,
+                         suggestions=[
+                             "The server may be overloaded or network is slow",
+                             "Try again in a moment or check network connectivity"
+                         ],
+                         original_exception=original_exception)
+
+
+class MCPSSLError(MCPError):
+    """Exception for MCP SSL/TLS errors."""
+
+    def __init__(self, url: str, original_exception: Exception | None = None):
+        super().__init__(f"SSL/TLS error connecting to {url}",
+                         url=url,
+                         category=MCPErrorCategory.SSL,
+                         suggestions=[
+                             "Check if the server requires HTTPS or has valid certificates",
+                             "Try using HTTP instead of HTTPS if appropriate"
+                         ],
+                         original_exception=original_exception)
+
+
+class MCPRequestError(MCPError):
+    """Exception for MCP request errors."""
+
+    def __init__(self, url: str, original_exception: Exception | None = None):
+        message = f"Request failed to MCP server at {url}"
+        if original_exception:
+            message += f": {original_exception}"
+
+        super().__init__(message,
+                         url=url,
+                         category=MCPErrorCategory.PROTOCOL,
+                         suggestions=["Check the server URL format and network settings"],
+                         original_exception=original_exception)
+
+
+class MCPToolNotFoundError(MCPError):
+    """Exception for when a specific MCP tool is not found."""
+
+    def __init__(self, tool_name: str, url: str, original_exception: Exception | None = None):
+        super().__init__(f"Tool '{tool_name}' not available at {url}",
+                         url=url,
+                         category=MCPErrorCategory.TOOL_NOT_FOUND,
+                         suggestions=[
+                             "Use 'aiq info mcp --detail' to see available tools",
+                             "Check that the tool name is spelled correctly"
+                         ],
+                         original_exception=original_exception)
+
+
+class MCPAuthenticationError(MCPError):
+    """Exception for MCP authentication failures."""
+
+    def __init__(self, url: str, original_exception: Exception | None = None):
+        super().__init__(f"Authentication failed when connecting to MCP server at {url}",
+                         url=url,
+                         category=MCPErrorCategory.AUTHENTICATION,
+                         suggestions=[
+                             "Check if the server requires authentication credentials",
+                             "Verify that your credentials are correct and not expired"
+                         ],
+                         original_exception=original_exception)
+
+
+class MCPProtocolError(MCPError):
+    """Exception for MCP protocol-related errors."""
+
+    def __init__(self, url: str, message: str = "Protocol error", original_exception: Exception | None = None):
+        super().__init__(f"{message} (MCP server at {url})",
+                         url=url,
+                         category=MCPErrorCategory.PROTOCOL,
+                         suggestions=[
+                             "Check that the MCP server is running and accessible at this URL",
+                             "Verify the server supports the expected MCP protocol version"
+                         ],
+                         original_exception=original_exception)