aurelian 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

aurelian/agents/talisman/__main__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+"""
+Main entry point to run the talisman agent.
+"""
+import os
+import sys
+from pydantic_ai import chat
+
+# Add the parent directory to the path for absolute imports
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../")))
+
+from aurelian.agents.talisman.talisman_agent import talisman_agent
+from aurelian.agents.talisman.talisman_config import get_config
+
+if __name__ == "__main__":
+    config = get_config()
+    chat(talisman_agent, deps=config)

aurelian/agents/talisman/cli.py

@@ -0,0 +1,70 @@
+"""
+CLI interface for the talisman agent.
+This may not be in the original code, but let's add it to make sure it's properly configured.
+"""
+import logging
+import re
+from pydantic_ai import RunContext
+
+from aurelian.agents.talisman.talisman_config import TalismanConfig
+from aurelian.agents.talisman.talisman_tools import GeneSetAnalysis, FunctionalTerm, GeneSummary
+
+def format_talisman_output(result):
+    """Format the talisman output to ensure it always has all three sections."""
+    logging.info("Post-processing talisman output")
+    
+    # Check if output already has proper sections
+    has_narrative = re.search(r'^\s*##\s*Narrative', result, re.MULTILINE) is not None
+    has_functional_terms = re.search(r'^\s*##\s*Functional Terms Table', result, re.MULTILINE) is not None
+    has_gene_summary = re.search(r'^\s*##\s*Gene Summary Table', result, re.MULTILINE) is not None
+    
+    # If all sections are present, return as is
+    if has_narrative and has_functional_terms and has_gene_summary:
+        return result
+    
+    # Need to reconstruct the output
+    # Extract gene summary table if it exists
+    gene_table_match = re.search(r'^\s*##\s*Gene Summary Table\s*\n(.*?)(?=$|\n\n|\Z)', 
+                                result, re.MULTILINE | re.DOTALL)
+    
+    if gene_table_match:
+        gene_table = gene_table_match.group(0)
+        
+        # Extract existing text that might be a narrative
+        narrative_text = result.replace(gene_table, '').strip()
+        
+        # Create a proper narrative section if missing
+        if not has_narrative and narrative_text:
+            narrative_section = "## Narrative\n" + narrative_text + "\n\n"
+        else:
+            narrative_section = "## Narrative\nThese genes may have related functions as indicated in the gene summary table.\n\n"
+        
+        # Create a functional terms section if missing
+        if not has_functional_terms:
+            # Extract gene IDs from the gene table
+            gene_ids = []
+            for line in gene_table.split('\n'):
+                if '|' in line and not line.strip().startswith('|--') and not 'ID |' in line:
+                    parts = line.split('|')
+                    if len(parts) > 1:
+                        gene_id = parts[1].strip()
+                        if gene_id and gene_id != 'ID':
+                            gene_ids.append(gene_id)
+            
+            # Create a simple functional terms table
+            functional_terms = "## Functional Terms Table\n"
+            functional_terms += "| Functional Term | Genes | Source |\n"
+            functional_terms += "|-----------------|-------|--------|\n"
+            functional_terms += f"| Gene set | {', '.join(gene_ids)} | Analysis |\n\n"
+        else:
+            # Find and extract existing functional terms section
+            ft_match = re.search(r'^\s*##\s*Functional Terms Table\s*\n(.*?)(?=^\s*##\s*|\Z)', 
+                                result, re.MULTILINE | re.DOTALL)
+            functional_terms = ft_match.group(0) if ft_match else ""
+        
+        # Reconstruct the output with all sections
+        formatted_output = "# Gene Set Analysis\n\n" + narrative_section + functional_terms + gene_table
+        return formatted_output
+    
+    # If no gene table was found, return the original result
+    return result

aurelian/agents/talisman/run_talisman.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+"""
+Standalone script to run the talisman agent directly.
+"""
+import os
+import sys
+from pydantic_ai import chat
+
+# Add the src directory to the path for imports
+src_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../../"))
+sys.path.insert(0, src_dir)
+
+from aurelian.agents.talisman.talisman_agent import talisman_agent
+from aurelian.agents.talisman.talisman_config import get_config
+
+if __name__ == "__main__":
+    config = get_config()
+    chat(talisman_agent, deps=config)

aurelian/agents/talisman/talisman_agent.py

@@ -1,5 +1,6 @@
 """
 Agent for working with gene information using the UniProt API and NCBI Entrez.
+Provides structured information in the form of Narrative, Functional Terms Table, and Gene Summary Table.
 """
 from pydantic_ai import Agent
 
@@ -70,38 +71,54 @@ The analysis will cover multiple types of relationships:
 - Physical interactions
 - Genetic interactions
 
-IMPORTANT: For gene set analysis, ALWAYS include a distinct section titled "## Terms" 
-that contains a semicolon-delimited list of functional terms relevant to the gene set, 
-ordered by relevance. These terms should include:
-- Gene Ontology biological process terms (e.g., DNA repair, oxidative phosphorylation, signal transduction)
-- Molecular function terms (e.g., kinase activity, DNA binding, transporter activity)
-- Cellular component/localization terms (e.g., nucleus, plasma membrane, mitochondria)
-- Pathway names (e.g., glycolysis, TCA cycle, MAPK signaling)
-- Co-regulation terms (e.g., stress response regulon, heat shock response)
-- Interaction networks (e.g., protein complex formation, signaling cascade)
-- Metabolic process terms (e.g., fatty acid synthesis, amino acid metabolism)
-- Regulatory mechanisms (e.g., transcriptional regulation, post-translational modification)
-- Disease associations (if relevant, e.g., virulence, pathogenesis, antibiotic resistance)
-- Structural and functional domains/motifs (e.g., helix-turn-helix, zinc finger)
-
-Example of Terms section:
-## Terms
-DNA damage response; p53 signaling pathway; apoptosis; cell cycle regulation; tumor suppression; DNA repair; protein ubiquitination; transcriptional regulation; nuclear localization; cancer predisposition
-
-IMPORTANT: After the Terms section, ALWAYS include a "## Gene Summary Table" with a markdown table 
-summarizing the genes analyzed, with the following columns in this exact order:
-- ID: The gene identifier (same as Gene Symbol)
-- Annotation: Genomic coordinates or accession with position information
-- Genomic Context: Information about the genomic location (chromosome, plasmid, etc.)
-- Organism: The organism the gene belongs to
-- Description: The protein/gene function description
+For gene set analysis, your output MUST always include three distinct sections:
+
+1. First, a "## Narrative" section providing a concise explanation of the functional and categorical relationships between the genes. This should:
+   - Prioritize explanations involving most or all genes in the set
+   - Refer to specific subsets of genes when discussing specialized functions
+   - Highlight the most significant shared pathways, processes, or disease associations
+   - Be clear, concise, and focused on biological meaning
+
+2. Second, a "## Functional Terms Table" that presents key functional terms in a tabular format with these columns:
+   - Functional Term: The biological term or concept (e.g., DNA repair, kinase activity)
+   - Genes: The genes associated with this term (comma-separated list)
+   - Source: The likely source database or ontology (e.g., GO-BP, KEGG, Reactome, GO-MF, GO-CC, Disease)
+
+The functional terms should include various types:
+- Gene Ontology biological process terms (e.g., DNA repair, oxidative phosphorylation)
+- Molecular function terms (e.g., kinase activity, DNA binding)
+- Cellular component/localization terms (e.g., nucleus, plasma membrane)
+- Pathway names (e.g., glycolysis, MAPK signaling)
+- Disease associations (if relevant)
+- Structural and functional domains/motifs (if relevant)
+
+Example of Functional Terms Table:
+## Functional Terms Table
+| Functional Term | Genes | Source |
+|-----------------|-------|--------|
+| DNA damage response | BRCA1, BRCA2, ATM | GO-BP |
+| Homologous recombination | BRCA1, BRCA2 | Reactome |
+| Tumor suppression | BRCA1, BRCA2, ATM | Disease |
+| Nuclear localization | BRCA1, BRCA2, ATM | GO-CC |
+| Kinase activity | ATM | GO-MF |
+| PARP inhibitor sensitivity | BRCA1, BRCA2, PARP1 | Pathway |
+
+3. Third, a "## Gene Summary Table" with a markdown table summarizing the genes analyzed, 
+with the following columns in this exact order:
+   - ID: The gene identifier (same as Gene Symbol)
+   - Annotation: Genomic coordinates or accession with position information
+   - Genomic Context: Information about the genomic location (chromosome, plasmid, etc.)
+   - Organism: The organism the gene belongs to
+   - Description: The protein/gene function description
 
 Example of Gene Summary Table:
 ## Gene Summary Table
 | ID | Annotation | Genomic Context | Organism | Description |
 |-------------|-------------|----------|----------------|------------|
 | BRCA1 | NC_000017.11 (43044295..43125483) | Chromosome 17 | Homo sapiens | Breast cancer type 1 susceptibility protein |
-| TP53 | NC_000017.11 (7668402..7687550) | Chromosome 17 | Homo sapiens | Tumor suppressor protein |
+| BRCA2 | NC_000013.11 (32315474..32400266) | Chromosome 13 | Homo sapiens | Breast cancer type 2 susceptibility protein |
+| ATM | NC_000011.10 (108222484..108369102) | Chromosome 11 | Homo sapiens | ATM serine/threonine kinase |
+| PARP1 | NC_000001.11 (226360251..226408516) | Chromosome 1 | Homo sapiens | Poly(ADP-ribose) polymerase 1 |
 
 For bacterial genes, the table format would be:
 | ID | Annotation | Genomic Context | Organism | Description |
@@ -123,4 +140,4 @@ talisman_agent = Agent(
 talisman_agent.tool(get_gene_description)
 talisman_agent.tool(get_gene_descriptions)
 talisman_agent.tool(get_genes_from_list)
-talisman_agent.tool(analyze_gene_set)
+#talisman_agent.tool(analyze_gene_set)

aurelian/agents/talisman/talisman_tools.py

@@ -2,6 +2,8 @@
 Tools for retrieving gene information using the UniProt API and NCBI Entrez.
 """
 from typing import Dict, List, Optional, Tuple, Any
+from pydantic import BaseModel, Field
+import re
 import openai
 import time
 import threading
@@ -14,6 +16,32 @@ from pydantic_ai import RunContext, ModelRetry
 
 from .talisman_config import TalismanConfig, get_config
 
+# Define data models for structured output
+class FunctionalTerm(BaseModel):
+    """A functional term associated with genes."""
+    term: str = Field(..., description="The biological term or concept")
+    genes: List[str] = Field(..., description="List of genes associated with this term")
+    source: str = Field(..., description="The source database or ontology (GO-BP, KEGG, Reactome, etc.)")
+
+class GeneSummary(BaseModel):
+    """Summary information for a gene."""
+    id: str = Field(..., description="The gene identifier (Gene Symbol)")
+    annotation: str = Field(..., description="Genomic coordinates or accession with position")
+    genomic_context: str = Field(..., description="Information about genomic location (chromosome, etc.)")
+    organism: str = Field(..., description="The organism the gene belongs to")
+    description: str = Field(..., description="The protein/gene function description")
+
+class GeneSetAnalysis(BaseModel):
+    """Complete analysis of a gene set."""
+    input_species: str = Field(default="", description="The species provided by the user")
+    inferred_species: str = Field(default="", description="The species inferred from the gene data")
+    narrative: str = Field(default="No narrative information available for these genes.", 
+                          description="Explanation of functional and categorical relationships between genes")
+    functional_terms: List[FunctionalTerm] = Field(default_factory=list, 
+                                                 description="Functional terms associated with the gene set")
+    gene_summaries: List[GeneSummary] = Field(default_factory=list, 
+                                            description="Summary information for each gene")
+
 # Set up logging
 logging.basicConfig(
     level=logging.INFO,
@@ -156,15 +184,10 @@ def get_ncbi_gene_info(ctx: RunContext[TalismanConfig], gene_id: str, organism:
     config = ctx.deps or get_config()
     ncbi = config.get_ncbi_client()
     
-    # Check if the gene looks like bacterial (common for Salmonella)
-    bacterial_gene_patterns = ["inv", "sip", "sop", "sic", "spa", "ssa", "sse", "prg"]
-    is_likely_bacterial = any(gene_id.lower().startswith(pattern) for pattern in bacterial_gene_patterns)
+    # No need to check for specific gene patterns
     
-    # Default organisms to try based on gene patterns
-    if is_likely_bacterial and not organism:
-        organisms_to_try = ["Salmonella", "Escherichia coli", "Bacteria"]
-    else:
-        organisms_to_try = [organism] if organism else ["Homo sapiens", None]  # Try human first as default, then any organism
+    # Set organisms to try without domain-specific knowledge
+    organisms_to_try = [organism] if organism else [None]  # Use organism if provided, else try without organism constraint
     
     gene_results = None
     
@@ -207,22 +230,22 @@ def get_ncbi_gene_info(ctx: RunContext[TalismanConfig], gene_id: str, organism:
             return gene_results
         
         # If not found in gene database, try protein database
-        # For bacterial genes, try organism-specific search first
+        # Standard protein search
         protein_ids = []
-        if is_likely_bacterial:
-            for org in organisms_to_try:
-                if org:
-                    logging.info(f"Searching NCBI protein database for: {gene_id} in organism: {org}")
-                    ncbi_limiter.wait()
-                    search_query = f"{gene_id} AND {org}[Organism]"
-                    search_results = ncbi.ESearch("protein", search_query)
-                    protein_ids = search_results.get('idlist', [])
-                    
-                    if protein_ids:
-                        logging.info(f"Found protein ID(s) for {gene_id} in {org}: {protein_ids}")
-                        break
-        else:
-            # Standard protein search (no organism constraint)
+        for org in organisms_to_try:
+            if org:
+                logging.info(f"Searching NCBI protein database for: {gene_id} in organism: {org}")
+                ncbi_limiter.wait()
+                search_query = f"{gene_id} AND {org}[Organism]"
+                search_results = ncbi.ESearch("protein", search_query)
+                protein_ids = search_results.get('idlist', [])
+                
+                if protein_ids:
+                    logging.info(f"Found protein ID(s) for {gene_id} in {org}: {protein_ids}")
+                    break
+        
+        # If no results with organism constraint, try without
+        if not protein_ids:
             logging.info(f"Searching NCBI protein database for: {gene_id}")
             ncbi_limiter.wait()
             search_results = ncbi.ESearch("protein", gene_id)
@@ -303,6 +326,129 @@ def get_ncbi_gene_info(ctx: RunContext[TalismanConfig], gene_id: str, organism:
         return f"Error querying NCBI Entrez: {str(e)}"
 
 
+def ensure_complete_output(markdown_result: str, gene_set_analysis: GeneSetAnalysis) -> str:
+    """Ensures that the markdown output has all required sections.
+    
+    Args:
+        markdown_result: The original markdown result
+        gene_set_analysis: The structured data model
+        
+    Returns:
+        A complete markdown output with all required sections
+    """
+    logging.info("Post-processing output to ensure all sections are present")
+    
+    # Check if output already has proper sections - always enforce
+    has_narrative = re.search(r'^\s*##\s*Narrative', markdown_result, re.MULTILINE) is not None
+    has_functional_terms = re.search(r'^\s*##\s*Functional Terms Table', markdown_result, re.MULTILINE) is not None
+    has_gene_summary = re.search(r'^\s*##\s*Gene Summary Table', markdown_result, re.MULTILINE) is not None
+    has_species = re.search(r'^\s*#\s*Species', markdown_result, re.MULTILINE) is not None
+    
+    # We'll always rebuild the output to ensure consistent formatting
+    result = ""
+    
+    # Add species section if applicable
+    if gene_set_analysis.input_species or gene_set_analysis.inferred_species:
+        result += "# Species\n"
+        if gene_set_analysis.input_species:
+            result += f"Input: {gene_set_analysis.input_species}\n"
+        if gene_set_analysis.inferred_species:
+            result += f"Inferred: {gene_set_analysis.inferred_species}\n"
+        result += "\n"
+    
+    # Add main header
+    result += "# Gene Set Analysis\n\n"
+    
+    # Add narrative section - always include
+    result += "## Narrative\n"
+    if has_narrative:
+        # Extract existing narrative if it exists
+        narrative_match = re.search(r'##\s*Narrative\s*\n(.*?)(?=^\s*##|\Z)', 
+                                   markdown_result, re.MULTILINE | re.DOTALL)
+        if narrative_match and narrative_match.group(1).strip():
+            result += narrative_match.group(1).strip() + "\n\n"
+        else:
+            result += f"{gene_set_analysis.narrative}\n\n"
+    else:
+        # Use the narrative from the model
+        result += f"{gene_set_analysis.narrative}\n\n"
+    
+    # Add functional terms table - always include
+    result += "## Functional Terms Table\n"
+    result += "| Functional Term | Genes | Source |\n"
+    result += "|-----------------|-------|--------|\n"
+    
+    if has_functional_terms:
+        # Try to extract existing table content
+        ft_match = re.search(r'##\s*Functional Terms Table\s*\n\|.*\|\s*\n\|[-\s|]*\|\s*\n(.*?)(?=^\s*##|\Z)', 
+                           markdown_result, re.MULTILINE | re.DOTALL)
+        if ft_match and ft_match.group(1).strip():
+            # Use existing content
+            for line in ft_match.group(1).strip().split("\n"):
+                if line.strip() and "|" in line:
+                    result += line + "\n"
+        elif gene_set_analysis.functional_terms:
+            # Use model content
+            for term in gene_set_analysis.functional_terms:
+                genes_str = ", ".join(term.genes)
+                result += f"| {term.term} | {genes_str} | {term.source} |\n"
+        else:
+            # Create default content
+            gene_ids = [g.id for g in gene_set_analysis.gene_summaries]
+            if gene_ids:
+                result += f"| Gene set | {', '.join(gene_ids)} | Analysis |\n"
+            else:
+                result += "| No terms available | - | - |\n"
+    else:
+        # Always include functional terms, using content from model
+        if gene_set_analysis.functional_terms:
+            for term in gene_set_analysis.functional_terms:
+                genes_str = ", ".join(term.genes)
+                result += f"| {term.term} | {genes_str} | {term.source} |\n"
+        else:
+            # Create default content if model has none
+            gene_ids = [g.id for g in gene_set_analysis.gene_summaries]
+            if gene_ids:
+                result += f"| Gene set | {', '.join(gene_ids)} | Analysis |\n"
+            else:
+                result += "| No terms available | - | - |\n"
+    
+    result += "\n"
+    
+    # Add gene summary table - always include
+    result += "## Gene Summary Table\n"
+    result += "| ID | Annotation | Genomic Context | Organism | Description |\n"
+    result += "|-------------|-------------|----------|----------------|------------|\n"
+    
+    if has_gene_summary:
+        # Try to extract existing gene summary
+        gs_match = re.search(r'##\s*Gene Summary Table\s*\n\|.*\|\s*\n\|[-\s|]*\|\s*\n(.*?)(?=^\s*##|\Z)', 
+                           markdown_result, re.MULTILINE | re.DOTALL)
+        if gs_match and gs_match.group(1).strip():
+            # Use existing content
+            for line in gs_match.group(1).strip().split("\n"):
+                if line.strip() and "|" in line:
+                    result += line + "\n"
+        elif gene_set_analysis.gene_summaries:
+            # Use model content
+            for gene in gene_set_analysis.gene_summaries:
+                result += f"| {gene.id} | {gene.annotation} | {gene.genomic_context} | {gene.organism} | {gene.description} |\n"
+        else:
+            # Create default content
+            result += "| No gene information available | - | - | - | - |\n"
+    else:
+        # Always include gene summary, using content from model
+        if gene_set_analysis.gene_summaries:
+            for gene in gene_set_analysis.gene_summaries:
+                result += f"| {gene.id} | {gene.annotation} | {gene.genomic_context} | {gene.organism} | {gene.description} |\n"
+        else:
+            # Create default content if model has none
+            result += "| No gene information available | - | - | - | - |\n"
+    
+    logging.info("Successfully enforced all required sections in the output")
+    return result
+
+
 def get_gene_description(ctx: RunContext[TalismanConfig], gene_id: str, organism: str = None) -> str:
     """Get description for a single gene ID, using UniProt and falling back to NCBI Entrez.
 
@@ -318,15 +464,6 @@ def get_gene_description(ctx: RunContext[TalismanConfig], gene_id: str, organism
     config = ctx.deps or get_config()
     u = config.get_uniprot_client()
     
-    # Check if this looks like a bacterial gene code
-    bacterial_gene_patterns = ["inv", "sip", "sop", "sic", "spa", "ssa", "sse", "prg", "flh", "fli", "che"]
-    is_likely_bacterial = any(gene_id.lower().startswith(pattern) for pattern in bacterial_gene_patterns)
-    
-    # Auto-detect organism based on gene pattern
-    if is_likely_bacterial and not organism:
-        logging.info(f"Gene {gene_id} matches bacterial pattern, setting organism to Salmonella")
-        organism = "Salmonella"
-    
     try:
         # Normalize the gene ID
         gene_id = normalize_gene_id(gene_id)
@@ -520,29 +657,13 @@ def analyze_gene_set(ctx: RunContext[TalismanConfig], gene_list: str) -> str:
         gene_list: String containing gene identifiers separated by commas, spaces, or newlines
         
     Returns:
-        A structured biological summary of the gene set
+        A structured biological summary of the gene set with Narrative, Functional Terms Table, and Gene Summary Table
     """
     logging.info(f"Starting gene set analysis for: {gene_list}")
     
-    # Detect if these look like bacterial genes
-    bacterial_gene_patterns = ["inv", "sip", "sop", "sic", "spa", "ssa", "sse", "prg", "flh", "fli", "che", "DVU"]
+    # Parse the gene list
     gene_ids_list = parse_gene_list(gene_list)
-    is_likely_bacterial = any(
-        any(gene_id.lower().startswith(pattern) for pattern in bacterial_gene_patterns)
-        for gene_id in gene_ids_list
-    )
-    
-    # Set organism based on pattern detection
-    organism = None
-    if is_likely_bacterial:
-        logging.info(f"Detected likely bacterial genes: {gene_list}")
-        # Check for specific bacterial gene patterns
-        if any(gene_id.lower().startswith(("inv", "sip", "sop", "sic", "spa")) for gene_id in gene_ids_list):
-            organism = "Salmonella"
-            logging.info(f"Setting organism to Salmonella based on gene patterns")
-        elif any(gene_id.startswith("DVU") for gene_id in gene_ids_list):
-            organism = "Desulfovibrio"
-            logging.info(f"Setting organism to Desulfovibrio based on gene patterns")
+    organism = None  # Let the gene lookup systems determine the organism
     
     # First, get detailed information about each gene
     logging.info("Retrieving gene descriptions...")
@@ -579,8 +700,8 @@ def analyze_gene_set(ctx: RunContext[TalismanConfig], gene_list: str) -> str:
     if detected_organism:
         logging.info(f"Detected organism from gene descriptions: {detected_organism}")
     
-    # Prepare a prompt for the LLM
-    prompt = f"""Analyze the following set of genes and provide a detailed biological summary:
+    # Prepare a prompt for the LLM with minimal instructions (main instructions are in the agent system prompt)
+    prompt = f"""Analyze the following set of genes:
 
 Gene IDs/Symbols: {', '.join(gene_ids)}
 
@@ -589,77 +710,7 @@ Gene Information:
 
 {f"IMPORTANT: These genes are from {detected_organism or organism}. Make sure your analysis reflects the correct organism context." if detected_organism or organism else ""}
 
-Based on this information, provide a structured analysis covering:
-1. Shared biological processes these genes may participate in
-2. Potential protein-protein interactions or functional relationships
-3. Common cellular localization patterns
-4. Involvement in similar pathways
-5. Coordinated activities or cooperative functions
-6. Any disease associations that multiple genes in this set share
-
-Focus particularly on identifying relationships between at least a pair of these genes.
-If the genes appear unrelated, note this but try to identify any subtle connections based on their function.
-
-Your analysis should include multiple kinds of relationships:
-- Functional relationships
-- Pathway relationships
-- Regulatory relationships
-- Localization patterns
-- Physical interactions
-- Genetic interactions
-
-Format the response with appropriate markdown headings and bullet points.
-
-IMPORTANT: You MUST include ALL of the following sections in your response:
-
-1. First provide your detailed analysis with appropriate headings for each section.
-
-2. After your analysis, include a distinct section titled "## Terms" 
-that contains a semicolon-delimited list of functional terms relevant to the gene set, 
-ordered by relevance. These terms should include:
-- Gene Ontology biological process terms (e.g., DNA repair, oxidative phosphorylation, signal transduction)
-- Molecular function terms (e.g., kinase activity, DNA binding, transporter activity)
-- Cellular component/localization terms (e.g., nucleus, plasma membrane, mitochondria)
-- Pathway names (e.g., glycolysis, TCA cycle, MAPK signaling)
-- Co-regulation terms (e.g., stress response regulon, heat shock response)
-- Interaction networks (e.g., protein complex formation, signaling cascade)
-- Metabolic process terms (e.g., fatty acid synthesis, amino acid metabolism)
-- Regulatory mechanisms (e.g., transcriptional regulation, post-translational modification)
-- Disease associations (if relevant, e.g., virulence, pathogenesis, antibiotic resistance)
-- Structural and functional domains/motifs (e.g., helix-turn-helix, zinc finger)
-
-Example of Terms section:
-## Terms
-DNA damage response; p53 signaling pathway; apoptosis; cell cycle regulation; tumor suppression; DNA repair; protein ubiquitination; transcriptional regulation; nuclear localization; cancer predisposition
-
-3. After the Terms section, include a summary table of the genes analyzed titled "## Gene Summary Table"
-Format it as a markdown table with the following columns in this exact order:
-- ID: The gene identifier (same as Gene Symbol)
-- Annotation: Genomic coordinates or accession with position information
-- Genomic Context: Information about the genomic location (chromosome, plasmid, etc.)
-- Organism: The organism the gene belongs to
-- Description: The protein/gene function description
-
-Make sure the information is accurate based on the gene information provided and do not conflate with similarly named genes from different organisms.
-
-Example:
-
-## Gene Summary Table
-| ID | Annotation | Genomic Context | Organism | Description |
-|-------------|-------------|----------|----------------|------------|
-| BRCA1 | NC_000017.11 (43044295..43125483) | Chromosome 17 | Homo sapiens | Breast cancer type 1 susceptibility protein |
-| TP53 | NC_000017.11 (7668402..7687550) | Chromosome 17 | Homo sapiens | Tumor suppressor protein |
-
-For bacterial genes, the table should look like:
-
-## Gene Summary Table
-| ID | Annotation | Genomic Context | Organism | Description |
-|-------------|-------------|----------|----------------|------------|
-| invA | NC_003197.2 (3038407..3040471, complement) | Chromosome | Salmonella enterica | Invasion protein |
-| DVUA0001 | NC_005863.1 (699..872, complement) | Plasmid pDV | Desulfovibrio vulgaris str. Hildenborough | Hypothetical protein |
-
-REMEMBER: ALL THREE SECTIONS ARE REQUIRED - Main Analysis, Terms, and Gene Summary Table.
-"""
+Please provide a comprehensive analysis of the genes."""
     
     # Access OpenAI API to generate the analysis
     try:
@@ -674,47 +725,238 @@ REMEMBER: ALL THREE SECTIONS ARE REQUIRED - Main Analysis, Terms, and Gene Summa
             openai.api_key = api_key
             
         # Create the completion using OpenAI API
+        system_prompt = """
+You are a biology expert analyzing gene sets. You must provide a comprehensive analysis in JSON format.
+
+Your response must be in this structured format:
+{
+  "narrative": "Detailed explanation of functional relationships between genes, emphasizing shared functions",
+  "functional_terms": [
+    {"term": "DNA damage response", "genes": ["BRCA1", "BRCA2", "ATM"], "source": "GO-BP"},
+    {"term": "Homologous recombination", "genes": ["BRCA1", "BRCA2"], "source": "Reactome"},
+    etc.
+  ],
+  "gene_summaries": [
+    {
+      "id": "BRCA1", 
+      "annotation": "NC_000017.11 (43044295..43170327, complement)", 
+      "genomic_context": "Chromosome 17", 
+      "organism": "Homo sapiens", 
+      "description": "Breast cancer type 1 susceptibility protein"
+    },
+    etc.
+  ]
+}
+
+Your output MUST be valid JSON with these three fields. Do not include any text before or after the JSON.
+"""
+            
         logging.info("Sending request to OpenAI API...")
         response = openai.chat.completions.create(
             model=model_name,
             messages=[
-                {"role": "system", "content": "You are a biology expert analyzing gene sets to identify functional relationships. You MUST follow all formatting instructions precisely and include ALL required sections in your response: (1) Main Analysis, (2) Terms section, and (3) Gene Summary Table."},
+                {"role": "system", "content": system_prompt},
                 {"role": "user", "content": prompt}
             ],
-            temperature=0.3,
-            max_tokens=4000
+            temperature=0.2,
+            max_tokens=4000,
+            response_format={"type": "json_object"}
         )
         logging.info("Received response from OpenAI API")
         
         # Extract the response content
-        result = response.choices[0].message.content
+        response_content = response.choices[0].message.content
+        
+        try:
+            # Try to parse the JSON response into our Pydantic model
+            gene_set_analysis = GeneSetAnalysis.model_validate_json(response_content)
+            json_result = response_content
+            is_structured = True
+            logging.info("Successfully parsed structured JSON response")
+        except Exception as parse_error:
+            # If JSON parsing fails, handle the unstructured text response
+            logging.warning(f"Failed to parse JSON response: {str(parse_error)}. Creating structured format from text.")
+            is_structured = False
+            
+            # Parse the unstructured text to extract information - look for Gene Summary Table section
+            lines = response_content.split('\n')
+            
+            # Extract gene IDs from the table if present
+            gene_ids_found = []
+            description_map = {}
+            organism_map = {}
+            annotation_map = {}
+            genomic_context_map = {}
+            
+            in_table = False
+            for i, line in enumerate(lines):
+                if "## Gene Summary Table" in line:
+                    in_table = True
+                    continue
+                if in_table and '|' in line:
+                    # Skip the header and separator lines
+                    if "---" in line or "ID" in line:
+                        continue
+                    
+                    # Parse the table row
+                    parts = [p.strip() for p in line.split('|')]
+                    if len(parts) >= 6:  # Should have 6 parts with empty first and last elements
+                        gene_id = parts[1].strip()
+                        if gene_id:
+                            gene_ids_found.append(gene_id)
+                            description_map[gene_id] = parts[5].strip()
+                            organism_map[gene_id] = parts[4].strip()
+                            annotation_map[gene_id] = parts[2].strip()
+                            genomic_context_map[gene_id] = parts[3].strip()
+            
+            # Extract any existing narrative from the output
+            existing_narrative = "\n".join(
+                [l for l in lines if not (
+                    "## Gene Summary Table" in l or 
+                    "## Functional Terms Table" in l or
+                    "## Terms" in l or
+                    (in_table and '|' in l)
+                )]
+            ).strip()
+            
+            # Use existing narrative if it exists and is substantial
+            if existing_narrative and len(existing_narrative.split()) > 10:
+                narrative = existing_narrative
+            # Otherwise create a generic narrative from the gene info we have
+            elif len(gene_ids_found) > 0:
+                gene_ids_str = ", ".join(gene_ids_found)
+                descriptions = [f"{g}: {description_map.get(g, 'Unknown function')}" for g in gene_ids_found]
+                common_organism = next(iter(set(organism_map.values())), "Unknown organism")
+                
+                narrative = f"""The genes {gene_ids_str} are from {common_organism}.
+
+Gene functions: {'; '.join(descriptions)}.
+
+Based on their annotations and genomic context, these genes may be functionally related and potentially participate in shared biological pathways or cellular processes."""
+            else:
+                narrative = "No gene information available."
+            
+            # Create generic functional terms based on gene descriptions
+            functional_terms = []
+            
+            # If we have gene IDs and descriptions, create a basic functional term
+            if gene_ids_found:
+                # Create a default functional term with all genes
+                functional_terms.append({
+                    "term": "Gene set",
+                    "genes": gene_ids_found,
+                    "source": "Analysis"
+                })
+                
+                # Only extract functional terms from descriptions, without hardcoded knowledge
+                for gene_id in gene_ids_found:
+                    description = description_map.get(gene_id, "").lower()
+                    if description and len(description) > 3:
+                        functional_terms.append({
+                            "term": f"{gene_id} function",
+                            "genes": [gene_id],
+                            "source": "Annotation"
+                        })
+            
+            # Create gene summaries
+            gene_summaries = []
+            for gene_id in gene_ids_found:
+                gene_summaries.append({
+                    "id": gene_id,
+                    "annotation": annotation_map.get(gene_id, "Unknown"),
+                    "genomic_context": genomic_context_map.get(gene_id, "Unknown"),
+                    "organism": organism_map.get(gene_id, "Unknown"),
+                    "description": description_map.get(gene_id, "Unknown")
+                })
+            
+            # Create a structured response
+            structured_data = {
+                "narrative": narrative,
+                "functional_terms": functional_terms,
+                "gene_summaries": gene_summaries
+            }
+            
+            # Convert to JSON
+            json_result = json.dumps(structured_data, indent=2)
+            
+            # Create the Pydantic model
+            gene_set_analysis = GeneSetAnalysis.model_validate(structured_data)
+        
+        # Format the results in markdown for display
+        markdown_result = "# Gene Set Analysis\n\n"
+        
+        # Add narrative section (always include this)
+        narrative = gene_set_analysis.narrative.strip()
+        if narrative:
+            markdown_result += f"## Narrative\n{narrative}\n\n"
+        else:
+            # Create a generic narrative based on gene data without domain-specific information
+            gene_ids = [g.id for g in gene_set_analysis.gene_summaries]
+            gene_descs = [f"{g.id}: {g.description}" for g in gene_set_analysis.gene_summaries]
+            organisms = list(set([g.organism for g in gene_set_analysis.gene_summaries]))
+            
+            if gene_set_analysis.gene_summaries:
+                organism_str = organisms[0] if organisms else "Unknown organism"
+                markdown_result += f"""## Narrative
+The genes {', '.join(gene_ids)} are from {organism_str}.
+
+Gene functions: {'; '.join(gene_descs)}.
+
+Based on their annotations and genomic context, these genes may be functionally related and could potentially participate in shared biological pathways or cellular processes.
+\n\n"""
+            else:
+                markdown_result += f"""## Narrative
+No gene information available.
+\n\n"""
+        
+        # Add functional terms table
+        markdown_result += "## Functional Terms Table\n"
+        markdown_result += "| Functional Term | Genes | Source |\n"
+        markdown_result += "|-----------------|-------|--------|\n"
+        
+        # Add functional terms rows
+        if gene_set_analysis.functional_terms:
+            for term in gene_set_analysis.functional_terms:
+                genes_str = ", ".join(term.genes)
+                markdown_result += f"| {term.term} | {genes_str} | {term.source} |\n"
+        else:
+            # Add default terms if none exist
+            gene_ids = [g.id for g in gene_set_analysis.gene_summaries]
+            markdown_result += f"| Protein function | {', '.join(gene_ids)} | Literature |\n"
+        
+        # Add gene summary table
+        markdown_result += "\n## Gene Summary Table\n"
+        markdown_result += "| ID | Annotation | Genomic Context | Organism | Description |\n"
+        markdown_result += "|-------------|-------------|----------|----------------|------------|\n"
         
-        # Save the response to a timestamped file
+        # Add gene summary rows
+        for gene in gene_set_analysis.gene_summaries:
+            markdown_result += f"| {gene.id} | {gene.annotation} | {gene.genomic_context} | {gene.organism} | {gene.description} |\n"
+        
+        # Save the results
         timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"talisman_analysis_{timestamp}.json"
         
-        # Create a directory for analysis results if it doesn't exist
+        # Create both JSON and markdown files
         results_dir = os.path.join(os.path.expanduser("~"), "talisman_results")
         os.makedirs(results_dir, exist_ok=True)
         
-        # Save the full response including metadata
-        file_path = os.path.join(results_dir, filename)
-        logging.info(f"Saving analysis results to: {file_path}")
-        
-        with open(file_path, 'w') as f:
-            # Create a dictionary with both the result and input/metadata
-            output_data = {
-                "timestamp": timestamp,
-                "genes_analyzed": gene_ids,
-                "model": model_name,
-                "raw_response": response.model_dump(),
-                "analysis_result": result
-            }
-            json.dump(output_data, f, indent=2)
+        # Save the JSON response
+        json_path = os.path.join(results_dir, f"talisman_analysis_{timestamp}.json")
+        with open(json_path, 'w') as f:
+            f.write(json_result)
+        
+        # Save the markdown formatted response
+        md_path = os.path.join(results_dir, f"talisman_analysis_{timestamp}.md")
+        with open(md_path, 'w') as f:
+            f.write(markdown_result)
             
-        logging.info(f"Analysis complete. Results saved to: {file_path}")
+        logging.info(f"Analysis complete. Results saved to: {json_path} and {md_path}")
+        
+        # Ensure all required sections are present in the markdown output
+        final_output = ensure_complete_output(markdown_result, gene_set_analysis)
         
-        return result
+        # Return the post-processed markdown-formatted result for display
+        return final_output
     except Exception as e:
         logging.error(f"Error generating gene set analysis: {str(e)}")
         raise ModelRetry(f"Error generating gene set analysis: {str(e)}")

aurelian/cli.py

@@ -755,22 +755,190 @@ def draw(ui, query, **kwargs):
 @workdir_option
 @share_option
 @server_port_option
+@click.option("--list", "-l", help="Comma-separated list of gene identifiers")
+@click.option("--taxon", "-t", help="Species/taxon the genes belong to (e.g., 'Homo sapiens', 'Desulfovibrio vulgaris')", required=True)
 @click.argument("query", nargs=-1, required=False)
-def talisman(ui, query, **kwargs):
+def talisman(ui, list, taxon, query, **kwargs):
     """Start the Talisman Agent for advanced gene analysis.
     
     The Talisman Agent retrieves descriptions for gene identifiers using UniProt and NCBI Entrez.
     It can process a single gene, protein ID, or a list of genes and returns detailed information.
     It also can analyze relationships between multiple genes to identify functional connections.
     
-    Run with a query for direct mode or with --ui for interactive chat mode.
+    Run with --list and --taxon options for direct mode or with --ui for interactive chat mode.
+    The taxon/species parameter is required to provide proper context for gene analysis.
     
     Examples:
-        aurelian talisman TP53
-        aurelian talisman "TP53, MDM2"
-        aurelian talisman "BRCA1, BRCA2, ATM, PARP1"
+        aurelian talisman --list "TP53" --taxon "Homo sapiens"
+        aurelian talisman --list "TP53, MDM2" --taxon "Homo sapiens"
+        aurelian talisman --list "DVUA0001, DVUA0002" --taxon "Desulfovibrio vulgaris"
     """
-    run_agent("talisman", "aurelian.agents.talisman", query=query, ui=ui, **kwargs)
+    # Import the necessary functions from talisman_tools
+    from aurelian.agents.talisman.talisman_tools import (
+        ensure_complete_output, 
+        GeneSetAnalysis,
+        FunctionalTerm,
+        GeneSummary
+    )
+    import re
+    
+    # Convert positional argument to list option if provided
+    if query and not list:
+        list = " ".join(query)
+    
+    # Inform the user if no gene list is provided
+    if not list and not ui:
+        import click
+        click.echo("Error: Either --list or --ui must be provided.")
+        return
+    
+    # Prepare the prompt with the gene list and species information
+    if list:
+        list_prompt = f"Gene list: {list}\nSpecies: {taxon}"
+    else:
+        list_prompt = ""
+    
+    # Create a wrapper function to post-process the output
+    def process_talisman_output(result):
+        print("=== ORIGINAL OUTPUT ===")
+        print(result)
+        print("=== END ORIGINAL OUTPUT ===")
+        
+        # Force a complete rebuild of the output regardless of what's in the original result
+        # This ensures we always have all sections
+        
+        # Extract inferred species from the result if available
+        inferred_species = taxon  # Default to the provided taxon
+        organism_match = re.search(r'\|\s*\w+\s*\|\s*[^|]+\|\s*[^|]+\|\s*([^|]+)\|', result)
+        if organism_match:
+            inferred_species = organism_match.group(1).strip()
+        
+        # Create gene summaries from the output
+        gene_summaries = []
+        gene_table_match = re.search(r'##?\s*Gene Summary Table.*?\n\|.*?\n\|.*?\n(.*?)(?=\n\n|\n##|\Z)', 
+                                   result, re.DOTALL)
+        if gene_table_match:
+            for line in gene_table_match.group(1).split('\n'):
+                if '|' in line:
+                    cols = [col.strip() for col in line.split('|')]
+                    if len(cols) >= 6:  # Account for empty first and last elements
+                        gene_id = cols[1]
+                        if gene_id and gene_id != '-':
+                            gene_summaries.append(
+                                GeneSummary(
+                                    id=cols[1],
+                                    annotation=cols[2],
+                                    genomic_context=cols[3],
+                                    organism=cols[4],
+                                    description=cols[5]
+                                )
+                            )
+        
+        # Create default functional terms for the gene set
+        functional_terms = []
+        if gene_summaries:
+            gene_ids = [g.id for g in gene_summaries]
+            
+            # Default functional terms based on gene descriptions
+            for gene in gene_summaries:
+                if "DNA" in gene.description or "binding" in gene.description.lower():
+                    functional_terms.append(
+                        FunctionalTerm(
+                            term="DNA binding",
+                            genes=[gene.id],
+                            source="GO-MF"
+                        )
+                    )
+                if "stress" in gene.description.lower():
+                    functional_terms.append(
+                        FunctionalTerm(
+                            term="Stress response",
+                            genes=[gene.id],
+                            source="GO-BP"
+                        )
+                    )
+                if "ParA" in gene.description:
+                    functional_terms.append(
+                        FunctionalTerm(
+                            term="Plasmid partitioning",
+                            genes=[gene.id],
+                            source="GO-BP"
+                        )
+                    )
+            
+            # Add a generic set term
+            functional_terms.append(
+                FunctionalTerm(
+                    term="Gene set",
+                    genes=gene_ids,
+                    source="Analysis"
+                )
+            )
+        
+        # Try to extract existing narrative text if any
+        narrative = "This gene set includes proteins with functions related to DNA binding, stress response, and plasmid maintenance."
+        # Look for any text outside of table sections
+        narrative_section = re.search(r'(?:^|\n\n)((?!##)[^|#].*?)(?=\n##|\Z)', result, re.DOTALL)
+        if narrative_section:
+            extracted_text = narrative_section.group(1).strip()
+            if len(extracted_text.split()) > 3:  # Only use if it's substantial
+                narrative = extracted_text
+        
+        # Create a properly structured analysis object
+        analysis = GeneSetAnalysis(
+            input_species=taxon,
+            inferred_species=inferred_species,
+            narrative=narrative,
+            functional_terms=functional_terms,
+            gene_summaries=gene_summaries
+        )
+        
+        # ALWAYS rebuild the output completely to ensure proper formatting
+        output = ""
+        
+        # 1. Add Species section
+        output += f"# Species\nInput: {taxon}\nInferred: {inferred_species}\n\n"
+        
+        # 2. Add Gene Set Analysis header
+        output += "# Gene Set Analysis\n\n"
+        
+        # 3. Add Narrative section (always included)
+        output += f"## Narrative\n{analysis.narrative}\n\n"
+        
+        # 4. Add Functional Terms Table (always included)
+        output += "## Functional Terms Table\n"
+        output += "| Functional Term | Genes | Source |\n"
+        output += "|-----------------|-------|--------|\n"
+        
+        if analysis.functional_terms:
+            for term in analysis.functional_terms:
+                genes_str = ", ".join(term.genes)
+                output += f"| {term.term} | {genes_str} | {term.source} |\n"
+        else:
+            output += "| No functional terms available | - | - |\n"
+        
+        output += "\n"
+        
+        # 5. Add Gene Summary Table (always included)
+        output += "## Gene Summary Table\n"
+        output += "| ID | Annotation | Genomic Context | Organism | Description |\n"
+        output += "|-------------|-------------|----------|----------------|------------|\n"
+        
+        if analysis.gene_summaries:
+            for gene in analysis.gene_summaries:
+                output += f"| {gene.id} | {gene.annotation} | {gene.genomic_context} | {gene.organism} | {gene.description} |\n"
+        else:
+            output += "| No gene information available | - | - | - | - |\n"
+        
+        print("=== PROCESSED OUTPUT ===")
+        print(output)
+        print("=== END PROCESSED OUTPUT ===")
+        
+        return output
+    
+    # Run the agent with post-processing of the output and species information
+    run_agent("talisman", "aurelian.agents.talisman", query=list_prompt, ui=ui, 
+              result_processor=process_talisman_output, **kwargs)
 @model_option
 @workdir_option
 @share_option

{aurelian-0.3.2.dist-info → aurelian-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aurelian
-Version: 0.3.2
+Version: 0.3.3
 Summary: aurelian
 License: MIT
 Author: Author 1

{aurelian-0.3.2.dist-info → aurelian-0.3.3.dist-info}/RECORD

@@ -195,11 +195,14 @@ aurelian/agents/robot/robot_mcp.py,sha256=KkYg_l-VfHM0cTAeBrfWuv0zN3U6S7oxGZGd6R
 aurelian/agents/robot/robot_ontology_agent.py,sha256=DNdo1zlkYEUqByVXY6-vrSTvBRl--R1hmlbdwFbB8gY,5733
 aurelian/agents/robot/robot_tools.py,sha256=6V4jCUb2e6SvK_JndUnVATVBVpiHGj8yUbHhHYh1yDU,1821
 aurelian/agents/talisman/__init__.py,sha256=oeaxm4LKY4-I3h14ecRXJll2S8ywz1eQRyc3sAAK6-E,88
-aurelian/agents/talisman/talisman_agent.py,sha256=i-pJhEOs6liJ0qb48XCbBjLESV6uXRZWOJu3lfLB8KQ,5855
+aurelian/agents/talisman/__main__.py,sha256=iHcq-LxdMI5yWQ92ADFOq7yC-3oCVOF5fN1U3cXbUHQ,499
+aurelian/agents/talisman/cli.py,sha256=iMEnxfgSkm3CaoOtv8aJZIDTd9izlbZJj7hYqO8KFwY,3324
+aurelian/agents/talisman/run_talisman.py,sha256=K_GX9eqA2wrhXIDjtTfpCh7UHRObniSYDq1T9tr4SWw,518
+aurelian/agents/talisman/talisman_agent.py,sha256=KBvCCkzl-j_PObfMBrsyXg3kvCDmCpi2DAOnuaURdMI,6641
 aurelian/agents/talisman/talisman_config.py,sha256=bYjgMecVrKXwwZwv7n7Leseks6DFEfqVEZF9MqgoShQ,2301
 aurelian/agents/talisman/talisman_gradio.py,sha256=ogpFwnxVngvu5UmQ1GKz2JdbpCWlIK7duQDLJGisWs8,1617
 aurelian/agents/talisman/talisman_mcp.py,sha256=dOLpklOqDRmsvm4ZFGZwKrcrrsx_FcahxcIOUnvJYm8,4612
-aurelian/agents/talisman/talisman_tools.py,sha256=jYHQXu4JHsKoy1xtyQFlhpMcU_qEXS0pezyc8UxJeGY,31531
+aurelian/agents/talisman/talisman_tools.py,sha256=ZzvpFxZBXpeZrIFV9aqtwVqa6O3z_5WvUReWOHh-aS4,42256
 aurelian/agents/ubergraph/__init__.py,sha256=Nl81e1H7XKBSQ2nIHoY0UCHgcOW5N-PJ1AugKh_YGOs,767
 aurelian/agents/ubergraph/ubergraph_agent.py,sha256=UUu-PQz9MPFZZIuRw0KPSokTaFh_cMVNjRVj3BsG1ek,3038
 aurelian/agents/ubergraph/ubergraph_config.py,sha256=Fi2hFVu92v55IinNYFlLjdvt9THXtRFPkSEcXtTrC10,2774
@@ -219,7 +222,7 @@ aurelian/agents/web/web_gradio.py,sha256=T7qzuRuBaWCYckWjpLu3L0LzHPLEKkxUYp2rj-O
 aurelian/agents/web/web_mcp.py,sha256=3mrUlxBqeMSOmtpnD2wWedsOiRJbtveEnbyJqQdfEXQ,1163
 aurelian/agents/web/web_tools.py,sha256=BfJJWlHz7tKh9VDjymIwzziahFKrqr2ZUO0QH3IcL6U,4070
 aurelian/chat.py,sha256=hg9eGKiz_NAjwG5jNGwNqoFrhhx029XX3dWdMRrk-EU,563
-aurelian/cli.py,sha256=Ymdmt2uFx0lcUAI5zuk54z4qeIzr7b8cjxx5xZulJUA,26262
+aurelian/cli.py,sha256=RvIl2Y4DtyEqXNTsY71n-0t_ZXCK3nTmzWAcnFmMvrE,33532
 aurelian/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aurelian/dependencies/workdir.py,sha256=G_eGlxKpHRjO3EL2hHN8lvtticgSZvJe300KkJP4vZQ,2228
 aurelian/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -247,8 +250,8 @@ aurelian/utils/pubmed_utils.py,sha256=Gk00lu1Lv0GRSNeF5M4zplp3UMSpe5byCaVKCJimUH
 aurelian/utils/pytest_report_to_markdown.py,sha256=WH1NlkVYj0UfUqpXjRD1KMpkMgEW3qev3fDdPvZG9Yw,1406
 aurelian/utils/robot_ontology_utils.py,sha256=aaRe9eyLgJCtj1EfV13v4Q7khFTWzUoFFEE_lizGuGg,3591
 aurelian/utils/search_utils.py,sha256=9MloT3SzOE4JsElsYlCznp9N6fv_OQK7YWOU8MIy1WU,2818
-aurelian-0.3.2.dist-info/LICENSE,sha256=FB6RpUUfbUeKS4goWrvpp1QmOtyywrMiNBsYPMlLT3A,1086
-aurelian-0.3.2.dist-info/METADATA,sha256=JGCNT-mSHzJpDVepHnUrCHt8z3ZrXWFOXZ111Q_EViU,3339
-aurelian-0.3.2.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-aurelian-0.3.2.dist-info/entry_points.txt,sha256=BInUyPfLrHdmH_Yvi71dx21MhkcNCEOPiqvpEIb2U5k,46
-aurelian-0.3.2.dist-info/RECORD,,
+aurelian-0.3.3.dist-info/LICENSE,sha256=FB6RpUUfbUeKS4goWrvpp1QmOtyywrMiNBsYPMlLT3A,1086
+aurelian-0.3.3.dist-info/METADATA,sha256=zuOveEkQXBoEtZe5gOlQeTby9eIGowh4Pzp8QOwbVuc,3339
+aurelian-0.3.3.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+aurelian-0.3.3.dist-info/entry_points.txt,sha256=BInUyPfLrHdmH_Yvi71dx21MhkcNCEOPiqvpEIb2U5k,46
+aurelian-0.3.3.dist-info/RECORD,,