iints-sdk-python35 1.1.1__py3-none-any.whl → 1.1.2__py3-none-any.whl

iints/__init__.py

@@ -3,7 +3,15 @@
 import pandas as pd # Required for type hints like pd.DataFrame
 from typing import Optional
 
-__version__ = "0.1.22"
+try:
+    from importlib.metadata import PackageNotFoundError, version
+except ImportError:  # pragma: no cover - Python < 3.8 fallback
+    from importlib_metadata import PackageNotFoundError, version  # type: ignore
+
+try:
+    __version__ = version("iints-sdk-python35")
+except PackageNotFoundError:  # pragma: no cover - source tree fallback
+    __version__ = "1.1.2"
 
 # Note to developers: this SDK is currently maintained by a single author.
 # Please report bugs via GitHub issues and feel free to contribute fixes via PRs.

iints/ai/__init__.py

@@ -2,6 +2,7 @@ from .assistant import AIResponse, IINTSAssistant
 from .backends import DEFAULT_MINISTRAL_MODEL, DEFAULT_OLLAMA_HOST, OllamaBackend
 from .mdmp_guard import GuardResult, MDMPGuard
 from .model_catalog import LocalMistralModelProfile, list_local_mistral_models
+from .prepare import prepare_ai_ready_artifacts
 
 __all__ = [
     "AIResponse",
@@ -13,4 +14,5 @@ __all__ = [
     "MDMPGuard",
     "LocalMistralModelProfile",
     "list_local_mistral_models",
+    "prepare_ai_ready_artifacts",
 ]

iints/ai/cli.py

@@ -13,6 +13,7 @@ from typing_extensions import Annotated
 from .assistant import AIResponse, IINTSAssistant
 from .backends import DEFAULT_MINISTRAL_MODEL, OllamaBackend
 from .model_catalog import list_local_mistral_models
+from .prepare import prepare_ai_ready_artifacts
 
 
 app = typer.Typer(help="Research-only AI assistant commands gated by MDMP certification.")
@@ -36,6 +37,57 @@ def _load_json_payload(path: Path, label: str) -> Any:
     return payload
 
 
+def _default_prepared_payload(task: str, ai_dir: Path) -> Path:
+    candidates = {
+        "explain": ["step_riskiest.json", "step_latest.json"],
+        "trends": ["trends_payload.json"],
+        "anomalies": ["anomalies_payload.json"],
+        "report": ["report_payload.json"],
+    }.get(task, [])
+    for filename in candidates:
+        candidate = ai_dir / filename
+        if candidate.is_file():
+            return candidate
+    expected = ", ".join(candidates) if candidates else "prepared payload"
+    raise typer.BadParameter(
+        f"No prepared AI payload found in {ai_dir}. Expected one of: {expected}. "
+        "Run `iints ai prepare <run_dir>` first."
+    )
+
+
+def _resolve_cli_inputs(
+    *,
+    task: str,
+    input_path: Path,
+    mdmp_cert: Path | None,
+    public_key: Path | None,
+    trust_store: Path | None,
+) -> tuple[Path, Path, Path | None]:
+    resolved_input = input_path
+    resolved_cert = mdmp_cert
+    resolved_public_key = public_key
+
+    if input_path.is_dir():
+        ai_dir = input_path / "ai"
+        resolved_input = _default_prepared_payload(task, ai_dir)
+        if resolved_cert is None:
+            candidate_cert = ai_dir / "report.signed.mdmp"
+            if candidate_cert.is_file():
+                resolved_cert = candidate_cert
+        if resolved_public_key is None and trust_store is None:
+            candidate_public_key = ai_dir / "keys" / "mdmp_pub_v1.pem"
+            if candidate_public_key.is_file():
+                resolved_public_key = candidate_public_key
+
+    if resolved_cert is None:
+        raise typer.BadParameter(
+            "No MDMP certificate provided. Pass --mdmp-cert or run "
+            "`iints ai prepare <run_dir>` to generate a local development certificate."
+        )
+
+    return resolved_input, resolved_cert, resolved_public_key
+
+
 def _write_output(path: Path | None, response: AIResponse) -> None:
     if path is None:
         return
@@ -117,6 +169,47 @@ def models() -> None:
     )
 
 
+@app.command("prepare")
+def prepare(
+    run_dir: Annotated[Path, typer.Argument(help="Run output directory containing results.csv and run_metadata.json.")],
+    create_dev_mdmp_cert: Annotated[
+        bool,
+        typer.Option(
+            "--create-dev-mdmp-cert/--no-create-dev-mdmp-cert",
+            help="Generate a local development MDMP certificate and keypair for AI commands.",
+        ),
+    ] = True,
+    grade: Annotated[str, typer.Option(help="Grade to embed in the local development MDMP certificate.")] = "research_grade",
+    expires_days: Annotated[int, typer.Option(help="Certificate expiry window in days for local development certs.")] = 30,
+    key_dir: Annotated[Optional[Path], typer.Option(help="Optional directory to store the generated local MDMP keypair.")] = None,
+) -> None:
+    console = Console()
+    try:
+        outputs = prepare_ai_ready_artifacts(
+            run_dir,
+            create_dev_mdmp_cert=create_dev_mdmp_cert,
+            grade=grade,
+            expires_days=expires_days,
+            key_dir=key_dir,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]Error:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS AI Prepared Artifacts")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Path", overflow="fold")
+    for key, value in outputs.items():
+        table.add_row(key, value)
+    console.print(table)
+    console.print("[green]Prepared AI payloads are ready.[/green]")
+    if "mdmp_cert" in outputs:
+        console.print(
+            "[green]You can now run:[/green] "
+            f"`iints ai report {run_dir}` or `iints ai explain {run_dir}`"
+        )
+
+
 def _build_assistant(
     *,
     mdmp_cert: Path,
@@ -169,8 +262,8 @@ def local_check(
 
 @app.command("explain")
 def explain(
-    input_json: Annotated[Path, typer.Argument(help="JSON file with a single simulation step or decision context.")],
-    mdmp_cert: Annotated[Path, typer.Option(help="Signed MDMP artifact required before AI analysis can run.")],
+    input_json: Annotated[Path, typer.Argument(help="Prepared run directory or JSON file with a single simulation step or decision context.")],
+    mdmp_cert: Annotated[Optional[Path], typer.Option(help="Signed MDMP artifact required before AI analysis can run.")] = None,
     mode: Annotated[str, typer.Option(help="AI backend mode. Use 'local' for Ollama/Ministral.")] = "auto",
     model: Annotated[str, typer.Option(help="Ollama model name to use.")] = DEFAULT_MINISTRAL_MODEL,
     minimum_grade: Annotated[str, typer.Option(help="Minimum MDMP grade required to allow analysis.")] = "research_grade",
@@ -182,13 +275,20 @@ def explain(
 ) -> None:
     console = Console()
     try:
-        payload = _load_json_payload(input_json, "Input JSON")
-        assistant = _build_assistant(
+        resolved_input, resolved_cert, resolved_public_key = _resolve_cli_inputs(
+            task="explain",
+            input_path=input_json,
             mdmp_cert=mdmp_cert,
+            public_key=public_key,
+            trust_store=trust_store,
+        )
+        payload = _load_json_payload(resolved_input, "Input JSON")
+        assistant = _build_assistant(
+            mdmp_cert=resolved_cert,
             mode=mode,
             model=model,
             minimum_grade=minimum_grade,
-            public_key=public_key,
+            public_key=resolved_public_key,
             trust_store=trust_store,
             ollama_host=ollama_host,
             timeout_seconds=timeout_seconds,
@@ -203,8 +303,8 @@ def explain(
 
 @app.command("trends")
 def trends(
-    input_json: Annotated[Path, typer.Argument(help="JSON file with glucose trace data or a run payload.")],
-    mdmp_cert: Annotated[Path, typer.Option(help="Signed MDMP artifact required before AI analysis can run.")],
+    input_json: Annotated[Path, typer.Argument(help="Prepared run directory or JSON file with glucose trace data or a run payload.")],
+    mdmp_cert: Annotated[Optional[Path], typer.Option(help="Signed MDMP artifact required before AI analysis can run.")] = None,
     mode: Annotated[str, typer.Option(help="AI backend mode. Use 'local' for Ollama/Ministral.")] = "auto",
     model: Annotated[str, typer.Option(help="Ollama model name to use.")] = DEFAULT_MINISTRAL_MODEL,
     minimum_grade: Annotated[str, typer.Option(help="Minimum MDMP grade required to allow analysis.")] = "research_grade",
@@ -216,13 +316,20 @@ def trends(
 ) -> None:
     console = Console()
     try:
-        payload = _load_json_payload(input_json, "Input JSON")
-        assistant = _build_assistant(
+        resolved_input, resolved_cert, resolved_public_key = _resolve_cli_inputs(
+            task="trends",
+            input_path=input_json,
             mdmp_cert=mdmp_cert,
+            public_key=public_key,
+            trust_store=trust_store,
+        )
+        payload = _load_json_payload(resolved_input, "Input JSON")
+        assistant = _build_assistant(
+            mdmp_cert=resolved_cert,
             mode=mode,
             model=model,
             minimum_grade=minimum_grade,
-            public_key=public_key,
+            public_key=resolved_public_key,
             trust_store=trust_store,
             ollama_host=ollama_host,
             timeout_seconds=timeout_seconds,
@@ -237,8 +344,8 @@ def trends(
 
 @app.command("anomalies")
 def anomalies(
-    input_json: Annotated[Path, typer.Argument(help="JSON file with simulation results or run summary.")],
-    mdmp_cert: Annotated[Path, typer.Option(help="Signed MDMP artifact required before AI analysis can run.")],
+    input_json: Annotated[Path, typer.Argument(help="Prepared run directory or JSON file with simulation results or run summary.")],
+    mdmp_cert: Annotated[Optional[Path], typer.Option(help="Signed MDMP artifact required before AI analysis can run.")] = None,
     mode: Annotated[str, typer.Option(help="AI backend mode. Use 'local' for Ollama/Ministral.")] = "auto",
     model: Annotated[str, typer.Option(help="Ollama model name to use.")] = DEFAULT_MINISTRAL_MODEL,
     minimum_grade: Annotated[str, typer.Option(help="Minimum MDMP grade required to allow analysis.")] = "research_grade",
@@ -250,13 +357,20 @@ def anomalies(
 ) -> None:
     console = Console()
     try:
-        payload = _load_json_payload(input_json, "Input JSON")
-        assistant = _build_assistant(
+        resolved_input, resolved_cert, resolved_public_key = _resolve_cli_inputs(
+            task="anomalies",
+            input_path=input_json,
             mdmp_cert=mdmp_cert,
+            public_key=public_key,
+            trust_store=trust_store,
+        )
+        payload = _load_json_payload(resolved_input, "Input JSON")
+        assistant = _build_assistant(
+            mdmp_cert=resolved_cert,
             mode=mode,
             model=model,
             minimum_grade=minimum_grade,
-            public_key=public_key,
+            public_key=resolved_public_key,
             trust_store=trust_store,
             ollama_host=ollama_host,
             timeout_seconds=timeout_seconds,
@@ -271,8 +385,8 @@ def anomalies(
 
 @app.command("report")
 def report(
-    input_json: Annotated[Path, typer.Argument(help="JSON file with run-level simulation outputs.")],
-    mdmp_cert: Annotated[Path, typer.Option(help="Signed MDMP artifact required before AI analysis can run.")],
+    input_json: Annotated[Path, typer.Argument(help="Prepared run directory or JSON file with run-level simulation outputs.")],
+    mdmp_cert: Annotated[Optional[Path], typer.Option(help="Signed MDMP artifact required before AI analysis can run.")] = None,
     mode: Annotated[str, typer.Option(help="AI backend mode. Use 'local' for Ollama/Ministral.")] = "auto",
     model: Annotated[str, typer.Option(help="Ollama model name to use.")] = DEFAULT_MINISTRAL_MODEL,
     minimum_grade: Annotated[str, typer.Option(help="Minimum MDMP grade required to allow analysis.")] = "research_grade",
@@ -284,13 +398,20 @@ def report(
 ) -> None:
     console = Console()
     try:
-        payload = _load_json_payload(input_json, "Input JSON")
-        assistant = _build_assistant(
+        resolved_input, resolved_cert, resolved_public_key = _resolve_cli_inputs(
+            task="report",
+            input_path=input_json,
             mdmp_cert=mdmp_cert,
+            public_key=public_key,
+            trust_store=trust_store,
+        )
+        payload = _load_json_payload(resolved_input, "Input JSON")
+        assistant = _build_assistant(
+            mdmp_cert=resolved_cert,
             mode=mode,
             model=model,
             minimum_grade=minimum_grade,
-            public_key=public_key,
+            public_key=resolved_public_key,
             trust_store=trust_store,
             ollama_host=ollama_host,
             timeout_seconds=timeout_seconds,

iints/ai/prepare.py

@@ -0,0 +1,342 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+import importlib
+import json
+import math
+
+import pandas as pd
+
+from iints.utils.run_io import compute_sha256
+
+
+def _now_utc() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError(f"Expected JSON object in {path}")
+    return payload
+
+
+def _normalize_value(value: Any) -> Any:
+    if value is None:
+        return None
+    if isinstance(value, (str, bool, int)):
+        return value
+    if isinstance(value, float):
+        if math.isnan(value) or math.isinf(value):
+            return None
+        return round(value, 4)
+    if hasattr(value, "item"):
+        return _normalize_value(value.item())
+    return value
+
+
+def _normalize_record(record: dict[str, Any]) -> dict[str, Any]:
+    return {key: _normalize_value(value) for key, value in record.items()}
+
+
+def _normalize_series_record(record: Any) -> dict[str, Any]:
+    if not isinstance(record, dict):
+        return {}
+    return {str(key): _normalize_value(value) for key, value in record.items()}
+
+
+def _glucose_column(df: pd.DataFrame) -> str:
+    for candidate in ("glucose_actual_mgdl", "glucose_to_algo_mgdl", "cgm"):
+        if candidate in df.columns:
+            return candidate
+    raise ValueError("Results CSV does not contain a supported glucose column.")
+
+
+def _bool_sum(df: pd.DataFrame, column: str) -> int:
+    if column not in df.columns:
+        return 0
+    return int(df[column].fillna(False).astype(bool).sum())
+
+
+def _safe_sum(df: pd.DataFrame, column: str) -> float:
+    if column not in df.columns:
+        return 0.0
+    return float(pd.to_numeric(df[column], errors="coerce").fillna(0.0).sum())
+
+
+def _time_in_band_pct(series: pd.Series, low: float, high: float) -> float:
+    clean = pd.to_numeric(series, errors="coerce").dropna()
+    if clean.empty:
+        return 0.0
+    mask = (clean >= low) & (clean <= high)
+    return float(mask.mean() * 100.0)
+
+
+def _sample_trace(df: pd.DataFrame, *, max_rows: int = 48) -> list[dict[str, Any]]:
+    interesting_columns = [
+        "time_minutes",
+        "glucose_actual_mgdl",
+        "glucose_to_algo_mgdl",
+        "glucose_trend_mgdl_min",
+        "predicted_glucose_30min",
+        "algo_recommended_insulin_units",
+        "delivered_insulin_units",
+        "safety_triggered",
+        "safety_reason",
+    ]
+    present = [column for column in interesting_columns if column in df.columns]
+    if not present:
+        return []
+    if len(df) <= max_rows:
+        sampled = df[present]
+    else:
+        step = max(1, len(df) // max_rows)
+        sampled = df.iloc[::step][present].head(max_rows)
+    return [_normalize_series_record(record) for record in sampled.to_dict(orient="records")]
+
+
+def _position_for_label(df: pd.DataFrame, label: Any) -> int:
+    location = df.index.get_loc(label)
+    if isinstance(location, int):
+        return location
+    raise ValueError(f"Could not resolve row position for label: {label!r}")
+
+
+def _select_step_payload(df: pd.DataFrame) -> tuple[dict[str, Any], dict[str, Any]]:
+    if df.empty:
+        raise ValueError("Results CSV is empty.")
+
+    glucose_column = _glucose_column(df)
+    risk_position = len(df.index) - 1
+    selection_reason = "latest_step"
+
+    if "safety_triggered" in df.columns and df["safety_triggered"].fillna(False).astype(bool).any():
+        safety_rows = df[df["safety_triggered"].fillna(False).astype(bool)]
+        risk_position = _position_for_label(df, safety_rows.index[0])
+        selection_reason = "first_safety_trigger"
+    else:
+        glucose_values = pd.to_numeric(df[glucose_column], errors="coerce")
+        if (glucose_values < 70).any():
+            risk_label = glucose_values.idxmin()
+            risk_position = _position_for_label(df, risk_label)
+            selection_reason = "lowest_glucose"
+        elif "predicted_glucose_30min" in df.columns:
+            predicted = pd.to_numeric(df["predicted_glucose_30min"], errors="coerce")
+            if (predicted > 180).any():
+                risk_label = predicted.idxmax()
+                risk_position = _position_for_label(df, risk_label)
+                selection_reason = "highest_predicted_glucose_30min"
+    latest_position = len(df.index) - 1
+
+    def _row_at(position: int) -> Optional[dict[str, Any]]:
+        if position < 0 or position >= len(df.index):
+            return None
+        return _normalize_series_record(df.iloc[position].to_dict())
+
+    risk_payload = {
+        "selection_reason": selection_reason,
+        "selected_step": _row_at(risk_position),
+        "previous_step": _row_at(risk_position - 1),
+        "next_step": _row_at(risk_position + 1),
+    }
+    latest_payload = {
+        "selection_reason": "latest_step",
+        "selected_step": _row_at(latest_position),
+        "previous_step": _row_at(latest_position - 1),
+        "next_step": None,
+    }
+    return risk_payload, latest_payload
+
+
+def _build_summary(df: pd.DataFrame, run_metadata: dict[str, Any], audit_summary: dict[str, Any]) -> dict[str, Any]:
+    glucose_column = _glucose_column(df)
+    glucose = pd.to_numeric(df[glucose_column], errors="coerce").dropna()
+    if glucose.empty:
+        raise ValueError("Results CSV glucose series is empty.")
+
+    duration_minutes = run_metadata.get("config", {}).get("duration_minutes")
+    if duration_minutes is None and "time_minutes" in df.columns:
+        duration_minutes = _normalize_value(pd.to_numeric(df["time_minutes"], errors="coerce").max())
+
+    return {
+        "steps": int(len(df)),
+        "duration_minutes": _normalize_value(duration_minutes),
+        "mean_glucose_mgdl": _normalize_value(float(glucose.mean())),
+        "min_glucose_mgdl": _normalize_value(float(glucose.min())),
+        "max_glucose_mgdl": _normalize_value(float(glucose.max())),
+        "time_in_range_70_180_pct": _normalize_value(_time_in_band_pct(glucose, 70.0, 180.0)),
+        "time_below_70_pct": _normalize_value(float((glucose < 70.0).mean() * 100.0)),
+        "time_above_180_pct": _normalize_value(float((glucose > 180.0).mean() * 100.0)),
+        "delivered_insulin_total_units": _normalize_value(_safe_sum(df, "delivered_insulin_units")),
+        "recommended_insulin_total_units": _normalize_value(_safe_sum(df, "algo_recommended_insulin_units")),
+        "safety_trigger_count": _bool_sum(df, "safety_triggered"),
+        "audit_override_count": int(audit_summary.get("total_overrides", 0)),
+    }
+
+
+def _build_payloads(
+    *,
+    run_dir: Path,
+    results_df: pd.DataFrame,
+    run_metadata: dict[str, Any],
+    run_manifest: dict[str, Any],
+    audit_summary: dict[str, Any],
+    baseline_comparison: dict[str, Any] | None,
+) -> dict[str, dict[str, Any]]:
+    summary = _build_summary(results_df, run_metadata, audit_summary)
+    risk_payload, latest_payload = _select_step_payload(results_df)
+    trace_sample = _sample_trace(results_df)
+
+    common = {
+        "generated_at_utc": _now_utc(),
+        "run_dir": str(run_dir),
+        "run_id": run_metadata.get("run_id"),
+        "sdk_version": run_metadata.get("sdk_version"),
+        "algorithm": run_metadata.get("config", {}).get("algorithm", {}),
+        "scenario": run_metadata.get("config", {}).get("scenario"),
+        "summary": summary,
+    }
+
+    payloads: dict[str, dict[str, Any]] = {
+        "report_payload.json": {
+            **common,
+            "artifacts": {
+                "run_metadata": str(run_dir / "run_metadata.json"),
+                "run_manifest": str(run_dir / "run_manifest.json"),
+                "results_csv": str(run_dir / "results.csv"),
+                "audit_summary": str(run_dir / "audit" / "audit_summary.json"),
+                "baseline_comparison": str(run_dir / "baseline" / "baseline_comparison.json"),
+            },
+            "audit_summary": audit_summary,
+            "baseline_comparison": baseline_comparison,
+            "trace_sample": trace_sample,
+            "run_manifest": run_manifest,
+        },
+        "anomalies_payload.json": {
+            **common,
+            "audit_summary": audit_summary,
+            "safety_events": [
+                record
+                for record in trace_sample
+                if bool(record.get("safety_triggered"))
+            ],
+        },
+        "trends_payload.json": {
+            **common,
+            "trace_sample": trace_sample,
+            "baseline_comparison": baseline_comparison,
+        },
+        "step_riskiest.json": {
+            **common,
+            **risk_payload,
+        },
+        "step_latest.json": {
+            **common,
+            **latest_payload,
+        },
+    }
+    return payloads
+
+
+def _load_mdmp_signer_tools() -> tuple[type[Any], Any]:
+    try:
+        module = importlib.import_module("mdmp_core")
+    except Exception as exc:
+        raise ImportError(
+            "Local AI certification requires the optional standalone MDMP package.\n"
+            "Install with: pip install 'iints-sdk-python35[mdmp]'"
+        ) from exc
+
+    signer_cls = getattr(module, "MDMPSigner", None)
+    keygen_fn = getattr(module, "generate_keypair", None)
+    if signer_cls is None or keygen_fn is None:
+        raise ImportError("mdmp_core is installed but does not expose MDMPSigner/generate_keypair.")
+    return signer_cls, keygen_fn
+
+
+def _write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+
+
+def prepare_ai_ready_artifacts(
+    run_dir: str | Path,
+    *,
+    create_dev_mdmp_cert: bool = True,
+    grade: str = "research_grade",
+    expires_days: int = 30,
+    key_dir: str | Path | None = None,
+) -> dict[str, str]:
+    bundle_dir = Path(run_dir).expanduser().resolve()
+    if not bundle_dir.is_dir():
+        raise FileNotFoundError(f"Run directory not found: {bundle_dir}")
+
+    results_csv = bundle_dir / "results.csv"
+    run_metadata_path = bundle_dir / "run_metadata.json"
+    run_manifest_path = bundle_dir / "run_manifest.json"
+
+    for required in (results_csv, run_metadata_path, run_manifest_path):
+        if not required.is_file():
+            raise FileNotFoundError(f"Required run artifact missing: {required}")
+
+    results_df = pd.read_csv(results_csv)
+    run_metadata = _read_json(run_metadata_path)
+    run_manifest = _read_json(run_manifest_path)
+
+    audit_summary_path = bundle_dir / "audit" / "audit_summary.json"
+    baseline_path = bundle_dir / "baseline" / "baseline_comparison.json"
+    audit_summary = _read_json(audit_summary_path) if audit_summary_path.is_file() else {}
+    baseline_comparison = _read_json(baseline_path) if baseline_path.is_file() else None
+
+    ai_dir = bundle_dir / "ai"
+    payloads = _build_payloads(
+        run_dir=bundle_dir,
+        results_df=results_df,
+        run_metadata=run_metadata,
+        run_manifest=run_manifest,
+        audit_summary=audit_summary,
+        baseline_comparison=baseline_comparison,
+    )
+
+    written: dict[str, str] = {}
+    for filename, payload in payloads.items():
+        target = ai_dir / filename
+        _write_json(target, payload)
+        written[filename.removesuffix(".json")] = str(target)
+
+    if create_dev_mdmp_cert:
+        signer_cls, keygen_fn = _load_mdmp_signer_tools()
+        resolved_key_dir = Path(key_dir).expanduser().resolve() if key_dir else ai_dir / "keys"
+        private_key_path = resolved_key_dir / "mdmp_private_v1.pem"
+        public_key_path = resolved_key_dir / "mdmp_pub_v1.pem"
+        if not private_key_path.is_file() or not public_key_path.is_file():
+            keygen_fn(output_dir=resolved_key_dir)
+
+        cert_payload = {
+            "mdmp_object": "iints_ai_local_cert",
+            "spec_version": "1.0",
+            "grade": grade,
+            "generated_at_utc": _now_utc(),
+            "run_id": run_metadata.get("run_id"),
+            "run_dir": str(bundle_dir),
+            "sdk_version": run_metadata.get("sdk_version"),
+            "purpose": "local_research_ai",
+            "results_csv_sha256": f"sha256:{compute_sha256(results_csv)}",
+            "run_manifest_sha256": f"sha256:{compute_sha256(run_manifest_path)}",
+            "notes": "Local development certificate generated by IINTS AI prepare.",
+        }
+        signer = signer_cls(
+            private_key_path=private_key_path,
+            signed_by="IINTS-Local-AI",
+            key_id="iints_local_ai_v1",
+        )
+        signed_cert = signer.sign_card(cert_payload, expires_days=expires_days)
+        cert_path = ai_dir / "report.signed.mdmp"
+        _write_json(cert_path, signed_cert)
+        written["mdmp_cert"] = str(cert_path)
+        written["mdmp_public_key"] = str(public_key_path)
+        written["mdmp_private_key"] = str(private_key_path)
+
+    return written

iints/cli/cli.py

@@ -22,6 +22,7 @@ from rich.table import Table  # type: ignore # For comparison table
 from rich.panel import Panel  # type: ignore # For nicer auto-doc output
 
 import iints # Import the top-level SDK package
+from iints.ai import prepare_ai_ready_artifacts
 from iints.ai.cli import app as ai_app
 from iints.analysis.baseline import run_baseline_comparison, write_baseline_comparison
 from iints.api.registry import list_algorithm_plugins
@@ -278,6 +279,30 @@ def _write_certification_summary(
     return summary_path
 
 
+def _maybe_prepare_ai_artifacts(output_dir: Path, console: Console) -> None:
+    try:
+        outputs = prepare_ai_ready_artifacts(output_dir, create_dev_mdmp_cert=True)
+        console.print(f"[green]AI-ready artifacts:[/green] {output_dir / 'ai'}")
+        if "mdmp_cert" in outputs:
+            console.print(f"[green]AI quick start:[/green] iints ai report {output_dir}")
+        return
+    except ImportError as exc:
+        console.print(f"[yellow]AI dev certificate skipped:[/yellow] {exc}")
+    except Exception as exc:
+        console.print(f"[yellow]AI-ready export skipped:[/yellow] {exc}")
+        return
+
+    try:
+        prepare_ai_ready_artifacts(output_dir, create_dev_mdmp_cert=False)
+        console.print(f"[green]AI-ready payloads:[/green] {output_dir / 'ai'}")
+        console.print(
+            "[yellow]Tip:[/yellow] Install the MDMP extra or rerun "
+            f"`iints ai prepare {output_dir}` to generate a local development certificate."
+        )
+    except Exception as exc:
+        console.print(f"[yellow]AI-ready payload export skipped:[/yellow] {exc}")
+
+
 def _get_preset(name: str) -> Dict[str, Any]:
     presets = _load_presets()
     for preset in presets:
@@ -1698,9 +1723,11 @@ def presets_run(
     run_manifest_path = output_dir / "run_manifest.json"
     write_json(run_manifest_path, run_manifest)
     console.print(f"Run manifest: {run_manifest_path}")
+    _maybe_prepare_ai_artifacts(output_dir, console)
     signature_path = maybe_sign_manifest(run_manifest_path)
     if signature_path:
         console.print(f"Run manifest signature: {signature_path}")
+    _maybe_prepare_ai_artifacts(output_dir, console)
 
 
 @presets_app.command("create")
@@ -2295,6 +2322,8 @@ def run_full(
         console.print(f"Profiling report: {outputs['profiling_path']}")
     if "run_manifest_signature" in outputs:
         console.print(f"Run manifest signature: {outputs['run_manifest_signature']}")
+    if "output_dir" in outputs:
+        _maybe_prepare_ai_artifacts(Path(outputs["output_dir"]), console)
 
 
 @app.command("run-parallel")

{iints_sdk_python35-1.1.1.dist-info → iints_sdk_python35-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iints-sdk-python35
-Version: 1.1.1
+Version: 1.1.2
 Summary: A pre-clinical Edge-AI SDK for diabetes management validation.
 Author-email: Rune Bobbaers <rune.bobbaers@gmail.com>
 Project-URL: Homepage, https://github.com/python35/IINTS-SDK
@@ -110,15 +110,21 @@ ollama pull ministral-3:8b
 iints ai local-check --model ministral-3:8b
 ```
 
-Example commands:
+Recommended flow:
+
+```bash
+iints quickstart --project-name iints_quickstart
+cd iints_quickstart
+iints presets run --name baseline_t1d --algo algorithms/example_algorithm.py
+iints ai prepare results/<run_id>
+iints ai report results/<run_id>
+```
+
+Direct JSON mode still works if you already have your own payloads and signed MDMP artifact:
 
 ```bash
 iints ai explain results/step.json \
   --mdmp-cert results/report.signed.mdmp
-
-iints ai report results/simulation_run.json \
-  --mdmp-cert results/report.signed.mdmp \
-  --output results/ai_report.md
 ```
 
 Notes:
@@ -127,8 +133,21 @@ Notes:
 - The SDK now targets the open local `Ministral 3` Ollama model by default.
 - Users can choose a larger or smaller local Mistral-family model with `--model ...`.
 - Large JSON payloads are clipped automatically before prompt generation to keep local inference stable.
+- `iints ai prepare <run_dir>` now creates AI-ready JSON payloads and, when MDMP is installed, a local development certificate plus keypair in `<run_dir>/ai/`.
+- After `iints ai prepare`, you can point `iints ai explain|trends|anomalies|report` directly at the run directory.
 - Output is research-only and not medical advice.
 
+Troubleshooting:
+- If `iints ai ...` says `No such command 'ai'`, your environment usually still has a legacy `iints` package installed alongside `iints-sdk-python35`.
+- Run `iints-sdk-doctor` first.
+- If it reports a conflict, repair the environment with:
+
+```bash
+python -m pip uninstall -y iints iints-sdk-python35
+python -m pip install -U "iints-sdk-python35[mdmp]==1.1.2"
+hash -r
+```
+
 ## MDMP (Short)
 MDMP is the data-quality protocol used by IINTS.
 

{iints_sdk_python35-1.1.1.dist-info → iints_sdk_python35-1.1.2.dist-info}/RECORD

@@ -1,11 +1,12 @@
-iints/__init__.py,sha256=XsWIyn-Zkw9S0NMRJA0BpUTAxHtXAdU4Te4BBEox-_I,6047
+iints/__init__.py,sha256=wfAcfS7htgnV4JD-R8_WyKZHOwR8Z98vy-oLYxu0-rE,6391
 iints/highlevel.py,sha256=DX12LRmL6YaYY99P0c_P93xfHe4mZjqyLhTYuS6L6hI,20491
 iints/metrics.py,sha256=O9hqOqJpUhUJDqsbfuqRMS9dkV97gzcgh3Y2jYUqHzg,907
-iints/ai/__init__.py,sha256=Otp_ZQ448lNrREakTZGy5ghToyszfNaMevGEJxjmCI8,493
+iints/ai/__init__.py,sha256=nyRDcFfSHI4a3NbTvySipFc3_inqRMEsr6xIEipWuyo,575
 iints/ai/assistant.py,sha256=0Ye1IaWEYg2rZnk3ny8f0GMoYqOWIa7U_GsV-sWrxtU,4346
-iints/ai/cli.py,sha256=Ol-lEYUIrwKjO2pfnfLHIWoGtIpT5IRU2HbbMGH6a08,13509
+iints/ai/cli.py,sha256=_1ogEAb36BAt7sZ2CQSRKIJSpdn5xrlM7nNTtBIqfRo,18345
 iints/ai/mdmp_guard.py,sha256=BpFQX0oyP9WMCUZbFhhoBzomNeVKuI1HY1EFH9cG8EE,4249
 iints/ai/model_catalog.py,sha256=gRW-i4eaXkrjX3mIKJlGzHqzU75lpIulEFKQsCX11CI,1804
+iints/ai/prepare.py,sha256=z3y5elCAMv0p_aNq4gQfZA1uIT7_cX3FGRdzmoZoKho,12967
 iints/ai/prompts.py,sha256=pGp9tC1wBZXGG5duxfktaJEF4p_cvmR0zEIxmMTEAyE,2812
 iints/ai/backends/__init__.py,sha256=EAJRZS8G0DK7fffw_LHio9DkyYHwtzvz2Jo7AXk7pk4,303
 iints/ai/backends/base.py,sha256=BLgP03X-jebYkF9D5n5crawoPBmy3RSh4q3jaT8a9XM,274
@@ -35,7 +36,7 @@ iints/api/registry.py,sha256=h2syJwacFbgrtgnVK20JwlXivvVO31zeJ_Ez4KBkn1g,3240
 iints/api/template_algorithm.py,sha256=AFs9AymL3ddWAjgpOkF1Oa3TeOSg56siyDt_BmsAND8,9195
 iints/assets/iints_logo.png,sha256=rWzP8XqIYDrPCTp378w73zA1snKCUHrZ76vwslro-uk,700372
 iints/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iints/cli/cli.py,sha256=bTYXVneLUBKBr4p1jSwg0aNKT2ECLZA-PwJ9UggYIVg,208838
+iints/cli/cli.py,sha256=oDg0rkD_zXu83oQHb6kTzjKzQBr7ETJA9-C5diPASg0,210187
 iints/core/__init__.py,sha256=rRH2lTmikavR7BgeJCUla0ZmPbZxATR6rEcSSv_tet4,28
 iints/core/device.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 iints/core/device_manager.py,sha256=479_CNn6YescDLWDE7w1BbwuLwRUmCUOColAVTEWQc8,2078
@@ -141,9 +142,9 @@ iints/validation/schemas.py,sha256=uXhiPxyfyvOgCA83ZPBIzlITOu663fWctYxOMXUyf1I,4
 iints/visualization/__init__.py,sha256=OdxVHDpY-9bDt8DTWWd-dspn1p0O9T908Cck-IGFaiM,640
 iints/visualization/cockpit.py,sha256=Y7hoJXcTEWQ8yLiU5X5abT58uqGGsQllftXJwqerG1E,25057
 iints/visualization/uncertainty_cloud.py,sha256=I5nNzSitgai21rkul31YNtJriSEmCeTsW0GWW2HUskY,19848
-iints_sdk_python35-1.1.1.dist-info/licenses/LICENSE,sha256=b1luljj2mWWDW10t_qFIqd9Z6euXAcDBmIXowWuUlm4,1417
-iints_sdk_python35-1.1.1.dist-info/METADATA,sha256=xaFWKcobC1go0uDhciKSLvguo55oPz6nYDmnJCK1duQ,8023
-iints_sdk_python35-1.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-iints_sdk_python35-1.1.1.dist-info/entry_points.txt,sha256=ZlC9C1-rhefU6t-Wr7tT05LI5agdKnpsDJgXKxDO350,528
-iints_sdk_python35-1.1.1.dist-info/top_level.txt,sha256=7Usr6NQKiC9SpNFyCis81MmgXy71lDCr5unR8BNXZ0E,6
-iints_sdk_python35-1.1.1.dist-info/RECORD,,
+iints_sdk_python35-1.1.2.dist-info/licenses/LICENSE,sha256=b1luljj2mWWDW10t_qFIqd9Z6euXAcDBmIXowWuUlm4,1417
+iints_sdk_python35-1.1.2.dist-info/METADATA,sha256=F-4k2b--KpKAGQpS6Kw8LP_AW3A1zzqATS7lgs_Mx8I,8887
+iints_sdk_python35-1.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+iints_sdk_python35-1.1.2.dist-info/entry_points.txt,sha256=aVioeLytTHG7WM7L3LIZ6XDJCKiSfqG-nVUQDVHPpQk,578
+iints_sdk_python35-1.1.2.dist-info/top_level.txt,sha256=7Usr6NQKiC9SpNFyCis81MmgXy71lDCr5unR8BNXZ0E,6
+iints_sdk_python35-1.1.2.dist-info/RECORD,,

{iints_sdk_python35-1.1.1.dist-info → iints_sdk_python35-1.1.2.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 iints = iints.cli.cli:app
+iints-sdk-doctor = iints_sdk_python35_doctor:main
 
 [iints.algorithms]
 Correction Bolus = iints.core.algorithms.correction_bolus:CorrectionBolusAlgorithm