tooluniverse 1.0.10__tar.gz → 1.0.11__tar.gz

{tooluniverse-1.0.10 → tooluniverse-1.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tooluniverse
-Version: 1.0.10
+Version: 1.0.11
 Summary: A comprehensive collection of scientific tools for Agentic AI, offering integration with the ToolUniverse SDK and MCP Server to support advanced scientific workflows.
 Author-email: Shanghua Gao <shanghuagao@gmail.com>
 Project-URL: Homepage, https://github.com/mims-harvard/ToolUniverse
@@ -29,7 +29,7 @@ Requires-Dist: sentence-transformers>=5.1.0
 Requires-Dist: fitz>=0.0.1.dev2
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: admet-ai>=1.2.0
-Requires-Dist: setuptools>=70.0.0
+Requires-Dist: setuptools<81.0.0,>=70.0.0
 Requires-Dist: pdfplumber>=0.11.0
 Requires-Dist: playwright>=1.55.0
 Requires-Dist: faiss-cpu>=1.12.0
@@ -39,6 +39,7 @@ Requires-Dist: aiohttp
 Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: markitdown[all]>=0.1.0
 Requires-Dist: psutil>=5.9.0
+Requires-Dist: ddgs>=9.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"

{tooluniverse-1.0.10 → tooluniverse-1.0.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tooluniverse"
-version = "1.0.10"
+version = "1.0.11"
 description = "A comprehensive collection of scientific tools for Agentic AI, offering integration with the ToolUniverse SDK and MCP Server to support advanced scientific workflows."
 authors = [
     { name = "Shanghua Gao", email = "shanghuagao@gmail.com" }
@@ -32,7 +32,7 @@ dependencies = [
     "fitz>=0.0.1.dev2",
     "pandas>=2.2.3",
     "admet-ai>=1.2.0",
-    "setuptools>=70.0.0",  # Fix pkg_resources deprecation warnings
+    "setuptools>=70.0.0,<81.0.0",  # Fix pkg_resources deprecation warnings
     "pdfplumber>=0.11.0",
     "playwright>=1.55.0",
     "faiss-cpu>=1.12.0",
@@ -41,7 +41,8 @@ dependencies = [
     "aiohttp",
     "beautifulsoup4>=4.12.0",
     "markitdown[all]>=0.1.0",
-    "psutil>=5.9.0"
+    "psutil>=5.9.0",
+    "ddgs>=9.0.0"
 ]
 requires-python = ">=3.10"
 readme = "README.md"

{tooluniverse-1.0.10 → tooluniverse-1.0.11}/src/tooluniverse/__init__.py

@@ -174,9 +174,26 @@ MCPAutoLoaderTool: Any
 ADMETAITool: Any
 AlphaFoldRESTTool: Any
 ComposeTool: Any
+PythonCodeExecutor: Any
+PythonScriptRunner: Any
 CellosaurusSearchTool: Any
 CellosaurusQueryConverterTool: Any
 CellosaurusGetCellLineInfoTool: Any
+# New database tools
+InterProRESTTool: Any
+NCBIBlastTool: Any
+CBioPortalRESTTool: Any
+RegulomeDBRESTTool: Any
+JASPARRESTTool: Any
+ReMapRESTTool: Any
+SCREENRESTTool: Any
+PRIDERESTTool: Any
+EMDBRESTTool: Any
+GtoPdbRESTTool: Any
+MPDRESTTool: Any
+WoRMSRESTTool: Any
+PaleobiologyRESTTool: Any
+OLSTool: Any
 if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
     # Import all tool classes immediately (old behavior) with warning suppression  # noqa: E501
     with warnings.catch_warnings():
@@ -185,7 +202,6 @@ if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
         warnings.filterwarnings("ignore", category=UserWarning)
         warnings.filterwarnings("ignore", category=FutureWarning)
         # Suppress specific third-party warnings
-        warnings.filterwarnings("ignore", category=UserWarning, module="hyperopt")
         warnings.filterwarnings(
             "ignore", category=DeprecationWarning, module="pkg_resources"
         )
@@ -213,6 +229,10 @@ if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
         )
         from .chem_tool import ChEMBLTool
         from .compose_tool import ComposeTool
+        from .python_executor_tool import (
+            PythonCodeExecutor,
+            PythonScriptRunner,
+        )
         from .europe_pmc_tool import EuropePMCTool
         from .semantic_scholar_tool import SemanticScholarTool
         from .pubtator_tool import PubTatorTool
@@ -235,6 +255,12 @@ if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
         from .embedding_database import EmbeddingDatabase
         from .embedding_sync import EmbeddingSync
         from .rcsb_pdb_tool import RCSBTool
+        from .web_search_tool import (
+            WebSearchTool,
+            WebAPIDocumentationSearchTool,
+        )
+        from .package_discovery_tool import DynamicPackageDiscovery
+        from .pypi_package_inspector_tool import PyPIPackageInspector
         from .gwas_tool import (
             GWASAssociationSearch,
             GWASStudySearch,
@@ -264,6 +290,14 @@ if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
         CellosaurusQueryConverterTool,
         CellosaurusGetCellLineInfoTool,
     )
+    from .ols_tool import OLSTool
+
+    # New database tools
+    from .clinvar_tool import (
+        ClinVarSearchVariants,
+        ClinVarGetVariantDetails,
+        ClinVarGetClinicalSignificance,
+    )
 
     # Literature search tools
     from .arxiv_tool import ArXivTool
@@ -310,6 +344,8 @@ else:
     )
     ChEMBLTool = _LazyImportProxy("chem_tool", "ChEMBLTool")
     ComposeTool = _LazyImportProxy("compose_tool", "ComposeTool")
+    PythonCodeExecutor = _LazyImportProxy("python_executor_tool", "PythonCodeExecutor")
+    PythonScriptRunner = _LazyImportProxy("python_executor_tool", "PythonScriptRunner")
     EuropePMCTool = _LazyImportProxy("europe_pmc_tool", "EuropePMCTool")
     SemanticScholarTool = _LazyImportProxy(
         "semantic_scholar_tool", "SemanticScholarTool"
@@ -368,6 +404,7 @@ else:
     CellosaurusGetCellLineInfoTool = _LazyImportProxy(
         "cellosaurus_tool", "CellosaurusGetCellLineInfoTool"
     )
+    OLSTool = _LazyImportProxy("ols_tool", "OLSTool")
     # Literature search tools
     ArXivTool = _LazyImportProxy("arxiv_tool", "ArXivTool")
     CrossrefTool = _LazyImportProxy("crossref_tool", "CrossrefTool")
@@ -381,6 +418,16 @@ else:
     CoreTool = _LazyImportProxy("core_tool", "CoreTool")
     PMCTool = _LazyImportProxy("pmc_tool", "PMCTool")
     ZenodoTool = _LazyImportProxy("zenodo_tool", "ZenodoTool")
+    WebSearchTool = _LazyImportProxy("web_search_tool", "WebSearchTool")
+    WebAPIDocumentationSearchTool = _LazyImportProxy(
+        "web_search_tool", "WebAPIDocumentationSearchTool"
+    )
+    DynamicPackageDiscovery = _LazyImportProxy(
+        "package_discovery_tool", "DynamicPackageDiscovery"
+    )
+    PyPIPackageInspector = _LazyImportProxy(
+        "pypi_package_inspector_tool", "PyPIPackageInspector"
+    )
 
 __all__ = [
     "__version__",
@@ -456,6 +503,7 @@ __all__ = [
     "CellosaurusSearchTool",
     "CellosaurusQueryConverterTool",
     "CellosaurusGetCellLineInfoTool",
+    "OLSTool",
     # Literature search tools
     "ArXivTool",
     "CrossrefTool",
@@ -469,4 +517,12 @@ __all__ = [
     "CoreTool",
     "PMCTool",
     "ZenodoTool",
+    "WebSearchTool",
+    "WebAPIDocumentationSearchTool",
+    "DynamicPackageDiscovery",
+    "PyPIPackageInspector",
+    # ClinVar tools
+    "ClinVarSearchVariants",
+    "ClinVarGetVariantDetails",
+    "ClinVarGetClinicalSignificance",
 ]

tooluniverse-1.0.11/src/tooluniverse/blast_tool.py

@@ -0,0 +1,132 @@
+from typing import Any, Dict
+from Bio.Blast import NCBIWWW, NCBIXML
+from Bio.Seq import Seq
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("NCBIBlastTool")
+class NCBIBlastTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.timeout = 300  # BLAST can take a long time
+        self.max_wait_time = 600  # Maximum wait time for results
+
+    def _parse_blast_results(self, blast_xml: str) -> Dict[str, Any]:
+        """Parse BLAST XML results into structured data"""
+        try:
+            from io import StringIO
+
+            blast_record = NCBIXML.read(StringIO(blast_xml))
+
+            results = {
+                "query_id": blast_record.query_id,
+                "query_length": blast_record.query_length,
+                "database": blast_record.database,
+                "algorithm": blast_record.application,
+                "alignments": [],
+            }
+
+            for alignment in blast_record.alignments:
+                alignment_data = {
+                    "hit_id": getattr(alignment, "hit_id", "unknown"),
+                    "hit_def": getattr(alignment, "hit_def", "unknown"),
+                    "hit_length": getattr(alignment, "hit_length", 0),
+                    "hsps": [],
+                }
+
+                for hsp in alignment.hsps:
+                    hsp_data = {
+                        "score": getattr(hsp, "score", 0),
+                        "bits": getattr(hsp, "bits", 0),
+                        "expect": getattr(hsp, "expect", 0),
+                        "identities": getattr(hsp, "identities", 0),
+                        "positives": getattr(hsp, "positives", 0),
+                        "gaps": getattr(hsp, "gaps", 0),
+                        "align_length": getattr(hsp, "align_length", 0),
+                        "query_start": getattr(hsp, "query_start", 0),
+                        "query_end": getattr(hsp, "query_end", 0),
+                        "hit_start": getattr(hsp, "hit_start", 0),
+                        "hit_end": getattr(hsp, "hit_end", 0),
+                        "query": getattr(hsp, "query", ""),
+                        "match": getattr(hsp, "match", ""),
+                        "sbjct": getattr(hsp, "sbjct", ""),
+                    }
+                    alignment_data["hsps"].append(hsp_data)
+
+                results["alignments"].append(alignment_data)
+
+            return results
+
+        except Exception as e:
+            return {
+                "error": f"Failed to parse BLAST results: {str(e)}",
+                "raw_xml": (
+                    blast_xml[:1000] + "..." if len(blast_xml) > 1000 else blast_xml
+                ),
+            }
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute BLAST search using NCBI Web service"""
+        try:
+            sequence = arguments.get("sequence", "")
+            blast_type = arguments.get("blast_type", "blastn")
+            database = arguments.get("database", "nt")
+            expect = arguments.get("expect", 10.0)
+            hitlist_size = arguments.get("hitlist_size", 50)
+
+            if not sequence:
+                return {
+                    "status": "error",
+                    "error": "Missing required parameter: sequence",
+                }
+
+            # Validate sequence
+            try:
+                seq_obj = Seq(sequence)
+                if len(seq_obj) < 10:
+                    return {
+                        "status": "error",
+                        "error": "Sequence too short (minimum 10 nucleotides)",
+                    }
+            except Exception as e:
+                return {
+                    "status": "error",
+                    "error": f"Invalid sequence format: {str(e)}",
+                }
+
+            # Perform BLAST search
+            result_handle = NCBIWWW.qblast(
+                blast_type,
+                database,
+                sequence,
+                expect=expect,
+                hitlist_size=hitlist_size,
+                format_type="XML",
+            )
+
+            # Read results
+            blast_xml = result_handle.read()
+            result_handle.close()
+
+            # Parse results
+            parsed_results = self._parse_blast_results(blast_xml)
+
+            if "error" in parsed_results:
+                return {
+                    "status": "error",
+                    "error": parsed_results["error"],
+                    "raw_data": parsed_results.get("raw_xml", ""),
+                }
+
+            return {
+                "status": "success",
+                "data": parsed_results,
+                "query_sequence": sequence,
+                "blast_type": blast_type,
+                "database": database,
+                "hit_count": len(parsed_results["alignments"]),
+            }
+
+        except Exception as e:
+            return {"status": "error", "error": f"BLAST search failed: {str(e)}"}

{tooluniverse-1.0.10 → tooluniverse-1.0.11}/src/tooluniverse/boltz_tool.py

@@ -170,7 +170,7 @@ class Boltz2DockingTool(BaseTool):
                     prediction_folder, f"{input_filename}_model_0.cif"
                 )
                 if os.path.exists(structure_file):
-                    with open(structure_file, "r") as f:
+                    with open(structure_file, "r", encoding="utf-8") as f:
                         results["predicted_structure"] = f.read()
                     results["structure_format"] = "cif"
                 else:
@@ -183,7 +183,7 @@ class Boltz2DockingTool(BaseTool):
                 prediction_folder, f"affinity_{input_filename}.json"
             )
             if os.path.exists(affinity_file):
-                with open(affinity_file, "r") as f:
+                with open(affinity_file, "r", encoding="utf-8") as f:
                     results["affinity_prediction"] = json.load(f)
             else:
                 results["affinity_error"] = f"Missing {os.path.basename(affinity_file)}"

tooluniverse-1.0.11/src/tooluniverse/cbioportal_tool.py

@@ -0,0 +1,42 @@
+import requests
+from typing import Any, Dict
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("CBioPortalRESTTool")
+class CBioPortalRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.base_url = "https://www.cbioportal.org/api"
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Accept": "application/json", "User-Agent": "ToolUniverse/1.0"}
+        )
+        self.timeout = 30
+
+    def _build_url(self, args: Dict[str, Any]) -> str:
+        url = self.tool_config["fields"]["endpoint"]
+        for k, v in args.items():
+            url = url.replace(f"{{{k}}}", str(v))
+        return url
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            url = self._build_url(arguments)
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+            data = response.json()
+
+            return {
+                "status": "success",
+                "data": data,
+                "url": url,
+                "count": len(data) if isinstance(data, list) else 1,
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": f"cBioPortal API error: {str(e)}",
+                "url": url,
+            }

tooluniverse-1.0.11/src/tooluniverse/clinvar_tool.py

@@ -0,0 +1,284 @@
+"""
+ClinVar REST API Tool
+
+This tool provides access to the ClinVar database for clinical variant information,
+disease associations, and clinical significance data.
+"""
+
+import requests
+import time
+from typing import Dict, Any, Optional
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+class ClinVarRESTTool(BaseTool):
+    """Base class for ClinVar REST API tools."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Accept": "application/json", "User-Agent": "ToolUniverse/1.0"}
+        )
+        self.timeout = 30
+
+    def _make_request(
+        self, endpoint: str, params: Optional[Dict] = None, max_retries: int = 3
+    ) -> Dict[str, Any]:
+        """Make a request to the ClinVar API with automatic retry for rate limiting."""
+        url = f"{self.base_url}{endpoint}"
+
+        for attempt in range(max_retries + 1):
+            try:
+                response = self.session.get(url, params=params, timeout=self.timeout)
+
+                # Handle rate limiting (429 error)
+                if response.status_code == 429:
+                    retry_after = response.headers.get("Retry-After")
+                    if retry_after:
+                        wait_time = int(retry_after)
+                    else:
+                        # Default exponential backoff: 1, 2, 4 seconds
+                        wait_time = 2**attempt
+
+                    if attempt < max_retries:
+                        print(
+                            f"Rate limited (429). Waiting {wait_time} seconds before retry {attempt + 1}/{max_retries}..."
+                        )
+                        time.sleep(wait_time)
+                        continue
+                    else:
+                        return {
+                            "status": "error",
+                            "error": f"Rate limited after {max_retries} retries. Please wait before making more requests.",
+                            "url": url,
+                            "retry_after": retry_after,
+                        }
+
+                response.raise_for_status()
+
+                # ClinVar API returns XML by default, but we can request JSON
+                if params and params.get("retmode") == "json":
+                    data = response.json()
+                else:
+                    # Parse XML response
+                    data = response.text
+
+                return {
+                    "status": "success",
+                    "data": data,
+                    "url": url,
+                    "content_type": response.headers.get(
+                        "content-type", "application/xml"
+                    ),
+                    "rate_limit_info": {
+                        "limit": response.headers.get("X-RateLimit-Limit"),
+                        "remaining": response.headers.get("X-RateLimit-Remaining"),
+                    },
+                }
+
+            except requests.exceptions.RequestException as e:
+                if attempt < max_retries:
+                    wait_time = 2**attempt
+                    print(
+                        f"Request failed: {str(e)}. Retrying in {wait_time} seconds..."
+                    )
+                    time.sleep(wait_time)
+                    continue
+                else:
+                    return {
+                        "status": "error",
+                        "error": f"ClinVar API request failed after {max_retries} retries: {str(e)}",
+                        "url": url,
+                    }
+
+        return {"status": "error", "error": "Maximum retries exceeded", "url": url}
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool with given arguments."""
+        return self._make_request(self.endpoint, arguments)
+
+
+@register_tool("ClinVarSearchVariants")
+class ClinVarSearchVariants(ClinVarRESTTool):
+    """Search for variants in ClinVar by gene or condition."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/esearch.fcgi"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Search variants by gene or condition."""
+        params = {
+            "db": "clinvar",
+            "retmode": "json",
+            "retmax": arguments.get("max_results", 20),
+        }
+
+        # Build search query
+        query_parts = []
+
+        if "gene" in arguments:
+            query_parts.append(f"{arguments['gene']}[gene]")
+
+        if "condition" in arguments:
+            query_parts.append(f"{arguments['condition']}[condition]")
+
+        if "variant_id" in arguments:
+            query_parts.append(f"{arguments['variant_id']}[variant_id]")
+
+        if not query_parts:
+            return {
+                "status": "error",
+                "error": "At least one search parameter is required",
+            }
+
+        params["term"] = " AND ".join(query_parts)
+
+        result = self._make_request(self.endpoint, params)
+
+        # Add search parameters to result and format data
+        if result.get("status") == "success":
+            result["search_params"] = {
+                "gene": arguments.get("gene"),
+                "condition": arguments.get("condition"),
+                "variant_id": arguments.get("variant_id"),
+            }
+
+            # Format search results for better usability
+            data = result.get("data", {})
+            if "esearchresult" in data:
+                esearch = data["esearchresult"]
+                formatted_results = {
+                    "total_count": int(esearch.get("count", 0)),
+                    "variant_ids": esearch.get("idlist", []),
+                    "query_translation": esearch.get("querytranslation", ""),
+                    "search_params": result["search_params"],
+                    "summary": f"Found {esearch.get('count', 0)} variants matching the search criteria",
+                }
+                result["formatted_results"] = formatted_results
+
+        return result
+
+
+@register_tool("ClinVarGetVariantDetails")
+class ClinVarGetVariantDetails(ClinVarRESTTool):
+    """Get detailed variant information by ClinVar ID."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/esummary.fcgi"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Get variant details by ClinVar ID."""
+        variant_id = arguments.get("variant_id", "")
+        if not variant_id:
+            return {"status": "error", "error": "variant_id is required"}
+
+        params = {"db": "clinvar", "id": variant_id, "retmode": "json"}
+
+        result = self._make_request(self.endpoint, params)
+
+        # Add variant_id to result and format data
+        if result.get("status") == "success":
+            result["variant_id"] = variant_id
+
+            # Format the data for better usability
+            data = result.get("data", {})
+            if "result" in data and variant_id in data["result"]:
+                variant_data = data["result"][variant_id]
+
+                # Extract key information
+                formatted_data = {
+                    "variant_id": variant_id,
+                    "accession": variant_data.get("accession", ""),
+                    "title": variant_data.get("title", ""),
+                    "obj_type": variant_data.get("obj_type", ""),
+                    "genes": [
+                        gene.get("symbol", "") for gene in variant_data.get("genes", [])
+                    ],
+                    "clinical_significance": variant_data.get(
+                        "germline_classification", {}
+                    ).get("description", ""),
+                    "review_status": variant_data.get(
+                        "germline_classification", {}
+                    ).get("review_status", ""),
+                    "chromosome": variant_data.get("chr_sort", ""),
+                    "location": variant_data.get("variation_set", [{}])[0]
+                    .get("variation_loc", [{}])[0]
+                    .get("band", ""),
+                    "variation_name": variant_data.get("variation_set", [{}])[0].get(
+                        "variation_name", ""
+                    ),
+                    "raw_data": variant_data,  # Keep original data for advanced users
+                }
+
+                result["formatted_data"] = formatted_data
+
+        return result
+
+
+@register_tool("ClinVarGetClinicalSignificance")
+class ClinVarGetClinicalSignificance(ClinVarRESTTool):
+    """Get clinical significance information for variants."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/esummary.fcgi"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Get clinical significance by variant ID."""
+        variant_id = arguments.get("variant_id", "")
+        if not variant_id:
+            return {"status": "error", "error": "variant_id is required"}
+
+        params = {"db": "clinvar", "id": variant_id, "retmode": "json"}
+
+        result = self._make_request(self.endpoint, params)
+
+        # Add variant_id to result and format clinical significance data
+        if result.get("status") == "success":
+            result["variant_id"] = variant_id
+
+            # Format the clinical significance data
+            data = result.get("data", {})
+            if "result" in data and variant_id in data["result"]:
+                variant_data = data["result"][variant_id]
+
+                # Extract clinical significance information
+                germline_class = variant_data.get("germline_classification", {})
+                clinical_impact = variant_data.get("clinical_impact_classification", {})
+                oncogenicity = variant_data.get("oncogenicity_classification", {})
+
+                formatted_data = {
+                    "variant_id": variant_id,
+                    "germline_classification": {
+                        "description": germline_class.get("description", ""),
+                        "review_status": germline_class.get("review_status", ""),
+                        "last_evaluated": germline_class.get("last_evaluated", ""),
+                        "fda_recognized": germline_class.get(
+                            "fda_recognized_database", ""
+                        ),
+                        "traits": [
+                            trait.get("trait_name", "")
+                            for trait in germline_class.get("trait_set", [])
+                        ],
+                    },
+                    "clinical_impact": {
+                        "description": clinical_impact.get("description", ""),
+                        "review_status": clinical_impact.get("review_status", ""),
+                        "last_evaluated": clinical_impact.get("last_evaluated", ""),
+                    },
+                    "oncogenicity": {
+                        "description": oncogenicity.get("description", ""),
+                        "review_status": oncogenicity.get("review_status", ""),
+                        "last_evaluated": oncogenicity.get("last_evaluated", ""),
+                    },
+                    "raw_data": variant_data,  # Keep original data for advanced users
+                }
+
+                result["formatted_data"] = formatted_data
+
+        return result