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

open_pharma_plugins_field_training/tools/list_documents.py

@@ -0,0 +1,51 @@
+"""list_documents — list all ingested documents in the content store."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ListDocumentsArgs(BaseModel):
+    file_type: str | None = Field(
+        default=None,
+        description="Filter by file type: 'pdf' or 'pptx'. Omit to list all.",
+    )
+
+
+TOOL: dict[str, Any] = {
+    "name": "list_documents",
+    "description": (
+        "List all documents ingested into the training content store. Shows "
+        "document ID, file name, type, page count, title, and ingest date. "
+        "Optionally filter by file type. Use this to see what source material "
+        "is available before searching or generating training content."
+    ),
+    "args": ListDocumentsArgs,
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    import json
+
+    from .._content_store import list_documents
+
+    file_type = arguments.get("file_type")
+    docs = list_documents(file_type)
+
+    output = {
+        "total": len(docs),
+        "documents": [
+            {
+                "document_id": d["document_id"],
+                "file_name": d["file_name"],
+                "file_type": d["file_type"],
+                "title": d.get("title", ""),
+                "total_pages": d["total_pages"],
+                "ingested_at": d["ingested_at"],
+            }
+            for d in docs
+        ],
+    }
+    return [{"type": "text", "text": json.dumps(output, indent=2)}]

open_pharma_plugins_field_training/tools/render_output.py

@@ -0,0 +1,118 @@
+"""render_output — validate and save structured training output as JSON plus HTML."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class RenderOutputArgs(BaseModel):
+    output_type: str = Field(
+        description="Type of output: 'learning_package', 'assessment', 'roleplay_kit', or 'roleplay_scorecard'"
+    )
+    content_json: str = Field(
+        description=(
+            "The structured output as a JSON string (LearningPackage, Assessment, RoleplayKit, or RoleplayScorecard)"
+        )
+    )
+    file_name: str | None = Field(
+        default=None,
+        description="Optional filename stem (without extension). Auto-generated from title + timestamp if omitted.",
+    )
+
+
+TOOL: dict[str, Any] = {
+    "name": "render_output",
+    "description": (
+        "Validate and render a learning package, assessment, pre-session role-play kit, "
+        "or post-session role-play scorecard as structured JSON and polished, interactive, "
+        "self-contained HTML. Saves both files to the private training output directory."
+    ),
+    "args": RenderOutputArgs,
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    import json
+    from datetime import datetime, timezone
+    from pathlib import Path
+
+    from pydantic import ValidationError
+
+    from shared.env import get_env
+    from shared.filesystem import atomic_write_json, atomic_write_text, contained_path, ensure_private_dir
+
+    from .._grounding import validate_output_sources
+    from .._html_renderers import RENDERERS
+    from ..models import Assessment, LearningPackage, RoleplayKit, RoleplayScorecard
+
+    output_type = arguments["output_type"]
+    content_json = arguments["content_json"]
+    file_name = arguments.get("file_name")
+
+    output_models = {
+        "learning_package": LearningPackage,
+        "assessment": Assessment,
+        "roleplay_kit": RoleplayKit,
+        "roleplay_scorecard": RoleplayScorecard,
+    }
+    if output_type not in output_models:
+        valid_types = ", ".join(output_models)
+        return [
+            {
+                "type": "text",
+                "text": json.dumps({"error": f"Invalid output_type '{output_type}'. Must be one of: {valid_types}"}),
+            }
+        ]
+
+    try:
+        data = json.loads(content_json)
+    except json.JSONDecodeError as exc:
+        return [{"type": "text", "text": json.dumps({"error": f"Invalid JSON: {exc}"})}]
+
+    try:
+        validated = output_models[output_type].model_validate(data)
+    except ValidationError as exc:
+        return [
+            {
+                "type": "text",
+                "text": json.dumps({"error": f"Output failed {output_type} schema validation: {exc}"}),
+            }
+        ]
+
+    grounding_errors = validate_output_sources(validated)
+    if grounding_errors:
+        return [{"type": "text", "text": json.dumps({"error": "; ".join(grounding_errors)})}]
+    data = validated.model_dump(mode="json", exclude_none=True)
+
+    if not file_name:
+        title = data.get("title") or data.get("topic") or output_type
+        safe = "".join(character if character.isalnum() or character in "-_ " else "" for character in title)
+        safe = safe[:50].strip().replace(" ", "_")
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+        file_name = f"{safe}_{timestamp}"
+
+    content_dir = get_env(
+        "OPEN_PHARMA_TRAINING_CONTENT_DIR",
+        str(Path.home() / ".open-pharma-plugins" / "training-content"),
+    )
+    output_dir = ensure_private_dir(Path(content_dir) / "outputs")
+
+    try:
+        json_path = contained_path(output_dir, f"{file_name}.json")
+        html_path = contained_path(output_dir, f"{file_name}.html")
+    except ValueError as exc:
+        return [{"type": "text", "text": json.dumps({"error": str(exc)})}]
+
+    atomic_write_json(json_path, data)
+    atomic_write_text(html_path, RENDERERS[output_type](data))
+
+    result = {
+        "success": True,
+        "output_type": output_type,
+        "output_dir": str(output_dir),
+        "json_path": str(json_path),
+        "html_path": str(html_path),
+    }
+    return [{"type": "text", "text": json.dumps(result, indent=2)}]

open_pharma_plugins_field_training/tools/search_content.py

@@ -0,0 +1,57 @@
+"""search_content — search across ingested documents for relevant passages."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class SearchContentArgs(BaseModel):
+    query: str = Field(description="Search query — keywords or phrases to find in the ingested documents")
+    document_id: str | None = Field(
+        default=None,
+        description=(
+            "Restrict search to a specific document by ID. Required for path-first workflows; "
+            "omit only when the user deliberately requests a global search of the persistent store."
+        ),
+    )
+    max_results: int = Field(
+        default=10,
+        ge=1,
+        le=30,
+        description="Maximum number of passages to return",
+    )
+
+
+TOOL: dict[str, Any] = {
+    "name": "search_content",
+    "description": (
+        "Search across all ingested training documents for passages matching a "
+        "query. Returns ranked results with document name, page/slide number, "
+        "relevant text excerpt, and relevance score. Use this to find source "
+        "material for specific topics when building learning packages, assessments, "
+        "or preparing for role-play. In a path-first request, pass document_id and "
+        "repeat the search for each submitted document; never use an unscoped search."
+    ),
+    "args": SearchContentArgs,
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    import json
+
+    from .._content_store import search_pages
+
+    query = arguments["query"]
+    document_id = arguments.get("document_id")
+    max_results = arguments.get("max_results", 10)
+
+    results = search_pages(query, document_id, max_results)
+
+    output = {
+        "query": query,
+        "total_results": len(results),
+        "results": results,
+    }
+    return [{"type": "text", "text": json.dumps(output, indent=2)}]

open_pharma_plugins_hcp_intelligence/__init__.py

@@ -0,0 +1,14 @@
+from mcp_framework import build_registry
+
+__version__ = "1.0.2"
+
+SPECS, get_handler, list_tools = build_registry(__name__, ["tools"])
+
+USAGE_NOTE = (
+    "HCP Intelligence builds evidence-backed profiles for healthcare professionals "
+    "and organizations. Call the search tools to gather data from PubMed, "
+    "ClinicalTrials.gov, and the web, then synthesize a structured profile "
+    "following the schema in the Skill."
+)
+
+SYSTEM_DEPS = []

open_pharma_plugins_hcp_intelligence/__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_hcp_intelligence/_crm_store.py

@@ -0,0 +1,70 @@
+"""Shared CRM fixture store used by list_accounts, get_account, update_account.
+
+Reads from fixtures/sample_accounts.csv (the account list) and a JSON sidecar
+(enrichment data written by update_account).
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+
+_FIXTURES_DIR = Path(__file__).parent / "fixtures"
+_CSV_PATH = _FIXTURES_DIR / "sample_accounts.csv"
+
+
+def _enrichment_path() -> Path:
+    from shared.env import get_env
+    from shared.filesystem import contained_path, ensure_private_dir
+
+    root = ensure_private_dir(
+        get_env(
+            "OPEN_PHARMA_HCP_DATA_DIR",
+            str(Path.home() / ".open-pharma-plugins" / "hcp-intelligence"),
+        )
+    )
+    return contained_path(root, "enrichment_store.json")
+
+
+def load_accounts() -> list[dict[str, str]]:
+    with open(_CSV_PATH, newline="", encoding="utf-8") as f:
+        rows = list(csv.DictReader(f))
+    enrichment = _load_enrichment()
+    for row in rows:
+        row["status"] = enrichment.get(row["id"], {}).get("status", "pending")
+    return rows
+
+
+def get_account_by_id(account_id: str) -> dict | None:
+    for row in load_accounts():
+        if row["id"] == account_id:
+            enrichment = _load_enrichment()
+            entry = enrichment.get(account_id, {})
+            row["status"] = entry.get("status", "pending")
+            row["enrichment"] = entry.get("profile")
+            row["last_enriched"] = entry.get("last_enriched")
+            return row
+    return None
+
+
+def write_enrichment(account_id: str, profile_json: str, status: str) -> None:
+    from datetime import datetime, timezone
+
+    enrichment = _load_enrichment()
+    enrichment[account_id] = {
+        "status": status,
+        "profile": json.loads(profile_json) if profile_json else None,
+        "last_enriched": datetime.now(timezone.utc).isoformat(),
+    }
+    from shared.filesystem import atomic_write_json
+
+    atomic_write_json(_enrichment_path(), enrichment)
+
+
+def _load_enrichment() -> dict:
+    path = _enrichment_path()
+    if path.exists():
+        with open(path, encoding="utf-8") as f:
+            return json.load(f)
+    return {}