nvidia-nat 1.3.0.dev2__py3-none-any.whl → 1.3.0rc1__py3-none-any.whl

{nvidia_nat-1.3.0.dev2.dist-info → nvidia_nat-1.3.0rc1.dist-info}/entry_points.txt

@@ -5,6 +5,7 @@ nat = nat.cli.main:run_cli
 [nat.components]
 nat_agents = nat.agent.register
 nat_authentication = nat.authentication.register
+nat_control_flow = nat.control_flow.register
 nat_embedders = nat.embedder.register
 nat_evaluators = nat.eval.register
 nat_llms = nat.llm.register

nat/cli/commands/info/list_mcp.py

@@ -1,304 +0,0 @@
-# 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.
-
-import asyncio
-import json
-import logging
-import time
-from typing import Any
-
-import click
-from pydantic import BaseModel
-
-from nat.tool.mcp.exceptions import MCPError
-from nat.tool.mcp.mcp_client import MCPBuilder
-from nat.utils.exception_handlers.mcp import format_mcp_error
-
-# Suppress verbose logs from mcp.client.sse and httpx
-logging.getLogger("mcp.client.sse").setLevel(logging.WARNING)
-logging.getLogger("httpx").setLevel(logging.WARNING)
-
-logger = logging.getLogger(__name__)
-
-
-class MCPPingResult(BaseModel):
-    """Result of an MCP server ping request.
-
-    Attributes:
-        url (str): The MCP server URL that was pinged
-        status (str): Health status - 'healthy', 'unhealthy', or 'unknown'
-        response_time_ms (float | None): Response time in milliseconds, None if request failed completely
-        error (str | None): Error message if the ping failed, None if successful
-    """
-    url: str
-    status: str
-    response_time_ms: float | None
-    error: str | None
-
-
-def format_tool(tool: Any) -> dict[str, str | None]:
-    """Format an MCP tool into a dictionary for display.
-
-    Extracts name, description, and input schema from various MCP tool object types
-    and normalizes them into a consistent dictionary format for CLI display.
-
-    Args:
-        tool (Any): MCPToolClient or raw MCP Tool object (uses Any due to different types)
-
-    Returns:
-        dict[str, str | None]: Dictionary with name, description, and input_schema as keys
-    """
-    name = getattr(tool, 'name', None)
-    description = getattr(tool, 'description', '')
-    input_schema = getattr(tool, 'input_schema', None) or getattr(tool, 'inputSchema', None)
-
-    schema_str = None
-    if input_schema:
-        if hasattr(input_schema, "schema_json"):
-            schema_str = input_schema.schema_json(indent=2)
-        else:
-            schema_str = str(input_schema)
-
-    return {
-        "name": name,
-        "description": description,
-        "input_schema": schema_str,
-    }
-
-
-def print_tool(tool_dict: dict[str, str | None], detail: bool = False) -> None:
-    """Print a formatted tool to the console with optional detailed information.
-
-    Outputs tool information in a user-friendly format to stdout. When detail=True
-    or when description/schema are available, shows full information with separator.
-
-    Args:
-        tool_dict (dict[str, str | None]): Dictionary containing tool information with name, description, and
-        input_schema as keys
-        detail (bool, optional): Whether to force detailed output. Defaults to False.
-    """
-    click.echo(f"Tool: {tool_dict.get('name', 'Unknown')}")
-    if detail or tool_dict.get('input_schema') or tool_dict.get('description'):
-        click.echo(f"Description: {tool_dict.get('description', 'No description available')}")
-        if tool_dict.get("input_schema"):
-            click.echo("Input Schema:")
-            click.echo(tool_dict.get("input_schema"))
-        else:
-            click.echo("Input Schema: None")
-        click.echo("-" * 60)
-
-
-async def list_tools_and_schemas(url: str, tool_name: str | None = None) -> list[dict[str, str | None]]:
-    """List MCP tools using MCPBuilder with structured exception handling.
-
-    Args:
-        url (str): MCP server URL to connect to
-        tool_name (str | None, optional): Specific tool name to retrieve.
-        If None, retrieves all available tools. Defaults to None.
-
-    Returns:
-        list[dict[str, str | None]]: List of formatted tool dictionaries, each containing name, description, and
-        input_schema as keys
-
-    Raises:
-        MCPError: Caught internally and logged, returns empty list instead
-    """
-    builder = MCPBuilder(url=url)
-    try:
-        if tool_name:
-            tool = await builder.get_tool(tool_name)
-            return [format_tool(tool)]
-        tools = await builder.get_tools()
-        return [format_tool(tool) for tool in tools.values()]
-    except MCPError as e:
-        format_mcp_error(e, include_traceback=False)
-        return []
-
-
-async def list_tools_direct(url: str, tool_name: str | None = None) -> list[dict[str, str | None]]:
-    """List MCP tools using direct MCP protocol with exception conversion.
-
-    Bypasses MCPBuilder and uses raw MCP ClientSession and SSE client directly.
-    Converts raw exceptions to structured MCPErrors for consistent user experience.
-    Used when --direct flag is specified in CLI.
-
-    Args:
-        url (str): MCP server URL to connect to
-        tool_name (str | None, optional): Specific tool name to retrieve.
-        If None, retrieves all available tools. Defaults to None.
-
-    Returns:
-        list[dict[str, str | None]]: List of formatted tool dictionaries, each containing name, description, and
-        input_schema as keys
-
-    Note:
-        This function handles ExceptionGroup by extracting the most relevant exception
-        and converting it to MCPError for consistent error reporting.
-    """
-    from mcp import ClientSession
-    from mcp.client.sse import sse_client
-
-    try:
-        async with sse_client(url=url) as (read, write):
-            async with ClientSession(read, write) as session:
-                await session.initialize()
-                response = await session.list_tools()
-
-                tools = []
-                for tool in response.tools:
-                    if tool_name:
-                        if tool.name == tool_name:
-                            return [format_tool(tool)]
-                    else:
-                        tools.append(format_tool(tool))
-                if tool_name and not tools:
-                    click.echo(f"[INFO] Tool '{tool_name}' not found.")
-                return tools
-    except Exception as e:
-        # Convert raw exceptions to structured MCPError for consistency
-        from nat.utils.exception_handlers.mcp import convert_to_mcp_error
-        from nat.utils.exception_handlers.mcp import extract_primary_exception
-
-        if isinstance(e, ExceptionGroup):  # noqa: F821
-            primary_exception = extract_primary_exception(list(e.exceptions))
-            mcp_error = convert_to_mcp_error(primary_exception, url)
-        else:
-            mcp_error = convert_to_mcp_error(e, url)
-
-        format_mcp_error(mcp_error, include_traceback=False)
-        return []
-
-
-async def ping_mcp_server(url: str, timeout: int) -> MCPPingResult:
-    """Ping an MCP server to check if it's responsive.
-
-    Args:
-        url (str): MCP server URL to ping
-        timeout (int): Timeout in seconds for the ping request
-
-    Returns:
-        MCPPingResult: Structured result with status, response_time, and any error info
-    """
-    from mcp.client.session import ClientSession
-    from mcp.client.sse import sse_client
-
-    async def _ping_operation():
-        async with sse_client(url) as (read, write):
-            async with ClientSession(read, write) as session:
-                # Initialize the session
-                await session.initialize()
-
-                # Record start time just before ping
-                start_time = time.time()
-                # Send ping request
-                await session.send_ping()
-
-                end_time = time.time()
-                response_time_ms = round((end_time - start_time) * 1000, 2)
-
-                return MCPPingResult(url=url, status="healthy", response_time_ms=response_time_ms, error=None)
-
-    try:
-        # Apply timeout to the entire ping operation
-        return await asyncio.wait_for(_ping_operation(), timeout=timeout)
-
-    except asyncio.TimeoutError:
-        return MCPPingResult(url=url,
-                             status="unreachable",
-                             response_time_ms=None,
-                             error=f"Timeout after {timeout} seconds")
-
-    except Exception as e:
-        return MCPPingResult(url=url, status="unhealthy", response_time_ms=None, error=str(e))
-
-
-@click.group(invoke_without_command=True, help="List tool names (default), or show details with --detail or --tool.")
-@click.option('--direct', is_flag=True, help='Bypass MCPBuilder and use direct MCP protocol')
-@click.option('--url', default='http://localhost:9901/sse', show_default=True, help='MCP server URL')
-@click.option('--tool', default=None, help='Get details for a specific tool by name')
-@click.option('--detail', is_flag=True, help='Show full details for all tools')
-@click.option('--json-output', is_flag=True, help='Output tool metadata in JSON format')
-@click.pass_context
-def list_mcp(ctx: click.Context, direct: bool, url: str, tool: str | None, detail: bool, json_output: bool) -> None:
-    """List MCP tool names (default) or show detailed tool information.
-
-    Use --detail for full output including descriptions and input schemas.
-    If --tool is provided, always shows full output for that specific tool.
-    Use --direct to bypass MCPBuilder and use raw MCP protocol.
-    Use --json-output to get structured JSON data instead of formatted text.
-
-    Args:
-        ctx (click.Context): Click context object for command invocation
-        direct (bool): Whether to bypass MCPBuilder and use direct MCP protocol
-        url (str): MCP server URL to connect to (default: http://localhost:9901/sse)
-        tool (str | None): Optional specific tool name to retrieve detailed info for
-        detail (bool): Whether to show full details (description + schema) for all tools
-        json_output (bool): Whether to output tool metadata in JSON format instead of text
-
-    Examples:
-        nat info mcp                           # List tool names only
-        nat info mcp --detail                  # Show all tools with full details
-        nat info mcp --tool my_tool            # Show details for specific tool
-        nat info mcp --json-output             # Get JSON format output
-        nat info mcp --direct --url http://...  # Use direct protocol with custom URL
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-    fetcher = list_tools_direct if direct else list_tools_and_schemas
-    tools = asyncio.run(fetcher(url, tool))
-
-    if json_output:
-        click.echo(json.dumps(tools, indent=2))
-    elif tool:
-        for tool_dict in tools:
-            print_tool(tool_dict, detail=True)
-    elif detail:
-        for tool_dict in tools:
-            print_tool(tool_dict, detail=True)
-    else:
-        for tool_dict in tools:
-            click.echo(tool_dict.get('name', 'Unknown tool'))
-
-
-@list_mcp.command()
-@click.option('--url', default='http://localhost:9901/sse', show_default=True, help='MCP server URL')
-@click.option('--timeout', default=60, show_default=True, help='Timeout in seconds for ping request')
-@click.option('--json-output', is_flag=True, help='Output ping result in JSON format')
-def ping(url: str, timeout: int, json_output: bool) -> None:
-    """Ping an MCP server to check if it's responsive.
-
-    This command sends a ping request to the MCP server and measures the response time.
-    It's useful for health checks and monitoring server availability.
-
-    Args:
-        url (str): MCP server URL to ping (default: http://localhost:9901/sse)
-        timeout (int): Timeout in seconds for the ping request (default: 60)
-        json_output (bool): Whether to output the result in JSON format
-
-    Examples:
-        nat info mcp ping                                    # Ping default server
-        nat info mcp ping --url http://custom-server:9901/sse # Ping custom server
-        nat info mcp ping --timeout 10                      # Use 10 second timeout
-        nat info mcp ping --json-output                     # Get JSON format output
-    """
-    result = asyncio.run(ping_mcp_server(url, timeout))
-
-    if json_output:
-        click.echo(result.model_dump_json(indent=2))
-    else:
-        if result.status == "healthy":
-            click.echo(f"Server at {result.url} is healthy (response time: {result.response_time_ms}ms)")
-        else:
-            click.echo(f"Server at {result.url} {result.status}: {result.error}")

nat/tool/github_tools/create_github_commit.py

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

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

@@ -1,106 +0,0 @@
-# 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)