fix(blast): poll cap 65min, DNA validation, program/db/max_hits params

.env.example

@@ -0,0 +1,22 @@
+# Required
+SUPABASE_URL=
+SUPABASE_SERVICE_ROLE_KEY=
+GROQ_API_KEY=
+
+# Optional (with defaults)
+REDIS_URL=redis://localhost:6379
+DAILY_LIMIT=10
+DEFAULT_MODEL=groq/llama-3.3-70b-versatile
+CORS_ORIGIN=https://bio-nexus.vercel.app
+
+# R2 (optional — falls back to local filesystem)
+R2_ACCOUNT_ID=
+R2_ACCESS_KEY_ID=
+R2_SECRET_ACCESS_KEY=
+R2_BUCKET_NAME=bioflow-raw-responses
+
+# Demo mode (optional — returns cached results for known sequences)
+DEMO_MODE=false
+
+# Hugging Face CLI (optional — for `hf upload` deploys only, not read by the app)
+HF_TOKEN=

Dockerfile

@@ -1,27 +1,31 @@
 FROM python:3.11-slim
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential gcc autoconf automake pkg-config wget && \
+    build-essential gcc g++ wget ca-certificates \
+    openbabel libgl1 libgomp1 libopenblas-dev \
+    libxml2 libxslt1.1 && \
     rm -rf /var/lib/apt/lists/*
 
-# Build PhyML from source (~2 min)
-RUN wget -qO /tmp/phyml.tar.gz \
-      https://github.com/stephaneguindon/phyml/archive/refs/tags/v3.3.20250515.tar.gz && \
-    tar xzf /tmp/phyml.tar.gz -C /tmp && \
-    cd /tmp/phyml-3.3.20250515 && \
-    ./autogen.sh && \
-    ./configure --enable-phyml && \
-    make -j$(nproc) && \
-    make install && \
-    cd / && \
-    rm -rf /tmp/phyml-3.3.20250515 /tmp/phyml.tar.gz
+# Download pre-compiled PhyML binary from bioconda
+RUN wget -qO /tmp/phyml.tar.bz2 \
+      https://anaconda.org/bioconda/phyml/3.3.20220408/download/linux-64/phyml-3.3.20220408-h9bc3f66_3.tar.bz2 && \
+    tar xjf /tmp/phyml.tar.bz2 -C /tmp && \
+    cp /tmp/bin/phyml /usr/local/bin/phyml && \
+    chmod +x /usr/local/bin/phyml && \
+    rm -rf /tmp/phyml.tar.bz2 /tmp/bin
+
+# Download pre-compiled AutoDock Vina binary from GitHub releases
+RUN wget -q "https://github.com/ccsb-scripps/AutoDock-Vina/releases/download/v1.2.7/vina_1.2.7_linux_x86_64" -O /usr/local/bin/vina && \
+    chmod +x /usr/local/bin/vina
 
 WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
-# primer3-py is optional (requires C compiler) — skip silently if it fails
+
+# primer3-py is optional — skip silently if it fails
 RUN pip install --no-cache-dir primer3-py>=2.0.3 2>/dev/null || echo "primer3-py skipped (optional)"
+
 COPY . .
 
 EXPOSE 7860
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["sh", "-c", "python -c 'import openmm; print(\"OpenMM\", openmm.__version__)' && uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}"]

Dockerfile.worker

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential gcc wget ca-certificates openbabel libgomp1 && \
+    rm -rf /var/lib/apt/lists/*
+
+# AutoDock Vina
+RUN wget -q "https://github.com/ccsb-scripps/AutoDock-Vina/releases/download/v1.2.7/vina_1.2.7_linux_x86_64" -O /usr/local/bin/vina && \
+    chmod +x /usr/local/bin/vina
+
+# minimap2 (for sequencing)
+RUN wget -q https://github.com/lh3/minimap2/releases/download/v2.28/minimap2-2.28_x64-linux.tar.bz2 -O /tmp/minimap2.tar.bz2 && \
+    tar xjf /tmp/minimap2.tar.bz2 -C /tmp && \
+    cp /tmp/minimap2-2.28_x64-linux/minimap2 /usr/local/bin/minimap2 && \
+    chmod +x /usr/local/bin/minimap2 && \
+    rm -rf /tmp/minimap2*
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+
+CMD ["python", "-m", "app.worker"]

app/__main__.py

@@ -0,0 +1,3 @@
+"""python -m app.worker"""
+from app.worker import main
+main()

app/ai/interpreter.py

@@ -0,0 +1,59 @@
+import json
+import logging
+from typing import AsyncGenerator
+from litellm import acompletion
+from app.config import settings
+from app.ai.llm_client import llm_client
+from app.ai.prompts import get_prompt
+
+logger = logging.getLogger(__name__)
+
+
+async def interpret_stream(pipeline_type: str, context: dict) -> AsyncGenerator[str, None]:
+    providers = llm_client.get_providers()
+    if not providers:
+        yield _error_event("No LLM API keys configured. AI interpretation unavailable.")
+        return
+
+    prompt = llm_client.build_prompt(pipeline_type, context)
+    last_error = None
+
+    for provider in providers:
+        try:
+            response = await acompletion(
+                model=provider["model"],
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.3,
+                max_tokens=2000,
+                stream=True,
+                timeout=25,
+                api_key=provider["api_key"],
+            )
+            async for chunk in response:
+                if chunk.choices and chunk.choices[0].delta.content:
+                    yield _chunk_event(chunk.choices[0].delta.content)
+
+            yield _done_event({"model": provider["model"], "pipeline_type": pipeline_type})
+            return
+        except Exception as e:
+            last_error = e
+            logger.warning("LLM provider %s failed: %s", provider["name"], e)
+            continue
+
+    msg = str(last_error) if last_error else "All providers failed"
+    if "organization_restricted" in msg or "Organization has been restricted" in msg:
+        yield _error_event("AI interpretation is temporarily unavailable due to a provider restriction. Please try again later.")
+    else:
+        yield _error_event(f"AI interpretation failed: {msg}")
+
+
+def _chunk_event(text: str) -> str:
+    return f"data: {json.dumps({'chunk': text})}\n\n"
+
+
+def _done_event(meta: dict) -> str:
+    return f"data: {json.dumps({'done': True, 'meta': meta})}\n\n"
+
+
+def _error_event(msg: str) -> str:
+    return f"data: {json.dumps({'error': msg})}\n\n"

app/ai/llm_client.py

@@ -0,0 +1,57 @@
+import os
+import logging
+from app.config import settings
+from app.ai.prompts import get_prompt
+
+logger = logging.getLogger(__name__)
+
+
+class LLMClient:
+    def __init__(self):
+        self.api_key = settings.GROQ_API_KEY
+        self.fallback_key = settings.GOOGLE_API_KEY
+        self.model = settings.DEFAULT_MODEL
+        self.fallback_model = "gemini/gemini-2.0-flash"
+        self.pro_model = settings.PRO_MODEL
+
+    def has_api_key(self) -> bool:
+        return bool(self.api_key) or bool(self.fallback_key)
+
+    def get_providers(self) -> list[dict]:
+        providers = []
+        if self.api_key:
+            providers.append({"model": self.model, "api_key": self.api_key, "name": "groq"})
+        if self.fallback_key:
+            providers.append({"model": self.fallback_model, "api_key": self.fallback_key, "name": "gemini"})
+        return providers
+
+    def build_prompt(self, pipeline_type: str, context: dict) -> str:
+        template = get_prompt(pipeline_type)
+        blast = context.get("blast", {})
+        top = blast.get("top_hit", {})
+        uniprot = context.get("uniprot", {}) or {}
+        af = context.get("alphafold", {}) or {}
+
+        return template.format(
+            blast_count=blast.get("count", 0),
+            top_hit_accession=top.get("accession", "N/A"),
+            top_hit_description=top.get("description", "N/A"),
+            top_hit_evalue=top.get("evalue", "N/A"),
+            top_hit_identity_pct=top.get("identity_pct", "N/A"),
+            top_hit_bit_score=top.get("bit_score", "N/A"),
+            uniprot_name=uniprot.get("full_name", "N/A"),
+            uniprot_organism=uniprot.get("organism", "N/A"),
+            uniprot_genes=", ".join(uniprot.get("gene_names", []) or []) or "N/A",
+            uniprot_functions="; ".join(uniprot.get("functions", []) or []) or "N/A",
+            uniprot_locations="; ".join(uniprot.get("subcellular_locations", []) or []) or "N/A",
+            uniprot_keywords=", ".join(uniprot.get("keywords", []) or []) or "N/A",
+            uniprot_go_terms=", ".join(uniprot.get("go_terms", []) or []) or "N/A",
+            uniprot_features="; ".join(
+                f"{f.get('type', '')}: {f.get('description', '')}" for f in (uniprot.get("features", []) or [])
+            ) or "N/A",
+            alphafold_available="Yes" if af.get("structure_available") else "No",
+            alphafold_confidence=af.get("confidence", "N/A"),
+        )
+
+
+llm_client = LLMClient()

app/ai/prompts.py

@@ -0,0 +1,47 @@
+PROTEIN_ANALYSIS_PROMPT = """You are a computational biology assistant at Bio Nexus. A researcher submitted a protein sequence, and the system ran BLAST, UniProt lookup, and AlphaFold structure retrieval. Here is the complete assembled context.
+
+## BLAST Results
+- Total hits found: {blast_count}
+- Top hit: {top_hit_description} (accession {top_hit_accession})
+- E-value: {top_hit_evalue}
+- Sequence identity: {top_hit_identity_pct}%
+- Bit score: {top_hit_bit_score}
+
+## UniProt Annotations (Top Hit)
+- Protein name: {uniprot_name}
+- Organism: {uniprot_organism}
+- Gene: {uniprot_genes}
+- Function: {uniprot_functions}
+- Subcellular location: {uniprot_locations}
+- Keywords: {uniprot_keywords}
+- GO terms: {uniprot_go_terms}
+- Active sites / binding regions: {uniprot_features}
+
+## AlphaFold Structure
+- Structure available: {alphafold_available}
+- Confidence score (pLDDT): {alphafold_confidence}
+
+## Instructions for your response
+1. Explain what the query protein likely is based on the BLAST hits and UniProt annotations.
+2. Interpret the E-value and identity percentage — what they mean for confidence in the match.
+3. Summarize the protein's function, cellular location, and any known domains or active sites.
+4. If an AlphaFold structure is available, note its confidence and what that means.
+5. Give a concise bottom-line assessment: what the researcher should conclude from this analysis.
+6. If experimental validation (e.g., PCR, qPCR, mutagenesis) would be useful to confirm function or expression, suggest it briefly.
+7. Use plain language. Avoid unnecessary jargon. When you use technical terms, explain them briefly.
+
+Write in a helpful, instructive tone. If any data is missing, state that honestly."""
+
+
+FALLBACK_PROMPT = """You are a computational biology assistant. The following BLAST search results were returned, but detailed annotations are not available. Summarize the search results and help the user understand what the top hits mean.
+
+BLAST search found {blast_count} hits.
+Top hit: {top_hit_description} (E-value: {top_hit_evalue}, Identity: {top_hit_identity_pct}%)
+"""
+
+
+def get_prompt(pipeline_type: str) -> str:
+    prompts = {
+        "protein_analysis": PROTEIN_ANALYSIS_PROMPT,
+    }
+    return prompts.get(pipeline_type, FALLBACK_PROMPT)

app/config.py

@@ -0,0 +1,37 @@
+import os
+from dotenv import load_dotenv, dotenv_values
+
+# Load from .env.deploy first, then .env, then env vars
+_env_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), ".env.deploy")
+if os.path.exists(_env_path):
+    load_dotenv(_env_path)
+    _env_file = dotenv_values(_env_path)
+else:
+    load_dotenv()
+    _env_file = dotenv_values()
+_env_supabase_url = _env_file.get("SUPABASE_URL")
+_env_supabase_key = _env_file.get("SUPABASE_SERVICE_ROLE_KEY")
+
+
+class Settings:
+    GROQ_API_KEY: str = os.getenv("GROQ_API_KEY", "")
+    GOOGLE_API_KEY: str = os.getenv("GOOGLE_API_KEY", "")
+    REDIS_URL: str = os.getenv("REDIS_URL", "redis://localhost:6379")
+    SUPABASE_URL: str = _env_supabase_url or os.getenv("SUPABASE_URL", "")
+    SUPABASE_SERVICE_ROLE_KEY: str = _env_supabase_key or os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
+    CELERY_BROKER_URL: str = os.getenv("CELERY_BROKER_URL", "redis://localhost:6379/1")
+    CELERY_RESULT_BACKEND: str = os.getenv("CELERY_RESULT_BACKEND", "redis://localhost:6379/2")
+    EBI_BASE_URL: str = "https://www.ebi.ac.uk/Tools/services/rest/ncbiblast"
+    UNIPROT_BASE_URL: str = "https://rest.uniprot.org/uniprotkb"
+    ALPHAFOLD_DB_URL: str = "https://alphafold.ebi.ac.uk/api/prediction"
+    DAILY_LIMIT: int = 10
+    DEFAULT_MODEL: str = os.getenv("DEFAULT_MODEL", "groq/llama-3.3-70b-versatile")
+    PRO_MODEL: str = os.getenv("PRO_MODEL", "claude-sonnet-4-20250514")
+    NCBI_EMAIL: str = os.getenv("NCBI_EMAIL", "bioflow@example.com")
+    NCBI_API_KEY: str = os.getenv("NCBI_API_KEY", "")
+    DEMO_MODE: bool = os.getenv("DEMO_MODE", "false").lower() in ("true", "1", "yes")
+    CORS_ORIGIN: str = os.getenv("CORS_ORIGIN", "https://bioai-platform.vercel.app")
+    SENTRY_DSN: str = os.getenv("SENTRY_DSN", "")
+
+
+settings = Settings()

app/core/storage.py

@@ -0,0 +1,74 @@
+import os
+import json
+import uuid
+from datetime import datetime
+from typing import Optional
+from app.config import settings
+
+_STORE_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "raw_store")
+R2_ENABLED = all([
+    os.getenv("R2_ACCOUNT_ID"),
+    os.getenv("R2_ACCESS_KEY_ID"),
+    os.getenv("R2_SECRET_ACCESS_KEY"),
+])
+
+
+async def store_raw_response(
+    job_id: str,
+    step: str,
+    service: str,
+    data: str,
+    fmt: str = "xml",
+) -> str:
+    key = f"raw/{job_id}/{step}-{service}.{fmt}"
+    if R2_ENABLED:
+        return await _store_r2(key, data)
+    return _store_local(key, data)
+
+
+async def store_result(
+    job_id: str,
+    result_type: str,
+    data: dict,
+    fmt: str = "json",
+) -> str:
+    key = f"results/{job_id}/{result_type}.{fmt}"
+    payload = json.dumps(data)
+    if R2_ENABLED:
+        return await _store_r2(key, payload)
+    return _store_local(key, payload)
+
+
+def _store_local(key: str, data: str) -> str:
+    path = os.path.join(_STORE_DIR, key)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(data)
+    return path
+
+
+async def _store_r2(key: str, data: str) -> str:
+    try:
+        import boto3
+        from botocore.config import Config
+        s3 = boto3.client(
+            "s3",
+            endpoint_url=f"https://{os.getenv('R2_ACCOUNT_ID')}.r2.cloudflarestorage.com",
+            aws_access_key_id=os.getenv("R2_ACCESS_KEY_ID"),
+            aws_secret_access_key=os.getenv("R2_SECRET_ACCESS_KEY"),
+            config=Config(signature_version="s3v4"),
+        )
+        bucket = os.getenv("R2_BUCKET_NAME", "bioflow-raw-responses")
+        s3.put_object(Bucket=bucket, Key=key, Body=data.encode(), ContentType="text/plain")
+        return f"r2://{bucket}/{key}"
+    except Exception as e:
+        return _store_local(key, data)
+
+
+def get_stored_response(path_or_key: str) -> Optional[str]:
+    if path_or_key.startswith("r2://"):
+        return None
+    if os.path.exists(path_or_key):
+        with open(path_or_key, "r", encoding="utf-8") as f:
+            return f.read()
+    return None

app/data/demo_results.py

@@ -0,0 +1,661 @@
+"""
+Demo-mode fallback BLAST results for well-characterized sequences.
+
+Used when DEMO_MODE=true or when NCBI API is unavailable.
+Provides instant results for the demo sequences below.
+"""
+
+DEMO_SEQUENCES = {
+    "P53_HUMAN": {
+        "accession": "NP_000537.3",
+        "uniprot_accession": "P04637",
+        "name": "p53",
+        "description": "Cellular tumor antigen p53 [Homo sapiens]",
+        "sequence": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+        "length": 393,
+        "organism": "Homo sapiens",
+    },
+    "INSULIN_HUMAN": {
+        "accession": "NP_000198.1",
+        "uniprot_accession": "P01308",
+        "name": "insulin",
+        "description": "Insulin [Homo sapiens]",
+        "sequence": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+        "length": 110,
+        "organism": "Homo sapiens",
+    },
+    "HBA_HUMAN": {
+        "accession": "NP_000549.1",
+        "uniprot_accession": "P69905",
+        "name": "hemoglobin subunit alpha",
+        "description": "Hemoglobin subunit alpha [Homo sapiens]",
+        "sequence": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+        "length": 142,
+        "organism": "Homo sapiens",
+    },
+    "BRCA1_HUMAN": {
+        "accession": "NP_009225.1",
+        "uniprot_accession": "P38398",
+        "name": "BRCA1 fragment",
+        "description": "Breast cancer type 1 susceptibility protein (BRCT domain) [Homo sapiens]",
+        "sequence": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKETEGLEKAKPNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+        "length": 160,
+        "organism": "Homo sapiens",
+    },
+}
+
+DEMO_BLAST_RESULTS = {
+    "NP_000537.3": {
+        "query_length": 393,
+        "hits": [
+            {
+                "accession": "NP_000537.3",
+                "id": "NP_000537.3",
+                "description": "Cellular tumor antigen p53",
+                "organism": "Homo sapiens",
+                "length": 393,
+                "score": 2506,
+                "bit_score": 2506.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 393,
+                "identity_pct": 100.0,
+                "positive": 393,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 393,
+                "query_from": 1,
+                "query_to": 393,
+                "hit_from": 1,
+                "hit_to": 393,
+                "query_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "hit_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "midline": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+            },
+            {
+                "accession": "XP_016780942.1",
+                "id": "XP_016780942.1",
+                "description": "cellular tumor antigen p53 isoform X1",
+                "organism": "Pan troglodytes",
+                "length": 393,
+                "score": 2476,
+                "bit_score": 2476.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 391,
+                "identity_pct": 99.5,
+                "positive": 392,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 393,
+                "query_from": 1,
+                "query_to": 393,
+                "hit_from": 1,
+                "hit_to": 393,
+                "query_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "hit_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "midline": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+            },
+            {
+                "accession": "NP_001347728.1",
+                "id": "NP_001347728.1",
+                "description": "cellular tumor antigen p53",
+                "organism": "Macaca mulatta",
+                "length": 393,
+                "score": 2446,
+                "bit_score": 2446.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 387,
+                "identity_pct": 98.5,
+                "positive": 389,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 393,
+                "query_from": 1,
+                "query_to": 393,
+                "hit_from": 1,
+                "hit_to": 393,
+                "query_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "hit_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "midline": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+            },
+            {
+                "accession": "NP_001003210.1",
+                "id": "NP_001003210.1",
+                "description": "cellular tumor antigen p53",
+                "organism": "Canis lupus familiaris",
+                "length": 392,
+                "score": 2337,
+                "bit_score": 2337.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 371,
+                "identity_pct": 94.4,
+                "positive": 378,
+                "gaps": 1,
+                "query_coverage_pct": 99.7,
+                "alignment_length": 392,
+                "query_from": 1,
+                "query_to": 392,
+                "hit_from": 1,
+                "hit_to": 392,
+                "query_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "hit_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "midline": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+            },
+            {
+                "accession": "NP_035770.2",
+                "id": "NP_035770.2",
+                "description": "cellular tumor antigen p53",
+                "organism": "Mus musculus",
+                "length": 387,
+                "score": 2211,
+                "bit_score": 2211.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 354,
+                "identity_pct": 90.1,
+                "positive": 365,
+                "gaps": 3,
+                "query_coverage_pct": 98.5,
+                "alignment_length": 387,
+                "query_from": 1,
+                "query_to": 387,
+                "hit_from": 1,
+                "hit_to": 387,
+                "query_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "hit_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "midline": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+            },
+            {
+                "accession": "NP_001106727.1",
+                "id": "NP_001106727.1",
+                "description": "cellular tumor antigen p53",
+                "organism": "Rattus norvegicus",
+                "length": 391,
+                "score": 2197,
+                "bit_score": 2197.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 350,
+                "identity_pct": 89.5,
+                "positive": 363,
+                "gaps": 3,
+                "query_coverage_pct": 97.9,
+                "alignment_length": 385,
+                "query_from": 1,
+                "query_to": 385,
+                "hit_from": 1,
+                "hit_to": 385,
+                "query_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "hit_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "midline": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+            },
+            {
+                "accession": "NP_989643.1",
+                "id": "NP_989643.1",
+                "description": "cellular tumor antigen p53",
+                "organism": "Gallus gallus",
+                "length": 368,
+                "score": 1785,
+                "bit_score": 1785.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 293,
+                "identity_pct": 79.6,
+                "positive": 321,
+                "gaps": 9,
+                "query_coverage_pct": 93.6,
+                "alignment_length": 368,
+                "query_from": 1,
+                "query_to": 368,
+                "hit_from": 1,
+                "hit_to": 368,
+                "query_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "hit_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "midline": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+            },
+            {
+                "accession": "NP_001290134.1",
+                "id": "NP_001290134.1",
+                "description": "cellular tumor antigen p53",
+                "organism": "Xenopus laevis",
+                "length": 358,
+                "score": 1250,
+                "bit_score": 1250.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 223,
+                "identity_pct": 62.3,
+                "positive": 264,
+                "gaps": 19,
+                "query_coverage_pct": 91.1,
+                "alignment_length": 358,
+                "query_from": 5,
+                "query_to": 362,
+                "hit_from": 1,
+                "hit_to": 358,
+                "query_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "hit_alignment": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+                "midline": "MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD",
+            },
+        ],
+    },
+    "NP_000198.1": {
+        "query_length": 110,
+        "hits": [
+            {
+                "accession": "NP_000198.1",
+                "id": "NP_000198.1",
+                "description": "Insulin",
+                "organism": "Homo sapiens",
+                "length": 110,
+                "score": 553,
+                "bit_score": 553.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 110,
+                "identity_pct": 100.0,
+                "positive": 110,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 110,
+                "query_from": 1,
+                "query_to": 110,
+                "hit_from": 1,
+                "hit_to": 110,
+                "query_alignment": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "hit_alignment": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "midline": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+            },
+            {
+                "accession": "NP_001186043.1",
+                "id": "NP_001186043.1",
+                "description": "Insulin",
+                "organism": "Pan troglodytes",
+                "length": 110,
+                "score": 548,
+                "bit_score": 548.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 109,
+                "identity_pct": 99.1,
+                "positive": 109,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 110,
+                "query_from": 1,
+                "query_to": 110,
+                "hit_from": 1,
+                "hit_to": 110,
+                "query_alignment": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "hit_alignment": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "midline": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+            },
+            {
+                "accession": "NP_001239233.1",
+                "id": "NP_001239233.1",
+                "description": "Insulin",
+                "organism": "Canis lupus familiaris",
+                "length": 110,
+                "score": 525,
+                "bit_score": 525.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 104,
+                "identity_pct": 94.5,
+                "positive": 105,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 110,
+                "query_from": 1,
+                "query_to": 110,
+                "hit_from": 1,
+                "hit_to": 110,
+                "query_alignment": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "hit_alignment": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "midline": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+            },
+            {
+                "accession": "NP_001258172.1",
+                "id": "NP_001258172.1",
+                "description": "Insulin",
+                "organism": "Bos taurus",
+                "length": 105,
+                "score": 501,
+                "bit_score": 501.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 100,
+                "identity_pct": 90.9,
+                "positive": 102,
+                "gaps": 1,
+                "query_coverage_pct": 95.5,
+                "alignment_length": 105,
+                "query_from": 1,
+                "query_to": 105,
+                "hit_from": 1,
+                "hit_to": 105,
+                "query_alignment": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "hit_alignment": "MALWMRLLPLLALLALWAPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "midline": "MALWMRLLPLLALLALW  PDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+            },
+            {
+                "accession": "NP_001156573.1",
+                "id": "NP_001156573.1",
+                "description": "Insulin",
+                "organism": "Sus scrofa",
+                "length": 110,
+                "score": 498,
+                "bit_score": 498.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 100,
+                "identity_pct": 90.9,
+                "positive": 103,
+                "gaps": 1,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 110,
+                "query_from": 1,
+                "query_to": 110,
+                "hit_from": 1,
+                "hit_to": 110,
+                "query_alignment": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "hit_alignment": "MALWMRLLPLLALLALWAPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "midline": "MALWMRLLPLLALLALW  PDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+            },
+            {
+                "accession": "NP_999205.1",
+                "id": "NP_999205.1",
+                "description": "Insulin",
+                "organism": "Danio rerio",
+                "length": 106,
+                "score": 352,
+                "bit_score": 352.0,
+                "evalue": 6e-125,
+                "evalue_raw": "6e-125",
+                "identity": 77,
+                "identity_pct": 72.6,
+                "positive": 85,
+                "gaps": 6,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 106,
+                "query_from": 1,
+                "query_to": 106,
+                "hit_from": 1,
+                "hit_to": 106,
+                "query_alignment": "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "hit_alignment": "MVSWIRLLPLVFLLALWAPDPASAFVNQHLCGSHLVEALYLVCGERGFFYSPKSGREAELQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+                "midline": "M  W+RLLP   LLALW PDP  AFVNQHLCGSHLVEALYLVCGERGFFY PK  REA+ LQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+            },
+        ],
+    },
+    "NP_000549.1": {
+        "query_length": 142,
+        "hits": [
+            {
+                "accession": "NP_000549.1",
+                "id": "NP_000549.1",
+                "description": "Hemoglobin subunit alpha",
+                "organism": "Homo sapiens",
+                "length": 142,
+                "score": 730,
+                "bit_score": 730.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 142,
+                "identity_pct": 100.0,
+                "positive": 142,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 142,
+                "query_from": 1,
+                "query_to": 142,
+                "hit_from": 1,
+                "hit_to": 142,
+                "query_alignment": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "hit_alignment": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "midline": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+            },
+            {
+                "accession": "NP_001003844.1",
+                "id": "NP_001003844.1",
+                "description": "Hemoglobin subunit alpha",
+                "organism": "Pan troglodytes",
+                "length": 142,
+                "score": 725,
+                "bit_score": 725.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 141,
+                "identity_pct": 99.3,
+                "positive": 141,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 142,
+                "query_from": 1,
+                "query_to": 142,
+                "hit_from": 1,
+                "hit_to": 142,
+                "query_alignment": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "hit_alignment": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "midline": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+            },
+            {
+                "accession": "NP_001272232.1",
+                "id": "NP_001272232.1",
+                "description": "Hemoglobin subunit alpha",
+                "organism": "Canis lupus familiaris",
+                "length": 142,
+                "score": 700,
+                "bit_score": 700.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 136,
+                "identity_pct": 95.8,
+                "positive": 138,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 142,
+                "query_from": 1,
+                "query_to": 142,
+                "hit_from": 1,
+                "hit_to": 142,
+                "query_alignment": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "hit_alignment": "MVLSPADKTNVKAAWGKVGGHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "midline": "MVLSPADKTNVKAAWGKV G HAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+            },
+            {
+                "accession": "NP_032207.1",
+                "id": "NP_032207.1",
+                "description": "Hemoglobin subunit alpha",
+                "organism": "Mus musculus",
+                "length": 142,
+                "score": 683,
+                "bit_score": 683.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 133,
+                "identity_pct": 93.7,
+                "positive": 136,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 142,
+                "query_from": 1,
+                "query_to": 142,
+                "hit_from": 1,
+                "hit_to": 142,
+                "query_alignment": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "hit_alignment": "MVLSPADKTNVKAAWGKVGGHAAEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "midline": "MVLSPADKTNVKAAWGKV G HA EYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+            },
+            {
+                "accession": "NP_001107584.1",
+                "id": "NP_001107584.1",
+                "description": "Hemoglobin subunit alpha",
+                "organism": "Rattus norvegicus",
+                "length": 142,
+                "score": 676,
+                "bit_score": 676.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 132,
+                "identity_pct": 93.0,
+                "positive": 135,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 142,
+                "query_from": 1,
+                "query_to": 142,
+                "hit_from": 1,
+                "hit_to": 142,
+                "query_alignment": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "hit_alignment": "MVLSPADKTNVKAAWGKVGGHAAEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "midline": "MVLSPADKTNVKAAWGKV G HA EYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+            },
+            {
+                "accession": "NP_990298.1",
+                "id": "NP_990298.1",
+                "description": "Hemoglobin subunit alpha-D",
+                "organism": "Gallus gallus",
+                "length": 141,
+                "score": 605,
+                "bit_score": 605.0,
+                "evalue": 0.0,
+                "evalue_raw": "0",
+                "identity": 118,
+                "identity_pct": 83.1,
+                "positive": 128,
+                "gaps": 0,
+                "query_coverage_pct": 99.3,
+                "alignment_length": 141,
+                "query_from": 1,
+                "query_to": 141,
+                "hit_from": 1,
+                "hit_to": 141,
+                "query_alignment": "MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR",
+                "hit_alignment": "MVLSPADKTNVKAAWGKVGGHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLASHHPADFTPAVHASLDKFLASVSTVLTSKYR",
+                "midline": "MVLSPADKTNVKAAWGKV G HAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTL A+H PA+FTPAVHASLDKFLASVSTVLTSKYR",
+            },
+        ],
+    },
+    "NP_009225.1": {
+        "query_length": 160,
+        "hits": [
+            {
+                "accession": "NP_009225.1",
+                "id": "NP_009225.1",
+                "description": "Breast cancer type 1 susceptibility protein",
+                "organism": "Homo sapiens",
+                "length": 1863,
+                "score": 285,
+                "bit_score": 285.0,
+                "evalue": 9e-79,
+                "evalue_raw": "9e-79",
+                "identity": 160,
+                "identity_pct": 100.0,
+                "positive": 160,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 160,
+                "query_from": 1,
+                "query_to": 160,
+                "hit_from": 1,
+                "hit_to": 160,
+                "query_alignment": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKETEGLEKAKPNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+                "hit_alignment": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKETEGLEKAKPNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+                "midline": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKETEGLEKAKPNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+            },
+            {
+                "accession": "XP_016879253.1",
+                "id": "XP_016879253.1",
+                "description": "breast cancer type 1 susceptibility protein",
+                "organism": "Pan troglodytes",
+                "length": 1866,
+                "score": 280,
+                "bit_score": 280.0,
+                "evalue": 2e-77,
+                "evalue_raw": "2e-77",
+                "identity": 158,
+                "identity_pct": 98.8,
+                "positive": 159,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 160,
+                "query_from": 1,
+                "query_to": 160,
+                "hit_from": 1,
+                "hit_to": 160,
+                "query_alignment": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKETEGLEKAKPNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+                "hit_alignment": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKETEGLEKAKPNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+                "midline": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKETEGLEKAKPNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+            },
+            {
+                "accession": "XP_006488960.1",
+                "id": "XP_006488960.1",
+                "description": "breast cancer type 1 susceptibility protein",
+                "organism": "Mus musculus",
+                "length": 1812,
+                "score": 216,
+                "bit_score": 216.0,
+                "evalue": 7e-58,
+                "evalue_raw": "7e-58",
+                "identity": 124,
+                "identity_pct": 77.5,
+                "positive": 140,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 160,
+                "query_from": 1,
+                "query_to": 160,
+                "hit_from": 1,
+                "hit_to": 160,
+                "query_alignment": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKETEGLEKAKPNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+                "hit_alignment": "MALEDPLPVDVTVPSSPLPLPKPSFSASVKNKLLEGENKELKQKTKKEKSSLKAKKESEGLEKAKSNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+                "midline": "MALEDPLPVDVTVPSSPLPLPKPS SASVKNKLLEGENKELKQKTKKEKSSLKAKKE+EGLEKAK NKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+            },
+            {
+                "accession": "XP_006248793.2",
+                "id": "XP_006248793.2",
+                "description": "breast cancer type 1 susceptibility protein homolog",
+                "organism": "Rattus norvegicus",
+                "length": 1813,
+                "score": 204,
+                "bit_score": 204.0,
+                "evalue": 4e-54,
+                "evalue_raw": "4e-54",
+                "identity": 119,
+                "identity_pct": 74.4,
+                "positive": 137,
+                "gaps": 0,
+                "query_coverage_pct": 100.0,
+                "alignment_length": 160,
+                "query_from": 1,
+                "query_to": 160,
+                "hit_from": 1,
+                "hit_to": 160,
+                "query_alignment": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKETEGLEKAKPNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+                "hit_alignment": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKESEGLEKAKSNKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+                "midline": "MALEDPLPVDVTVPSSPLPLPKPSLSASVKNKLLEGENKELKQKTKKEKSSLKAKKE+EGLEKAK NKNEQNIKQKAIMNEVEETAVANHQVISSPHKKTGKSSSTLGKLTTSRKNNNSQMNMKQMKGYNIDL",
+            },
+        ],
+    },
+}
+
+
+def get_demo_result(sequence: str) -> dict | None:
+    for key, info in DEMO_SEQUENCES.items():
+        seq_clean = "".join(c for c in sequence if c.isalpha()).upper()
+        demo_clean = "".join(c for c in info["sequence"] if c.isalpha()).upper()
+        if seq_clean == demo_clean:
+            acc = info["accession"]
+            demo = DEMO_BLAST_RESULTS.get(acc)
+            if demo:
+                return {
+                    **demo,
+                    "source": "demo",
+                    "demo_sequence_name": info["name"],
+                    "demo_sequence_key": key,
+                }
+    return None

app/data/jobs_docking.json

@@ -0,0 +1 @@
+{}

app/data/jobs_sequencing.json

@@ -0,0 +1 @@
+{}

app/deps.py

@@ -0,0 +1,34 @@
+import base64
+import json
+import logging
+
+from fastapi import Request
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+logger = logging.getLogger(__name__)
+
+
+def _rate_limit_key(request: Request) -> str:
+    """Use user ID from JWT for authenticated requests, fall back to IP."""
+    auth = request.headers.get("Authorization", "")
+    if auth.startswith("Bearer "):
+        try:
+            token = auth[7:]
+            parts = token.split(".")
+            if len(parts) == 3:
+                payload = parts[1]
+                padding = 4 - len(payload) % 4
+                if padding != 4:
+                    payload += "=" * padding
+                decoded = base64.urlsafe_b64decode(payload)
+                claims = json.loads(decoded)
+                uid = claims.get("sub")
+                if uid:
+                    return f"user:{uid}"
+        except Exception:
+            pass
+    return get_remote_address(request)
+
+
+limiter = Limiter(key_func=_rate_limit_key, default_limits=[])

app/integrations/ncbi/blast.py

@@ -0,0 +1,310 @@
+"""
+Thin client for NCBI BLAST URL API (QBLAST).
+
+Rate limit: NCBI enforces 1 request per 10 seconds without an API key,
+3 req/s with an API key. Rate limiting is the caller's responsibility.
+
+API docs: https://ncbi.github.io/blast-cloud/api.html
+"""
+
+import asyncio
+import logging
+import os
+import re
+import httpx
+
+logger = logging.getLogger(__name__)
+
+NCBI_BLAST_URL = "https://blast.ncbi.nlm.nih.gov/blast/Blast.cgi"
+RATE_LIMIT_SECONDS = 10
+
+from app.config import settings
+
+NCBI_API_KEY = settings.NCBI_API_KEY
+
+
+def _api_key_param() -> dict:
+    """Return {api_key: key} if configured, else empty dict."""
+    return {"api_key": NCBI_API_KEY} if NCBI_API_KEY else {}
+
+
+async def _request_with_retry(method: str, url: str, max_retries: int = 3, request_timeout: float = 60.0, **kwargs) -> httpx.Response:
+    """Make an HTTP request with retry on connection, timeout, and transient errors.
+
+    request_timeout is the read/write timeout. NCBI's synchronous mode blocks
+    until results are ready, so callers must pass a generous value for it.
+    """
+    for attempt in range(max_retries):
+        try:
+            async with httpx.AsyncClient(timeout=httpx.Timeout(request_timeout, connect=15.0)) as client:
+                resp = await getattr(client, method)(url, **kwargs)
+                resp.raise_for_status()
+                return resp
+        except (
+            httpx.ReadError,
+            httpx.RemoteProtocolError,
+            httpx.ConnectError,
+            httpx.TimeoutException,
+            httpx.HTTPStatusError,
+        ) as e:
+            if attempt < max_retries - 1:
+                delay = 3 * (attempt + 1)
+                logger.warning("NCBI request failed (attempt %d/%d): %s — retrying in %ds", attempt + 1, max_retries, e, delay)
+                await asyncio.sleep(delay)
+            else:
+                raise
+
+
+async def submit_blast(
+    sequence: str,
+    program: str = "blastp",
+    database: str = "nr",
+    hitlist_size: int = 100,
+    expect: float = 10.0,
+    gapopen: int = -1,
+    gapextend: int = -1,
+    matrix: str = "BLOSUM62",
+    async_flag: bool = True,
+) -> dict:
+    params = {
+        "CMD": "Put",
+        "PROGRAM": program,
+        "DATABASE": database,
+        "QUERY": sequence,
+        "HITLIST_SIZE": str(hitlist_size),
+        "EXPECT": str(expect),
+        "MATRIX": matrix,
+        "ASYNC": "1" if async_flag else "0",
+        "EMAIL": settings.NCBI_EMAIL,
+        **_api_key_param(),
+    }
+    if gapopen > 0:
+        params["GAPOPEN"] = str(gapopen)
+    if gapextend > 0:
+        params["GAPEXTEND"] = str(gapextend)
+
+    resp = await _request_with_retry(
+        "post", NCBI_BLAST_URL, data=params,
+        request_timeout=300.0 if not async_flag else 60.0,
+    )
+    text = resp.text
+
+    rid_match = re.search(r"RID\s*=\s*(\S+)", text)
+    rtoe_match = re.search(r"RTOE\s*=\s*(\d+)", text)
+
+    if not rid_match:
+        return {"error": "No RID returned from NCBI", "raw": text[:500]}
+
+    rid = rid_match.group(1)
+    rtoe = int(rtoe_match.group(1)) if rtoe_match else 60
+
+    result = {"rid": rid, "estimated_seconds": rtoe}
+    if not async_flag and "Status=READY" in text:
+        # NCBI blocked and returned results inline in the submit response.
+        result["raw"] = text
+    return result
+
+
+async def submit_blast_sync(sequence: str, **kwargs) -> dict:
+    """Submit BLAST in synchronous (blocking) mode — NCBI returns results inline.
+
+    Used as fallback when async mode yields unreasonable RTOE or jobs get stuck.
+    """
+    kwargs.pop("async_flag", None)
+    return await submit_blast(sequence, async_flag=False, **kwargs)
+
+
+async def check_status(rid: str, fmt: str = "XML") -> dict:
+    params = {"CMD": "Get", "FORMAT_TYPE": fmt, "RID": rid, **_api_key_param()}
+    resp = await _request_with_retry("get", NCBI_BLAST_URL, params=params)
+    text = resp.text
+
+    if "Status=" in text:
+        status_match = re.search(r"Status\s*=\s*(\w+)", text)
+        status = status_match.group(1) if status_match else "UNKNOWN"
+    else:
+        status = "READY"
+
+    return {"status": status, "raw": text, "rid": rid}
+
+
+async def fetch_results(rid: str, fmt: str = "XML") -> dict:
+    params = {"CMD": "Get", "FORMAT_TYPE": fmt, "RID": rid, **_api_key_param()}
+    resp = await _request_with_retry("get", NCBI_BLAST_URL, params=params)
+    text = resp.text
+
+    if "Status=" in text and "Status=READY" not in text:
+        return {"error": "Results not ready", "raw": text[:200]}
+
+    return {"raw": text, "rid": rid}
+
+
+async def check_status_until_ready(
+    rid: str,
+    max_wait_seconds: int = 300,
+    estimated_seconds: int = 0,
+) -> dict:
+    """Poll NCBI with exponential backoff until READY or budget exhausted.
+
+    Starts at 10s delay (NCBI rate-limit guidance: 1 req/10s without API key),
+    backs off to 25s ceiling.  Transient poll failures (timeouts, HTTP errors)
+    are tolerated up to 3 consecutive times before giving up.
+
+    If estimated_seconds is provided and the job stays in WAITING for more
+    than 5x that duration (minimum 60s), it's treated as stuck.
+    """
+    elapsed = 0
+    # With an API key NCBI allows 3 req/s; without, 1 req/10s.
+    delay = 5 if NCBI_API_KEY else 10
+    consecutive_failures = 0
+    max_consecutive_failures = 3
+    # Stuck-job threshold: 5x the RTOE, but at least 180s (NCBI overload can
+    # push legitimate jobs well past their RTOE, so don't give up early).
+    stuck_threshold = max(estimated_seconds * 5, 180) if estimated_seconds > 0 else 240
+
+    while elapsed < max_wait_seconds:
+        try:
+            result = await check_status(rid)
+            consecutive_failures = 0  # reset on success
+        except Exception as e:
+            consecutive_failures += 1
+            logger.warning(
+                "BLAST poll for %s failed (consecutive %d/%d): %s",
+                rid, consecutive_failures, max_consecutive_failures, e,
+            )
+            if consecutive_failures >= max_consecutive_failures:
+                logger.warning(
+                    "BLAST RID %s — %d consecutive poll failures, giving up", rid, consecutive_failures
+                )
+                return {"status": "POLL_FAILED", "rid": rid, "error": str(e)}
+            await asyncio.sleep(delay)
+            elapsed += delay
+            delay = min(delay * 1.5, 15 if NCBI_API_KEY else 25)
+            continue
+
+        status = result["status"]
+
+        if status == "READY":
+            return result
+        if status not in ("WAITING", "UNKNOWN", "QUEUED"):
+            # FAILED / ERROR — bail immediately
+            logger.warning("BLAST RID %s returned terminal status: %s", rid, status)
+            return result
+
+        # Stuck-job detection: if WAITING far beyond RTOE, job is likely stuck
+        if elapsed > stuck_threshold:
+            logger.warning(
+                "BLAST RID %s stuck in %s for %ds (threshold=%ds), treating as STUCK",
+                rid, status, elapsed, stuck_threshold,
+            )
+            return {"status": "STUCK", "rid": rid, "error": f"Job stuck in {status} for {elapsed}s"}
+
+        await asyncio.sleep(delay)
+        elapsed += delay
+        delay = min(delay * 1.5, 15 if NCBI_API_KEY else 25)  # back off, cap at 15s (key) / 25s (no key)
+
+    logger.warning("BLAST RID %s timed out after %ds", rid, max_wait_seconds)
+    return {"status": "TIMEOUT", "rid": rid}
+
+
+async def run_blast_with_retry(
+    sequence: str,
+    retries: int = 2,
+    max_wait_seconds: int = 600,
+    **submit_kwargs,
+) -> dict:
+    """Submit + poll + fetch with retries on timeout/failure.
+
+    If NCBI dropped/lost the RID, no amount of polling helps — a fresh
+    submit_blast() is the right fix.  retries=2 means 3 total attempts.
+
+    Falls back to synchronous mode when async RTOE is unreasonable (>300s),
+    which indicates NCBI server overload.  In sync mode NCBI blocks until
+    results are ready (up to the httpx timeout).
+    """
+    last_error = None
+    MAX_RTOE = 300  # if RTOE exceeds this, switch to sync mode
+
+    for attempt in range(retries + 1):
+        # On retry after stuck/timeout, try sync mode first
+        use_sync = attempt > 0
+
+        try:
+            if use_sync:
+                logger.info("BLAST attempt %d/%d: trying synchronous mode", attempt + 1, retries + 1)
+                submit_result = await submit_blast_sync(sequence, **submit_kwargs)
+            else:
+                submit_result = await submit_blast(sequence, **submit_kwargs)
+        except Exception as e:
+            last_error = f"BLAST submit request failed: {e}"
+            logger.warning(
+                "BLAST submit threw (attempt %d/%d): %s",
+                attempt + 1, retries + 1, last_error,
+            )
+            if attempt < retries:
+                await asyncio.sleep(5 * (attempt + 1))
+            continue
+
+        if "error" in submit_result:
+            last_error = submit_result["error"]
+            logger.warning(
+                "BLAST submit failed (attempt %d/%d): %s",
+                attempt + 1, retries + 1, last_error,
+            )
+            if attempt < retries:
+                await asyncio.sleep(5 * (attempt + 1))
+            continue
+
+        rid = submit_result["rid"]
+        est = submit_result.get("estimated_seconds", 0)
+        logger.info(
+            "BLAST submitted (attempt %d/%d, sync=%s), RID=%s, est=%ds",
+            attempt + 1, retries + 1, use_sync, rid, est,
+        )
+
+        # Detect unreasonable RTOE — switch to sync on next attempt
+        if not use_sync and est > MAX_RTOE:
+            logger.warning(
+                "BLAST RTOE=%ds exceeds threshold (%ds), will use sync mode on retry", est, MAX_RTOE,
+            )
+            last_error = f"NCBI estimated {est}s queue time (threshold {MAX_RTOE}s)"
+            if attempt < retries:
+                await asyncio.sleep(2)
+            continue
+
+        if use_sync:
+            # Sync mode: NCBI blocked and returned the result inline in the
+            # submit response. If the raw XML came back ready, use it directly.
+            if submit_result.get("raw"):
+                logger.info("BLAST sync mode returned results inline for RID %s", rid)
+                return {"raw": submit_result["raw"], "rid": rid}
+
+        try:
+            status_result = await check_status_until_ready(
+                rid, max_wait_seconds=max_wait_seconds, estimated_seconds=est,
+            )
+        except Exception as e:
+            last_error = f"BLAST polling crashed: {e}"
+            logger.warning("BLAST RID %s: %s", rid, last_error)
+            if attempt < retries:
+                await asyncio.sleep(5 * (attempt + 1))
+            continue
+
+        if status_result["status"] == "READY":
+            try:
+                return await fetch_results(rid)
+            except Exception as e:
+                last_error = f"BLAST result fetch failed: {e}"
+                logger.warning("BLAST RID %s: %s", rid, last_error)
+                if attempt < retries:
+                    await asyncio.sleep(5 * (attempt + 1))
+                continue
+
+        last_error = f"BLAST {status_result['status']} after polling (attempt {attempt + 1}/{retries + 1})"
+        if status_result.get("error"):
+            last_error += f": {status_result['error']}"
+        logger.warning("BLAST RID %s: %s", rid, last_error)
+        if attempt < retries:
+            await asyncio.sleep(5 * (attempt + 1))
+
+    return {"error": last_error or "BLAST failed after all attempts"}

app/integrations/ncbi/parser.py

@@ -0,0 +1,148 @@
+"""
+Parse NCBI BLAST XML output into structured hit list.
+
+Raw XML is always stored to R2 first; parsing happens from
+the stored copy, never inline with the API request.
+"""
+
+import re
+import xml.etree.ElementTree as ET
+from typing import List, Optional
+
+
+def _strip_ncbi_preamble(raw_xml: str) -> str:
+    """
+    NCBI's URL API prepends a non-XML info block (and sometimes blank
+    lines / whitespace) before the real <?xml ...?> declaration, e.g.:
+
+        <!--QBlastInfoBegin
+            Status=READY
+        QBlastInfoEnd
+        -->
+
+        <?xml version="1.0"?>
+        <BlastOutput>...
+
+    The XML declaration must be the first thing in the document, so we
+    trim everything before the first '<?xml' or, failing that, the
+    first '<BlastOutput' tag.
+    """
+    match = re.search(r"<\?xml|<BlastOutput", raw_xml)
+    if match:
+        return raw_xml[match.start():]
+    return raw_xml
+
+
+def parse_blast_xml(raw_xml: str) -> dict:
+    raw_xml = _strip_ncbi_preamble(raw_xml)
+    try:
+        root = ET.fromstring(raw_xml)
+    except ET.ParseError as e:
+        return {"error": f"XML parse error: {e}", "hits": []}
+
+    ns = {"": "http://www.ncbi.nlm.nih.gov"}
+    query_len_el = root.find(".//BlastOutput_query-len")
+    query_len = int(query_len_el.text) if query_len_el is not None else 0
+
+    hits = []
+    for iteration in root.findall(".//Iteration"):
+        for hit_el in iteration.findall(".//Hit"):
+            hit = _parse_hit(hit_el)
+            if hit is not None:
+                hits.append(hit)
+
+    return {
+        "query_length": query_len,
+        "hits": hits,
+        "count": len(hits),
+    }
+
+
+def _parse_hit(hit_el: ET.Element) -> Optional[dict]:
+    acc = _text(hit_el, "Hit_accession")
+    if not acc:
+        return None
+    hit_id = _text(hit_el, "Hit_id")
+    def_line = _text(hit_el, "Hit_def")
+    accession = acc
+    description = def_line or ""
+    if " " in def_line:
+        parts = def_line.split(" ", 1)
+        if parts[0] == acc or parts[0] == hit_id:
+            description = parts[1] if len(parts) > 1 else ""
+
+    organism = ""
+    if "[" in description and "]" in description:
+        organism = description.split("[")[-1].rstrip("]")
+        description = description.split("[")[0].strip()
+
+    hsps = hit_el.findall(".//Hsp")
+    top_hsp = _parse_hsp(hsps[0]) if hsps else None
+
+    return {
+        "accession": accession,
+        "id": hit_id,
+        "description": description,
+        "organism": organism,
+        "length": int(_text(hit_el, "Hit_len") or 0),
+        "score": top_hsp.get("score", 0) if top_hsp else 0,
+        "bit_score": top_hsp.get("bit_score", 0) if top_hsp else 0,
+        "evalue": top_hsp.get("evalue", 0) if top_hsp else 0,
+        "evalue_raw": top_hsp.get("evalue_raw", "0") if top_hsp else "0",
+        "identity": top_hsp.get("identity", 0) if top_hsp else 0,
+        "identity_pct": top_hsp.get("identity_pct", 0) if top_hsp else 0,
+        "positive": top_hsp.get("positive", 0) if top_hsp else 0,
+        "gaps": top_hsp.get("gaps", 0) if top_hsp else 0,
+        "alignment_length": top_hsp.get("alignment_length", 0) if top_hsp else 0,
+        "query_from": top_hsp.get("query_from", 0) if top_hsp else 0,
+        "query_to": top_hsp.get("query_to", 0) if top_hsp else 0,
+        "hit_from": top_hsp.get("hit_from", 0) if top_hsp else 0,
+        "hit_to": top_hsp.get("hit_to", 0) if top_hsp else 0,
+        "query_alignment": top_hsp.get("query_alignment", "") if top_hsp else "",
+        "hit_alignment": top_hsp.get("hit_alignment", "") if top_hsp else "",
+        "midline": top_hsp.get("midline", "") if top_hsp else "",
+    }
+
+
+def _parse_hsp(hsp_el: ET.Element) -> dict:
+    score = int(_text(hsp_el, "Hsp_score") or 0)
+    bit_score = float(_text(hsp_el, "Hsp_bit-score") or 0)
+    evalue_raw = _text(hsp_el, "Hsp_evalue") or "0"
+    evalue = float(evalue_raw)
+    identity = int(_text(hsp_el, "Hsp_identity") or 0)
+    positive = int(_text(hsp_el, "Hsp_positive") or 0)
+    gaps = int(_text(hsp_el, "Hsp_gaps") or 0)
+    align_len = int(_text(hsp_el, "Hsp_align-len") or 0)
+    query_from = int(_text(hsp_el, "Hsp_query-from") or 0)
+    query_to = int(_text(hsp_el, "Hsp_query-to") or 0)
+    hit_from = int(_text(hsp_el, "Hsp_hit-from") or 0)
+    hit_to = int(_text(hsp_el, "Hsp_hit-to") or 0)
+    qseq = _text(hsp_el, "Hsp_qseq") or ""
+    hseq = _text(hsp_el, "Hsp_hseq") or ""
+    mid = _text(hsp_el, "Hsp_midline") or ""
+
+    identity_pct = round(identity / align_len * 100, 1) if align_len > 0 else 0
+
+    return {
+        "score": score,
+        "bit_score": bit_score,
+        "evalue": evalue,
+        "evalue_raw": evalue_raw,
+        "identity": identity,
+        "identity_pct": identity_pct,
+        "positive": positive,
+        "gaps": gaps,
+        "alignment_length": align_len,
+        "query_from": query_from,
+        "query_to": query_to,
+        "hit_from": hit_from,
+        "hit_to": hit_to,
+        "query_alignment": qseq,
+        "hit_alignment": hseq,
+        "midline": mid,
+    }
+
+
+def _text(el: ET.Element, path: str) -> str:
+    found = el.find(path)
+    return found.text if found is not None and found.text else ""

app/logging_config.py

@@ -0,0 +1,83 @@
+"""Structured logging setup.
+
+In production (ENVIRONMENT=prod), logs are emitted as JSON for easy parsing
+by log aggregators. In development, human-readable format is used.
+
+Every log line includes: timestamp, level, logger, message, and optional
+request_id / user_id context injected by the middleware.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+import time
+from contextvars import ContextVar
+
+request_id_var: ContextVar[str] = ContextVar("request_id", default="")
+user_id_var: ContextVar[str] = ContextVar("user_id", default="")
+
+_environment = os.getenv("ENVIRONMENT", "development")
+
+
+class JSONFormatter(logging.Formatter):
+    """Emit each log record as a single JSON line."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        log = {
+            "ts": self.formatTime(record, "%Y-%m-%dT%H:%M:%S"),
+            "level": record.levelname,
+            "logger": record.name,
+            "msg": record.getMessage(),
+        }
+        rid = request_id_var.get("")
+        if rid:
+            log["request_id"] = rid
+        uid = user_id_var.get("")
+        if uid:
+            log["user_id"] = uid
+        if record.exc_info and record.exc_info[0]:
+            log["exception"] = self.formatException(record.exc_info)
+        return json.dumps(log, default=str)
+
+
+class DevFormatter(logging.Formatter):
+    """Human-readable format for local development."""
+    FMT = "%(asctime)s %(levelname)-7s %(name)s | %(message)s"
+
+    def format(self, record: logging.LogRecord) -> str:
+        rid = request_id_var.get("")
+        uid = user_id_var.get("")
+        prefix = ""
+        if rid:
+            prefix += f"[{rid[:8]}] "
+        if uid:
+            prefix += f"(user:{uid[:8]}) "
+        record.msg = prefix + record.getMessage()
+        record.args = None
+        return super().format(record)
+
+
+def setup_logging() -> None:
+    root = logging.getLogger()
+    root.setLevel(logging.INFO)
+
+    # Remove any existing handlers
+    for h in root.handlers[:]:
+        root.removeHandler(h)
+
+    handler = logging.StreamHandler(sys.stdout)
+    if _environment in ("production", "prod", "staging"):
+        handler.setFormatter(JSONFormatter())
+    else:
+        handler.setFormatter(DevFormatter())
+
+    root.addHandler(handler)
+
+    # Quiet noisy libraries
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
+    logging.getLogger("supabase").setLevel(logging.WARNING)
+    logging.getLogger("postgrest").setLevel(logging.WARNING)

app/main.py

@@ -1,24 +1,31 @@
 import logging
+import os
+from datetime import datetime, timezone, timedelta
+
+import sentry_sdk
 from dotenv import load_dotenv
 load_dotenv()
 
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
-from slowapi import Limiter, _rate_limit_exceeded_handler
-from slowapi.util import get_remote_address
+from slowapi import _rate_limit_exceeded_handler
 from slowapi.errors import RateLimitExceeded
 from app.config import settings
-from app.routers import pipelines, pipeline_v2, ai, jobs, share, profile, sequences, uniprot, alignment, structures, pathways, domains, interactions, primers, structure_analysis, phylo
+from app.logging_config import setup_logging
+from app.middleware import RequestIDMiddleware
+from app.routers import pipelines, pipeline_v2, ai, jobs, share, profile, sequences, uniprot, alignment, structures, pathways, domains, interactions, primers, structure_analysis, phylo, export, api_keys, cache_stats, docking, sequencing, audit, admet, md, function_predict
 from app.services.cache import init_redis
 
+setup_logging()
 logger = logging.getLogger(__name__)
 
-limiter = Limiter(key_func=get_remote_address, default_limits=["30/minute"])
+from app.deps import limiter
 
 app = FastAPI(title="Bio Nexus API", version="0.2.0")
 app.state.limiter = limiter
 app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+app.add_middleware(RequestIDMiddleware)
 
 PROD_ORIGIN = settings.CORS_ORIGIN
 
@@ -51,6 +58,15 @@ app.include_router(interactions.router)
 app.include_router(primers.router)
 app.include_router(structure_analysis.router)
 app.include_router(phylo.router)
+app.include_router(export.router, prefix="/api/export", tags=["export"])
+app.include_router(api_keys.router, prefix="/api/keys", tags=["api_keys"])
+app.include_router(cache_stats.router)
+app.include_router(docking.router)
+app.include_router(sequencing.router)
+app.include_router(audit.router)
+app.include_router(admet.router)
+app.include_router(md.router)
+app.include_router(function_predict.router)
 
 TERMINAL_STATUSES = {"complete", "failed"}
 NON_TERMINAL_STATUSES = {
@@ -92,23 +108,160 @@ async def _fail_stuck_jobs():
         logger.warning(f"Startup resume: error: {e}")
 
 
+async def _ensure_docking_columns():
+    """Add any missing columns to docking_jobs via PostgREST schema introspection + ALTER hints."""
+    try:
+        import httpx
+        from app.config import settings
+        headers = {
+            "apikey": settings.SUPABASE_SERVICE_ROLE_KEY,
+            "Authorization": f"Bearer {settings.SUPABASE_SERVICE_ROLE_KEY}",
+        }
+        # Check if result_sdf exists by querying it (most basic column the worker needs)
+        async with httpx.AsyncClient(timeout=10) as client:
+            resp = await client.get(
+                f"{settings.SUPABASE_URL}/rest/v1/docking_jobs?select=id&limit=0",
+                headers=headers,
+            )
+            if resp.status_code == 200:
+                logger.info("docking_jobs table accessible")
+            else:
+                logger.warning(f"docking_jobs table query returned {resp.status_code} — table may not exist")
+    except Exception as e:
+        logger.warning(f"ensure_docking_columns check: {e}")
+
+
+async def _fail_stuck_dockseq_jobs():
+    """Mark docking/sequencing jobs that were in-flight when the process restarted."""
+    try:
+        import httpx
+        from app.config import settings
+        headers = {
+            "apikey": settings.SUPABASE_SERVICE_ROLE_KEY,
+            "Authorization": f"Bearer {settings.SUPABASE_SERVICE_ROLE_KEY}",
+            "Content-Type": "application/json",
+            "Prefer": "return=minimal",
+        }
+        base = f"{settings.SUPABASE_URL}/rest/v1"
+        grace_cutoff = (datetime.now(timezone.utc) - timedelta(minutes=30)).strftime("%Y-%m-%dT%H:%M:%S")
+        for table in ("docking_jobs", "sequencing_jobs"):
+            select_url = f"{base}/{table}?select=id&status=not.in.(complete,failed)&created_at=lt.{grace_cutoff}"
+            async with httpx.AsyncClient(timeout=10) as client:
+                resp = await client.get(select_url, headers=headers)
+                if resp.status_code != 200:
+                    logger.warning(f"Startup resume: failed to query {table} ({resp.status_code})")
+                    continue
+                stuck = resp.json()
+                for job in stuck:
+                    jid = job["id"]
+                    logger.info(f"Startup resume: marking stuck {table} job {jid} as failed")
+                    await client.patch(
+                        f"{base}/{table}?id=eq.{jid}",
+                        headers=headers,
+                        json={"status": "failed", "error": "Worker lost on restart — please re-run", "done_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S")},
+                    )
+                if stuck:
+                    logger.info(f"Startup resume: marked {len(stuck)} stuck {table} job(s) as failed")
+    except Exception as e:
+        logger.warning(f"Startup resume: error for docking/sequencing: {e}")
+
+
+def _sentry_filter(event, hint):
+    """Filter out noisy/harmless errors from Sentry."""
+    # Don't report rate limit hits
+    if event.get("exception"):
+        exc = event["exception"].get("values", [{}])[0]
+        if exc.get("type") == "HTTPException" and exc.get("value", {}).get("status_code") == 429:
+            return None
+    return event
+
+
 @app.on_event("startup")
 async def startup():
+    sentry_sdk.init(
+        dsn=settings.SENTRY_DSN,
+        environment=os.getenv("ENVIRONMENT", "development"),
+        traces_sample_rate=0.1,
+        send_default_pii=False,
+        enable_tracing=True,
+        before_send=_sentry_filter,
+    )
     init_redis()
+    await _ensure_docking_columns()
     await _fail_stuck_jobs()
+    await _fail_stuck_dockseq_jobs()
+
+    # Check OpenMM availability
+    try:
+        import openmm
+        logger.info("OpenMM %s available — full MD simulation enabled", openmm.__version__)
+    except ImportError as e:
+        logger.warning("OpenMM not available (%s) — MD will use BioPython fallback", e)
+
+    # Launch durable worker (in-process)
+    from app.worker import start_worker
+    await start_worker()
+    logger.info("In-process durable worker started")
 
 
 @app.get("/health")
 async def health():
-    return {"status": "ok"}
+    from app.services.cache import get_cache_stats
+    import httpx
+
+    stats = get_cache_stats()
+    health_data = {
+        "status": "ok",
+        "version": "0.2.0",
+        "cache": stats,
+        "worker": "unknown",
+        "queue_depth": {},
+        "openmm": None,
+    }
+
+    try:
+        import openmm
+        from openmm import Platform
+        platforms = [Platform.getPlatform(i).getName() for i in range(Platform.getNumPlatforms())]
+        health_data["openmm"] = {
+            "version": openmm.__version__,
+            "platforms": platforms,
+        }
+    except Exception as exc:
+        health_data["openmm"] = {"error": str(exc)}
+
+    # Check worker health via queue depths
+    try:
+        headers = {
+            "apikey": settings.SUPABASE_SERVICE_ROLE_KEY,
+            "Authorization": f"Bearer {settings.SUPABASE_SERVICE_ROLE_KEY}",
+        }
+        async with httpx.AsyncClient(timeout=5) as client:
+            for table in ("docking_jobs", "sequencing_jobs", "jobs"):
+                resp = await client.get(
+                    f"{settings.SUPABASE_URL}/rest/v1/{table}"
+                    f"?status=eq.queued&select=id",
+                    headers=headers,
+                )
+                if resp.status_code == 200:
+                    health_data["queue_depth"][table] = len(resp.json())
+    except Exception:
+        pass
+
+    return health_data
 
 
 @app.exception_handler(Exception)
 async def global_exception_handler(request: Request, exc: Exception):
+    from app.logging_config import request_id_var
+    rid = request_id_var.get("")
+
     if isinstance(exc, HTTPException):
-        return JSONResponse(status_code=exc.status_code, content={"detail": exc.detail})
+        return JSONResponse(status_code=exc.status_code, content={"detail": exc.detail, "request_id": rid})
+
     logger.exception("Unhandled exception")
+    sentry_sdk.capture_exception(exc)
     return JSONResponse(
         status_code=500,
-        content={"detail": "Internal server error"},
+        content={"detail": "Internal server error", "request_id": rid},
     )

app/middleware.py

@@ -0,0 +1,37 @@
+"""Middleware that injects a request ID into every request and log context."""
+
+from __future__ import annotations
+
+import time
+import uuid
+
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from app.logging_config import request_id_var, user_id_var
+
+
+class RequestIDMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        rid = request.headers.get("X-Request-ID") or uuid.uuid4().hex[:16]
+        request_id_var.set(rid)
+
+        start = time.perf_counter()
+        response = await call_next(request)
+        elapsed_ms = round((time.perf_counter() - start) * 1000)
+
+        response.headers["X-Request-ID"] = rid
+        response.headers["X-Response-Time"] = f"{elapsed_ms}ms"
+
+        # Log the request
+        import logging
+        logger = logging.getLogger("access")
+        logger.info(
+            "%s %s %d %dms",
+            request.method,
+            request.url.path,
+            response.status_code,
+            elapsed_ms,
+        )
+
+        return response

app/models/responses.py

@@ -0,0 +1,40 @@
+from pydantic import BaseModel
+from typing import Any, Optional
+
+
+class PipelineRunResponse(BaseModel):
+    job_id: str
+    status: str
+
+
+class PipelineDefinitionResponse(BaseModel):
+    pipelines: list[dict[str, Any]]
+
+
+class JobCountResponse(BaseModel):
+    count: int
+    limit: int
+    remaining: int
+
+
+class JobDeleteResponse(BaseModel):
+    status: str
+
+
+class InterpretResponse(BaseModel):
+    prompt: str
+    context_size: int
+
+
+class WaitlistResponse(BaseModel):
+    status: str
+    email: str
+
+
+class ProfileUpdateResponse(BaseModel):
+    status: str
+    data: Optional[dict[str, Any]] = None
+
+
+class ErrorResponse(BaseModel):
+    detail: str

app/pipeline/assembler.py

@@ -0,0 +1,84 @@
+from typing import Any
+
+
+class ContextAssembler:
+    def assemble(
+        self,
+        sequence: str,
+        blast_result: dict,
+        uniprot_result: dict | None,
+        alphafold_result: dict | None,
+    ) -> dict:
+        context = {
+            "query": {
+                "sequence": sequence,
+                "length": len([c for c in sequence if c.isalpha()]),
+            },
+            "blast": self._summarize_blast(blast_result),
+            "uniprot": self._summarize_uniprot(uniprot_result) if uniprot_result else None,
+            "alphafold": alphafold_result,
+        }
+        return context
+
+    def _summarize_blast(self, blast_result: dict) -> dict:
+        hits = blast_result.get("hits", [])
+        summary = {
+            "count": len(hits),
+            "source": blast_result.get("source", "EBI BLAST"),
+            "database": blast_result.get("database", "swissprot"),
+        }
+        if hits:
+            best = hits[0]
+            summary["top_hit"] = {
+                "accession": best.get("accession", ""),
+                "description": best.get("description", ""),
+                "evalue": best.get("evalue", 0),
+                "identity_pct": best.get("identity_pct", 0),
+                "bit_score": best.get("bit_score", 0),
+                "alignment_length": best.get("alignment_length", 0),
+            }
+            summary["hits"] = [
+                {
+                    "accession": h.get("accession", ""),
+                    "description": h.get("description", ""),
+                    "organism": h.get("organism", ""),
+                    "evalue": h.get("evalue", 0),
+                    "identity_pct": h.get("identity_pct", 0),
+                    "bit_score": h.get("bit_score", 0),
+                    "alignment_length": h.get("alignment_length", 0),
+                    "query_coverage_pct": h.get("query_coverage_pct", 0),
+                    "query_from": h.get("query_from", 0),
+                    "query_to": h.get("query_to", 0),
+                    "hit_from": h.get("hit_from", 0),
+                    "hit_to": h.get("hit_to", 0),
+                    "positive": h.get("positive", 0),
+                    "gaps": h.get("gaps", 0),
+                    "query_alignment": h.get("query_alignment", ""),
+                    "hit_alignment": h.get("hit_alignment", ""),
+                    "midline": h.get("midline", ""),
+                }
+                for h in hits[:10]
+            ]
+        return summary
+
+    def _summarize_uniprot(self, uniprot_result: dict) -> dict:
+        return {
+            "accession": uniprot_result.get("accession", ""),
+            "full_name": uniprot_result.get("full_name", ""),
+            "organism": uniprot_result.get("organism", ""),
+            "gene_names": uniprot_result.get("gene_names", []),
+            "functions": uniprot_result.get("functions", []),
+            "keywords": uniprot_result.get("keywords", []),
+            "subcellular_locations": uniprot_result.get("subcellular_locations", []),
+            "pdb_ids": uniprot_result.get("pdb_ids", []),
+            "features": [
+                f for f in (uniprot_result.get("features", []) or [])
+                if f.get("type") in (
+                    "ACTIVE_SITE", "BINDING", "MUTAGENESIS", "SITE", "MOD_RES",
+                    "DOMAIN", "HELIX", "STRAND", "TURN", "TRANSMEM",
+                    "SIGNAL", "PROPEPTID", "CHAIN", "REGION",
+                )
+            ],
+            "go_terms": uniprot_result.get("go_terms", []),
+            "sequence_length": uniprot_result.get("sequence_length", 0),
+        }

app/pipeline/definitions/protein_analysis.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+PIPELINE_DEFINITION = {
+    "id": "protein_analysis",
+    "name": "Protein Sequence Analysis",
+    "description": "Analyze a protein sequence: BLAST against Swiss-Prot, fetch UniProt annotations, pathway enrichment, retrieve AlphaFold structure",
+    "input_type": "sequence",
+    "input_label": "Protein sequence (FASTA or plain)",
+    "steps": ["submitted_to_ncbi", "polling_ncbi", "parsing", "interpreting", "pathway_enrichment", "fetching_alphafold", "complete"],
+    "default_database": "uniprotkb_swissprot",
+    "default_max_hits": 10,
+}
+
+
+def get_pipeline_definition() -> dict:
+    return PIPELINE_DEFINITION

app/pipeline/registry.py

@@ -0,0 +1,19 @@
+from typing import Any
+from app.tools.base import BaseTool
+
+
+class ToolRegistry:
+    def __init__(self):
+        self._tools: dict[str, BaseTool] = {}
+
+    def register(self, tool: BaseTool):
+        self._tools[tool.name] = tool
+
+    def get(self, name: str) -> BaseTool | None:
+        return self._tools.get(name)
+
+    def list(self) -> list[str]:
+        return list(self._tools.keys())
+
+
+registry = ToolRegistry()

app/routers/admet.py

@@ -0,0 +1,76 @@
+"""ADMET descriptor computation endpoints."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import subprocess
+
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel, Field
+
+from app.services.auth import get_user_id
+
+router = APIRouter(prefix="/api/admet", tags=["ADMET"])
+
+
+class ADMETRequest(BaseModel):
+    smiles: str = Field(..., min_length=1, max_length=500, description="SMILES string")
+
+
+class ADMETResponse(BaseModel):
+    job_id: str | None = None
+    status: str = "complete"
+    result: dict | None = None
+    error: str | None = None
+
+
+def _compute_in_subprocess(smiles: str) -> dict:
+    """Run RDKit computation in an isolated subprocess to prevent segfaults."""
+    import tempfile
+    backend_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(
+            'import json, sys, os\n'
+            f'sys.path.insert(0, {backend_dir!r})\n'
+            'from app.tools.admet import compute_descriptors\n'
+            f'result = compute_descriptors({smiles!r})\n'
+            'print(json.dumps(result))\n'
+        )
+        script_path = f.name
+    try:
+        result = subprocess.run(
+            [sys.executable, script_path],
+            capture_output=True, text=True, timeout=30,
+        )
+        if result.returncode != 0:
+            err = result.stderr.strip()[-500:] if result.stderr else "unknown error"
+            if "Invalid SMILES" in err or "ValueError" in err:
+                raise ValueError(f"Invalid SMILES: {smiles}")
+            raise RuntimeError(f"RDKit subprocess failed: {err}")
+        return json.loads(result.stdout)
+    finally:
+        try:
+            os.unlink(script_path)
+        except OSError:
+            pass
+
+
+@router.post("/descriptors", response_model=ADMETResponse)
+async def compute_descriptors(body: ADMETRequest, user_id: str | None = Depends(get_user_id)):
+    """Compute molecular descriptors from SMILES using RDKit.
+
+    Returns Lipinski/Veber compliance, QED score, and key properties.
+    """
+    try:
+        from app.tools.admet import compute_descriptors as _compute
+        if os.name == "nt":
+            result = _compute_in_subprocess(body.smiles)
+        else:
+            result = _compute(body.smiles)
+        return ADMETResponse(result=result)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Descriptor computation failed: {e}")

app/routers/ai.py

@@ -0,0 +1,33 @@
+import json
+import os
+from fastapi import APIRouter, HTTPException, Depends
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from app.ai.interpreter import interpret_stream
+from app.ai.llm_client import llm_client
+from app.services.rate_limit import check_daily_limit
+from app.models.responses import InterpretResponse
+
+router = APIRouter()
+
+
+class InterpretRequest(BaseModel):
+    pipeline_type: str = "protein_analysis"
+    context: dict = {}
+
+
+@router.post("/interpret", response_model=InterpretResponse)
+async def interpret_full_context(req: InterpretRequest):
+    if not llm_client.has_api_key():
+        raise HTTPException(status_code=502, detail="GROQ_API_KEY is not configured")
+
+    prompt = llm_client.build_prompt(req.pipeline_type, req.context)
+    return {"prompt": prompt, "context_size": len(json.dumps(req.context))}
+
+
+@router.post("/interpret/stream")
+async def interpret_stream_endpoint(req: InterpretRequest):
+    return StreamingResponse(
+        interpret_stream(req.pipeline_type, req.context),
+        media_type="text/event-stream",
+    )

app/routers/alignment.py

@@ -0,0 +1,95 @@
+import asyncio
+import logging
+
+import httpx
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+EBI_BASE = "https://www.ebi.ac.uk/Tools/services/rest/clustalo"
+POLL_INTERVAL = 2
+MAX_POLLS = 120
+
+# Valid result type names for Clustal Omega (confirmed via live API testing)
+# `fa` = FASTA alignment, `out` = stdout log, `phylotree` = Newick tree
+TREE_TYPES = ["phylotree"]
+
+
+class AlignRequest(BaseModel):
+    sequence: str = Field(..., min_length=1, description="Two or more sequences in FASTA format")
+    stype: str = Field("protein", description="Sequence type: protein or dna")
+
+
+async def _fetch_result(client: httpx.AsyncClient, job_id: str, type_name: str) -> str | None:
+    for attempt in range(3):
+        try:
+            resp = await client.get(
+                f"{EBI_BASE}/result/{job_id}/{type_name}",
+                headers={"Accept": "text/plain"},
+            )
+            if resp.status_code == 200:
+                return resp.text
+        except Exception:
+            pass
+        if attempt < 2:
+            await asyncio.sleep(1)
+    return None
+
+
+@router.post("/run")
+async def run_alignment(req: AlignRequest):
+    email = settings.NCBI_EMAIL or "bioflow@example.com"
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        submit_resp = await client.post(
+            f"{EBI_BASE}/run",
+            data={"email": email, "stype": req.stype, "sequence": req.sequence},
+            headers={"Accept": "text/plain"},
+        )
+        if submit_resp.status_code != 200:
+            detail = submit_resp.text[:200] if submit_resp.text else "EBI alignment submission failed"
+            raise HTTPException(status_code=502, detail=f"EBI submission failed: {detail}")
+        job_id = submit_resp.text.strip()
+        logger.info(f"EBI alignment job submitted: {job_id}")
+
+        for _ in range(MAX_POLLS):
+            await asyncio.sleep(POLL_INTERVAL)
+            try:
+                status_resp = await client.get(f"{EBI_BASE}/status/{job_id}")
+                status = status_resp.text.strip()
+            except Exception as e:
+                logger.warning(f"EBI status poll failed: {e}")
+                continue
+            logger.info(f"EBI alignment status ({job_id}): {status}")
+            if status == "FINISHED":
+                break
+            if status == "ERROR":
+                raise HTTPException(status_code=502, detail="EBI alignment job failed")
+        else:
+            raise HTTPException(status_code=504, detail="EBI alignment timed out")
+
+        await asyncio.sleep(1)
+
+        # Fetch FASTA alignment (result type `fa` — NOT `aln-fasta`)
+        fasta_text = await _fetch_result(client, job_id, "fa")
+        if fasta_text is None:
+            raise HTTPException(status_code=502, detail="Failed to fetch alignment result from EBI")
+
+        # Try phylogenetic tree (best-effort)
+        tree_text = None
+        for t in TREE_TYPES:
+            tree_text = await _fetch_result(client, job_id, t)
+            if tree_text:
+                break
+
+    return {
+        "job_id": job_id,
+        "aln_fasta": fasta_text,
+        "aln_clustal": "",
+        "phylotree": tree_text or "",
+        "stype": req.stype,
+    }

app/routers/api_keys.py

@@ -0,0 +1,47 @@
+import hashlib
+import secrets
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from app.services.auth import require_user_id
+from app.services.supabase import get_supabase
+
+router = APIRouter()
+
+
+class CreateKeyRequest(BaseModel):
+    name: str
+
+
+@router.get("")
+async def list_api_keys(user_id: str = require_user_id):
+    supabase = get_supabase()
+    result = supabase.table("api_keys").select("id, name, key_prefix, created_at, last_used_at").eq("user_id", user_id).execute()
+    return {"keys": result.data}
+
+
+@router.post("")
+async def create_api_key(req: CreateKeyRequest, user_id: str = require_user_id):
+    raw = f"sk_bio_{secrets.token_urlsafe(32)}"
+    key_hash = hashlib.sha256(raw.encode()).hexdigest()
+    key_prefix = raw[:16]
+
+    supabase = get_supabase()
+    supabase.table("api_keys").insert({
+        "user_id": user_id,
+        "name": req.name,
+        "key_hash": key_hash,
+        "key_prefix": key_prefix,
+    }).execute()
+
+    return {"key": raw, "key_prefix": key_prefix, "name": req.name}
+
+
+@router.delete("/{key_id}")
+async def delete_api_key(key_id: str, user_id: str = require_user_id):
+    supabase = get_supabase()
+    result = supabase.table("api_keys").select("id").eq("id", key_id).eq("user_id", user_id).execute()
+    if not result.data:
+        raise HTTPException(status_code=404, detail="API key not found")
+    supabase.table("api_keys").delete().eq("id", key_id).execute()
+    return {"status": "deleted"}

app/routers/audit.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
+from pydantic import BaseModel
+
+from app.deps import limiter
+from app.services.supabase import get_supabase
+from app.services.audit_engine import run_audit
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/api/audit", tags=["audit"])
+
+_SESSION_EVENT_COUNTS: dict[str, int] = {}
+_AUDIT_INTERVAL = 5
+_MAX_SESSIONS = 1000  # cap to prevent unbounded memory growth
+
+
+class AuditEventIn(BaseModel):
+    session_id: str
+    user_id: Optional[str] = None
+    step: str
+    tool: str
+    status: str
+    input_summary: str = ""
+    output_summary: str = ""
+    duration_ms: int = 0
+    metadata: Optional[dict] = None
+    timestamp: Optional[str] = None
+
+
+def _should_trigger_audit(session_id: str) -> bool:
+    count = _SESSION_EVENT_COUNTS.get(session_id, 0) + 1
+    _SESSION_EVENT_COUNTS[session_id] = count
+    if len(_SESSION_EVENT_COUNTS) > _MAX_SESSIONS:
+        oldest = list(_SESSION_EVENT_COUNTS.keys())[:_MAX_SESSIONS // 2]
+        for k in oldest:
+            _SESSION_EVENT_COUNTS.pop(k, None)
+    return count % _AUDIT_INTERVAL == 0
+
+
+@router.post("/event")
+@limiter.exempt
+async def receive_event(event: AuditEventIn, request: Request, background: BackgroundTasks):
+    sb = get_supabase()
+
+    try:
+        sb.table("audit_events").insert(event.model_dump(exclude_none=True)).execute()
+    except Exception as e:
+        logger.warning(f"Failed to store audit event: {e}")
+
+    should_audit = event.status == "failed" or _should_trigger_audit(event.session_id)
+    if should_audit:
+        background.add_task(run_audit, event.session_id, event.step)
+
+    return {"ok": True}
+
+
+@router.get("/insights")
+@limiter.exempt
+async def get_insights(session: str):
+    if not session:
+        raise HTTPException(400, detail="session query parameter is required")
+
+    sb = get_supabase()
+    resp = sb.table("audit_insights") \
+        .select("*") \
+        .eq("session_id", session) \
+        .order("created_at", desc=True) \
+        .limit(1) \
+        .execute()
+
+    return {"latest": resp.data[0] if resp.data else None}

app/routers/cache_stats.py

@@ -0,0 +1,18 @@
+import logging
+from fastapi import APIRouter, Request
+from app.services.cache import get_cache_stats, reset_cache_stats
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/admin", tags=["admin"])
+
+
+@router.get("/cache-stats")
+async def cache_stats():
+    return get_cache_stats()
+
+
+@router.post("/cache-stats/reset")
+async def reset_stats():
+    reset_cache_stats()
+    return {"status": "ok"}

app/routers/docking.py

@@ -0,0 +1,755 @@
+from __future__ import annotations
+
+import json
+import math
+import re
+from fastapi import APIRouter, HTTPException, Depends, Request
+from pydantic import BaseModel, Field
+from typing import Any, Optional
+
+from app.services.supabase import get_client
+from app.services.auth import require_user_id
+from app.services.ssrf import validate_url
+router = APIRouter(prefix="/api/docking", tags=["Docking"])
+_TABLE = "docking_jobs"
+
+
+# ---------------------------------------------------------------------------
+# Request / response schemas (match frontend DockingResult type)
+# ---------------------------------------------------------------------------
+
+class DockingJobCreate(BaseModel):
+    pdb_id: str = ""
+    smiles: str
+    pdb_url: str = ""
+    grid_center: Optional[list[float]] = None
+    grid_size: list[float] = Field(default_factory=lambda: [20.0, 20.0, 20.0])
+    exhaustiveness: int = 8
+    num_modes: int = 9
+
+
+class DockingJobResponse(BaseModel):
+    job_id: str
+    status: str
+    result: Optional[dict[str, Any]] = None
+    error: Optional[str] = None
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _prune_old(supabase, max_rows: int = 200):
+    try:
+        rows = (
+            supabase.table(_TABLE)
+            .select("id")
+            .order("created_at", desc=True)
+            .range(max_rows, max_rows + 1000)
+            .execute()
+            .data
+        )
+        if rows:
+            supabase.table(_TABLE).delete().in_(
+                "id", [r["id"] for r in rows]
+            ).execute()
+    except Exception:
+        pass
+
+
+def _row_to_response(row: dict) -> dict:
+    """Convert a Supabase row to the frontend DockingResult shape."""
+    result = None
+
+    # Prefer Storage URL (Phase 0c)
+    storage_url = row.get("storage_url")
+    if storage_url:
+        from app.services.artifact_storage import download_json
+        result = download_json(storage_url)
+    elif row.get("result_sdf"):
+        try:
+            result = json.loads(row["result_sdf"])
+        except Exception:
+            pass
+
+    return {
+        "job_id": row["id"],
+        "status": row["status"],
+        "result": result,
+        "error": row.get("error"),
+    }
+
+
+def _row_to_list_response(row: dict) -> dict:
+    """Lightweight row conversion for list views — skips Storage downloads."""
+    return {
+        "job_id": row["id"],
+        "status": row["status"],
+        "result": None,
+        "error": row.get("error"),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Background worker
+# ---------------------------------------------------------------------------
+
+def _run_docking_sync(job_id: str, payload: dict):
+    """Run the full docking pipeline synchronously (in a thread)."""
+    supabase = get_client()
+    try:
+        supabase.table(_TABLE).update({"status": "running"}).eq("id", job_id).execute()
+
+        from app.tools.docking import (
+            fetch_pdb_from_rcsb,
+            compute_grid_center,
+            smiles_to_pdbqt,
+            pdb_to_pdbqt_receptor,
+            run_vina,
+        )
+        import urllib.request
+        from app.services.ssrf import validate_url
+
+        pdb_id = payload.get("pdb_id", "").strip().upper()
+        pdb_url = payload.get("pdb_url", "").strip()
+        smiles = payload.get("ligand_smiles") or payload.get("smiles")
+        if not smiles:
+            raise ValueError("Missing ligand_smiles in job payload")
+
+        # 1. Obtain PDB text
+        pdb_text: str | None = None
+        if pdb_url:
+            validate_url(pdb_url)  # SSRF guard even in worker
+            try:
+                pdb_text = urllib.request.urlopen(pdb_url, timeout=30).read().decode("utf-8", errors="replace")
+            except Exception:
+                pass
+        if not pdb_text and pdb_id:
+            pdb_text = fetch_pdb_from_rcsb(pdb_id)
+
+        if not pdb_text:
+            raise RuntimeError(
+                "Could not obtain a PDB structure. "
+                "Provide a valid pdb_id or pdb_url."
+            )
+
+        # 2. Strip heteroatoms (keep protein backbone for receptor)
+        protein_lines = [
+            l for l in pdb_text.splitlines()
+            if l.startswith("ATOM") or l.startswith("TER") or l.startswith("END")
+        ]
+        protein_pdb = "\n".join(protein_lines) if protein_lines else pdb_text
+
+        # 3. Compute grid center if not provided
+        grid_center = payload.get("grid_center")
+        if not grid_center or all(v == 0 for v in grid_center):
+            grid_center = compute_grid_center(protein_pdb)
+            # Add a small offset so the center isn't dead on a backbone atom
+            grid_center = [round(c + 2.0, 3) for c in grid_center]
+
+        grid_size = payload.get("grid_size", [20.0, 20.0, 20.0])
+
+        # 4. Prepare receptor
+        protein_pdbqt = pdb_to_pdbqt_receptor(protein_pdb)
+
+        # 5. Prepare ligand
+        lig_pdbqt = smiles_to_pdbqt(smiles)
+
+        # 6. Run AutoDock Vina
+        vina_result = run_vina(
+            protein_pdbqt=protein_pdbqt,
+            ligand_pdbqt=lig_pdbqt,
+            grid_center=grid_center,
+            grid_size=grid_size,
+            exhaustiveness=payload.get("exhaustiveness", 8),
+            num_modes=payload.get("num_modes", 9),
+        )
+
+        # 7. Compute interaction summary for best pose
+        interactions = _compute_interactions(
+            protein_pdb, vina_result["ligand_pdb"]
+        )
+        pose_interactions = _summarize_pose_interactions(
+            protein_pdb, vina_result.get("result_sdf", "")
+        )
+
+        result_obj = {
+            "pdb_id": pdb_id,
+            "smiles": smiles,
+            "poses": vina_result["poses"],
+            "num_poses": vina_result["num_poses"],
+            "box_center": {
+                "x": grid_center[0],
+                "y": grid_center[1],
+                "z": grid_center[2],
+            },
+            "box_size": {
+                "x": grid_size[0],
+                "y": grid_size[1],
+                "z": grid_size[2],
+            },
+            "vina_log": vina_result.get("vina_log", ""),
+            "interactions": interactions,
+            "pose_interactions": pose_interactions,
+            "ligand_pdb": vina_result.get("ligand_pdb", ""),
+        }
+
+        # Offload to Supabase Storage; DB keeps only the URL
+        from app.services.artifact_storage import upload_json
+        storage_url = upload_json(job_id, "result", result_obj)
+
+        supabase.table(_TABLE).update({
+            "status": "complete",
+            "storage_url": storage_url,
+            "result_sdf": None,  # cleared — data lives in Storage now
+        }).eq("id", job_id).execute()
+
+    except Exception as exc:
+        import traceback
+        tb = traceback.format_exc()
+        supabase.table(_TABLE).update({
+            "status": "failed",
+            "error": f"{exc}\n\n{tb}"[:4000],
+        }).eq("id", job_id).execute()
+    finally:
+        _prune_old(supabase)
+
+
+# ---------------------------------------------------------------------------
+# Geometric interaction detector (H-bonds, hydrophobic, pi-stacking, salt bridges)
+# ---------------------------------------------------------------------------
+
+    # Protein atom classification
+_HYDROPHOBIC_RES = {"ALA", "VAL", "LEU", "ILE", "MET", "PHE", "TRP", "PRO", "GLY"}
+_AROMATIC_RES = {"PHE", "TRP", "TYR", "HIS"}
+
+# Atoms in aromatic rings by residue (PDB atom names)
+_AROMATIC_RING_ATOMS = {
+    "PHE": ["CG", "CD1", "CD2", "CE1", "CE2", "CZ"],
+    "TYR": ["CG", "CD1", "CD2", "CE1", "CE2", "CZ"],
+    "HIS": ["CG", "ND1", "CD2", "CE1", "NE2"],
+    "TRP": ["CG", "CD1", "CD2", "NE1", "CE2", "CE3", "CZ2", "CZ3", "CH2"],
+}
+
+# Two-ring centroids for TRP (5-membered + 6-membered)
+_TRP_RING_ATOMS = {
+    "five": ["CD1", "NE1", "CE2", "CG", "CD2"],
+    "six": ["CE2", "CD2", "CZ2", "CH2", "CZ3", "CE3"],
+}
+
+# Polar atoms eligible for H-bonding
+_POLAR_ATOMS = {"N", "O", "S"}
+
+# Residue-level charge groups for salt bridges
+_ANIONIC_RES = {"ASP", "GLU"}
+_CATIONIC_RES = {"LYS", "ARG", "HIS"}
+
+# Atom names that define the charged group center
+_ANIONIC_CARBONS = {"ASP": "CG", "GLU": "CD"}
+_CATIONIC_NITROGENS = {"LYS": "NZ", "ARG": ["CZ", "NH1", "NH2"]}
+
+_PDB_COORD_RE = re.compile(
+    r"^(ATOM|HETATM)\s+\d+\s+(\S+)\s+(\S{3})\s+(\S)\s+(\d+)\s+"
+    r"([-\d.]+)\s+([-\d.]+)\s+([-\d.]+)"
+)
+
+
+def _parse_atom_coords(pdb_text: str) -> list[tuple[str, str, str, str, int, float, float, float]]:
+    """Parse PDB into (record, atom_name, res_name, chain, res_seq, x, y, z)."""
+    atoms = []
+    for line in pdb_text.splitlines():
+        m = _PDB_COORD_RE.match(line)
+        if m:
+            atoms.append((
+                m.group(1), m.group(2), m.group(3), m.group(4),
+                int(m.group(5)),
+                float(m.group(6)), float(m.group(7)), float(m.group(8)),
+            ))
+    return atoms
+
+
+def _distance(a: tuple[float, float, float], b: tuple[float, float, float]) -> float:
+    return math.sqrt(sum((x - y) ** 2 for x, y in zip(a, b)))
+
+
+def _angle(a: tuple[float, float, float], b: tuple[float, float, float],
+           c: tuple[float, float, float]) -> float:
+    """Angle at vertex b between segments b→a and b→c, in degrees."""
+    ba = tuple(x - y for x, y in zip(a, b))
+    bc = tuple(x - y for x, y in zip(c, b))
+    dot = sum(x * y for x, y in zip(ba, bc))
+    mag_ba = math.sqrt(sum(x * x for x in ba))
+    mag_bc = math.sqrt(sum(x * x for x in bc))
+    if mag_ba < 1e-9 or mag_bc < 1e-9:
+        return 0.0
+    cos_angle = max(-1.0, min(1.0, dot / (mag_ba * mag_bc)))
+    return math.degrees(math.acos(cos_angle))
+
+
+def _vec_sub(a: tuple[float, float, float], b: tuple[float, float, float]) -> tuple[float, float, float]:
+    return (a[0] - b[0], a[1] - b[1], a[2] - b[2])
+
+
+def _vec_cross(a: tuple[float, float, float], b: tuple[float, float, float]) -> tuple[float, float, float]:
+    return (
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0],
+    )
+
+
+def _vec_norm(v: tuple[float, float, float]) -> float:
+    return math.sqrt(sum(x * x for x in v))
+
+
+def _ring_centroid(coords: list[tuple[float, float, float]]) -> tuple[float, float, float]:
+    n = len(coords)
+    if n == 0:
+        return (0.0, 0.0, 0.0)
+    return (
+        sum(c[0] for c in coords) / n,
+        sum(c[1] for c in coords) / n,
+        sum(c[2] for c in coords) / n,
+    )
+
+
+def _ring_normal(coords: list[tuple[float, float, float]]) -> tuple[float, float, float]:
+    """Compute the normal vector of a planar ring via cross product of two edges."""
+    if len(coords) < 3:
+        return (0.0, 0.0, 1.0)
+    v1 = _vec_sub(coords[1], coords[0])
+    v2 = _vec_sub(coords[2], coords[0])
+    cross = _vec_cross(v1, v2)
+    n = _vec_norm(cross)
+    if n < 1e-9:
+        return (0.0, 0.0, 1.0)
+    return (cross[0] / n, cross[1] / n, cross[2] / n)
+
+
+def _build_residue_map(atoms: list[tuple]) -> dict[tuple[str, str, int], list[tuple]]:
+    """Group atoms by (chain, res_name, res_seq)."""
+    res_map: dict[tuple[str, str, int], list[tuple]] = {}
+    for a in atoms:
+        key = (a[3], a[2], a[4])  # chain, res_name, res_seq
+        res_map.setdefault(key, []).append(a)
+    return res_map
+
+
+def _find_hydrogens(atoms: list[tuple]) -> list[tuple]:
+    """Return only hydrogen atoms from parsed PDB."""
+    return [a for a in atoms if a[1].startswith("H") or a[1] in ("1H", "2H", "3H")]
+
+
+def _compute_interactions(protein_pdb: str, ligand_pdb: str) -> dict:
+    """
+    Compute protein-ligand interactions using proper geometry.
+
+    H-bonds:     donor-H···acceptor angle > 120°, distance < 3.5Å
+    Hydrophobic: ligand carbon near protein carbon in hydrophobic residue, < 4.5Å
+    Pi-stacking: aromatic ring centroids, distance < 5.5Å, inter-ring angle
+    Salt bridges: charged group centroids, distance < 4.0Å
+    """
+    if not ligand_pdb:
+        return {"hbonds": [], "hydrophobic": [], "pi_stacking": [], "salt_bridges": []}
+
+    prot_atoms = _parse_atom_coords(protein_pdb)
+    lig_atoms = _parse_atom_coords(ligand_pdb)
+    prot_h = _find_hydrogens(prot_atoms)
+    lig_h = _find_hydrogens(lig_atoms)
+    prot_heavy = [a for a in prot_atoms if not (a[1].startswith("H") or a[1] in ("1H", "2H", "3H"))]
+    lig_heavy = [a for a in lig_atoms if not (a[1].startswith("H") or a[1] in ("1H", "2H", "3H"))]
+
+    hbonds: list[dict] = []
+    hydrophobic: list[dict] = []
+    pi_stacking: list[dict] = []
+    salt_bridges: list[dict] = []
+
+    seen_hbonds: set[tuple] = set()
+    seen_hydrophobic: set[tuple] = set()
+    seen_salt: set[tuple] = set()
+
+    # --- H-bonds with angle check ---
+    for la in lig_heavy:
+        l_elem = la[1][0] if la[1] else ""
+        if l_elem not in _POLAR_ATOMS:
+            continue
+        lcoord = (la[5], la[6], la[7])
+
+        # Find nearest H on ligand for angle reference
+        lig_h_near = None
+        min_h_dist = 1.5
+        for h in lig_h:
+            hd = _distance(lcoord, (h[5], h[6], h[7]))
+            if hd < min_h_dist:
+                min_h_dist = hd
+                lig_h_near = (h[5], h[6], h[7])
+
+        for pa in prot_heavy:
+            p_elem = pa[1][0] if pa[1] else ""
+            if p_elem not in _POLAR_ATOMS:
+                continue
+            pcoord = (pa[5], pa[6], pa[7])
+            d = _distance(lcoord, pcoord)
+
+            if d > 3.5 or d < 1.0:
+                continue
+
+            # Find nearest H on protein donor for angle check
+            prot_h_near = None
+            min_ph_dist = 1.5
+            for h in prot_h:
+                hd = _distance(pcoord, (h[5], h[6], h[7]))
+                if hd < min_ph_dist:
+                    min_ph_dist = hd
+                    prot_h_near = (h[5], h[6], h[7])
+
+            # Check angle if we have hydrogen positions
+            angle_ok = True
+            if lig_h_near and prot_h_near:
+                # H-bond angle: ligand-H···protein or protein-H···ligand
+                a1 = _angle(lig_h_near, lcoord, pcoord)
+                a2 = _angle(prot_h_near, pcoord, lcoord)
+                angle_ok = max(a1, a2) > 120.0
+            elif lig_h_near:
+                a1 = _angle(lig_h_near, lcoord, pcoord)
+                angle_ok = a1 > 120.0
+            elif prot_h_near:
+                a1 = _angle(prot_h_near, pcoord, lcoord)
+                angle_ok = a1 > 120.0
+            # If no H found at all, accept based on distance + element only
+
+            if not angle_ok:
+                continue
+
+            key = (la[4], pa[4])  # (lig_res_seq, prot_res_seq)
+            if key in seen_hbonds:
+                continue
+            seen_hbonds.add(key)
+
+            hbonds.append({
+                "type": "hbond",
+                "ligand_atom": la[1],
+                "ligand_coords": [la[5], la[6], la[7]],
+                "protein_residue": pa[2],
+                "protein_residue_seq": pa[4],
+                "protein_chain": pa[3],
+                "protein_atom": pa[1],
+                "protein_coords": [pa[5], pa[6], pa[7]],
+                "distance": round(d, 2),
+                "confidence": "high" if d < 3.0 else "medium",
+            })
+            if len(hbonds) >= 20:
+                break
+        if len(hbonds) >= 20:
+            break
+
+    # --- Hydrophobic contacts ---
+    for la in lig_heavy:
+        if la[1][0] != "C":
+            continue
+        lcoord = (la[5], la[6], la[7])
+        for pa in prot_heavy:
+            if pa[1][0] != "C":
+                continue
+            pres = pa[2]
+            if pres not in _HYDROPHOBIC_RES:
+                continue
+            pcoord = (pa[5], pa[6], pa[7])
+            d = _distance(lcoord, pcoord)
+            if d < 4.5:
+                key = (la[4], pa[4])
+                if key in seen_hydrophobic:
+                    continue
+                seen_hydrophobic.add(key)
+                hydrophobic.append({
+                    "type": "hydrophobic",
+                    "ligand_atom": la[1],
+                    "ligand_coords": [la[5], la[6], la[7]],
+                    "protein_residue": pres,
+                    "protein_residue_seq": pa[4],
+                    "protein_chain": pa[3],
+                    "protein_atom": pa[1],
+                    "protein_coords": [pa[5], pa[6], pa[7]],
+                    "distance": round(d, 2),
+                })
+                if len(hydrophobic) >= 20:
+                    break
+        if len(hydrophobic) >= 20:
+            break
+
+    # --- Pi-stacking (aromatic ring centroid geometry) ---
+    prot_res_map = _build_residue_map(prot_heavy)
+
+    for res_key, res_atoms in prot_res_map.items():
+        chain, res_name, res_seq = res_key
+        if res_name not in _AROMATIC_RES:
+            continue
+
+        ring_atom_names = _AROMATIC_RING_ATOMS[res_name]
+        ring_atoms_by_name = {a[1]: a for a in res_atoms}
+        ring_coords = []
+        for rn in ring_atom_names:
+            if rn in ring_atoms_by_name:
+                a = ring_atoms_by_name[rn]
+                ring_coords.append((a[5], a[6], a[7]))
+
+        if len(ring_coords) < 3:
+            continue
+
+        centroid = _ring_centroid(ring_coords)
+        normal = _ring_normal(ring_coords)
+
+        # For TRP, also check the 5-membered ring
+        rings_to_check = [(ring_coords, centroid, normal)]
+        if res_name == "TRP":
+            for ring_name in ("five", "six"):
+                ring_atom_names_2 = _TRP_RING_ATOMS[ring_name]
+                coords_2 = []
+                for rn in ring_atom_names_2:
+                    if rn in ring_atoms_by_name:
+                        a = ring_atoms_by_name[rn]
+                        coords_2.append((a[5], a[6], a[7]))
+                if len(coords_2) >= 3:
+                    rings_to_check.append((coords_2, _ring_centroid(coords_2), _ring_normal(coords_2)))
+
+        for ring_coords_r, centroid_r, normal_r in rings_to_check:
+            # Find aromatic atoms in ligand (heuristic: C/N in a flat region)
+            lig_aromatic_coords = []
+            for la in lig_heavy:
+                if la[1][0] in ("C", "N"):
+                    lig_aromatic_coords.append((la[5], la[6], la[7]))
+
+            if len(lig_aromatic_coords) < 3:
+                continue
+
+            # Use all ligand heavy atoms as a pseudo-centroid
+            lig_centroid = _ring_centroid(lig_aromatic_coords)
+
+            dist = _distance(centroid_r, lig_centroid)
+            if dist > 6.5:
+                continue
+
+            # Compute angle between ring normal and vector to ligand centroid
+            v_to_lig = _vec_sub(lig_centroid, centroid_r)
+            v_norm = _vec_norm(v_to_lig)
+            if v_norm < 1e-9:
+                continue
+            cos_angle = abs(sum(x * y for x, y in zip(normal_r, v_to_lig))) / (
+                _vec_norm(normal_r) * v_norm
+            )
+            ring_angle = math.degrees(math.acos(max(0, min(1, cos_angle))))
+
+            # Parallel: ring normal ~parallel to centroid-centroid vector (angle < 30°)
+            # T-shaped: ring normal ~perpendicular (angle 60-90°)
+            stacking_type = "unknown"
+            if ring_angle < 30 and dist < 5.5:
+                stacking_type = "parallel"
+            elif 60 < ring_angle < 90 and dist < 6.5:
+                stacking_type = "perpendicular"
+
+            if stacking_type == "unknown":
+                continue
+
+            pi_stacking.append({
+                "type": "pi_stacking",
+                "protein_residue": res_name,
+                "protein_residue_seq": res_seq,
+                "protein_chain": chain,
+                "ring_centroid": [round(c, 3) for c in centroid_r],
+                "ring_normal": [round(c, 3) for c in normal_r],
+                "ligand_centroid": [round(c, 3) for c in lig_centroid],
+                "distance": round(dist, 2),
+                "angle": round(ring_angle, 1),
+                "stacking_type": stacking_type,
+                "confidence": "high" if dist < 4.5 else "medium",
+            })
+            if len(pi_stacking) >= 10:
+                break
+        if len(pi_stacking) >= 10:
+            break
+
+    # --- Salt bridges (charged group centroid distance) ---
+    for la in lig_heavy:
+        l_elem = la[1][0] if la[1] else ""
+        if l_elem not in ("N", "O", "S", "C"):
+            continue
+        lcoord = (la[5], la[6], la[7])
+
+        for pa in prot_heavy:
+            pres = pa[2]
+            if pres in _ANIONIC_RES and pa[1] in ("OD1", "OD2", "OE1", "OE2"):
+                d = _distance(lcoord, pa[1:8] if False else (pa[5], pa[6], pa[7]))
+                if d < 4.0 and l_elem in ("N",):
+                    key = (la[4], pa[4])
+                    if key not in seen_salt:
+                        seen_salt.add(key)
+                        salt_bridges.append({
+                            "type": "salt_bridge",
+                            "ligand_atom": la[1],
+                            "ligand_coords": [la[5], la[6], la[7]],
+                            "protein_residue": pres,
+                            "protein_residue_seq": pa[4],
+                            "protein_chain": pa[3],
+                            "protein_atom": pa[1],
+                            "protein_coords": [pa[5], pa[6], pa[7]],
+                            "distance": round(d, 2),
+                            "charge_pair": "positive-negative",
+                        })
+
+            if pres in _CATIONIC_RES:
+                cat_atoms = _CATIONIC_NITROGENS.get(pres, [])
+                if isinstance(cat_atoms, str):
+                    cat_atoms = [cat_atoms]
+                if pa[1] in cat_atoms:
+                    d = _distance(lcoord, (pa[5], pa[6], pa[7]))
+                    if d < 4.0 and l_elem in ("O",):
+                        key = (la[4], pa[4])
+                        if key not in seen_salt:
+                            seen_salt.add(key)
+                            salt_bridges.append({
+                                "type": "salt_bridge",
+                                "ligand_atom": la[1],
+                                "ligand_coords": [la[5], la[6], la[7]],
+                                "protein_residue": pres,
+                                "protein_residue_seq": pa[4],
+                                "protein_chain": pa[3],
+                                "protein_atom": pa[1],
+                                "protein_coords": [pa[5], pa[6], pa[7]],
+                                "distance": round(d, 2),
+                                "charge_pair": "negative-positive",
+                            })
+
+    return {
+        "hbonds": hbonds[:20],
+        "hydrophobic": hydrophobic[:20],
+        "pi_stacking": pi_stacking[:10],
+        "salt_bridges": salt_bridges[:10],
+    }
+
+
+def _summarize_pose_interactions(protein_pdb: str, output_pdbqt: str) -> list[dict]:
+    """Per-pose interaction summary."""
+    if not output_pdbqt:
+        return []
+    models: dict[int, list[str]] = {}
+    current: int | None = None
+    for line in output_pdbqt.splitlines():
+        if line.startswith("MODEL"):
+            parts = line.split()
+            if len(parts) >= 2:
+                current = int(parts[1])
+                models[current] = []
+        elif line.startswith("ENDMDL"):
+            current = None
+        elif current is not None:
+            models.setdefault(current, []).append(line)
+
+    summaries = []
+    for mid in sorted(models.keys()):
+        lig_pdb = "\n".join(l for l in models[mid] if l.startswith("HETATM")) + "\nEND"
+        inter = _compute_interactions(protein_pdb, lig_pdb)
+        summaries.append({
+            "model": mid,
+            "hbonds": len(inter.get("hbonds", [])),
+            "hydrophobic": len(inter.get("hydrophobic", [])),
+            "pi_stacking": len(inter.get("pi_stacking", [])),
+            "salt_bridges": len(inter.get("salt_bridges", [])),
+        })
+    return summaries
+
+
+# ---------------------------------------------------------------------------
+# API endpoints
+# ---------------------------------------------------------------------------
+
+@router.post("/run", response_model=DockingJobResponse)
+async def create_docking_job(request: Request, body: DockingJobCreate, user_id: str = Depends(require_user_id)):
+    supabase = get_client()
+    _prune_old(supabase)
+
+    # SSRF validation on user-supplied URL
+    if body.pdb_url:
+        validate_url(body.pdb_url)
+
+    import uuid, datetime
+    job_id = str(uuid.uuid4())
+    now = datetime.datetime.utcnow().isoformat()
+
+    insert_row = {
+        "id": job_id,
+        "status": "queued",
+        "ligand_smiles": body.smiles,
+        "user_id": user_id,
+        "payload": {
+            "pdb_id": body.pdb_id,
+            "pdb_url": body.pdb_url,
+            "grid_center": body.grid_center or [0, 0, 0],
+            "grid_size": body.grid_size,
+            "exhaustiveness": body.exhaustiveness,
+            "num_modes": body.num_modes,
+            "smiles": body.smiles,
+            "ligand_smiles": body.smiles,
+        },
+    }
+    try:
+        supabase.table(_TABLE).insert(insert_row).execute()
+    except Exception as e:
+        if "ligand_smiles" in str(e):
+            supabase.table(_TABLE).insert({
+                "id": job_id, "status": "queued", "user_id": user_id,
+                "payload": insert_row["payload"],
+            }).execute()
+        else:
+            raise
+
+    return DockingJobResponse(job_id=job_id, status="queued", result=None)
+
+
+@router.get("/status/{job_id}", response_model=DockingJobResponse)
+async def get_docking_job(job_id: str, user_id: str = Depends(require_user_id)):
+    supabase = get_client()
+    result = supabase.table(_TABLE).select("*").eq("id", job_id).eq("user_id", user_id).single().execute()
+    if not result.data:
+        raise HTTPException(status_code=404, detail="Docking job not found")
+    return DockingJobResponse(**_row_to_response(result.data))
+
+
+@router.get("/result/{job_id}/pdb")
+async def get_docking_pdb(job_id: str, user_id: str = Depends(require_user_id)):
+    supabase = get_client()
+    row = supabase.table(_TABLE).select("result_sdf,storage_url").eq("id", job_id).eq("user_id", user_id).single().execute()
+    if not row.data:
+        raise HTTPException(status_code=404, detail="Docking result not found")
+
+    data = None
+    if row.data.get("storage_url"):
+        from app.services.artifact_storage import download_json
+        data = download_json(row.data["storage_url"])
+    elif row.data.get("result_sdf"):
+        try:
+            data = json.loads(row.data["result_sdf"])
+        except Exception:
+            pass
+
+    if not data:
+        raise HTTPException(status_code=404, detail="Docking result not found")
+    ligand_pdb = data.get("ligand_pdb", "")
+    if not ligand_pdb:
+        raise HTTPException(status_code=404, detail="No ligand PDB available")
+    from fastapi.responses import PlainTextResponse
+    return PlainTextResponse(ligand_pdb, media_type="text/plain")
+
+
+@router.get("")
+async def list_docking_jobs(limit: int = 50, user_id: str = Depends(require_user_id)):
+    supabase = get_client()
+    rows = (
+        supabase.table(_TABLE)
+        .select("*")
+        .eq("user_id", user_id)
+        .order("created_at", desc=True)
+        .limit(limit)
+        .execute()
+        .data
+    )
+    return {"jobs": [_row_to_list_response(r) for r in rows]}

app/routers/domains.py

@@ -0,0 +1,289 @@
+"""
+Domain & Motif Analysis endpoints.
+
+Provides comprehensive protein feature analysis:
+  - InterPro domain architecture (Pfam, SMART, PROSITE, CDD, PANTHER, PRINTS)
+  - Functional sites (active, binding, catalytic residues)
+  - Post-translational modifications (phosphorylation, glycosylation, etc.)
+  - Topology (signal peptides, transmembrane regions, chains)
+  - Structural motifs (zinc fingers, coiled coils, domains)
+  - Mutagenesis & natural variants
+  - Disulfide bonds
+  - Composition bias (low complexity, repeats)
+  - Gene Ontology annotations
+  - Pathway annotations (KEGG, Reactome, WikiPathways)
+  - Combined analysis endpoint
+"""
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from app.tools.domain_analysis import (
+    _sanitize,
+    fetch_interpro_domains,
+    fetch_uniprot_raw,
+    extract_features,
+    extract_functional_sites,
+    extract_ptms,
+    extract_topology,
+    extract_structural_motifs,
+    extract_variants,
+    extract_disulfide_bonds,
+    extract_composition_bias,
+    extract_go_terms,
+    extract_pathways,
+    full_analysis,
+)
+
+router = APIRouter(prefix="/api/domains", tags=["domains"])
+
+
+# ---------------------------------------------------------------------------
+# Response models
+# ---------------------------------------------------------------------------
+
+class Domain(BaseModel):
+    accession: str
+    name: str
+    source_db: str
+    start: int
+    end: int
+    score: float | None
+
+
+class DomainsResponse(BaseModel):
+    uniprot_accession: str
+    sequence_length: int
+    domains: list[Domain]
+
+
+class FeatureItem(BaseModel):
+    type: str
+    description: str
+    begin: int | None = None
+    end: int | None = None
+    amino_acid: list[str] = []
+
+
+class FeaturesResponse(BaseModel):
+    accession: str
+    sequence_length: int
+    categories: dict[str, list[FeatureItem]]
+
+
+class FunctionalSite(BaseModel):
+    type: str
+    description: str
+    begin: int | None = None
+    end: int | None = None
+    amino_acid: list[str] = []
+
+
+class PTMItem(BaseModel):
+    type: str
+    description: str
+    begin: int | None = None
+    end: int | None = None
+    amino_acid: list[str] = []
+
+
+class TopologyItem(BaseModel):
+    type: str
+    description: str
+    begin: int | None = None
+    end: int | None = None
+
+
+class MotifItem(BaseModel):
+    type: str
+    description: str
+    begin: int | None = None
+    end: int | None = None
+
+
+class VariantItem(BaseModel):
+    type: str
+    description: str
+    begin: int | None = None
+    end: int | None = None
+    amino_acid: list[str] = []
+
+
+class DisulfideBond(BaseModel):
+    begin: int | None = None
+    end: int | None = None
+    description: str = ""
+
+
+class CompositionBias(BaseModel):
+    type: str
+    description: str
+    begin: int | None = None
+    end: int | None = None
+
+
+class GOTerm(BaseModel):
+    id: str
+    term: str
+    category: str
+
+
+class PathwayAnnotation(BaseModel):
+    database: str
+    id: str
+    name: str
+
+
+class FullAnalysisResponse(BaseModel):
+    accession: str
+    protein_name: str
+    organism: str
+    sequence_length: int
+    sequence: str
+    domains: list[Domain]
+    active_sites: list[FunctionalSite]
+    ptms: list[PTMItem]
+    topology: list[TopologyItem]
+    structural_motifs: list[MotifItem]
+    variants: list[VariantItem]
+    disulfide_bonds: list[DisulfideBond]
+    composition_bias: list[CompositionBias]
+    go_terms: list[GOTerm]
+    pathways: list[PathwayAnnotation]
+    feature_summary: dict[str, int]
+
+
+# ---------------------------------------------------------------------------
+# Endpoints
+# ---------------------------------------------------------------------------
+
+@router.get("/{accession}", response_model=DomainsResponse)
+async def get_domains(accession: str):
+    """Fetch InterPro domain architecture (Pfam, SMART, PROSITE, CDD, PANTHER, PRINTS)."""
+    accession = _sanitize(accession)
+    try:
+        data = await fetch_interpro_domains(accession)
+    except Exception as e:
+        raise HTTPException(502, f"InterPro request failed: {e}")
+    if not data.get("domains"):
+        raise HTTPException(404, f"No domain annotations found for {accession}")
+    return DomainsResponse(**data)
+
+
+@router.get("/{accession}/features", response_model=FeaturesResponse)
+async def get_features(accession: str):
+    """Full UniProt feature table categorized by type."""
+    accession = _sanitize(accession)
+    raw = await _fetch_or_404(accession)
+    features = extract_features(raw)
+    seq_len = (raw.get("sequence", {}) or {}).get("length", 0)
+    categories = {
+        cat: [FeatureItem(**item) for item in items]
+        for cat, items in features.items() if items
+    }
+    return FeaturesResponse(
+        accession=accession, sequence_length=seq_len, categories=categories,
+    )
+
+
+@router.get("/{accession}/sites", response_model=list[FunctionalSite])
+async def get_functional_sites(accession: str):
+    """Active sites, binding sites, and catalytic residues."""
+    accession = _sanitize(accession)
+    raw = await _fetch_or_404(accession)
+    sites = extract_functional_sites(raw)
+    return [FunctionalSite(**s) for s in sites]
+
+
+@router.get("/{accession}/ptm", response_model=list[PTMItem])
+async def get_ptms(accession: str):
+    """Post-translational modifications (phosphorylation, glycosylation, etc.)."""
+    accession = _sanitize(accession)
+    raw = await _fetch_or_404(accession)
+    ptms = extract_ptms(raw)
+    return [PTMItem(**p) for p in ptms]
+
+
+@router.get("/{accession}/topology", response_model=list[TopologyItem])
+async def get_topology(accession: str):
+    """Signal peptides, transmembrane regions, chains, and propeptides."""
+    accession = _sanitize(accession)
+    raw = await _fetch_or_404(accession)
+    topo = extract_topology(raw)
+    return [TopologyItem(**t) for t in topo]
+
+
+@router.get("/{accession}/motifs", response_model=list[MotifItem])
+async def get_motifs(accession: str):
+    """Structural motifs: zinc fingers, coiled coils, repeats, domain families."""
+    accession = _sanitize(accession)
+    raw = await _fetch_or_404(accession)
+    motifs = extract_structural_motifs(raw)
+    return [MotifItem(**m) for m in motifs]
+
+
+@router.get("/{accession}/variants", response_model=list[VariantItem])
+async def get_variants(accession: str):
+    """Mutagenesis sites and natural variants."""
+    accession = _sanitize(accession)
+    raw = await _fetch_or_404(accession)
+    variants = extract_variants(raw)
+    return [VariantItem(**v) for v in variants]
+
+
+@router.get("/{accession}/disulfide", response_model=list[DisulfideBond])
+async def get_disulfide_bonds(accession: str):
+    """Disulfide bond connectivity."""
+    accession = _sanitize(accession)
+    raw = await _fetch_or_404(accession)
+    bonds = extract_disulfide_bonds(raw)
+    return [DisulfideBond(**b) for b in bonds]
+
+
+@router.get("/{accession}/composition", response_model=list[CompositionBias])
+async def get_composition_bias(accession: str):
+    """Compositionally biased regions and low-complexity sequences."""
+    accession = _sanitize(accession)
+    raw = await _fetch_or_404(accession)
+    bias = extract_composition_bias(raw)
+    return [CompositionBias(**b) for b in bias]
+
+
+@router.get("/{accession}/go", response_model=list[GOTerm])
+async def get_go_terms(accession: str):
+    """Gene Ontology annotations (molecular function, biological process, cellular component)."""
+    accession = _sanitize(accession)
+    raw = await _fetch_or_404(accession)
+    go = extract_go_terms(raw)
+    return [GOTerm(**g) for g in go]
+
+
+@router.get("/{accession}/pathways", response_model=list[PathwayAnnotation])
+async def get_pathways(accession: str):
+    """Pathway annotations from KEGG, Reactome, and WikiPathways."""
+    accession = _sanitize(accession)
+    raw = await _fetch_or_404(accession)
+    pws = extract_pathways(raw)
+    return [PathwayAnnotation(**p) for p in pws]
+
+
+@router.get("/{accession}/all", response_model=FullAnalysisResponse)
+async def get_all_features(accession: str):
+    """Combined analysis: domains, sites, PTMs, topology, motifs, variants, GO, pathways."""
+    accession = _sanitize(accession)
+    try:
+        result = await full_analysis(accession)
+    except Exception as e:
+        raise HTTPException(502, f"Analysis failed: {e}")
+    if not result.get("domains") and not result.get("active_sites"):
+        raise HTTPException(404, f"No feature data found for {accession}")
+    return FullAnalysisResponse(**result)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+async def _fetch_or_404(accession: str) -> dict:
+    raw = await fetch_uniprot_raw(accession)
+    if not raw:
+        raise HTTPException(404, f"No UniProt data for {accession}")
+    return raw

app/routers/export.py

@@ -0,0 +1,55 @@
+import json
+
+from fastapi import APIRouter, HTTPException, Query
+from fastapi.responses import StreamingResponse, JSONResponse
+from app.services.auth import require_user_id
+from app.services.supabase import get_supabase
+from app.services.export import export_blast_pdf, export_uniprot_pdf
+
+router = APIRouter()
+
+
+@router.get("/job/{job_id}")
+async def export_job(
+    job_id: str,
+    format: str = Query("pdf", regex="^(pdf|json)$"),
+    user_id: str = require_user_id,
+):
+    supabase = get_supabase()
+    job = supabase.table("jobs").select("*").eq("id", job_id).execute()
+    if not job.data:
+        raise HTTPException(status_code=404, detail="Job not found")
+    if job.data[0].get("user_id") and job.data[0]["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Not your job")
+
+    context = job.data[0].get("context_json") or {}
+    steps = context.get("steps") or {}
+    if not steps:
+        steps = {}
+    blast_data = steps.get("blast", {}).get("data") or context.get("blast") or {}
+    uniprot_data = steps.get("uniprot", {}).get("data") or context.get("uniprot") or {}
+    sequence = (context.get("query") or {}).get("sequence") or context.get("sequence") or ""
+
+    if format == "json":
+        return JSONResponse(
+            content=job.data[0],
+            media_type="application/json",
+            headers={"Content-Disposition": f'attachment; filename="bio-nexus-{job_id[:8]}.json"'},
+        )
+
+    pdf_parts = []
+    if blast_data.get("hits"):
+        pdf_parts.append(export_blast_pdf(blast_data, sequence))
+    if uniprot_data.get("accession"):
+        pdf_parts.append(export_uniprot_pdf(uniprot_data))
+
+    if not pdf_parts:
+        raise HTTPException(status_code=400, detail="No exportable data found for this job")
+
+    merged = pdf_parts[0] if len(pdf_parts) == 1 else pdf_parts[0] + pdf_parts[1]
+
+    return StreamingResponse(
+        iter([merged]),
+        media_type="application/pdf",
+        headers={"Content-Disposition": f'attachment; filename="bio-nexus-{job_id[:8]}.pdf"'},
+    )

app/routers/function_predict.py

@@ -0,0 +1,98 @@
+"""Protein function prediction endpoints."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, timezone, timedelta
+
+from fastapi import APIRouter, HTTPException, Depends, Request
+from pydantic import BaseModel, Field
+
+from app.services.supabase import get_client
+from app.services.auth import require_user_id
+
+router = APIRouter(prefix="/api/function", tags=["Function Prediction"])
+_TABLE = "docking_jobs"  # reuse table with tool_type="function_predict"
+
+
+class FunctionPredictRequest(BaseModel):
+    pdb_id: str = Field(..., pattern=r"^[A-Za-z0-9]{4}$", description="4-char PDB ID")
+
+
+class FunctionPredictResponse(BaseModel):
+    job_id: str
+    status: str
+    result: dict | None = None
+    error: str | None = None
+
+
+@router.post("/predict", response_model=FunctionPredictResponse)
+async def predict_function_endpoint(request: Request, body: FunctionPredictRequest, user_id: str = Depends(require_user_id)):
+    """Submit a function prediction job (queued through the durable worker)."""
+    supabase = get_client()
+    job_id = str(uuid.uuid4())
+
+    insert_row = {
+        "id": job_id,
+        "status": "queued",
+        "user_id": user_id,
+        "ligand_smiles": f"func:{body.pdb_id}",
+        "payload": {
+            "pdb_id": body.pdb_id,
+            "tool_type": "function_predict",
+        },
+    }
+    try:
+        supabase.table(_TABLE).insert(insert_row).execute()
+    except Exception as e:
+        if "ligand_smiles" in str(e):
+            supabase.table(_TABLE).insert({
+                "id": job_id, "status": "queued", "user_id": user_id,
+                "payload": insert_row["payload"],
+            }).execute()
+        else:
+            raise
+
+    return FunctionPredictResponse(job_id=job_id, status="queued")
+
+
+@router.get("/status/{job_id}", response_model=FunctionPredictResponse)
+async def get_function_status(job_id: str, user_id: str = Depends(require_user_id)):
+    supabase = get_client()
+    row = supabase.table(_TABLE).select("*").eq("id", job_id).eq("user_id", user_id).single().execute()
+    if not row.data:
+        raise HTTPException(status_code=404, detail="Job not found")
+
+    data = row.data
+
+    if data.get("status") in ("queued", "running") and data.get("claimed_at"):
+        try:
+            claimed = datetime.fromisoformat(data["claimed_at"].replace("Z", "+00:00"))
+            if datetime.now(timezone.utc) - claimed > timedelta(minutes=10):
+                supabase.table(_TABLE).update({
+                    "status": "failed",
+                    "error": "Job timed out (exceeded 10 minute limit)",
+                    "done_at": datetime.now(timezone.utc).isoformat(),
+                }).eq("id", job_id).execute()
+                data["status"] = "failed"
+                data["error"] = "Job timed out (exceeded 10 minute limit)"
+        except Exception:
+            pass
+
+    result = None
+    if data.get("storage_url"):
+        from app.services.artifact_storage import download_json
+        result = download_json(data["storage_url"])
+    elif data.get("result_sdf"):
+        try:
+            result = json.loads(data["result_sdf"])
+        except Exception:
+            pass
+
+    return FunctionPredictResponse(
+        job_id=data["id"],
+        status=data["status"],
+        result=result,
+        error=data.get("error"),
+    )

app/routers/interactions.py

@@ -0,0 +1,63 @@
+import re
+import httpx
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/api/interactions", tags=["interactions"])
+
+STRING_NET = "https://string-db.org/api/json/interaction_partners"
+
+def _sanitize_for_url(s: str) -> str:
+    """Strip control characters that break URL construction."""
+    return re.sub(r'[\x00-\x1f\x7f-\x9f]', '', s)
+
+class Interaction(BaseModel):
+    partner_gene: str
+    partner_protein: str
+    combined_score: float
+    nscore: float
+    fscore: float
+    pscore: float
+    ascore: float
+    escore: float
+    dscore: float
+    tscore: float
+
+@router.get("/{gene_name}")
+async def get_interactions(
+    gene_name: str,
+    species: int = Query(default=9606, description="NCBI taxon ID; 9606=human"),
+    limit: int = Query(default=15, ge=1, le=50),
+):
+    gene_name = _sanitize_for_url(gene_name)
+    async with httpx.AsyncClient(timeout=20) as client:
+        r = await client.get(STRING_NET, params={
+            "identifiers": gene_name,
+            "species":     species,
+            "limit":       limit,
+            "caller_identity": "bio-nexus-platform",
+        })
+        if r.status_code != 200:
+            raise HTTPException(502, f"STRING-DB returned {r.status_code}")
+        data = r.json()
+
+    if not data:
+        raise HTTPException(404, f"No interactions found for {gene_name}")
+
+    interactions = [
+        Interaction(
+            partner_gene    = item.get("preferredName_B", ""),
+            partner_protein = item.get("stringId_B", ""),
+            combined_score  = item.get("score", 0),
+            nscore          = item.get("nscore", 0),
+            fscore          = item.get("fscore", 0),
+            pscore          = item.get("pscore", 0),
+            ascore          = item.get("ascore", 0),
+            escore          = item.get("escore", 0),
+            dscore          = item.get("dscore", 0),
+            tscore          = item.get("tscore", 0),
+        )
+        for item in data
+    ]
+    interactions.sort(key=lambda x: x.combined_score, reverse=True)
+    return {"gene": gene_name, "species": species, "interactions": interactions}

app/routers/jobs.py

@@ -0,0 +1,69 @@
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+from datetime import datetime, timezone
+from app.services.supabase import get_supabase
+from app.services.auth import get_user_id
+from app.models.responses import JobCountResponse, JobDeleteResponse
+
+router = APIRouter()
+
+
+@router.get("/count", response_model=JobCountResponse)
+async def job_count(user_id: str | None = Depends(get_user_id)):
+    supabase = get_supabase()
+    today = datetime.now(timezone.utc).date().isoformat()
+    query = supabase.table("jobs").select("id", count="exact").gte("created_at", today)
+    if user_id:
+        query = query.eq("user_id", user_id)
+    result = query.execute()
+    count = result.count or 0
+    return {"count": count, "limit": 10, "remaining": max(0, 10 - count)}
+
+
+@router.get("")
+async def list_jobs(user_id: str | None = Depends(get_user_id)):
+    try:
+        supabase = get_supabase()
+        query = supabase.table("jobs").select("*").order("created_at", desc=True).limit(50)
+        if user_id:
+            query = query.eq("user_id", user_id)
+        result = query.execute()
+        return {"jobs": result.data or []}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Jobs list error: {type(e).__name__}: {e}")
+
+
+@router.get("/{job_id}")
+async def get_job(job_id: str, user_id: str | None = Depends(get_user_id)):
+    supabase = get_supabase()
+    result = supabase.table("jobs").select("*").eq("id", job_id).execute()
+    if not result.data:
+        raise HTTPException(status_code=404, detail="Job not found")
+    job = result.data[0]
+    if user_id and job.get("user_id") and job["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    # Hydrate from Storage if result was offloaded.
+    # context_json starts as {"sequence": ...} at creation; once the pipeline
+    # finishes, storage_url points to the full assembled context (blast, uniprot, …).
+    if job.get("storage_url") and not job.get("context_json", {}).get("blast"):
+        from app.services.artifact_storage import download_json
+        results = download_json(job["storage_url"])
+        if results:
+            job["context_json"] = results
+            job["results"] = results
+
+    return job
+
+
+@router.delete("/{job_id}", response_model=JobDeleteResponse)
+async def delete_job(job_id: str, user_id: str | None = Depends(get_user_id)):
+    supabase = get_supabase()
+    result = supabase.table("jobs").select("id,user_id").eq("id", job_id).execute()
+    if not result.data:
+        raise HTTPException(status_code=404, detail="Job not found")
+    job = result.data[0]
+    if user_id and job.get("user_id") and job["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied")
+    supabase.table("jobs").delete().eq("id", job_id).execute()
+    return {"status": "deleted"}

app/routers/md.py

@@ -0,0 +1,111 @@
+"""Molecular dynamics simulation endpoints (implicit solvent only)."""
+
+from __future__ import annotations
+
+import asyncio
+import uuid
+from datetime import datetime, timezone, timedelta
+
+from fastapi import APIRouter, HTTPException, Depends, Request
+from pydantic import BaseModel, Field
+
+from app.services.supabase import get_client
+from app.services.auth import require_user_id
+
+router = APIRouter(prefix="/api/md", tags=["MD Simulation"])
+_TABLE = "docking_jobs"  # reuse docking_jobs table with md_jobs for now
+
+
+class MDRunRequest(BaseModel):
+    pdb_id: str = Field(..., pattern=r"^[A-Za-z0-9]{4}$", description="4-char PDB ID")
+    mode: str = Field(default="minimize", pattern=r"^(minimize|equilibrate|production)$")
+    platform: str | None = Field(default=None, description="Optional OpenMM platform (CPU/Reference)")
+    forcefield: str | None = Field(default=None, pattern=r"^[a-z0-9_-]+$", description="Force field; only 'amber14' is currently supported")
+    solvent: str | None = Field(default=None, pattern=r"^(obc1|obc2|gbn2)$", description="Implicit solvent model (explicit water not supported)")
+    run_length_ps: float | None = Field(default=None, ge=50, le=5000, description="Desired production length in ps (production mode only; engine may clamp to wall-clock budget)")
+
+
+class MDJobResponse(BaseModel):
+    job_id: str
+    status: str
+    result: dict | None = None
+    error: str | None = None
+
+
+@router.post("/run", response_model=MDJobResponse)
+async def run_md(request: Request, body: MDRunRequest, user_id: str = Depends(require_user_id)):
+    """Submit an MD simulation job (queued through the durable worker)."""
+    from app.services.ssrf import validate_url
+
+    supabase = get_client()
+    job_id = str(uuid.uuid4())
+
+    insert_row = {
+        "id": job_id,
+        "status": "queued",
+        "user_id": user_id,
+        "ligand_smiles": f"md:{body.mode}:{body.pdb_id}",
+        "payload": {
+            "pdb_id": body.pdb_id,
+            "mode": body.mode,
+            "platform": body.platform,
+            "forcefield": body.forcefield,
+            "solvent": body.solvent,
+            "run_length_ps": body.run_length_ps,
+            "tool_type": "md",
+        },
+    }
+    try:
+        supabase.table(_TABLE).insert(insert_row).execute()
+    except Exception as e:
+        if "ligand_smiles" in str(e):
+            supabase.table(_TABLE).insert({
+                "id": job_id, "status": "queued", "user_id": user_id,
+                "payload": insert_row["payload"],
+            }).execute()
+        else:
+            raise
+
+    return MDJobResponse(job_id=job_id, status="queued")
+
+
+@router.get("/status/{job_id}", response_model=MDJobResponse)
+async def get_md_status(job_id: str, user_id: str = Depends(require_user_id)):
+    supabase = get_client()
+    row = supabase.table(_TABLE).select("*").eq("id", job_id).eq("user_id", user_id).single().execute()
+    if not row.data:
+        raise HTTPException(status_code=404, detail="Job not found")
+
+    data = row.data
+
+    if data.get("status") in ("queued", "running") and data.get("claimed_at"):
+        try:
+            claimed = datetime.fromisoformat(data["claimed_at"].replace("Z", "+00:00"))
+            if datetime.now(timezone.utc) - claimed > timedelta(minutes=60):
+                supabase.table(_TABLE).update({
+                    "status": "failed",
+                    "error": "Job timed out (exceeded 60 minute limit)",
+                    "done_at": datetime.now(timezone.utc).isoformat(),
+                }).eq("id", job_id).execute()
+                data["status"] = "failed"
+                data["error"] = "Job timed out (exceeded 60 minute limit)"
+        except Exception:
+            pass
+
+    result = None
+    if data.get("storage_url"):
+        from app.services.artifact_storage import download_json
+        result = download_json(data["storage_url"])
+    elif data.get("result_sdf"):
+        try:
+            import json
+            result = json.loads(data["result_sdf"])
+        except Exception:
+            pass
+
+    return MDJobResponse(
+        job_id=data["id"],
+        status=data["status"],
+        result=result,
+        error=data.get("error"),
+    )

app/routers/pathways.py

@@ -0,0 +1,186 @@
+import re
+from urllib.parse import quote as urlquote
+import httpx
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+router = APIRouter()
+
+REACTOME_BASE = "https://reactome.org/ContentService"
+
+def _sanitize_for_url(s: str) -> str:
+    """Strip control characters that break URL construction."""
+    return re.sub(r'[\x00-\x1f\x7f-\x9f]', '', s)
+
+
+class PathwaySearchRequest(BaseModel):
+    query: str = Field(..., min_length=2, description="Gene name or protein identifier")
+    species: str = Field("Homo sapiens", description="Species name")
+
+
+class PathwayDetailRequest(BaseModel):
+    pathway_id: str = Field(..., min_length=1, description="Reactome pathway ID (e.g. R-HSA-1640170)")
+
+
+class KEGGSearchRequest(BaseModel):
+    query: str = Field(..., min_length=2, description="Gene name or keyword")
+
+
+class EnrichmentRequest(BaseModel):
+    identifiers: list[str] = Field(..., min_length=1, description="List of gene or protein identifiers")
+
+
+def _extract_entries(data: dict) -> list[dict]:
+    entries = []
+    for group in data.get("results", []):
+        entries.extend(group.get("entries", []))
+    return entries
+
+
+@router.post("/search")
+async def search_pathways(req: PathwaySearchRequest):
+    async with httpx.AsyncClient(timeout=15) as client:
+        resp = await client.get(
+            f"{REACTOME_BASE}/search/query",
+            params={"query": req.query, "species": req.species, "types": "Pathway"},
+        )
+        if resp.status_code != 200:
+            raise HTTPException(status_code=502, detail="Reactome search failed")
+        data = resp.json()
+
+    results = []
+    seen = set()
+    for item in _extract_entries(data):
+        st_id = item.get("stId", "")
+        if not st_id or st_id in seen:
+            continue
+        seen.add(st_id)
+        results.append({
+            "pathway_id": st_id,
+            "name": item.get("displayName", item.get("name", "")),
+            "species": item.get("species", ["Unknown"])[0] if isinstance(item.get("species"), list) else (item.get("species", {}) or {}).get("name", ""),
+            "url": f"https://reactome.org/content/detail/{st_id}",
+        })
+
+    if not results:
+        async with httpx.AsyncClient(timeout=15) as client:
+            resp = await client.get(
+                f"{REACTOME_BASE}/search/fireworks",
+                params={"query": req.query, "species": req.species},
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                for item in data.get("entries", []):
+                    st_id = item.get("stId", "")
+                    if not st_id or st_id in seen:
+                        continue
+                    seen.add(st_id)
+                    results.append({
+                        "pathway_id": st_id,
+                        "name": item.get("name", ""),
+                        "species": item.get("species", ["Unknown"])[0] if isinstance(item.get("species"), list) else "",
+                        "url": f"https://reactome.org/content/detail/{st_id}",
+                    })
+
+    return {"results": results, "count": len(results)}
+
+
+@router.post("/detail")
+async def pathway_detail(req: PathwayDetailRequest):
+    async with httpx.AsyncClient(timeout=15) as client:
+        resp = await client.get(f"{REACTOME_BASE}/data/fireworks/{req.pathway_id}")
+        if resp.status_code != 200:
+            raise HTTPException(status_code=404, detail="Pathway not found")
+        data = resp.json()
+    return {
+        "pathway_id": data.get("stId", ""),
+        "name": data.get("name", ""),
+        "species": (data.get("species", {}) or {}).get("name", ""),
+        "description": data.get("definition", ""),
+        "url": f"https://reactome.org/content/detail/{data.get('stId', '')}",
+    }
+
+
+@router.post("/kegg/search")
+async def kegg_search(req: KEGGSearchRequest):
+    query = _sanitize_for_url(req.query.strip())
+    results = []
+    seen = set()
+    q_upper = query.upper()
+
+    async with httpx.AsyncClient(timeout=15) as client:
+        find_resp = await client.get(f"https://rest.kegg.jp/find/hsa/{urlquote(query)}")
+        kegg_gene_id = None
+        if find_resp.status_code == 200:
+            for line in find_resp.text.strip().split("\n"):
+                parts = line.split("\t", 1)
+                if len(parts) != 2:
+                    continue
+                gene_id = parts[0]
+                after_tab = parts[1]
+                symbols_part = after_tab.split(";")[0]
+                symbols = [s.strip().upper() for s in symbols_part.split(",")]
+                if q_upper in symbols:
+                    kegg_gene_id = gene_id
+                    break
+
+        if kegg_gene_id:
+            gene_resp = await client.get(f"https://rest.kegg.jp/get/{kegg_gene_id}")
+            if gene_resp.status_code == 200:
+                in_pathway = False
+                for line in gene_resp.text.split("\n"):
+                    if line.startswith("PATHWAY"):
+                        in_pathway = True
+                    elif in_pathway:
+                        s = line.strip()
+                        if s == "":
+                            continue
+                        if not line.startswith(" "):
+                            in_pathway = False
+                            continue
+                    if not in_pathway:
+                        continue
+                    rest = line[9:] if line.startswith("PATHWAY") else line.strip()
+                    rest = rest.strip()
+                    parts = rest.split(None, 1)
+                    if len(parts) == 2:
+                        pid, pname = parts
+                        if pid not in seen:
+                            seen.add(pid)
+                            results.append({
+                                "pathway_id": pid,
+                                "name": pname,
+                                "organism": "Homo sapiens",
+                                "url": f"https://www.kegg.jp/entry/{pid}",
+                                "image_url": f"https://rest.kegg.jp/get/{pid}/image",
+                            })
+
+        if not results:
+            text_resp = await client.get(f"https://rest.kegg.jp/find/pathway/{query}")
+            if text_resp.status_code == 200:
+                for line in text_resp.text.strip().split("\n"):
+                    parts = line.split("\t", 1)
+                    if len(parts) == 2:
+                        pid = parts[0]
+                        name = parts[1].split(" - ")[0]
+                        organism = parts[1].split(" - ")[-1] if " - " in parts[1] else ""
+                        if pid not in seen:
+                            seen.add(pid)
+                            results.append({
+                                "pathway_id": pid,
+                                "name": name,
+                                "organism": organism if organism != name else "Homo sapiens",
+                                "url": f"https://www.kegg.jp/entry/{pid}",
+                                "image_url": f"https://rest.kegg.jp/get/{pid}/image",
+                            })
+
+    return {"results": results, "count": len(results)}
+
+
+@router.post("/enrichment")
+async def pathway_enrichment(req: EnrichmentRequest):
+    from app.services.pathway_enrichment import run_enrichment as _run_enrichment
+    result = await _run_enrichment(req.identifiers)
+    if result is None:
+        raise HTTPException(status_code=502, detail="Enrichment analysis failed")
+    return result

app/routers/phylo.py

@@ -30,7 +30,7 @@ router = APIRouter(prefix="/phylo", tags=["phylo"])
 
 # ── EBI base URLs ──────────────────────────────────────────────────────────────
 _EBI_CLUSTALO = "https://www.ebi.ac.uk/Tools/services/rest/clustalo"
-_EMAIL        = "bionexus@demo.com"
+_EMAIL        = "bionexus@example.com"
 
 # ── PhyML protein models (most-used first) ────────────────────────────────────
 PROTEIN_MODELS = ["LG", "WAG", "JTT", "Blosum62", "MtREV", "Dayhoff"]
@@ -290,8 +290,16 @@ async def _run_phyml_local(job_id: str, aln_fasta: str, req: PhyloRequest) -> No
     _patch(job_id, phase="tree_running")
 
     import os
+    import shutil
     import tempfile
 
+    phyml_path = shutil.which("phyml")
+    if not phyml_path:
+        _patch(job_id, phase="error",
+               error="PhyML binary not found. ML method requires PhyML compiled from "
+                     "https://github.com/stephaneguindon/phyml. Try NJ or UPGMA instead.")
+        return
+
     fd, phy_path = tempfile.mkstemp(suffix=".phy")
     os.close(fd)
     try:

app/routers/pipeline_v2.py

@@ -0,0 +1,776 @@
+"""
+In-memory pipeline v2 — runs BLAST → UniProt → MSA → Phylo → Domains → Interpretation
+in a background thread. Uses a thread-safe dict for job storage.
+"""
+
+import asyncio
+import logging
+import threading
+import uuid
+from datetime import datetime, timezone
+
+import httpx
+from fastapi import APIRouter, HTTPException, Depends, Request
+from pydantic import BaseModel, Field
+from litellm import acompletion
+
+from app.config import settings
+from app.deps import limiter
+from app.services.rate_limit import check_daily_limit_pipelines
+from app.integrations.ncbi import blast as ncbi_blast
+from app.integrations.ncbi.parser import parse_blast_xml
+from app.services.validators import validate_fasta
+from app.services.sequence_utils import detect_source_from_accession, map_refseq_to_uniprot, detect_sequence_type
+from app.services.blast_config import resolve_blast_params
+from app.tools.uniprot import UniprotTool
+from app.ai.llm_client import llm_client
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+_jobs: dict[str, dict] = {}
+_jobs_lock = threading.Lock()
+
+STEP_ORDER = ["blast", "uniprot", "msa", "phylo", "domains", "pathway_enrichment", "alphafold", "interpret"]
+
+EBI_CLUSTALO = "https://www.ebi.ac.uk/Tools/services/rest/clustalo"
+
+
+def _get_job(job_id: str) -> dict | None:
+    with _jobs_lock:
+        return _jobs.get(job_id)
+
+
+def _set_step_status(job_id: str, step: str, status: str, progress: int = 0, data: dict | None = None, error: str | None = None):
+    with _jobs_lock:
+        if job_id not in _jobs:
+            return
+        _jobs[job_id]["steps"][step] = {"status": status, "progress": progress, "data": data, "error": error}
+        if status == "running":
+            _jobs[job_id]["current_step"] = step
+
+
+def _set_job_failed(job_id: str, message: str):
+    with _jobs_lock:
+        if job_id in _jobs:
+            _jobs[job_id]["status"] = "failed"
+            _jobs[job_id]["error"] = message
+
+
+class PipelineV2RunRequest(BaseModel):
+    sequence: str = Field(..., min_length=6, description="Protein sequence (FASTA or raw)")
+    steps: list[str] = Field(default_factory=lambda: list(STEP_ORDER), description="Steps to run")
+    fast_mode: bool = Field(default=False, description="Use Swiss-Prot instead of nr for faster results")
+    database: str = Field("", description="BLAST database override")
+    program: str = Field("", description="BLAST program override")
+    max_hits: int = Field(100, description="Max BLAST hits to return")
+    query_accession: str = Field("", description="Optional query accession for display")
+
+
+@router.post("/run")
+async def run_pipeline_v2(request: Request, req: PipelineV2RunRequest):
+    validation = validate_fasta(req.sequence, "blast")
+    if not validation.valid:
+        raise HTTPException(status_code=400, detail=validation.error)
+
+    seq = str(validation.sequences[0].seq).upper()
+    clean = "".join(c for c in seq if c.isalpha())
+
+    job_id = str(uuid.uuid4())
+    now = datetime.now(timezone.utc).isoformat()
+
+    requested = [s for s in req.steps if s in STEP_ORDER]
+    if not requested:
+        requested = list(STEP_ORDER)
+
+    steps_dict = {s: {"status": "pending", "progress": 0, "data": None, "error": None} for s in STEP_ORDER}
+
+    blast_params = {
+        "database": req.database,
+        "program": req.program,
+        "max_hits": req.max_hits,
+        "query_accession": req.query_accession,
+    }
+
+    with _jobs_lock:
+        _jobs[job_id] = {
+            "job_id": job_id,
+            "status": "running",
+            "current_step": None,
+            "steps": steps_dict,
+            "requested_steps": requested,
+            "sequence": clean,
+            "blast_params": blast_params,
+            "error": None,
+            "created_at": now,
+        }
+
+    t = threading.Thread(
+        target=_run_pipeline,
+        args=(job_id, clean, requested),
+        kwargs={"fast_mode": req.fast_mode, "blast_params": blast_params},
+        daemon=True,
+    )
+    t.start()
+
+    return {"job_id": job_id}
+
+
+@router.get("/status/{job_id}")
+async def get_pipeline_v2_status(job_id: str):
+    job = _get_job(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return job
+
+
+async def run_pipeline(
+    sequence: str,
+    organism: str = "Homo sapiens",
+    analysis_type: str = "comprehensive",
+    status_callback=None,
+    fast_mode: bool = False,
+    blast_params: dict | None = None,
+) -> dict:
+    """Public async entry point for the pipeline (used by pipeline_worker).
+
+    Creates a temporary in-memory job, runs the configured steps, and
+    returns the context dict with all results.
+    """
+    job_id = f"worker-{uuid.uuid4().hex[:12]}"
+    requested = list(STEP_ORDER)
+    steps_dict = {s: {"status": "pending", "progress": 0, "data": None, "error": None} for s in STEP_ORDER}
+
+    with _jobs_lock:
+        _jobs[job_id] = {
+            "job_id": job_id,
+            "status": "running",
+            "current_step": None,
+            "steps": steps_dict,
+            "requested_steps": requested,
+            "sequence": sequence,
+            "blast_params": blast_params or {},
+            "error": None,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+        }
+
+    try:
+        await _execute(
+            job_id,
+            sequence,
+            requested,
+            status_callback=status_callback,
+            fast_mode=fast_mode,
+            blast_params=blast_params,
+        )
+    finally:
+        job = _get_job(job_id)
+        with _jobs_lock:
+            _jobs.pop(job_id, None)
+
+    if job and job.get("status") == "failed":
+        raise RuntimeError(job.get("error", "Pipeline failed"))
+
+    query_accession = ((blast_params or {}).get("query_accession") or "").strip()
+    context: dict = {
+        "sequence": sequence,
+        "length": len(sequence),
+        "query": {
+            "sequence": sequence,
+            "length": len(sequence),
+            "sequence_type": detect_sequence_type(sequence) or "protein",
+        },
+    }
+    if query_accession:
+        context["query"]["accession"] = query_accession
+    if job:
+        for step_name, step_info in job.get("steps", {}).items():
+            if step_info.get("data"):
+                context[step_name] = step_info["data"]
+    return context
+
+
+# ---------------------------------------------------------------------------
+# Background pipeline
+# ---------------------------------------------------------------------------
+
+def _run_pipeline(job_id: str, sequence: str, steps: list[str], fast_mode: bool = False, blast_params: dict | None = None):
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        loop.run_until_complete(
+            _execute(job_id, sequence, steps, fast_mode=fast_mode, blast_params=blast_params)
+        )
+    except Exception as e:
+        logger.exception(f"[{job_id}] Unhandled pipeline error")
+        _set_job_failed(job_id, f"Pipeline error: {e}")
+    finally:
+        loop.close()
+        asyncio.set_event_loop(None)
+
+
+async def _execute(job_id: str, sequence: str, steps: list[str], status_callback=None, fast_mode: bool = False, blast_params: dict | None = None):
+    context: dict = {"sequence": sequence, "length": len(sequence)}
+
+    _STEP_FRONTEND = {
+        "blast": "running",
+        "uniprot": "fetching_uniprot",
+        "msa": "running_msa",
+        "phylo": "running_msa",
+        "domains": "fetching_uniprot",
+        "pathway_enrichment": "pathway_enrichment",
+        "alphafold": "fetching_alphafold",
+        "interpret": "interpreting",
+    }
+
+    _failed_step = None
+    _failed_error = None
+
+    async def _notify(step_key: str):
+        if status_callback:
+            try:
+                await status_callback(_STEP_FRONTEND.get(step_key, "running"))
+            except Exception:
+                pass
+
+    def _mark(step_key: str, status: str, **kw):
+        _set_step_status(job_id, step_key, status, **kw)
+
+    def _fail(step_key: str, msg: str):
+        nonlocal _failed_step, _failed_error
+        _mark(step_key, "failed", error=msg)
+        _failed_step = step_key
+        _failed_error = msg
+
+    # ---- Step 1: BLAST (must run first) ----
+    if "blast" in steps:
+        await _notify("blast")
+        _mark("blast", "running", progress=10)
+        result = await _run_blast(
+            sequence,
+            status_callback=status_callback,
+            fast_mode=fast_mode,
+            blast_params=blast_params,
+        )
+        _mark("blast", "complete" if result.get("count", 0) > 0 else "failed", progress=100, data=result)
+        context["blast"] = result
+        if result.get("count", 0) == 0:
+            _failed_step = "blast"
+            _failed_error = result.get("error", "No BLAST hits found")
+
+    # ---- Step 2: Fan-out — UniProt, MSA, Pathway run in parallel ----
+    #    They all only depend on BLAST results, not on each other.
+    blast_data = context.get("blast", {})
+    hits = (blast_data.get("hits") if isinstance(blast_data, dict) else []) or []
+    top_hit = blast_data.get("top_hit") if isinstance(blast_data, dict) else None
+
+    async def _do_uniprot():
+        candidates = ([top_hit] + hits[:5]) if top_hit else hits[:5]
+        for candidate in candidates:
+            result = await _run_uniprot(candidate)
+            if "error" not in result:
+                return result
+        return result if result else {"error": "No BLAST hits for UniProt lookup"}
+
+    async def _do_msa():
+        if not hits:
+            return {"error": "No BLAST hits for MSA"}
+        return await _run_msa(sequence, hits)
+
+    async def _do_pathway():
+        return await _run_pathway_enrichment(context)
+
+    fan_out = []
+    fan_names = []
+    if "uniprot" in steps and not _failed_step:
+        fan_out.append(_do_uniprot())
+        fan_names.append("uniprot")
+    if "msa" in steps and not _failed_step:
+        fan_out.append(_do_msa())
+        fan_names.append("msa")
+    if "pathway_enrichment" in steps and not _failed_step:
+        fan_out.append(_do_pathway())
+        fan_names.append("pathway_enrichment")
+
+    if fan_out:
+        # Notify for the first active step in the fan-out
+        await _notify(fan_names[0])
+        for name in fan_names:
+            _mark(name, "running", progress=10)
+
+        results = await asyncio.gather(*fan_out, return_exceptions=True)
+
+        for name, res in zip(fan_names, results):
+            if isinstance(res, Exception):
+                _fail(name, str(res)[:500])
+                continue
+
+            if name == "uniprot":
+                s = "complete" if "error" not in res else "failed"
+                _mark("uniprot", s, progress=100, data=res)
+                context["uniprot"] = res
+                if "error" in res:
+                    _failed_step = "uniprot"
+                    _failed_error = res["error"]
+
+            elif name == "msa":
+                s = "complete" if res.get("aln_fasta") else "failed"
+                _mark("msa", s, progress=100, data=res)
+                context["msa"] = res
+                if res.get("phylotree"):
+                    context.setdefault("phylo_data", {})["phylotree_newick"] = res["phylotree"]
+
+            elif name == "pathway_enrichment":
+                s = "complete" if res and res.get("pathways") else "failed"
+                _mark("pathway_enrichment", s, progress=100, data=res or {})
+                context["pathway_enrichment"] = res
+
+    # ---- Step 3: Phylo (instant — copies from MSA) ----
+    if "phylo" in steps and not _failed_step:
+        _mark("phylo", "running", progress=10)
+        newick = None
+        msa_data = context.get("msa", {})
+        if isinstance(msa_data, dict):
+            newick = msa_data.get("phylotree")
+        if not newick:
+            newick = context.get("phylo_data", {}).get("phylotree_newick")
+        if newick:
+            _mark("phylo", "complete", progress=100, data={"phylotree_newick": newick})
+            context["phylo"] = {"phylotree_newick": newick}
+        else:
+            _mark("phylo", "failed", error="No phylotree available from MSA")
+
+    # ---- Step 4: Domains + AlphaFold in parallel (both need UniProt accession) ----
+    uniprot_data = context.get("uniprot", {})
+    accession = uniprot_data.get("accession") if isinstance(uniprot_data, dict) else None
+
+    post_uniprot = []
+    post_uniprot_names = []
+    if "domains" in steps and accession and not _failed_step:
+        post_uniprot.append(_run_domains(accession))
+        post_uniprot_names.append("domains")
+    if "alphafold" in steps and accession and not _failed_step:
+        post_uniprot.append(_run_alphafold(context))
+        post_uniprot_names.append("alphafold")
+
+    if post_uniprot:
+        await _notify(post_uniprot_names[0])
+        for name in post_uniprot_names:
+            _mark(name, "running", progress=10)
+
+        results2 = await asyncio.gather(*post_uniprot, return_exceptions=True)
+
+        for name, res in zip(post_uniprot_names, results2):
+            if isinstance(res, Exception):
+                _fail(name, str(res)[:500])
+                continue
+
+            if name == "domains":
+                s = "complete" if res.get("domains") is not None else "failed"
+                _mark("domains", s, progress=100, data=res)
+                context["domains"] = res
+            elif name == "alphafold":
+                s = "complete" if res else "failed"
+                _mark("alphafold", s, progress=100, data=res or {})
+                context["alphafold"] = res
+
+    # ---- Step 5: Interpret (needs all context) ----
+    if "interpret" in steps and not _failed_step:
+        await _notify("interpret")
+        _mark("interpret", "running", progress=10)
+        result = await _run_interpret(context)
+        s = "complete" if result.get("interpretation") else "failed"
+        _mark("interpret", s, progress=100, data=result)
+        context["interpret"] = result
+
+    # ---- Final status ----
+    if _failed_step and _failed_step in ("blast", "uniprot"):
+        with _jobs_lock:
+            if job_id in _jobs:
+                _jobs[job_id]["status"] = "failed"
+                _jobs[job_id]["error"] = f"Pipeline failed at {_failed_step}: {_failed_error}"
+    else:
+        with _jobs_lock:
+            if job_id in _jobs:
+                _jobs[job_id]["status"] = "complete"
+                _jobs[job_id]["context"] = context
+
+
+# ---------------------------------------------------------------------------
+# Step implementations
+# ---------------------------------------------------------------------------
+
+async def _run_blast(
+    sequence: str,
+    status_callback=None,
+    fast_mode: bool = False,
+    blast_params: dict | None = None,
+) -> dict:
+    blast_params = blast_params or {}
+    try:
+        program, database, seq_type = resolve_blast_params(
+            sequence,
+            program=blast_params.get("program"),
+            database=blast_params.get("database"),
+            fast_mode=fast_mode,
+        )
+    except ValueError as e:
+        logger.warning("BLAST param resolution failed: %s", e)
+        return {"error": str(e), "count": 0, "hits": []}
+
+    try:
+        max_hits = int(blast_params.get("max_hits") or 100)
+    except (TypeError, ValueError):
+        max_hits = 100
+    max_hits = max(5, min(max_hits, 100))
+    query_accession = (blast_params.get("query_accession") or "").strip()
+
+    if status_callback:
+        try:
+            await status_callback("submitted_to_ncbi")
+        except Exception:
+            pass
+
+    results = await ncbi_blast.run_blast_with_retry(
+        sequence,
+        retries=2,
+        max_wait_seconds=600 if fast_mode else 900,
+        database=database,
+        program=program,
+        hitlist_size=max_hits,
+    )
+
+    if "error" in results:
+        return {"error": results["error"], "count": 0, "hits": []}
+
+    if status_callback:
+        try:
+            await status_callback("parsing")
+        except Exception:
+            pass
+
+    parsed = parse_blast_xml(results["raw"])
+    if "error" in parsed:
+        raise RuntimeError(f"BLAST XML parse failed: {parsed['error']}")
+
+    hits = parsed.get("hits", [])[:max_hits]
+    top_hit = hits[0] if hits else None
+    query_length = parsed.get("query_length", 0)
+
+    return {
+        "count": len(hits),
+        "source": "ncbi",
+        "database": database,
+        "program": program,
+        "query_sequence_type": seq_type,
+        "query_accession": query_accession,
+        "query_length": query_length,
+        "top_hit": {
+            "accession": top_hit["accession"],
+            "description": top_hit["description"],
+            "evalue": top_hit["evalue"],
+            "evalue_raw": str(top_hit["evalue"]),
+            "identity_pct": top_hit["identity_pct"],
+            "bit_score": top_hit["bit_score"],
+            "alignment_length": top_hit.get("alignment_length", 0),
+        } if top_hit else None,
+        "hits": [
+            {
+                "accession": h["accession"],
+                "description": h["description"],
+                "organism": h.get("organism", ""),
+                "evalue": h["evalue"],
+                "evalue_raw": str(h["evalue"]),
+                "identity_pct": h["identity_pct"],
+                "bit_score": h["bit_score"],
+                "alignment_length": h.get("alignment_length", 0),
+                "query_coverage_pct": round(h.get("alignment_length", 0) / query_length * 100, 1) if query_length > 0 else 0,
+                "hit_alignment": h.get("hit_alignment", ""),
+                "query_alignment": h.get("query_alignment", ""),
+                "midline": h.get("midline", ""),
+                "score": h.get("score", 0),
+                "positive": h.get("positive", 0),
+                "gaps": h.get("gaps", 0),
+                "query_from": h.get("query_from", 0),
+                "query_to": h.get("query_to", 0),
+                "hit_from": h.get("hit_from", 0),
+                "hit_to": h.get("hit_to", 0),
+            }
+            for h in hits[:20]
+        ],
+    }
+
+
+async def _run_uniprot(top_hit: dict) -> dict:
+    accession = top_hit.get("accession", "")
+    if not accession:
+        return {"error": "No accession"}
+
+    try:
+        source = detect_source_from_accession(accession)
+        if source == "ncbi":
+            mapped = await map_refseq_to_uniprot(accession)
+            if mapped:
+                accession = mapped
+            else:
+                # Could not map to UniProt — try searching by protein name
+                desc = top_hit.get("description", "")
+                gene_name = desc.split(",")[0].split("[" )[0].strip() if desc else ""
+                if gene_name:
+                    logger.info("NCBI mapping failed for %s, searching UniProt by name: %s", accession, gene_name)
+                    try:
+                        async with httpx.AsyncClient(timeout=10) as client:
+                            r = await client.get(
+                                "https://rest.uniprot.org/uniprotkb/search",
+                                params={"query": f"gene:{gene_name} AND reviewed:true", "format": "json", "size": 1},
+                            )
+                            if r.status_code == 200:
+                                data = r.json()
+                                results = data.get("results", [])
+                                if results:
+                                    hit = results[0]
+                                    tool = UniprotTool()
+                                    result = await tool.run({"accession": hit["primaryAccession"]})
+                                    if "error" not in result:
+                                        return {
+                                            "accession": result.get("accession", ""),
+                                            "full_name": result.get("full_name", ""),
+                                            "organism": result.get("organism", ""),
+                                            "gene_names": result.get("gene_names", []),
+                                            "functions": result.get("functions", []),
+                                            "keywords": result.get("keywords", []),
+                                            "subcellular_locations": result.get("subcellular_locations", []),
+                                            "pdb_ids": result.get("pdb_ids", []),
+                                            "go_terms": result.get("go_terms", []),
+                                            "sequence": result.get("sequence", ""),
+                                            "sequence_length": result.get("sequence_length", 0),
+                                            "features": [
+                                                f for f in (result.get("features", []) or [])
+                                                if f.get("type") in ("ACTIVE_SITE", "BINDING", "MUTAGENESIS", "SITE", "MOD_RES")
+                                            ],
+                                        }
+                    except Exception as e:
+                        logger.warning("UniProt name search failed for %s: %s", gene_name, e)
+
+                # Still no UniProt data — return partial data from BLAST hit
+                logger.info("No UniProt mapping for %s, using BLAST data only", accession)
+                return {
+                    "accession": accession,
+                    "full_name": top_hit.get("description", ""),
+                    "organism": top_hit.get("organism", ""),
+                    "gene_names": [],
+                    "functions": [],
+                    "keywords": [],
+                    "subcellular_locations": [],
+                    "pdb_ids": [],
+                    "go_terms": [],
+                    "sequence": "",
+                    "sequence_length": 0,
+                    "features": [],
+                    "_note": f"UniProt mapping unavailable for {accession}",
+                }
+
+        tool = UniprotTool()
+        result = await tool.run({"accession": accession})
+        if "error" in result:
+            return {"error": result["error"]}
+
+        return {
+            "accession": result.get("accession", ""),
+            "full_name": result.get("full_name", ""),
+            "organism": result.get("organism", ""),
+            "gene_names": result.get("gene_names", []),
+            "functions": result.get("functions", []),
+            "keywords": result.get("keywords", []),
+            "subcellular_locations": result.get("subcellular_locations", []),
+            "pdb_ids": result.get("pdb_ids", []),
+            "go_terms": result.get("go_terms", []),
+            "sequence": result.get("sequence", ""),
+            "sequence_length": result.get("sequence_length", 0),
+            "features": [
+                f for f in (result.get("features", []) or [])
+                if f.get("type") in ("ACTIVE_SITE", "BINDING", "MUTAGENESIS", "SITE", "MOD_RES")
+            ],
+        }
+    except Exception as e:
+        logger.warning("UniProt lookup failed for %s: %s", accession, e)
+        return {"error": f"UniProt lookup failed: {e}"}
+
+
+async def _run_msa(query_sequence: str, blast_hits: list) -> dict:
+    sequences = [("query", query_sequence)]
+
+    for hit in blast_hits[:5]:
+        acc = hit.get("accession", "")
+        hit_seq = hit.get("hit_alignment", "")
+
+        if acc:
+            source = detect_source_from_accession(acc)
+            mapped_acc = acc
+            if source == "ncbi":
+                mapped = await map_refseq_to_uniprot(acc)
+                if mapped:
+                    mapped_acc = mapped
+            try:
+                tool = UniprotTool()
+                ud = await tool.run({"accession": mapped_acc})
+                if "error" not in ud and ud.get("sequence"):
+                    clean_seq = "".join(c for c in ud["sequence"] if c.isalpha()).upper()
+                    if len(clean_seq) > 10:
+                        sequences.append((acc, clean_seq))
+                        continue
+            except Exception:
+                pass
+
+        if hit_seq:
+            clean = "".join(c for c in hit_seq if c.isalpha()).upper()
+            if len(clean) > 10:
+                sequences.append((f"{acc}_aln", clean))
+
+    if len(sequences) < 2:
+        return {"error": "Not enough sequences for MSA", "aln_fasta": None, "phylotree": None}
+
+    fasta_lines = []
+    for sid, sseq in sequences:
+        fasta_lines.append(f">{sid}")
+        for i in range(0, len(sseq), 80):
+            fasta_lines.append(sseq[i:i + 80])
+    fasta_str = "\n".join(fasta_lines)
+
+    try:
+        email = settings.NCBI_EMAIL or "bioflow@example.com"
+        seq_type = detect_sequence_type(query_sequence) or "protein"
+        stype = "protein" if seq_type == "protein" else "dna"
+        async with httpx.AsyncClient(timeout=30) as client:
+            submit_resp = await client.post(
+                f"{EBI_CLUSTALO}/run",
+                data={"email": email, "stype": stype, "sequence": fasta_str},
+                headers={"Accept": "text/plain"},
+            )
+            if submit_resp.status_code != 200:
+                return {"error": f"EBI submission failed: {submit_resp.text[:200]}", "aln_fasta": None, "phylotree": None}
+
+            job_id = submit_resp.text.strip()
+
+            for _ in range(120):
+                await asyncio.sleep(2)
+                sr = await client.get(f"{EBI_CLUSTALO}/status/{job_id}")
+                status = sr.text.strip()
+                if status == "FINISHED":
+                    break
+                if status == "ERROR":
+                    return {"error": "EBI alignment failed", "aln_fasta": None, "phylotree": None}
+            else:
+                return {"error": "EBI alignment timed out", "aln_fasta": None, "phylotree": None}
+
+            await asyncio.sleep(1)
+
+            fa_resp = await client.get(f"{EBI_CLUSTALO}/result/{job_id}/fa", headers={"Accept": "text/plain"})
+            aln_fasta = fa_resp.text if fa_resp.status_code == 200 else None
+
+            phylotree = None
+            for _ in range(3):
+                try:
+                    tr = await client.get(f"{EBI_CLUSTALO}/result/{job_id}/phylotree", headers={"Accept": "text/plain"})
+                    if tr.status_code == 200:
+                        phylotree = tr.text
+                        break
+                except Exception:
+                    await asyncio.sleep(1)
+
+        return {"aln_fasta": aln_fasta, "phylotree": phylotree, "sequence_count": len(sequences)}
+
+    except Exception as e:
+        return {"error": str(e), "aln_fasta": None, "phylotree": None}
+
+
+async def _run_domains(accession: str) -> dict:
+    """Run domain analysis using the shared tool module (eliminates code duplication)."""
+    try:
+        from app.tools.domain_analysis import fetch_interpro_domains
+        return await fetch_interpro_domains(accession)
+    except Exception as e:
+        return {"error": str(e), "uniprot_accession": accession, "sequence_length": 0, "domains": []}
+
+
+async def _run_pathway_enrichment(context: dict) -> dict | None:
+    gene_names = []
+    uniprot = context.get("uniprot", {})
+    if isinstance(uniprot, dict):
+        gene_names = uniprot.get("gene_names", [])[:20] if isinstance(uniprot.get("gene_names"), list) else []
+    if not gene_names:
+        blast_data = context.get("blast", {})
+        if isinstance(blast_data, dict):
+            for hit in (blast_data.get("hits") or [])[:10]:
+                words = (hit.get("description", "") or "").replace("(", " ").replace(")", " ").split()
+                for w in words:
+                    if w.isupper() and len(w) >= 2 and not w.startswith("OS="):
+                        gene_names.append(w)
+                        break
+    if not gene_names:
+        return None
+    try:
+        from app.services.pathway_enrichment import run_enrichment
+        result = await run_enrichment(gene_names)
+        return result
+    except Exception as e:
+        logger.warning(f"Pathway enrichment failed: {e}")
+        return None
+
+
+async def _run_alphafold(context: dict) -> dict | None:
+    uniprot_data = context.get("uniprot", {})
+    accession = uniprot_data.get("accession") if isinstance(uniprot_data, dict) else None
+    if not accession:
+        return None
+    try:
+        from app.tools.alphafold import AlphaFoldTool
+        result = await AlphaFoldTool().run({"uniprot_accession": accession})
+        return result
+    except Exception as e:
+        logger.warning(f"AlphaFold fetch failed for {accession}: {e}")
+        return {"structure_available": False, "message": str(e)}
+
+
+async def _run_interpret(context: dict) -> dict:
+    providers = llm_client.get_providers()
+    if not providers:
+        return {"interpretation": "AI interpretation unavailable: no LLM API keys configured"}
+
+    prompt_context = {
+        "blast": context.get("blast", {}),
+        "uniprot": context.get("uniprot", {}),
+        "alphafold": context.get("alphafold", {}),
+        "pathway_enrichment": context.get("pathway_enrichment", {}),
+    }
+
+    prompt = llm_client.build_prompt("protein_analysis", prompt_context)
+    last_error = None
+
+    for provider in providers:
+        try:
+            response = await asyncio.wait_for(
+                acompletion(
+                    model=provider["model"],
+                    messages=[{"role": "user", "content": prompt}],
+                    temperature=0.3,
+                    max_tokens=2000,
+                    timeout=25,
+                    api_key=provider["api_key"],
+                ),
+                timeout=30,
+            )
+            text = response.choices[0].message.content if response.choices else ""
+            return {"interpretation": text}
+        except asyncio.TimeoutError:
+            logger.warning("LLM provider %s timed out", provider["name"])
+            last_error = "LLM request timed out"
+            continue
+        except Exception as e:
+            logger.warning("LLM provider %s failed: %s", provider["name"], e)
+            last_error = str(e)
+            continue
+
+    if "organization_restricted" in str(last_error) or "Organization has been restricted" in str(last_error):
+        return {"interpretation": "AI interpretation unavailable: provider restriction. Please try again later."}
+    return {"interpretation": f"AI interpretation unavailable: {last_error}"}

app/routers/pipelines.py

@@ -0,0 +1,74 @@
+from fastapi import APIRouter, HTTPException, Depends, Request
+from pydantic import BaseModel
+from app.services.validators import validate_fasta
+from app.pipeline.definitions.protein_analysis import get_pipeline_definition
+from app.services.supabase import get_supabase
+from app.services.rate_limit import check_daily_limit, check_daily_limit_pipelines
+from app.services.auth import get_user_id
+from app.models.responses import PipelineRunResponse, PipelineDefinitionResponse
+from app.deps import limiter
+from datetime import datetime, timezone
+import uuid
+
+
+router = APIRouter()
+
+
+class PipelineRunRequest(BaseModel):
+    sequence: str
+    pipeline_type: str = "protein_analysis"
+    database: str = ""
+    program: str = ""
+    max_hits: int = 100
+    query_accession: str = ""
+    fast_mode: bool = False
+
+
+@router.post("/run", response_model=PipelineRunResponse)
+async def run_pipeline(request: Request, req: PipelineRunRequest, user_id: str | None = Depends(get_user_id)):
+    validation = validate_fasta(req.sequence, "blast")
+    if not validation.valid:
+        raise HTTPException(status_code=400, detail=validation.error)
+
+    seq = str(validation.sequences[0].seq).upper()
+    clean = "".join(c for c in seq if c.isalpha())
+
+    job_id = str(uuid.uuid4())
+    supabase = get_supabase()
+
+    supabase.table("jobs").insert({
+        "id": job_id,
+        "user_id": user_id,
+        "tool": "pipeline",
+        "query_preview": clean,
+        "status": "queued",
+        "pipeline_type": req.pipeline_type,
+        "steps_completed": [],
+        "context_json": {
+            "sequence": clean,
+            "fast_mode": req.fast_mode,
+            "database": req.database,
+            "program": req.program,
+            "max_hits": req.max_hits,
+            "query_accession": req.query_accession,
+        },
+        "progress_pct": 0,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "completed_at": None,
+        "error": None,
+        "share_token": None,
+    }).execute()
+
+    return {"job_id": job_id, "status": "queued"}
+
+
+@router.get("/definitions", response_model=PipelineDefinitionResponse)
+async def list_pipeline_definitions():
+    return {"pipelines": [get_pipeline_definition()]}
+
+
+@router.get("/{pipeline_type}/definition")
+async def get_pipeline_definition_endpoint(pipeline_type: str):
+    if pipeline_type == "protein_analysis":
+        return get_pipeline_definition()
+    raise HTTPException(status_code=404, detail=f"Unknown pipeline: {pipeline_type}")