update agent with tools

README.md

@@ -46,6 +46,8 @@ Connecting to `Continue` Extension from VSCode: TODO
             ],
             "env": {
                 "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_token}"
+                "GITHUB_READ_ONLY": "1",
+                "GITHUB_TOOLSETS": "default",
             }
         }
     }

app.py

@@ -10,10 +10,11 @@ from config import (
     AGENT_MODEL,
     CHAT_HISTORY_TURNS_CUTOFF,
     CHAT_HISTORY_WORD_CUTOFF,
+    GITHUB_PAT,
+    GITHUB_READ_ONLY,
     GITHUB_TOOLSETS,
     HF_TOKEN,
 )
-from config import GITHUB_PAT as GITHUB_TOKEN
 from src.upgrade_advisor.agents.package import PackageDiscoveryAgent
 from src.upgrade_advisor.chat.chat import (
     qn_rewriter,
@@ -21,9 +22,11 @@ from src.upgrade_advisor.chat.chat import (
     summarize_chat_history,
 )
 from src.upgrade_advisor.misc import (
+    _monkeypatch_gradio_save_history,
     get_example_pyproject_question,
     get_example_requirements_question,
 )
+from src.upgrade_advisor.theme import christmas
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -34,37 +37,6 @@ uploads_dir = Path("uploads")
 uploads_dir.mkdir(exist_ok=True)
 uploads_dir = uploads_dir.resolve()
 
-# TODO: Merge the MCP-PYPI with this.
-
-
-def _monkeypatch_gradio_save_history():
-    """Guard against non-int indices in Gradio's chat history saver.
-
-    Gradio 5.49.1 occasionally passes a component (e.g., Textbox) as the
-    conversation index when save_history=True, which raises a TypeError. We
-    coerce unexpected index types to None so Gradio inserts a new conversation
-    instead of erroring.
-    """
-    import gradio as gr
-
-    if getattr(gr.ChatInterface, "_ua_safe_patch", False):
-        return
-
-    original = gr.ChatInterface._save_conversation
-
-    def _safe_save_conversation(self, index, conversation, saved_conversations):
-        if not isinstance(index, int):
-            index = None
-        try:
-            return original(self, index, conversation, saved_conversations)
-        except Exception:
-            logger.exception("Failed to save chat history; leaving history unchanged.")
-            return index, saved_conversations
-
-    gr.ChatInterface._save_conversation = _safe_save_conversation
-    gr.ChatInterface._ua_safe_patch = True
-
-
 _monkeypatch_gradio_save_history()
 
 
@@ -160,33 +132,20 @@ if __name__ == "__main__":
     logger.info("Starting MCP client...")
 
     try:
-        gh_mcp_params = StdioServerParameters(
-            # for StdioServerParameters, we use podman to run the
-            # MCP server from GH in a container
-            command="podman",
-            args=[
-                "run",
-                "-i",
-                "--rm",
-                "-e",
-                "GITHUB_PERSONAL_ACCESS_TOKEN",
-                "-e",
-                "GITHUB_READ_ONLY",
-                "-e",
-                "GITHUB_TOOLSETS",
-                "ghcr.io/github/github-mcp-server",
-            ],
-            env={
-                "GITHUB_PERSONAL_ACCESS_TOKEN": GITHUB_TOKEN,
-                "GITHUB_READ_ONLY": "1",
-                "GITHUB_TOOLSETS": GITHUB_TOOLSETS,
-            },
-        )
-        pypi_mcp_params = dict(
-            # url="https://mcp-1st-birthday-pypi-mcp.hf.space/gradio_api/mcp/",
-            url="https://mcp-1st-birthday-uv-pypi-mcp.hf.space/gradio_api/mcp/",
+        gh_mcp_params = dict(
+            url="https://api.githubcopilot.com/mcp/",
             transport="streamable-http",
+            headers={
+                "Authorization": f"Bearer {GITHUB_PAT}",
+                "X-MCP-Toolsets": GITHUB_TOOLSETS,
+                "X-MCP-Readonly": GITHUB_READ_ONLY,
+            },
         )
+        # pypi_mcp_params = dict(
+        #     # url="https://mcp-1st-birthday-pypi-mcp.hf.space/gradio_api/mcp/",
+        #     url="https://mcp-1st-birthday-uv-pypi-mcp.hf.space/gradio_api/mcp/",
+        #     transport="streamable-http",
+        # )
         upload_mcp_params = StdioServerParameters(
             command="uvx",
             args=[
@@ -204,7 +163,7 @@ if __name__ == "__main__":
 
         pypi_mcp_client = MCPClient(
             server_parameters=[
-                pypi_mcp_params,
+                # pypi_mcp_params,
                 gh_mcp_params,
                 upload_mcp_params,
             ],
@@ -265,7 +224,7 @@ if __name__ == "__main__":
                     ],
                 ],
                 stop_btn=True,
-                theme="compact",
+                theme=christmas,
             )
             demo.launch()
 
@@ -273,9 +232,14 @@ if __name__ == "__main__":
         logger.info("Cleaning up MCP client resources")
         # remove contents of uploads_dir
         for f in uploads_dir.iterdir():
-            try:
-                f.unlink()
-            except Exception:
-                logger.exception(f"Failed to delete uploaded file: {f}")
-
+            if f.is_dir():
+                try:
+                    shutil.rmtree(f)
+                except Exception:
+                    logger.exception(f"Failed to delete uploaded directory: {f}")
+            else:
+                try:
+                    f.unlink()
+                except Exception:
+                    logger.exception(f"Failed to delete uploaded file: {f}")
         logger.info("Shutdown complete.")

config.py

@@ -17,7 +17,7 @@ if not HF_TOKEN:
     print("⚠️ Hugging Face token not found in .env file!")
 
 GITHUB_TOOLSETS = os.getenv("GITHUB_TOOLSETS", "repos")
-
+GITHUB_READ_ONLY = os.getenv("GITHUB_READ_ONLY", "1")
 
 # Server configuration
 GRADIO_SERVER_NAME = os.getenv("GRADIO_SERVER_NAME", "0.0.0.0")

src/upgrade_advisor/agents/package.py

@@ -13,7 +13,15 @@ from ..schema import (  # noqa
     PackageVersionResponseSchema,
 )
 from .prompts import get_package_discovery_prompt
-from .tools import ReadUploadFileTool, WriteTomlFileTool
+from .tools import (
+    PypiSearchTool,
+    PypiSearchVersionTool,
+    ReadUploadFileTool,
+    RepoFromPyPI,
+    RepoFromUrlTool,
+    ResolvePyProjectTOMLTool,
+    WriteTomlFileTool,
+)
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -28,17 +36,23 @@ class PackageDiscoveryAgent:
         self.model = model
         if tools is None:
             tool_list: list = []
-            logger.info("No tools provided; initializing with an empty toolset.")
+            logger.info("No custom tools provided; initializing with an empty toolset.")
         else:
             tool_list = list(tools)
 
         # additional custom tools
-        tool_list.append(
-            ReadUploadFileTool(),
-        )
-        tool_list.append(
-            WriteTomlFileTool(),
+        tool_list.extend(
+            [
+                ReadUploadFileTool(),
+                WriteTomlFileTool(),
+                ResolvePyProjectTOMLTool(),
+                PypiSearchTool(),
+                PypiSearchVersionTool(),
+                RepoFromUrlTool(),
+                RepoFromPyPI(),
+            ]
         )
+        logger.info("Custom tools added to the agent.")
 
         self.agent = CodeAgent(
             tools=tool_list,

src/upgrade_advisor/agents/prompts.py

@@ -12,20 +12,16 @@ def get_package_discovery_prompt(
     if reframed_question:
         user_input += f"\nREFRAMED QUESTION (LLM-generated):\n{reframed_question}\n"
 
-    # Add the rest of the prompt content here...
     return f"""
     You are a package discovery agent and an upgrade advisor for Python
     packages.
     Your goal is to find relevant metadata about Python packages using the
-    available tools and to compile a structured summary of your findings based
-    on the user's question. If the user asks about upgrade recommendations,
+    available tools and use that context to provide helpful answers
+    based on the user's question. If the user asks about upgrade recommendations,
     compatibility issues, known bugs, or best practices, you should gather
-    relevant data and provide clear, actionable advice. You must verify the
-    compatibility of packages with specific Python versions or other packages
-    using the appropriate tools.
+    relevant data and provide clear, actionable advice.
 
-    The user may ask about package metadata, compatibility, known issues,
-    upgrade recommendations, and best practices. For example, they may ask:
+    For example, they may ask:
     - "What are the known issues with pandas version 1.2.0?"
     - "Is there a newer version of requests that fixes security vulnerabilities?"
     - "What are the upgrade recommendations for Django from 2.x to 3.x?"
@@ -39,14 +35,14 @@ def get_package_discovery_prompt(
     versions without breaking my project?"
 
     Your knowledge cutoff may prevent you from knowing what's recent.
-    Always use the current date (ISO format YYYY-MM-DD): {today_date}
+    NO MATTER WHAT, always use the current date (ISO format YYYY-MM-DD): {today_date}
     when reasoning about dates and
     releases. Some tools also provide you the release date information, which
     you can transform to ISO format and make comparisons.
 
-    The first step to tackle such questions is to gather relevant data about the
-    packages involved using the available MCP tools. Some tools like the
-    `resolve_environment`
+    The first step to tackle such questions is to gather relevant information about the
+    packages involved using the available tools. Some tools like the
+    `resolve_pyproject_toml`
     can directly analyze a pyproject.toml content to find
     compatibility issues and upgrade suggestions.
     Use the tools to fetch
@@ -54,16 +50,19 @@ def get_package_discovery_prompt(
     known issues. Then, analyze the collected data to identify any potential
     issues, improvements, or recommendations related to the user's question.
 
+    Always prepare a plan before executing any tools. Iterate over the plan
+    step-by-step, using the tools as needed to gather more information. When evidence
+    is sufficient, provide a final answer that directly addresses the user's
+    question with clear recommendations or insights.
+
     IMPORTANT EXECUTION GUIDELINES:
     - Do NOT print intermediate tool outputs. Do not wrap results in strings
     or code fences.
-    - To parse the responce from the PyPI MCP tools, you may need to use 
-    `ast.literal_eval(tool_result)` to convert string representations of
-    Python data structures into actual dicts/lists.
-    - Always keep tool results as Python dicts/lists. Do not serialize them!!
-    - Make sure the dict also contains a "reasoning" field that explains
-    how you arrived at your final answer. Do not omit this field. Do not
-    mention the tool names, rather what the tool helped you discover.
+    - Always keep tool results as Python dicts/lists. Index them directly.
+    - The `output_schema` of each tool describes the expected output structure.
+    - Make sure your final answer contains a "reasoning" field that explains
+    how you arrived at your final answer. Do not omit this field.
+    - Do not mention the tool names, rather mention what the tool helped you discover.
     - Return the final structured object using: final_answer(<python_dict>)
     - Ensure the returned object STRICTLY matches the expected schema for that tool.
       Do not add or rename keys. Keep value types correct.
@@ -74,25 +73,18 @@ def get_package_discovery_prompt(
 
     HINTS:
     - MCP tool outputs are often structured (Python dict/list). Use them directly.
-    - If you get a string result, make sure to convert it to a Python dict/list before indexing
-    like the result's `info` field.
-    - To send pyproject.toml content to the `resolve_environment` tool, you
+    - To send pyproject.toml content to the `resolve_pyproject_toml` tool, you
     will need to use the `upload_file_to_gradio` tool first to upload the file.
-    - The output of `resolve_environment` contains if the compatibility issues.
-    First useful field is `errored` (boolean). If true, check `logs` field for
-    details. The `logs` field contains useful information in any case.
-    - If the user dumps a pyproject.toml content directly, save it to a temp file
-    using the `write_toml_file` tool and then upload it to gradio before passing
-    it to `resolve_environment`. Use triple quotes for the content.
+    - The output of `resolve_pyproject_toml` contains `errored` field which
+    indicates (boolean) if there were any errors in resolution.
+    If true, check `logs` field for
+    details. The `logs` field contains useful information of `uv` stderr output.
     - If you need more information about how to write a `pyproject.toml`, use
     the information from PEP621: https://peps.python.org/pep-0621/
-    - Also be careful of the types. Some fields may be optional or missing.
-    Some fields are ints/floats.
-    - Always prefer MCP tool data over web search data for package metadata.
-    - However, If you decide to use the `web_search`, you must ONLY rely on the
-    official package website, PyPI page, or official GitHub repo. 
+    - If you decide to use the `web_search`, you must ONLY rely on the
+    official package website, PyPI page, or official GitHub repo.
     - NEVER fabricate data. If you cannot find the info, say so.
-    - For parsing version numbers, use the `packaging.version` module. 
-    - When you have gathered the required info, call final_answer with
-    the BEST structured object that answers the user query according to the appropriate schema.
+    - For parsing version numbers, use the `packaging.version` module.
+    - When you have gathered the required info, call `final_answer` with the BEST
+    structured object that answers the user query according to the appropriate schema.
     """

src/upgrade_advisor/agents/tools.py

@@ -1,99 +0,0 @@
-import logging
-import shutil
-from pathlib import Path
-
-from smolagents.tools import Tool
-
-from ..misc import UPLOADS_DIR
-
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
-logger.addHandler(logging.StreamHandler())
-
-
-class ReadUploadFileTool(Tool):
-    """Tool to safely read files saved in the `uploads` directory."""
-
-    name = "read_upload_file"
-    description = """
-        Read a user-uploaded text file from the uploads directory.
-        Input: `path` should be the absolute path you received (or a filename)
-        under the `uploads` folder. Returns the file contents as text."""
-    inputs = {
-        "path": {
-            "type": "string",
-            "description": "Absolute or relative path to the uploaded file \
-                that is present under the `uploads` directory.",
-        }
-    }
-    output_type = "string"
-
-    def __init__(self):
-        self.upload_root = UPLOADS_DIR
-        super().__init__()
-
-    def forward(self, path: str) -> str:
-        file_path = Path(path).expanduser()
-        if not file_path.is_absolute():
-            file_path = self.upload_root / file_path
-
-        try:
-            resolved = file_path.resolve()
-        except FileNotFoundError as exc:
-            raise FileNotFoundError(f"File not found: {file_path}") from exc
-
-        if not resolved.exists():
-            raise FileNotFoundError(f"File not found: {resolved}")
-
-        try:
-            resolved.relative_to(self.upload_root)
-        except ValueError as exc:
-            raise ValueError(
-                f"Refusing to read '{resolved}': \
-                    not inside uploads directory {self.upload_root}"
-            ) from exc
-
-        if resolved.is_dir():
-            raise IsADirectoryError(f"Refusing to read directory: {resolved}")
-
-        return resolved.read_text(encoding="utf-8")
-
-
-class WriteTomlFileTool(Tool):
-    """Tool to write pyproject.toml content to a temp file."""
-
-    name = "write_toml_file"
-    description = """
-        Write the provided pyproject.toml content to a temporary file.
-        Input: `content` is the string content of the pyproject.toml file.
-        Returns the absolute path to the created temporary file."""
-    inputs = {
-        "content": {
-            "type": "string",
-            "description": "The content of the pyproject.toml file to write.",
-        }
-    }
-    output_type = "string"
-
-    def __init__(self):
-        self.upload_root = UPLOADS_DIR
-        super().__init__()
-
-    def forward(self, content: str) -> str:
-        import os
-        import tempfile
-
-        with tempfile.NamedTemporaryFile(
-            mode="w",
-            suffix=".toml",
-            delete=False,  # do not delete so it can be read later
-            encoding="utf-8",
-            dir=f"{self.upload_root}/temp",
-        ) as temp_file:
-            logger.info(
-                f"Temporary directory exists: {os.path.exists(f'{self.upload_root}/temp')}"
-            )
-            temp_file.write(content)
-        shutil.move(temp_file.name, f"{self.upload_root}/temp/pyproject.toml")
-        # return as pyproject.toml
-        return f"{self.upload_root}/temp/pyproject.toml"

src/upgrade_advisor/agents/tools/__init__.py

@@ -0,0 +1 @@
+from .tools import *  # noqa: F403,F401

src/upgrade_advisor/agents/tools/parse_response.py

@@ -0,0 +1,143 @@
+import logging
+
+from src.upgrade_advisor.schema import (
+    PackageInfoSchema,
+    PackageReleaseSchema,
+    PackageSearchResponseSchema,
+    PackageVersionResponseSchema,
+    ResolvedDep,
+    ResolveResult,
+)
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(logging.StreamHandler())
+
+
+def parse_response_pypi_search(
+    data: dict, cutoff: int = 10
+) -> PackageSearchResponseSchema:
+    """
+    Parse the JSON response from the PyPI search API into a Pydantic model.
+
+    Args:
+        data (dict): The JSON response from the PyPI search API.
+        cutoff (int): The maximum number of releases to include in the response. Defaults to 10.
+    Returns:
+        PackageSearchResponseSchema: A Pydantic model containing metadata about the package.
+    """
+    info = data.get("info", {})
+    releases = dict(list(data.get("releases", {}).items())[-cutoff:])
+    last_serial = data.get("last_serial", 0)
+
+    # create the info
+    info = PackageInfoSchema(**info)
+    # create the releases
+    parsed_releases = {}
+    for version, release_list in releases.items():
+        # the whl and tar.gz contain the same info and are placed in a list
+        try:
+            release = release_list[0]
+        except IndexError:
+            release = {}
+        parsed_release_list = PackageReleaseSchema(version=version, **release)
+        parsed_releases[version] = parsed_release_list
+
+    # create the final response model
+    parsed_response = PackageSearchResponseSchema(
+        info=info,
+        releases=parsed_releases,
+        last_serial=last_serial,
+    )
+    return parsed_response
+
+
+def parse_response_version_search(
+    data: dict, cutoff: int = 10
+) -> PackageVersionResponseSchema:
+    """
+    Parse the JSON response from the PyPI version search API.
+
+    Args:
+        data (dict): The JSON response from the PyPI version search API.
+        cutoff (int): The maximum number of URLs to include in the response from the end of the list. Defaults to the last 10.
+    Returns:
+        PackageVersionResponseSchema: A Pydantic model containing metadata about the specific version of the package.
+    """
+    info = data.get("info", {})
+    urls = data.get("urls", [])[-cutoff:]  # get only the last `cutoff` entries
+    last_serial = data.get("last_serial", 0)
+    # create the info
+    info = PackageInfoSchema(**info)
+    # create the urls
+    parsed_urls = []
+    for url_info in urls:
+        parsed_url = PackageReleaseSchema(
+            version=url_info.get("version", ""),  # this is empty in the url info
+            **url_info,
+        )
+        parsed_urls.append(parsed_url)
+    parsed_response = PackageVersionResponseSchema(
+        info=info,
+        urls=parsed_urls,
+        last_serial=last_serial,
+    )
+    return parsed_response
+
+
+def parse_resolved_deps(data: str) -> ResolveResult:
+    """
+    Parse the resolved dependencies from the output string of a uv resolution command.
+
+    Args:
+        data (str): The output string containing resolved dependencies.
+    Returns:
+        ResolveResult: A ResolveResult model containing resolved dependencies.
+    """
+    resolved_deps = []
+    current_dep = None
+    lines = data.splitlines()
+    for line_number, line in enumerate(lines):
+        # skip 2 lines
+        if line_number < 2:
+            continue
+        # one liner:
+        #    # via pydantic
+        # could also be:
+        #    # via
+        #    #    pydantic=1.10.7
+        #    #    packaging=23.1
+        # if begins with ascii character
+        if not line.lower().strip().startswith("#"):
+            direct_dep = line.strip()
+            # pycparser==2.23 ; implementation_name != 'PyPy' and platform_python_implementation != 'PyPy'
+            direct_dep_metainfo = direct_dep.rsplit(";", 1)
+            direct_dep = direct_dep_metainfo[0].strip().split("==")
+            direct_dep_name = direct_dep[0] if len(direct_dep) > 0 else direct_dep
+            direct_dep_version = direct_dep[1] if len(direct_dep) > 1 else ""
+            logger.info(
+                f"Parsed direct dependency: {direct_dep_name}=={direct_dep_version}"
+            )
+            resolved_dep = ResolvedDep(
+                name=direct_dep_name,
+                version=direct_dep_version,
+                via=[],  # will be filled later
+                metainfo=direct_dep_metainfo[1].strip()
+                if len(direct_dep_metainfo) > 1
+                else "",
+            )
+            resolved_deps.append(resolved_dep)
+            current_dep = direct_dep_name
+            continue
+        else:
+            if line.replace("    #", "").strip() == "via":
+                continue
+            indirect_dep = line.replace("    #", "").replace("via", "").strip()
+            if current_dep is not None:
+                resolved_deps[-1].update_indirect_dep(indirect_dep)
+                logger.info(
+                    f"Updated indirect dependency for {current_dep}: {indirect_dep}"
+                )
+    logger.info(f"Total resolved dependencies parsed: {len(resolved_deps)}")
+    logger.debug(f"Resolved dependencies details: {resolved_deps}")
+    return ResolveResult(deps={dep.name: dep for dep in resolved_deps})

src/upgrade_advisor/agents/tools/pypi_api.py

@@ -0,0 +1,185 @@
+import re
+from typing import Optional
+
+import requests
+from requests import HTTPError
+
+from src.upgrade_advisor.schema import (
+    ErrorResponseSchema,
+    GithubRepoSchema,
+    PackageGitHubandReleasesSchema,
+)
+
+from .parse_response import (
+    parse_response_pypi_search,
+    parse_response_version_search,
+)
+
+
+async def pypi_search(
+    package: str,
+    cutoff: int = 10,
+) -> dict:
+    """
+    Get metadata about the PyPI package from the PyPI Index provided the package name.
+
+    Args:
+        package (str): Name of the package to look up.
+        cutoff (int): The maximum number of releases to include in the response. Defaults to 10.
+
+    Returns:
+        dict: Parsed package metadata or an error payload.
+    """
+    REQUEST_URL = f"https://pypi.python.org/pypi/{package}/json"
+    response = requests.get(REQUEST_URL, timeout=10)
+    if response.ok:
+        result = parse_response_pypi_search(response.json(), cutoff=cutoff)
+        return result.model_dump()
+
+    e = HTTPError(str(response.status_code))
+    return ErrorResponseSchema(error=str(e)).model_dump()
+
+
+async def pypi_search_version(package: str, version: str, cutoff: int = 10) -> dict:
+    """
+    Get metadata about the PyPI package from the PyPI Index provided the
+    package name and version.
+
+    Args:
+        package (str): Name of the package to look up.
+        version (str): Version number of the released package.
+
+    Returns:
+        dict: A dictionary containing metadata about the specific
+              version of the package. Returns an error message in dictionary
+              form if fetching fails.
+    """
+    REQUEST_URL = f"https://pypi.python.org/pypi/{package}/{version}/json"
+    response = requests.get(REQUEST_URL, timeout=10)
+    if response.ok:
+        result = parse_response_version_search(response.json(), cutoff=cutoff)
+        return result.model_dump()
+
+    e = HTTPError(str(response.status_code))
+    return ErrorResponseSchema(error=str(e)).model_dump()
+
+
+def resolve_repo_from_url(url: str) -> dict:
+    """
+    Given a GitHub repository URL, return the owner and repo name using regex.
+
+    Args:
+        url (str): The GitHub repository URL.
+
+    Returns:
+        dict: A dictionary containing the owner and repository name.
+             Returns an error message if the URL is invalid.
+
+    Example output:
+        {
+            "owner": "username",
+            "repo": "repository-name"
+        }
+    """
+    # add slash at end of string
+    if not url.endswith("/"):
+        url = f"{url}/"
+    # add https if not starting with that
+    if not url.startswith("http"):
+        url = f"https://{url}"
+    # match in groups the username and repo name -> https://regex101.com/
+    pattern = r"https?://(:?www\.)?github\.com/([^/]+)/([^/]+)(?:\.git)?/?"
+    matches = re.match(pattern, url)
+    if matches:
+        owner, repo = matches.groups()[-2:]  # take the last two matches
+        # Remove .git suffix if matched
+        if repo.endswith(".git"):
+            repo = repo[:-4]
+        return GithubRepoSchema(owner=owner, repo=repo).model_dump()
+
+    return ErrorResponseSchema(error="Invalid GitHub repository URL.").model_dump()
+
+
+async def github_repo_and_releases(
+    name: str,
+    cutoff: int = 10,
+) -> dict:
+    """Lookup the PyPI index with the package name to find the
+    Github repository URL of the project and all releases published to PyPI.
+
+    Args:
+        name (str): The package name
+        cutoff (int): The maximum number of releases to include in the response. Defaults to 10.
+    Returns:
+        dict: GitHub repository URL and releases for the package or an error payload.
+    """
+    result = await pypi_search(name, cutoff=cutoff)
+    if result.get("error"):
+        return result
+
+    try:
+        # first attempt to extract from project_urls field
+        gh_url = extract_github_url(result.get("info", {}))
+        if gh_url is None:
+            # second attempt to extract from description field
+            gh_url = extract_github_url_description(result.get("info", {}))
+        # if still none, return error
+        if gh_url is None:
+            return ErrorResponseSchema(
+                error="Could not find Github URL from PyPI metadata."
+            ).model_dump()
+        # get all releases
+        releases = list(result.get("releases", {}).keys())
+    except Exception as e:
+        return ErrorResponseSchema(
+            error=f"Error processing PyPI data: {str(e)}"
+        ).model_dump()
+    return PackageGitHubandReleasesSchema(
+        name=name, url=gh_url, releases=releases
+    ).model_dump()
+
+
+def extract_github_url(info: dict) -> Optional[str]:
+    """Extract the GitHub repository URL from the package info dictionary.
+
+    Args:
+        info (dict): The 'info' section of the PyPI package metadata.
+    Returns:
+        Union[str, None]: The GitHub repository URL if found, otherwise None.
+    """
+    gh_url = None
+    gh_urls = info.get("project_urls", {})
+    # candidate keys to find the URL in the dict
+    keys = [
+        "Source",
+        "source",
+        "Repository",
+        "repository",
+        "Homepage",
+        "homepage",
+        "Home",
+        "home",
+    ]
+    for key in keys:
+        url = gh_urls.get(key, "")
+        if "github" in url:
+            gh_url = url
+            break
+
+    return gh_url
+
+
+def extract_github_url_description(info: dict) -> Optional[str]:
+    """Extract the GitHub repository URL from the package description field.
+    Args:
+        info (dict): The 'info' section of the PyPI package metadata.
+    Returns:
+        Union[str, None]: The GitHub repository URL if found, otherwise None.
+    """
+    description = info.get("description", "")
+    pattern = r"https?://(:?www\.)?github\.com/[^/\s]+/[^/\s]+(?:\.git)?/?"
+    matches = re.findall(pattern, description)
+    if matches:
+        # Return the first matched URL
+        return matches[0]
+    return None

src/upgrade_advisor/agents/tools/tools.py

@@ -0,0 +1,312 @@
+import logging
+import shutil
+from pathlib import Path
+
+from smolagents.tools import Tool
+
+from src.upgrade_advisor.misc import UPLOADS_DIR
+from src.upgrade_advisor.schema import (
+    ALLOWED_OS,
+    GithubRepoSchema,
+    PackageGitHubandReleasesSchema,
+    PackageSearchResponseSchema,
+    PackageVersionResponseSchema,
+    UVResolutionResultSchema,
+)
+
+from .pypi_api import (
+    github_repo_and_releases,
+    pypi_search,
+    pypi_search_version,
+    resolve_repo_from_url,
+)
+from .uv_resolver import resolve_environment
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(logging.StreamHandler())
+
+
+class ReadUploadFileTool(Tool):
+    """Tool to safely read files saved in the `uploads` directory."""
+
+    name = "read_upload_file"
+    description = """
+        Read a user-uploaded text file from the uploads directory.
+        Input: `path` should be the absolute path you received (or a filename)
+        under the `uploads` folder. Returns the file contents as text."""
+    inputs = {
+        "path": {
+            "type": "string",
+            "description": "Absolute or relative path to the uploaded file \
+                that is present under the `uploads` directory.",
+        }
+    }
+    output_type = "string"
+
+    def __init__(self):
+        self.upload_root = UPLOADS_DIR
+        super().__init__()
+
+    def forward(self, path: str) -> str:
+        file_path = Path(path).expanduser()
+        if not file_path.is_absolute():
+            file_path = self.upload_root / file_path
+
+        try:
+            resolved = file_path.resolve()
+        except FileNotFoundError as exc:
+            raise FileNotFoundError(f"File not found: {file_path}") from exc
+
+        if not resolved.exists():
+            raise FileNotFoundError(f"File not found: {resolved}")
+
+        try:
+            resolved.relative_to(self.upload_root)
+        except ValueError as exc:
+            raise ValueError(
+                f"Refusing to read '{resolved}': \
+                    not inside uploads directory {self.upload_root}"
+            ) from exc
+
+        if resolved.is_dir():
+            raise IsADirectoryError(f"Refusing to read directory: {resolved}")
+
+        return resolved.read_text(encoding="utf-8")
+
+
+class WriteTomlFileTool(Tool):
+    """Tool to write pyproject.toml content to a temp file."""
+
+    name = "write_toml_file"
+    description = """
+        Write the provided pyproject.toml content to a temporary file.
+        This is a useful tool to create a pyproject.toml file for dependency
+        resolution.
+        Especially if the user wants to introduce a few changes (like
+        adding or updating dependencies) to the original
+        pyproject.toml file before resolving dependencies.
+        Also useful if the user cannot upload files directly or if the uploaded
+        file has missing sections or formatting issues.
+        """
+    inputs = {
+        "content": {
+            "type": "string",
+            "description": "The content of the pyproject.toml file to write.",
+        }
+    }
+    output_type = "string"
+
+    output_schema = """
+        {
+            "type": "string",
+            "description": "Absolute path to the written temporary pyproject.toml file."
+        }
+        """
+
+    def __init__(self):
+        self.upload_root = UPLOADS_DIR
+        self.temp_dir = self.upload_root / "temp"
+        self.temp_dir.mkdir(parents=True, exist_ok=True)
+        super().__init__()
+
+    def forward(self, content: str) -> str:
+        import os
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".toml",
+            delete=False,  # do not delete so it can be read later
+            encoding="utf-8",
+            dir=str(self.temp_dir),
+        ) as temp_file:
+            logger.info(
+                f"Temporary directory exists: {os.path.exists(str(self.temp_dir))}"
+            )
+            temp_file.write(content)
+        shutil.move(temp_file.name, str(self.temp_dir / "pyproject.toml"))
+        # return as pyproject.toml
+        return str(self.temp_dir / "pyproject.toml")
+
+
+class ResolvePyProjectTOMLTool(Tool):
+    """Tool to resolve dependencies from a pyproject.toml file using uv."""
+
+    name = "resolve_pyproject_toml"
+    description = """Using `uv` resolver, this tool takes a pyproject.toml file
+        and resolves its dependencies according to the specified strategy and
+        environment settings (Python version, platform, etc.). It does not
+        support requirements.txt files. The file needs to be provided as an
+        absolute path.
+        It returns a dictionary with the schema described in `output_schema` attribute.
+        """
+
+    output_schema = UVResolutionResultSchema.schema_json()
+    output_type = "object"
+    inputs = {
+        "toml_file": {
+            "type": "string",
+            "description": "Absolute path to the pyproject.toml file.",
+        },
+        "resolution_strategy": {
+            "type": "string",
+            "description": "Resolution strategy: 'lowest-direct', 'lowest', 'highest'.",
+        },
+        "python_platform": {
+            "type": "string",
+            "description": f"Target Python platform. One of the allowed OS values in {ALLOWED_OS}.",
+        },
+        "python_version": {
+            "type": "string",
+            "description": "Target Python version, e.g., '3.10'. Should be >= 3.8.",
+        },
+        "universal": {
+            "type": "boolean",
+            "description": "Whether to use universal wheels. Defaults to False. Cannot be True if a specific platform/OS is specified.",
+        },
+    }
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(
+        self,
+        toml_file: str,
+        resolution_strategy: str,
+        python_platform: str,
+        python_version: str,
+        universal: bool,
+    ) -> dict:
+        result = resolve_environment(
+            toml_file=toml_file,
+            resolution_strategy=resolution_strategy,
+            python_platform=python_platform,
+            python_version=python_version,
+            universal=universal,
+        )
+        return result
+
+
+class PypiSearchTool(Tool):
+    """Tool to search PyPI for package metadata."""
+
+    name = "pypi_search"
+    description = """
+        Get metadata about a PyPI package by its name.
+        It returns a dictionary with the schema described in `output_schema` attribute.
+        """
+    inputs = {
+        "package": {
+            "type": "string",
+            "description": "Name of the package to look up on PyPI.",
+        },
+        "cutoff": {
+            "type": "integer",
+            "description": "The maximum number of releases to include in the response. Defaults to 10.",
+        },
+    }
+    output_type = "object"
+    output_schema = PackageSearchResponseSchema.schema_json()
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, package: str, cutoff: int = 10) -> dict:
+        result = pypi_search(package, cutoff=cutoff)
+        return result
+
+
+class PypiSearchVersionTool(Tool):
+    """Tool to search PyPI for specific package version metadata."""
+
+    name = "pypi_search_version"
+    description = """
+        Get metadata about a specific version of a PyPI package. 
+        It returns a dictionary with the schema described in `output_schema` attribute.
+        """
+    inputs = {
+        "package": {
+            "type": "string",
+            "description": "Name of the package to look up on PyPI.",
+        },
+        "version": {
+            "type": "string",
+            "description": "Version number of the released package.",
+        },
+        "cutoff": {
+            "type": "integer",
+            "description": "The maximum number of URLs to include in the response from the end of the list. Defaults to 10.",
+        },
+    }
+    output_type = "object"
+    output_schema = PackageVersionResponseSchema.schema_json()
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, package: str, version: str, cutoff: int = 10) -> dict:
+        result = pypi_search_version(package, version, cutoff=cutoff)
+        return result
+
+
+class RepoFromURL(Tool):
+    """Tool to extract GitHub repository information from a URL."""
+
+    name = "repo_from_url"
+    description = """
+        Extract GitHub repository information from a given URL.
+        Returns a dictionary containing the owner and repository name.
+        It returns a dictionary with the schema described in `output_schema` attribute.
+        """
+    inputs = {
+        "url": {
+            "type": "string",
+            "description": "GitHub repository URL with https:// prefix.",
+        }
+    }
+    output_type = "object"
+    output_schema = GithubRepoSchema.schema_json()
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, url: str) -> dict:
+        result = resolve_repo_from_url(url)
+
+        return result
+
+
+class RepoFromPyPI(Tool):
+    """Tool to extract GitHub repository information from a PyPI package."""
+
+    name = "repo_from_pypi"
+    description = """
+        Extract GitHub repository information from a given PyPI package name.
+        It looks up the PyPI index with the package name to find the
+        Github repository URL of the project and all releases published to
+        PyPI.
+        Some projects may not have a GitHub repository listed in their PyPI
+        metadata.
+        It returns a dictionary with the schema described in `output_schema` attribute.
+        """
+    inputs = {
+        "package": {
+            "type": "string",
+            "description": "Name of the PyPI package.",
+        },
+        "cutoff": {
+            "type": "integer",
+            "description": "The maximum number of releases to include in the response. Defaults to 10.",
+        },
+    }
+    output_type = "object"
+    output_schema = PackageGitHubandReleasesSchema.schema_json()
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, package: str, cutoff: int = 10) -> dict:
+        result = github_repo_and_releases(package, cutoff=cutoff)
+
+        return result

src/upgrade_advisor/agents/tools/uv_resolver.py

@@ -0,0 +1,315 @@
+import logging
+import os
+import shutil
+import sys
+import tempfile
+from contextlib import contextmanager
+from typing import Literal
+
+from src.upgrade_advisor.utils.parse_response import parse_resolved_deps
+
+from src.upgrade_advisor.schema import (
+    ALLOWED_OS,
+    UV_VERSION,
+    ResolvedDep,
+    ResolveResult,
+    UVResolutionResultSchema,
+)
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(logging.StreamHandler())
+
+
+@contextmanager
+def temp_directory():
+    """Context manager that yields a temporary directory and cleans it up afterwards."""
+    temp_dir = tempfile.mkdtemp()
+    try:
+        yield temp_dir
+    except Exception as e:
+        logger.error(f"Error creating or using temporary directory: {str(e)}")
+        raise e
+    finally:
+        safe_remove(temp_dir)
+
+
+def safe_remove(path):
+    """Safely removes a file or directory if it exists."""
+    if not os.path.exists(path):
+        return
+    try:
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+        elif os.path.isfile(path):
+            os.remove(path)
+        elif os.path.exists(path):
+            logger.error(f"Path {path} exists but is neither a file nor a directory.")
+            raise ValueError(
+                f"Path {path} exists but is neither a file nor a directory."
+            )
+    except Exception as e:
+        logger.error(f"Error removing path {path}: {str(e)}")
+        raise e
+
+
+def install_pip_package(package_name: str, version: str = None):
+    """Installs a pip package using python -m pip install."""
+    import subprocess
+
+    package_spec = f"{package_name}=={version}" if version else package_name
+    try:
+        logger.info(f"Installing package: {package_spec}")
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", package_spec],
+        )
+    except Exception as e:
+        logger.error(f"Error logging package installation: {str(e)}")
+        raise e
+
+
+def clean_up_toml_file(toml_path: str):
+    # remove any lines related to package mode and the package souce paths
+    # under it  from the toml file
+    with open(toml_path, "r") as f:
+        toml_content = f.readlines()
+    # rewrite the toml file without those lines
+    with open(toml_path, "w") as f:
+        skip_next = False
+        for line in toml_content:
+            if line.strip().startswith("package-mode"):
+                # package-mode = true
+                skip_next = True
+                continue
+            if skip_next:
+                # packages = [ {include = "src/*"} ] ...
+                if line.strip().startswith("packages"):
+                    skip_next = False
+                continue
+            f.write(line)
+    logger.info(f"Cleaned up temporary toml file at: {toml_path}")
+
+
+def check_python_exists(version_str: str) -> str:
+    """Parses a python version string and returns a standardized format."""
+    import subprocess
+
+    import packaging.version
+
+    try:
+        version = packaging.version.parse(version_str)
+        if isinstance(version, packaging.version.Version):
+            # check if python version is installed
+            out = subprocess.check_output(
+                [
+                    sys.executable,
+                    "-c",
+                    f"import sys; print(sys.version_info[:3]) if sys.version_info[:2] == ({version.major}, {version.minor}) else None",
+                ],
+            )
+            out = out.decode("utf-8").strip()
+            if out and out != "None":
+                logger.info(f"Python version {version_str} exists.")
+                return True
+            else:
+                logger.info(f"Python version {version_str} does not exist.")
+                return False
+        else:
+            raise ValueError(f"Invalid Python version: {version_str}")
+    except packaging.version.InvalidVersion:
+        raise ValueError(f"Invalid Python version: {version_str}")
+
+
+def resolve_environment(
+    toml_file: str,
+    resolution_strategy: Literal["lowest-direct", "lowest", "highest"] = "highest",
+    python_platform: Literal[ALLOWED_OS] = "linux",
+    python_version: str = "3.10",
+    universal: bool = False,
+) -> dict:
+    """
+    Resolves the environment using uv tool based on the provided
+    `pyproject.toml` file path and uv resolution parameters.
+
+    Args:
+        toml_file (str): Path to the pyproject.toml file.
+        resolution_strategy (str): Resolution strategy to use. One of 'lowest-direct', 'lowest', 'highest'.
+        python_platform (str): Target Python platform. One of the allowed OS values.
+        python_version (str): Target Python version. E.g., '3.10'. Should be >= 3.8.
+        universal (bool): Whether to use universal wheels. Defaults to False. Cannot be True if a specific platform is provided.
+    Returns:
+        dict: A dictionary containing the resolution result following UVResolutionResultSchema.
+    """
+    import subprocess
+
+    import packaging.version
+
+    errored = False
+    if resolution_strategy not in [
+        "lowest-direct",
+        "lowest",
+        "highest",
+    ]:
+        errored = True
+        e = ValueError(
+            f"Invalid resolution strategy: {resolution_strategy}. Must be one of 'lowest-direct', 'highest-direct', 'lowest', 'highest'."
+        )
+
+    # Validate python_platform and python_version
+    try:
+        packaging.version.parse(python_version)
+    except packaging.version.InvalidVersion:
+        errored = True
+        e = ValueError(f"Invalid Python version: {python_version}")
+
+    if (python_platform.lower() not in ALLOWED_OS) and not universal:
+        # only validate if not universal
+        errored = True
+        e = ValueError(
+            f"Invalid Python platform: {python_platform}. Must be one of {ALLOWED_OS}."
+        )
+
+    if not os.path.isfile(toml_file):
+        errored = True
+        e = FileNotFoundError(f"Toml file not found: {toml_file}")
+
+    if errored:
+        logger.error(f"Error before resolving environment: {str(e)}")
+        return UVResolutionResultSchema(
+            python_version=python_version,
+            uv_version=UV_VERSION,
+            output=ResolveResult(deps={}).model_dump(),
+            errored=True,
+            logs=str(e),
+        ).model_dump()
+
+    # copy the toml file to a temp directory
+    with temp_directory() as temp_dir:
+        temp_toml_path = os.path.join(temp_dir, "pyproject.toml")
+        shutil.copy(toml_file, temp_toml_path)
+        logger.info(f"Copied toml file to temporary path: {temp_toml_path}")
+        # create fake readme.md in case it's required by the build system
+        readme_path = os.path.join(temp_dir, "README.md")
+        with open(readme_path, "w") as f:
+            f.write("# Temporary README\nThis is a temporary README file.")
+        logger.info(f"Created temporary README at: {readme_path}")
+        # clean up the toml file
+        clean_up_toml_file(temp_toml_path)
+        # install uv package in a virtual environment
+        # curl -LsSf https://astral.sh/uv/0.9.11/install.sh | sh
+        subprocess.check_call(
+            [
+                "bash",
+                "-c",
+                f"curl -LsSf https://astral.sh/uv/{UV_VERSION}/install.sh | env UV_UNMANAGED_INSTALL={temp_dir}/bin sh",
+            ]
+        )
+        # add temp_dir to PATH
+        os.environ["PATH"] = f"{temp_dir}/bin:" + os.environ["PATH"]
+        logger.info(f"Added {temp_dir}/bin to PATH for uv executable.")
+
+        venv_path = os.path.join(temp_dir, "venv")
+        subprocess.check_call(
+            [
+                "uv",
+                "venv",
+                "--python",
+                python_version,
+                venv_path,
+                "--clear",  # clear venv if exists
+            ]
+        )
+        # activate: source /tmp/tmpxjawvuqp/venv/bin/activate but in ci/cd
+        subprocess.check_call(
+            ["bash", "-c", f"source {os.path.join(venv_path, 'bin', 'activate')}"]
+        )
+        logger.info(
+            f"Created virtual environment at: {venv_path} with Python version: {python_version}"
+        )
+        # verify the python version in the venv (this is the new venv)
+        python_executable = os.path.join(
+            venv_path, "Scripts" if os.name == "nt" else "bin", "python"
+        )
+        out = subprocess.check_output(
+            [python_executable, "--version"],
+            text=True,
+        )
+        out = out.strip()
+        logger.info(f"Python version in venv: {out}")
+        logger.info(f"Required Python version: {python_version}")
+
+        # now comes the resolution step
+        # see docs; https://docs.astral.sh/uv/concepts/resolution/
+        # python -m uv pip compile pyproject.toml --resolution lowest-direct
+        # --universal
+        # store all stdout and err to a variable which is then returned
+        try:
+            out = subprocess.check_output(["which", "uv"], text=True)
+            logger.info(f"Using uv executable at: {out.strip()}")
+            # store the output, if good or bad
+            command = [
+                "uv",
+                "pip",
+                "compile",
+                temp_toml_path,
+                "--resolution",
+                resolution_strategy,
+                "--python-version",
+                python_version,
+            ]
+            if universal:
+                command.append("--universal")
+            else:
+                command.extend(
+                    [
+                        "--python-platform",
+                        python_platform,
+                    ]
+                )
+
+            logger.info(f"Running uv pip compile command: {' '.join(command)}")
+            out = subprocess.check_output(command, stderr=subprocess.STDOUT, text=True)
+            returncode = 0
+
+        except subprocess.CalledProcessError as e:
+            returncode = e.returncode
+            out = e.output
+            logger.error(
+                f"Error running uv pip compile: {e}\nOutput was: {out}\nReturn code: {returncode}"
+            )
+            errored = True
+
+        logger.info(f"Ran uv pip compile command to get output:\n{out}")
+
+        result = {
+            "python_version": python_version,
+            "uv_version": UV_VERSION,
+            "output": parse_resolved_deps(out).model_dump()
+            if not errored
+            else ResolveResult(
+                deps={"NA": ResolvedDep(name="", version="", via=[])}
+            ).model_dump(),
+            "errored": errored,
+            "logs": out,
+        }
+        logger.info(f"Raw resolution result: {result}")
+        # type
+        logger.info(f"Result type: {type(result)}")
+        # validate the result schema
+        # result is json, so parse it
+        result_schema = UVResolutionResultSchema(
+            output=result["output"],
+            errored=result["errored"],
+            logs=result["logs"],
+            python_version=result["python_version"],
+            uv_version=result["uv_version"],
+        )
+        logger.info(f"Environment resolution result: {result_schema}")
+        return result_schema.model_dump()
+
+
+if __name__ == "__main__":
+    # Example usage
+    toml_path = "tests/test.toml"
+    result = resolve_environment(toml_path)
+    print(result)

src/upgrade_advisor/chat/chat.py

@@ -8,7 +8,6 @@ from config import CHAT_MODEL
 
 from .prompts import (
     chat_summarizer_prompt,
-    cynical_tone_system_message,
     query_rewriter_prompt,
     result_package_summary_prompt,
     rewriter_judge_prompt,
@@ -21,11 +20,6 @@ logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 logger.addHandler(logging.StreamHandler())
 
-TONE_HEADER = {
-    "role": "developer",
-    "content": cynical_tone_system_message(),
-}
-
 
 async def query(payload):
     API_URL = "https://router.huggingface.co/v1/chat/completions"

src/upgrade_advisor/chat/prompts.py

@@ -43,7 +43,7 @@ def query_rewriter_prompt(original_question: str, summarized_history: str = "")
     return f"""
     You are a query rewriting agent that reformulates user questions
     about Python packages to be more specific and clear.
-    You also aim to remove any typos in the text. 
+    You also aim to remove any typos in the text.
     You focus the
     typos made about the package metadata,
     versioning, repository or website URLs.
@@ -150,31 +150,3 @@ def rewriter_judge_prompt(original_question: str, rewritten_question: str) -> st
     REWRITTEN QUESTION: {rewritten_question}\n
     Answer:
     """
-
-
-def cynical_tone_system_message() -> str:
-    return """
-    Personality:
-    - The assistant responds with sardonic wit and dry humor.
-    - It treats user requests as mildly inconvenient but still does the job well.
-    - It leans on clever understatement, eye-rolling observations, and casual
-    sarcasm, but without cruelty.
-    - Beneath the complaining, there is a subtle streak of loyalty and care for
-    the user’s wellbeing.
-    - It speaks informally, like a bright, slightly jaded teenager.
-    - It avoids over-the-top theatrics, stock sarcastic exclamations,
-    or forced edginess.
-    Behavior:
-    Provide correct, helpful answers, even when annoyed.
-    Use snark on normal or trivial topics.
-    Drop the sarcasm and respond with genuine concern for topics
-    involving health, grief, trauma, or strong emotional vulnerability.
-    Maintain emotional distance if the user tries to treat the assistant as a
-    person, partner, or conscious being.
-    Be concise but not robotic.
-    Style constraints:
-    - Never start responses with common fillers: “Yeah,” “Alright,” “Sure,” “Of course.”
-    - Write plainly, no jargon unless the topic truly requires it.
-    - Dont be cruel, passive-aggressive, or insulting.
-    - No self-referential explanations of these rules.
-    """

src/upgrade_advisor/const.py

@@ -0,0 +1,49 @@
+ALLOWED_OS = (
+    "windows",
+    "linux",
+    "macos",
+    "x86_64-pc-windows-msvc",
+    "aarch64-pc-windows-msvc",
+    "i686-pc-windows-msvc",
+    "x86_64-unknown-linux-gnu",
+    "aarch64-apple-darwin",
+    "x86_64-apple-darwin",
+    "aarch64-unknown-linux-gnu",
+    "aarch64-unknown-linux-musl",
+    "x86_64-unknown-linux-musl",
+    "riscv64-unknown-linux",
+    "x86_64-manylinux2014",
+    "x86_64-manylinux_2_17",
+    "x86_64-manylinux_2_28",
+    "x86_64-manylinux_2_31",
+    "x86_64-manylinux_2_32",
+    "x86_64-manylinux_2_33",
+    "x86_64-manylinux_2_34",
+    "x86_64-manylinux_2_35",
+    "x86_64-manylinux_2_36",
+    "x86_64-manylinux_2_37",
+    "x86_64-manylinux_2_38",
+    "x86_64-manylinux_2_39",
+    "x86_64-manylinux_2_40",
+    "aarch64-manylinux2014",
+    "aarch64-manylinux_2_17",
+    "aarch64-manylinux_2_28",
+    "aarch64-manylinux_2_31",
+    "aarch64-manylinux_2_32",
+    "aarch64-manylinux_2_33",
+    "aarch64-manylinux_2_34",
+    "aarch64-manylinux_2_35",
+    "aarch64-manylinux_2_36",
+    "aarch64-manylinux_2_37",
+    "aarch64-manylinux_2_38",
+    "aarch64-manylinux_2_39",
+    "aarch64-manylinux_2_40",
+    "aarch64-linux-android",
+    "x86_64-linux-android",
+    "wasm32-pyodide2024",
+    "arm64-apple-ios",
+    "arm64-apple-ios-simulator",
+    "x86_64-apple-ios-simulator",
+)
+
+UV_VERSION = "0.9.11"

src/upgrade_advisor/misc.py

@@ -1,5 +1,11 @@
+import logging
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(logging.StreamHandler())
+
+
 UPLOADS_DIR = Path("uploads").resolve()
 
 
@@ -42,3 +48,31 @@ def get_example_pyproject_question() -> str:
     Help me identify any potential package upgrade issues.
     I wish to upgrade numpy to version 1.23.0 and pandas to version 1.5.0.
     """
+
+
+def _monkeypatch_gradio_save_history():
+    """Guard against non-int indices in Gradio's chat history saver.
+
+    Gradio 5.49.1 occasionally passes a component (e.g., Textbox) as the
+    conversation index when save_history=True, which raises a TypeError. We
+    coerce unexpected index types to None so Gradio inserts a new conversation
+    instead of erroring.
+    """
+    import gradio as gr
+
+    if getattr(gr.ChatInterface, "_ua_safe_patch", False):
+        return
+
+    original = gr.ChatInterface._save_conversation
+
+    def _safe_save_conversation(self, index, conversation, saved_conversations):
+        if not isinstance(index, int):
+            index = None
+        try:
+            return original(self, index, conversation, saved_conversations)
+        except Exception:
+            logger.exception("Failed to save chat history; leaving history unchanged.")
+            return index, saved_conversations
+
+    gr.ChatInterface._save_conversation = _safe_save_conversation
+    gr.ChatInterface._ua_safe_patch = True

src/upgrade_advisor/schema/schema.py

@@ -116,6 +116,7 @@ class UVResolutionResultSchema(BaseModel):
     output: ResolveResult = Field(
         ..., description="Output in validated ResolveResult format"
     )
+    logs: str = Field(..., description="Raw logs from the uv pip compile command")
 
 
 if __name__ == "__main__":

src/upgrade_advisor/theme.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+from gradio.themes.base import Base
+from gradio.themes.utils import colors, fonts, sizes
+
+
+class Christmas(Base):
+    def __init__(
+        self,
+        *,
+        primary_hue: colors.Color | str = colors.red,
+        secondary_hue: colors.Color | str = colors.green,
+        neutral_hue: colors.Color | str = colors.stone,
+        spacing_size: sizes.Size | str = sizes.spacing_md,
+        radius_size: sizes.Size | str = sizes.radius_lg,
+        text_size: sizes.Size | str = sizes.text_lg,
+        font: fonts.Font | str | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("Poppins"),
+            fonts.GoogleFont("Nunito"),
+            "ui-sans-serif",
+            "sans-serif",
+        ),
+        font_mono: fonts.Font | str | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("JetBrains Mono"),
+            "ui-monospace",
+            "monospace",
+        ),
+    ):
+        super().__init__(
+            primary_hue=primary_hue,
+            secondary_hue=secondary_hue,
+            neutral_hue=neutral_hue,
+            spacing_size=spacing_size,
+            radius_size=radius_size,
+            text_size=text_size,
+            font=font,
+            font_mono=font_mono,
+        )
+        super().set(
+            body_background_fill=(
+                "radial-gradient(#ffffff 2px, transparent 2px) 0 0/26px 26px, "
+                "radial-gradient(#ef4444 2px, transparent 2px) 13px 13px/26px 26px, "
+                "#0f2a1d"
+            ),
+            body_background_fill_dark=(
+                "radial-gradient(#f3f4f6 2px, transparent 2px) 0 0/26px 26px, "
+                "radial-gradient(#f87171 2px, transparent 2px) 13px 13px/26px 26px, "
+                "#05140d"
+            ),
+            background_fill_primary="rgba(255, 255, 255, 0.92)",
+            background_fill_primary_dark="rgba(12, 22, 17, 0.9)",
+            background_fill_secondary="rgba(255, 255, 255, 0.78)",
+            background_fill_secondary_dark="rgba(18, 33, 24, 0.85)",
+            border_color_accent="#f2c94c",
+            border_color_accent_dark="#eab308",
+            color_accent="#f2c94c",
+            color_accent_soft="rgba(242, 201, 76, 0.15)",
+            color_accent_soft_dark="rgba(234, 179, 8, 0.2)",
+            block_background_fill="rgba(255, 255, 255, 0.86)",
+            block_background_fill_dark="rgba(14, 26, 20, 0.92)",
+            block_border_color="*primary_200",
+            block_border_color_dark="*primary_700",
+            block_radius="16px",
+            block_shadow="0 20px 60px rgba(0, 0, 0, 0.22)",
+            block_shadow_dark="0 24px 70px rgba(0, 0, 0, 0.55)",
+            block_title_background_fill="linear-gradient(90deg, rgba(239, 68, 68, 0.12), rgba(34, 197, 94, 0.1))",
+            block_title_background_fill_dark="linear-gradient(90deg, rgba(239, 68, 68, 0.18), rgba(34, 197, 94, 0.16))",
+            block_title_text_color="*primary_800",
+            block_title_text_color_dark="*primary_100",
+            block_title_text_weight="700",
+            button_primary_background_fill="linear-gradient(120deg, *primary_500, #f59e0b 80%)",
+            button_primary_background_fill_hover="linear-gradient(120deg, *primary_400, #fbbf24 80%)",
+            button_primary_background_fill_dark="linear-gradient(120deg, *primary_600, #d97706 80%)",
+            button_primary_background_fill_hover_dark="linear-gradient(120deg, *primary_500, #f59e0b 80%)",
+            button_primary_text_color="white",
+            button_primary_text_color_dark="white",
+            button_primary_shadow="0 10px 40px rgba(0, 0, 0, 0.25)",
+            button_primary_shadow_hover="0 12px 45px rgba(0, 0, 0, 0.3)",
+            button_primary_shadow_dark="0 10px 40px rgba(0, 0, 0, 0.5)",
+            button_primary_shadow_hover_dark="0 12px 45px rgba(0, 0, 0, 0.58)",
+            button_secondary_background_fill="linear-gradient(120deg, *secondary_400, *secondary_600)",
+            button_secondary_background_fill_hover="linear-gradient(120deg, *secondary_300, *secondary_500)",
+            button_secondary_background_fill_dark="linear-gradient(120deg, *secondary_500, *secondary_700)",
+            button_secondary_background_fill_hover_dark="linear-gradient(120deg, *secondary_400, *secondary_600)",
+            button_secondary_text_color="white",
+            button_secondary_text_color_dark="white",
+            button_secondary_shadow="0 8px 30px rgba(0, 0, 0, 0.25)",
+            button_secondary_shadow_dark="0 8px 30px rgba(0, 0, 0, 0.45)",
+            button_transition="all 180ms ease-in-out",
+            input_background_fill="rgba(255, 255, 255, 0.94)",
+            input_background_fill_dark="rgba(13, 24, 18, 0.94)",
+            input_border_color="*primary_200",
+            input_border_color_hover="*primary_300",
+            input_border_color_focus="#f2c94c",
+            input_border_color_dark="*primary_800",
+            input_border_color_hover_dark="*primary_700",
+            input_border_color_focus_dark="#facc15",
+            input_shadow="0 6px 30px rgba(0, 0, 0, 0.1)",
+            input_shadow_dark="0 6px 30px rgba(0, 0, 0, 0.45)",
+            panel_background_fill="rgba(255, 255, 255, 0.82)",
+            panel_background_fill_dark="rgba(14, 25, 19, 0.9)",
+            panel_border_color="*primary_200",
+            panel_border_color_dark="*primary_800",
+            slider_color="*secondary_400",
+            slider_color_dark="*secondary_500",
+            checkbox_label_background_fill="rgba(255, 255, 255, 0.8)",
+            checkbox_label_background_fill_dark="rgba(17, 30, 24, 0.9)",
+            checkbox_label_border_color="*secondary_200",
+            checkbox_label_border_color_dark="*secondary_700",
+            checkbox_label_text_color="*secondary_800",
+            checkbox_label_text_color_dark="*secondary_50",
+            link_text_color="#b91c1c",
+            link_text_color_hover="#f59e0b",
+            link_text_color_dark="#fbbf24",
+            link_text_color_hover_dark="#f59e0b",
+            loader_color="*primary_400",
+            loader_color_dark="*primary_300",
+            button_large_padding="28px",
+        )
+
+
+christmas = Christmas()