open-pharma-plugins 2.2.0__py3-none-any.whl

open_pharma_plugins_competitive_intelligence/tools/ci_trial_detail.py

@@ -0,0 +1,55 @@
+"""ci_trial_detail — full trial record with arms, endpoints, and results."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from .. import _clinical_trials
+from ..models import TrialDetailRequest
+
+
+class TrialDetailArgs(BaseModel):
+    nct_id: str = Field(description="ClinicalTrials.gov identifier, e.g. 'NCT04567890'")
+
+
+TOOL: dict[str, Any] = {
+    "name": "ci_trial_detail",
+    "description": (
+        "Fetch the full record for a single clinical trial including arms, "
+        "endpoints, eligibility criteria, current status, milestone dates, and "
+        "posted results. Use after ci_scan_trials to drill into a specific trial."
+    ),
+    "args": TrialDetailArgs,
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    request = TrialDetailRequest.model_validate(arguments)
+    result = _clinical_trials.get_trial_detail(request)
+    ledger = result.model_dump(mode="json", exclude={"records"})
+    if not result.records:
+        payload: dict[str, Any] = {
+            "error": result.error.message if result.error else "ClinicalTrials.gov detail failed",
+            "coverage": result.status.value,
+            "source_ledger": [ledger],
+            "limitations": result.limitations,
+        }
+        return [{"type": "text", "text": json.dumps(payload, indent=2)}]
+
+    detail = dict(result.records[0])
+    trial = dict(detail["trial"])
+    interventions = trial.get("interventions", [])
+    trial["intervention_details"] = interventions
+    trial["interventions"] = [item.get("name", "") for item in interventions]
+    detail["trial"] = trial
+    detail.update(
+        {
+            "coverage": result.status.value,
+            "source_ledger": [ledger],
+            "limitations": result.limitations,
+        }
+    )
+    return [{"type": "text", "text": json.dumps(detail, indent=2)}]

open_pharma_plugins_field_training/__init__.py

@@ -0,0 +1,13 @@
+from mcp_framework import build_registry
+
+__version__ = "1.1.1"
+
+SPECS, get_handler, list_tools = build_registry(__name__, ["tools"])
+
+USAGE_NOTE = (
+    "Field Training turns approved PDF/PPTX file paths into source-grounded "
+    "learning packages, assessments, pre-session role-play kits, and "
+    "post-session scorecards for field reps."
+)
+
+SYSTEM_DEPS = []

open_pharma_plugins_field_training/__main__.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+from mcp_framework import run_main
+
+
+def main() -> None:
+    run_main(__package__ or Path(__file__).resolve().parent.name)
+
+
+if __name__ == "__main__":
+    main()

open_pharma_plugins_field_training/_content_store.py

@@ -0,0 +1,131 @@
+"""Content store for ingested training documents.
+
+Stores extracted document content as JSON files in a configurable directory.
+A manifest (_index.json) tracks all ingested documents.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+from shared.filesystem import atomic_write_json, contained_path, ensure_private_dir
+
+
+def _store_dir() -> Path:
+    from shared.env import get_env
+
+    d = Path(
+        get_env(
+            "OPEN_PHARMA_TRAINING_CONTENT_DIR",
+            str(Path.home() / ".open-pharma-plugins" / "training-content"),
+        )
+    )
+    return ensure_private_dir(d)
+
+
+def document_id_from_path(file_path: str) -> str:
+    """Generate a stable document ID from the file path."""
+    name = Path(file_path).stem
+    short_hash = hashlib.sha256(file_path.encode()).hexdigest()[:8]
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in name)[:40]
+    return f"{safe_name}_{short_hash}"
+
+
+def save_document(doc: dict) -> None:
+    """Save an ingested document to the content store."""
+    store = _store_dir()
+    doc_path = contained_path(store, f"{doc['document_id']}.json")
+    atomic_write_json(doc_path, doc)
+    _update_index(doc)
+
+
+def load_document(document_id: str) -> dict | None:
+    """Load a document by ID."""
+    doc_path = contained_path(_store_dir(), f"{document_id}.json")
+    if doc_path.exists():
+        return json.loads(doc_path.read_text())
+    return None
+
+
+def list_documents(file_type: str | None = None) -> list[dict]:
+    """List all ingested documents from the index."""
+    index = _load_index()
+    docs = index.get("documents", [])
+    if file_type:
+        docs = [d for d in docs if d.get("file_type") == file_type.lower()]
+    return docs
+
+
+def search_pages(query: str, document_id: str | None = None, max_results: int = 10) -> list[dict]:
+    """Simple keyword search across all ingested documents.
+
+    Returns ranked results with document info and page content.
+    Uses term frequency scoring.
+    """
+    query_terms = set(query.lower().split())
+    if not query_terms:
+        return []
+
+    results = []
+
+    doc_ids = [document_id] if document_id else [d["document_id"] for d in list_documents()]
+
+    for doc_id in doc_ids:
+        doc = load_document(doc_id)
+        if doc is None:
+            continue
+        for page in doc.get("pages", []):
+            text = page.get("text", "")
+            text_lower = text.lower()
+
+            notes = page.get("speaker_notes") or ""
+            combined = text_lower + " " + notes.lower()
+
+            score = sum(combined.count(term) for term in query_terms)
+            if score > 0:
+                if query.lower() in combined:
+                    score += 10
+                results.append(
+                    {
+                        "document_id": doc_id,
+                        "document_name": doc.get("file_name", ""),
+                        "page_number": page["page_number"],
+                        "page_type": page.get("page_type", "page"),
+                        "slide_title": page.get("slide_title"),
+                        "text": text[:500],
+                        "speaker_notes": notes[:300] if notes else None,
+                        "score": score,
+                    }
+                )
+
+    results.sort(key=lambda r: r["score"], reverse=True)
+    return results[:max_results]
+
+
+def _load_index() -> dict:
+    index_path = contained_path(_store_dir(), "_index.json")
+    if index_path.exists():
+        return json.loads(index_path.read_text())
+    return {"documents": []}
+
+
+def _update_index(doc: dict) -> None:
+    index = _load_index()
+    docs = index.get("documents", [])
+    docs = [d for d in docs if d.get("document_id") != doc["document_id"]]
+    docs.append(
+        {
+            "document_id": doc["document_id"],
+            "file_name": doc.get("file_name", ""),
+            "file_type": doc.get("file_type", ""),
+            "title": doc.get("title"),
+            "total_pages": doc.get("total_pages", 0),
+            "ingested_at": doc.get("ingested_at", datetime.now(timezone.utc).isoformat()),
+        }
+    )
+    index["documents"] = docs
+    index_path = contained_path(_store_dir(), "_index.json")
+    atomic_write_json(index_path, index)

open_pharma_plugins_field_training/_grounding.py

@@ -0,0 +1,75 @@
+"""Validate training-output citations against the ingested content store."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+
+from pydantic import BaseModel
+
+from ._content_store import list_documents, load_document
+from .models import SourceReference
+
+
+def validate_output_sources(output: BaseModel) -> list[str]:
+    errors: list[str] = []
+    declared_names = set(getattr(output, "source_documents", []))
+    known_documents = {item.get("file_name", ""): item for item in list_documents()}
+
+    for name in sorted(declared_names):
+        if name not in known_documents:
+            errors.append(f"source_documents contains unknown ingested document {name!r}")
+
+    for reference in _source_references(output):
+        if reference.document_name not in declared_names:
+            errors.append(
+                f"source {reference.document_id!r} names {reference.document_name!r} "
+                "but that file is absent from source_documents"
+            )
+        try:
+            document = load_document(reference.document_id)
+        except ValueError as exc:
+            errors.append(str(exc))
+            continue
+        if document is None:
+            errors.append(f"source document_id {reference.document_id!r} is not ingested")
+            continue
+        if document.get("file_name") != reference.document_name:
+            errors.append(
+                f"source {reference.document_id!r} document_name does not match ingested file "
+                f"{document.get('file_name')!r}"
+            )
+        page = next(
+            (item for item in document.get("pages", []) if item.get("page_number") == reference.page_number),
+            None,
+        )
+        if page is None:
+            errors.append(f"source {reference.document_id!r} has no page or slide {reference.page_number}")
+            continue
+        excerpt = _normalize(reference.excerpt)
+        source_text = _normalize(f"{page.get('text', '')} {page.get('speaker_notes') or ''}")
+        if not excerpt or excerpt not in source_text:
+            errors.append(
+                f"source {reference.document_id!r} page {reference.page_number} excerpt is not present in ingested content"
+            )
+    return errors
+
+
+def _source_references(value: object) -> Iterator[SourceReference]:
+    if isinstance(value, SourceReference):
+        yield value
+        return
+    if isinstance(value, BaseModel):
+        for field in type(value).model_fields:
+            yield from _source_references(getattr(value, field))
+        return
+    if isinstance(value, dict):
+        for item in value.values():
+            yield from _source_references(item)
+        return
+    if isinstance(value, (list, tuple, set)):
+        for item in value:
+            yield from _source_references(item)
+
+
+def _normalize(text: str) -> str:
+    return " ".join(str(text).split()).casefold()