uxarray-mcp 0.2.0__tar.gz → 0.2.2__tar.gz

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: uxarray-mcp
-Version: 0.2.0
+Version: 0.2.2
 Summary: MCP server for analyzing unstructured meshes with UXarray
 Keywords: uxarray,mcp,unstructured grids,scientific computing,globus compute
 Author: Rajeev Jain, Dayan Abdulla
@@ -215,10 +215,11 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: Apache Software License
 Requires-Dist: toolregistry-server[mcp]>=0.4.0
+Requires-Dist: mcp>=1.20,<2
 Requires-Dist: holoviews>=1.19.0
 Requires-Dist: matplotlib>=3.9.0
 Requires-Dist: pyyaml>=6.0
-Requires-Dist: uxarray>=2026.6.0
+Requires-Dist: uxarray>=2026.7.0
 Requires-Dist: sphinx>=7.0 ; extra == 'docs'
 Requires-Dist: sphinx-book-theme>=1.1.0 ; extra == 'docs'
 Requires-Dist: myst-parser>=3.0 ; extra == 'docs'

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uxarray-mcp"
-version = "0.2.0"
+version = "0.2.2"
 description = "MCP server for analyzing unstructured meshes with UXarray"
 readme = "README.md"
 keywords = [
@@ -22,10 +22,11 @@ classifiers = [
 requires-python = ">=3.12,<3.13"
 dependencies = [
     "toolregistry-server[mcp]>=0.4.0",
+    "mcp>=1.20,<2",
     "holoviews>=1.19.0",
     "matplotlib>=3.9.0",
     "pyyaml>=6.0",
-    "uxarray>=2026.6.0",
+    "uxarray>=2026.7.0",
 ]
 
 [[project.authors]]

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "uxarray-mcp"
-version = "0.2.0"
+version = "0.2.2"
 description = "MCP server for analyzing unstructured meshes with UXarray"
 readme = "README.md"
 keywords = ["uxarray", "mcp", "unstructured grids", "scientific computing", "globus compute"]
@@ -26,10 +26,12 @@ license = { file = "LICENSE" }
 requires-python = ">=3.12,<3.13"
 dependencies = [
     "toolregistry-server[mcp]>=0.4.0",
+    # toolregistry-server 0.4.x imports McpError, renamed to MCPError in mcp 2.
+    "mcp>=1.20,<2",
     "holoviews>=1.19.0",
     "matplotlib>=3.9.0",
     "pyyaml>=6.0",
-    "uxarray>=2026.6.0",
+    "uxarray>=2026.7.0",
 ]
 
 [project.optional-dependencies]

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/__init__.py

@@ -3,4 +3,4 @@
 from uxarray_mcp.tools import inspect_mesh
 
 __all__ = ["inspect_mesh"]
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/domain/vector_calc.py

@@ -354,7 +354,15 @@ def compute_curl(
     from uxarray_mcp.provenance import attach_scientific_status
 
     return attach_scientific_status(
-        result, warnings=component_warnings, warning_codes=warning_codes
+        result,
+        warnings=component_warnings,
+        warning_codes=warning_codes,
+        extra={
+            "physical_scaling_requested": bool(scale_by_radius),
+            "physical_scaling_applied": bool(
+                scale_by_radius and not deduped_uxarray_warnings
+            ),
+        },
     )
 
 

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/provenance.py

@@ -84,13 +84,17 @@ def attach_scientific_status(
     *,
     warnings: list[str] | None = None,
     warning_codes: list[str] | None = None,
+    extra: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Attach a machine-actionable scientific interpretation status."""
     messages = warnings or []
-    result["scientific_status"] = {
+    status = {
         "status": "warning" if messages else "complete",
         "physically_interpretable": not messages,
         "warning_codes": warning_codes or [],
         "warnings": messages,
     }
+    if extra:
+        status.update(extra)
+    result["scientific_status"] = status
     return result

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/remote/agent.py

@@ -166,6 +166,19 @@ class UXarrayComputeAgent(_AcademyAgent):
         else:
             return self._run_local_inspect_variable(grid_path, data_path, variable_name)
 
+    @action
+    async def validate_dataset_remote(
+        self, grid_path: str, data_path: str, use_remote: bool = False
+    ) -> Dict[str, Any]:
+        """Validate a dataset in the environment that can read its paths."""
+        from uxarray_mcp.remote.compute_functions import remote_validate_dataset
+
+        if use_remote and self.config.endpoint_id:
+            return await self._run_on_hpc(remote_validate_dataset, grid_path, data_path)
+        from uxarray_mcp.tools.inspection import validate_dataset
+
+        return validate_dataset(grid_path, data_path)
+
     @action
     async def calculate_zonal_mean_remote(
         self,
@@ -453,9 +466,14 @@ class UXarrayComputeAgent(_AcademyAgent):
         # — not the local submitter — and warn on local/remote version drift.
         drift_warnings: list[str] = []
         worker_uxarray = None
+        worker_runtime: dict[str, Any] = {}
         if isinstance(result, dict):
             worker_uxarray = result.pop("_worker_uxarray_version", None)
-            result.pop("_worker_python_version", None)
+            worker_runtime = result.pop("_worker_runtime", {}) or {}
+            worker_python = result.pop("_worker_python_version", None)
+            if worker_python and "python_version" not in worker_runtime:
+                worker_runtime["python_version"] = worker_python
+            worker_uxarray = worker_runtime.get("uxarray_version") or worker_uxarray
         local_uxarray = _get_uxarray_version()
         if (
             worker_uxarray
@@ -484,6 +502,16 @@ class UXarrayComputeAgent(_AcademyAgent):
         # Record the worker's uxarray version explicitly alongside the local one.
         if worker_uxarray:
             annotated["_provenance"]["remote_uxarray_version"] = worker_uxarray
+        for key in (
+            "hostname",
+            "python_version",
+            "xarray_version",
+            "numpy_version",
+            "slurm_job_id",
+            "pbs_job_id",
+        ):
+            if worker_runtime.get(key):
+                annotated["_provenance"][f"remote_{key}"] = worker_runtime[key]
         return annotated
 
     def _run_local_inspect_mesh(self, file_path: str) -> Dict[str, Any]:

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/remote/compute_functions.py

@@ -162,6 +162,80 @@ def remote_inspect_mesh(file_path: str) -> Dict[str, Any]:
         "n_edge": int(grid.n_edge),
         "source": file_path,
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
+    }
+
+
+def remote_validate_dataset(grid_path: str, data_path: str) -> Dict[str, Any]:
+    """Validate numeric variables on the worker that can read the dataset."""
+    import os
+    import platform
+
+    import numpy as np
+    import uxarray as ux
+
+    if grid_path.startswith("healpix:"):
+        grid = ux.Grid.from_healpix(int(grid_path.split(":")[1]))
+        xr_ds = __import__("xarray").open_dataset(data_path)
+        uxds = ux.UxDataset(xr_ds, uxgrid=grid)
+    elif os.path.splitext(grid_path.lower())[1] in [".shp", ".geojson"]:
+        grid = ux.Grid.from_file(grid_path, backend="geopandas")
+        xr_ds = __import__("xarray").open_dataset(data_path)
+        uxds = ux.UxDataset(xr_ds, uxgrid=grid)
+    else:
+        uxds = ux.open_dataset(grid_path, data_path)
+
+    fill_candidates = [1e20, 9.96920996838687e36, -999.0, -9999.0]
+    results = []
+    all_warnings: list[str] = []
+    for name in uxds.data_vars:
+        values = uxds[name].values
+        if not np.issubdtype(values.dtype, np.number):
+            continue
+        is_float = np.issubdtype(values.dtype, np.floating)
+        n_nan = int(np.sum(np.isnan(values))) if is_float else 0
+        n_inf = int(np.sum(np.isinf(values))) if is_float else 0
+        n_fill = 0
+        detected_fill = None
+        if is_float:
+            for candidate in fill_candidates:
+                count = int(np.sum(np.isclose(values, candidate, rtol=1e-3)))
+                if count:
+                    n_fill = count
+                    detected_fill = candidate
+                    break
+        warnings = []
+        if n_nan:
+            warnings.append(f"{name}: contains {n_nan} NaN values")
+        if n_inf:
+            warnings.append(f"{name}: contains {n_inf} Inf values")
+        if n_fill:
+            warnings.append(f"{name}: contains {n_fill} fill values")
+        all_warnings.extend(warnings)
+        results.append(
+            {
+                "name": name,
+                "passed": not warnings,
+                "n_nan": n_nan,
+                "n_inf": n_inf,
+                "n_fill_values": n_fill,
+                "detected_fill_value": detected_fill,
+                "shape": list(values.shape),
+                "dtype": str(values.dtype),
+                "warnings": warnings,
+            }
+        )
+
+    passed = all(item["passed"] for item in results)
+    return {
+        "passed": passed,
+        "is_valid": passed,
+        "n_variables_checked": len(results),
+        "n_variables_failed": sum(not item["passed"] for item in results),
+        "variables": results,
+        "issues": all_warnings,
+        "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": platform.python_version(),
     }
 
 
@@ -212,6 +286,7 @@ def remote_calculate_area(file_path: str) -> Dict[str, Any]:
         "area_units": units,
         "n_face": int(grid.n_face),
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
 
@@ -264,6 +339,17 @@ def remote_inspect_variable(
 
     variables = []
 
+    def _jsonable(value: Any) -> Any:
+        if isinstance(value, np.generic):
+            return value.item()
+        if isinstance(value, np.ndarray):
+            return value.tolist()
+        if isinstance(value, dict):
+            return {str(key): _jsonable(item) for key, item in value.items()}
+        if isinstance(value, (list, tuple)):
+            return [_jsonable(item) for item in value]
+        return value
+
     for name in var_names:
         if name not in uxds:
             continue
@@ -298,7 +384,7 @@ def remote_inspect_variable(
                 "shape": list(var.shape),
                 "dtype": str(var.dtype),
                 "location": location,
-                "attrs": dict(var.attrs),
+                "attrs": _jsonable(dict(var.attrs)),
                 "statistics": stats,
             }
         )
@@ -311,6 +397,7 @@ def remote_inspect_variable(
             "n_edge": int(uxds.uxgrid.n_edge),
         },
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
 
@@ -707,6 +794,7 @@ def remote_calculate_zonal_mean(
             "n_edge": int(uxds.uxgrid.n_edge),
         },
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
 
@@ -1155,6 +1243,7 @@ def remote_calculate_gradient(
             "warnings": uxarray_warnings,
         },
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
 
@@ -1260,6 +1349,12 @@ def remote_calculate_curl(
             applied_scale = bool(scale_by_radius)
         else:
             result = u.curl(v)
+            if scale_by_radius:
+                component_warnings.append(
+                    "Worker UXarray does not support scale_by_radius; returned "
+                    "the unit-sphere curl."
+                )
+                warning_codes.append("SCALE_BY_RADIUS_UNSUPPORTED")
         _seen: set = set()
         for _w in _caught:
             _msg = str(_w.message)
@@ -1267,6 +1362,7 @@ def remote_calculate_curl(
                 _seen.add(_msg)
                 component_warnings.append(_msg)
                 warning_codes.append("SPHERE_RADIUS_UNAVAILABLE")
+                applied_scale = False
     vals = result.values
     finite = vals[np.isfinite(vals)]
     stats: Dict[str, Any] = (
@@ -1290,10 +1386,13 @@ def remote_calculate_curl(
         "scientific_status": {
             "status": "warning" if component_warnings else "complete",
             "physically_interpretable": not component_warnings,
+            "physical_scaling_requested": bool(scale_by_radius),
+            "physical_scaling_applied": bool(applied_scale),
             "warning_codes": warning_codes,
             "warnings": component_warnings,
         },
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
 
@@ -1420,6 +1519,7 @@ def remote_calculate_divergence(
             "warnings": component_warnings,
         },
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
 
@@ -1474,6 +1574,7 @@ def remote_calculate_azimuthal_mean(
         "azimuthal_mean_values": values,
         "n_face": int(uxds.uxgrid.n_face),
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
 
@@ -1516,6 +1617,7 @@ def remote_grid_facts(
         "n_node": int(grid.n_node) if hasattr(grid, "n_node") else 0,
         "n_edge": int(grid.n_edge) if hasattr(grid, "n_edge") else 0,
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
     if data_path is not None:
@@ -1634,6 +1736,7 @@ def remote_remap_variable(
         "result_shape": list(remapped.shape),
         "stats": stats,
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
 
@@ -1715,6 +1818,7 @@ def remote_regrid_dataset(
         },
         "per_variable_stats": per_variable,
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
 
@@ -1781,6 +1885,7 @@ def remote_remap_to_rectilinear(
         "target_lon": lon,
         "target_lat": lat,
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }
 
 
@@ -1860,4 +1965,5 @@ def remote_calculate_zonal_anomaly(
             "n_edge": int(uxds.uxgrid.n_edge),
         },
         "_worker_uxarray_version": getattr(ux, "__version__", "unknown"),
+        "_worker_python_version": __import__("platform").python_version(),
     }

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/remote/config.py

@@ -162,7 +162,7 @@ class HPCConfig:
     def resolve_endpoint(
         self, endpoint: str | None = None, path: str | None = None
     ) -> EndpointProfile | None:
-        """Resolve an explicit endpoint name, default endpoint, or raw UUID."""
+        """Resolve an explicit endpoint, matching path prefix, or default."""
         if endpoint:
             if endpoint in self.endpoints:
                 return self.endpoints[endpoint]
@@ -185,6 +185,23 @@ class HPCConfig:
                 "Pass a configured endpoint name or a Globus Compute endpoint UUID."
             )
 
+        if path:
+            matches: list[tuple[int, EndpointProfile, str]] = []
+            for profile in self.endpoints.values():
+                for prefix in profile.path_prefixes:
+                    if path.startswith(prefix):
+                        matches.append((len(prefix), profile, prefix))
+            if matches:
+                longest = max(length for length, _, _ in matches)
+                best = [item for item in matches if item[0] == longest]
+                names = {profile.name for _, profile, _ in best}
+                if len(names) > 1:
+                    raise ValueError(
+                        f"Path {path!r} matches equally specific endpoint prefixes: "
+                        + ", ".join(sorted(names))
+                    )
+                return best[0][1]
+
         if self.default_endpoint and self.default_endpoint in self.endpoints:
             return self.endpoints[self.default_endpoint]
 

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/tools/catalog.py

@@ -2,13 +2,11 @@
 
 from __future__ import annotations
 
-import warnings
 from pathlib import Path
 from typing import Any, Dict, List
 
 from uxarray_mcp.provenance import attach_provenance
 from uxarray_mcp.remote.agent import get_agent
-from uxarray_mcp.remote.config import load_config
 from uxarray_mcp.tools.remote_tools import _endpoint_is_ready
 
 # File extensions recognised as potential mesh/data files
@@ -36,6 +34,7 @@ def list_datasets(
     recursive: bool = False,
     max_files: int = 200,
     use_remote: bool = False,
+    endpoint: str | None = None,
 ) -> Dict[str, Any]:
     """Scan a directory for mesh and data files and return a structured catalog.
 
@@ -80,7 +79,7 @@ def list_datasets(
             list_datasets("/lus/grand/projects/climate", recursive=True, max_files=500)
     """
     if use_remote:
-        return _list_datasets_remote(directory, recursive, max_files)
+        return _list_datasets_remote(directory, recursive, max_files, endpoint)
 
     root = Path(directory)
     if not root.exists():
@@ -187,6 +186,7 @@ def list_datasets(
             "recursive": recursive,
             "max_files": max_files,
             "use_remote": False,
+            "endpoint": endpoint,
         },
     )
 
@@ -307,49 +307,28 @@ def _remote_catalog_fn(
 
 
 def _list_datasets_remote(
-    directory: str, recursive: bool, max_files: int
+    directory: str, recursive: bool, max_files: int, endpoint: str | None = None
 ) -> Dict[str, Any]:
-    """Run list_datasets on the configured HPC endpoint."""
-    config = load_config()
-    if not config.has_endpoint:
+    """Run list_datasets on the selected HPC endpoint."""
+    agent = get_agent(endpoint=endpoint, path=directory)
+    config = agent.config
+    if not config.endpoint_id:
         raise RuntimeError(
             "No HPC endpoint configured. Set endpoint_id in config.yaml "
             "or the GLOBUS_COMPUTE_ENDPOINT_ID environment variable."
         )
 
-    agent = get_agent()
     ready, reason = _endpoint_is_ready(agent)
     if not ready:
         raise RuntimeError(
             f"HPC endpoint not ready ({reason}). Remote catalog scan not submitted."
         )
 
-    try:
-        from globus_compute_sdk import Executor
-        from globus_compute_sdk.serialize import AllCodeStrategies, ComputeSerializer
-    except ImportError as exc:
-        raise RuntimeError(
-            "HPC dependencies not installed. Run: uv sync --extra hpc"
-        ) from exc
-
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            message=r"(?s).*Environment differences detected between local SDK and endpoint.*",
-            category=UserWarning,
-        )
-        executor = Executor(
-            endpoint_id=config.endpoint_id,
-            serializer=ComputeSerializer(strategy_code=AllCodeStrategies()),
-        )
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            message=r"(?s).*Environment differences detected between local SDK and endpoint.*",
-            category=UserWarning,
-        )
-        future = executor.submit(_remote_catalog_fn, directory, recursive, max_files)
-        raw = future.result(timeout=config.timeout_seconds)
+    from uxarray_mcp.tools.remote_tools import _run_sync
+
+    raw = _run_sync(
+        lambda: agent._run_on_hpc(_remote_catalog_fn, directory, recursive, max_files)
+    )
 
     if "error" in raw:
         raise FileNotFoundError(raw["error"])
@@ -364,6 +343,7 @@ def _list_datasets_remote(
             "recursive": recursive,
             "max_files": max_files,
             "use_remote": True,
+            "endpoint": endpoint,
         },
         venue=f"hpc:{endpoint_label}",
     )

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/tools/execution_control.py

@@ -145,11 +145,12 @@ def _run_sync(awaitable_factory) -> Dict[str, Any]:
     """Run an async call from sync code in CLI and server contexts."""
     try:
         asyncio.get_running_loop()
-        with concurrent.futures.ThreadPoolExecutor() as pool:
-            return pool.submit(asyncio.run, awaitable_factory()).result()
     except RuntimeError:
         return asyncio.run(awaitable_factory())
 
+    with concurrent.futures.ThreadPoolExecutor() as pool:
+        return pool.submit(lambda: asyncio.run(awaitable_factory())).result()
+
 
 def probe_path_access(
     file_path: str,

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/tools/frontdoor.py

@@ -113,12 +113,13 @@ def run_analysis(
         subset_polygon,
         write_result,
     )
-    from uxarray_mcp.tools.inspection import calculate_zonal_anomaly, validate_dataset
+    from uxarray_mcp.tools.inspection import calculate_zonal_anomaly
     from uxarray_mcp.tools.remote_tools import (
         calculate_area,
         calculate_zonal_mean,
         inspect_mesh,
         inspect_variable,
+        validate_dataset,
     )
     from uxarray_mcp.tools.vector_calc import (
         calculate_azimuthal_mean,
@@ -146,10 +147,12 @@ def run_analysis(
             session_id=session_id,
         )
     if op == "validate_dataset":
-        _reject_unsupported_remote(use_remote, op)
         return validate_dataset(
             _require(grid_path, "grid_path", op),
             _require(data_path, "data_path", op),
+            use_remote=use_remote,
+            endpoint=endpoint,
+            session_id=session_id,
         )
     if op == "calculate_area":
         return calculate_area(

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/tools/orchestration.py

@@ -46,6 +46,7 @@ def _png_meta(items: list[Any]) -> dict[str, Any]:
         "image_size_bytes": image_size_bytes,
         "grid_info": meta.get("grid_info"),
         "variable_name": meta.get("variable_name"),
+        "_provenance": meta.get("_provenance", {}),
     }
 
 
@@ -126,6 +127,7 @@ def analyze_dataset(
         inspect_variable,
         plot_mesh,
         plot_variable,
+        validate_dataset,
     )
 
     resolved_grid, resolved_data = _resolve_plot_paths(
@@ -155,14 +157,15 @@ def analyze_dataset(
     selected_variable: Optional[str] = variable_name
 
     if resolved_data is not None:
-        # validate_dataset is local-only by design (data is read directly);
-        # if the dispatcher were ever added, prefer that. For now use the
-        # local variant via inspection.validate_dataset.
-        from .inspection import validate_dataset as _validate_dataset
-
         validation = _safe_call(
             "validate_dataset",
-            lambda: _validate_dataset(resolved_grid, resolved_data),
+            lambda: validate_dataset(
+                resolved_grid,
+                resolved_data,
+                use_remote=use_remote,
+                endpoint=endpoint,
+                session_id=session_id,
+            ),
             warnings,
         )
         if validation is not None:
@@ -204,7 +207,7 @@ def analyze_dataset(
 
     # ── Stage 5: zonal mean (needs data + face-centered variable) ───────────
     zonal_mean: Optional[dict[str, Any]] = None
-    validation_passed = validation is None or validation.get("passed") is not False
+    validation_passed = validation is not None and validation.get("passed") is True
     if (
         resolved_data is not None
         and selected_variable is not None
@@ -226,7 +229,7 @@ def analyze_dataset(
             stages_run.append("calculate_zonal_mean")
     elif resolved_data is not None and selected_variable is not None:
         warnings.append(
-            "calculate_zonal_mean: skipped because dataset validation failed."
+            "calculate_zonal_mean: skipped because dataset validation failed or was unavailable."
         )
 
     # ── Stage 6 + 7: plots (optional) ────────────────────────────────────────
@@ -269,7 +272,9 @@ def analyze_dataset(
                 variable_plot = _png_meta(var_plot_items)
                 stages_run.append("plot_variable")
         elif resolved_data is not None and selected_variable is not None:
-            warnings.append("plot_variable: skipped because dataset validation failed.")
+            warnings.append(
+                "plot_variable: skipped because dataset validation failed or was unavailable."
+            )
 
     # ── Recommended next steps ──────────────────────────────────────────────
     next_steps: list[str] = []
@@ -322,7 +327,15 @@ def analyze_dataset(
     # (used by tests that import `inspect_mesh` directly from this module).
     _ = inspect_mesh  # keep import alive
 
-    stage_results = [mesh, variables, area, zonal_mean]
+    stage_results = [
+        mesh,
+        validation,
+        variables,
+        area,
+        zonal_mean,
+        mesh_plot,
+        variable_plot,
+    ]
     venues = {
         stage.get("_provenance", {}).get("execution_venue")
         for stage in stage_results

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/tools/remote_tools.py

@@ -48,13 +48,15 @@ def _run_sync(async_call: Callable[[], Any]) -> Dict[str, Any]:
     """
     try:
         asyncio.get_running_loop()
-        # Inside async context (e.g. MCP server) — run in a new thread
-        with concurrent.futures.ThreadPoolExecutor() as pool:
-            return pool.submit(asyncio.run, async_call()).result()
     except RuntimeError:
         # No event loop running (tests, CLI) — run directly
         return asyncio.run(async_call())
 
+    # Inside async context (e.g. MCP server) — run in a new thread. Keep the
+    # operation outside the loop-detection try so its RuntimeError is preserved.
+    with concurrent.futures.ThreadPoolExecutor() as pool:
+        return pool.submit(lambda: asyncio.run(async_call())).result()
+
 
 def _path_is_locally_reachable(path_hint: str | None) -> bool:
     """True when local fallback can plausibly handle ``path_hint``.
@@ -220,6 +222,29 @@ def inspect_mesh(
     )
 
 
+def validate_dataset(
+    grid_path: str,
+    data_path: str,
+    use_remote: bool = False,
+    endpoint: str | None = None,
+    session_id: str | None = None,
+) -> Dict[str, Any]:
+    """Validate a dataset locally or on the selected endpoint."""
+    from uxarray_mcp.tools.inspection import validate_dataset as local_validate
+
+    return _run_with_optional_hpc(
+        tool_name="validate_dataset",
+        use_remote=use_remote,
+        endpoint=endpoint,
+        path_hint=grid_path,
+        session_id=session_id,
+        local_call=lambda: local_validate(grid_path, data_path),
+        remote_call=lambda agent: _run_sync(
+            lambda: agent.validate_dataset_remote(grid_path, data_path, True)
+        ),
+    )
+
+
 def calculate_area(
     file_path: str,
     use_remote: bool = False,

{uxarray_mcp-0.2.0 → uxarray_mcp-0.2.2}/src/uxarray_mcp/tools/stateful.py

@@ -159,12 +159,12 @@ def _execute_workflow(workflow_id: str, *, resume: bool) -> dict[str, Any]:
         probe_path_access,
         validate_hpc_setup,
     )
-    from uxarray_mcp.tools.inspection import validate_dataset
     from uxarray_mcp.tools.remote_tools import (
         calculate_area,
         calculate_zonal_mean,
         inspect_mesh,
         inspect_variable,
+        validate_dataset,
     )
 
     workflow = get_workflow(workflow_id)
@@ -182,6 +182,8 @@ def _execute_workflow(workflow_id: str, *, resume: bool) -> dict[str, Any]:
     data_path = workflow["inputs"].get("data_path")
     variable_name = workflow["inputs"].get("variable_name")
     sample_path = workflow["inputs"].get("sample_path")
+    use_remote = bool(workflow["inputs"].get("use_remote", False))
+    endpoint = workflow["inputs"].get("endpoint")
     session_id = workflow.get("session_id")
 
     steps: list[tuple[str, Any]] = [
@@ -190,17 +192,31 @@ def _execute_workflow(workflow_id: str, *, resume: bool) -> dict[str, Any]:
             lambda: validate_hpc_setup(
                 run_remote_probe=True,
                 sample_path=sample_path,
+                endpoint=endpoint,
             ),
         ),
         (
             "probe_path_access",
-            lambda: probe_path_access(sample_path or file_path, use_remote=False),
+            lambda: probe_path_access(
+                sample_path or file_path,
+                use_remote=use_remote,
+                endpoint=endpoint,
+            ),
+        ),
+        (
+            "inspect_mesh",
+            lambda: inspect_mesh(file_path, use_remote=use_remote, endpoint=endpoint),
         ),
-        ("inspect_mesh", lambda: inspect_mesh(file_path)),
         (
             "inspect_variable",
             lambda: (
-                inspect_variable(file_path, data_path, variable_name)
+                inspect_variable(
+                    file_path,
+                    data_path,
+                    variable_name,
+                    use_remote=use_remote,
+                    endpoint=endpoint,
+                )
                 if data_path is not None
                 else {"skipped": True}
             ),
@@ -208,12 +224,20 @@ def _execute_workflow(workflow_id: str, *, resume: bool) -> dict[str, Any]:
         (
             "validate_dataset",
             lambda: (
-                validate_dataset(file_path, data_path)
+                validate_dataset(
+                    file_path,
+                    data_path,
+                    use_remote=use_remote,
+                    endpoint=endpoint,
+                )
                 if data_path is not None
                 else {"skipped": True}
             ),
         ),
-        ("calculate_area", lambda: calculate_area(file_path)),
+        (
+            "calculate_area",
+            lambda: calculate_area(file_path, use_remote=use_remote, endpoint=endpoint),
+        ),
     ]
 
     # `calculate_zonal_mean` depends on inspected variables and validation.
@@ -286,7 +310,13 @@ def _execute_workflow(workflow_id: str, *, resume: bool) -> dict[str, Any]:
             )
             tracker.stage(zonal_step_name, f"Running {zonal_step_name}")
             update_workflow_step(workflow_id, zonal_step_name, status="running")
-            zonal_result = calculate_zonal_mean(file_path, data_path, selected_variable)
+            zonal_result = calculate_zonal_mean(
+                file_path,
+                data_path,
+                selected_variable,
+                use_remote=use_remote,
+                endpoint=endpoint,
+            )
             last_results[zonal_step_name] = zonal_result
             update_workflow_step(
                 workflow_id,
@@ -341,6 +371,8 @@ def run_workflow(
     session_id: str | None = None,
     dataset_handle: str | None = None,
     sample_path: str | None = None,
+    use_remote: bool = False,
+    endpoint: str | None = None,
 ) -> dict[str, Any]:
     """Run the canonical scientific workflow with persisted state and progress."""
     resolved_grid, resolved_data = _resolve_workflow_inputs(
@@ -356,6 +388,8 @@ def run_workflow(
             "data_path": resolved_data,
             "variable_name": variable_name,
             "sample_path": sample_path,
+            "use_remote": use_remote,
+            "endpoint": endpoint,
         },
         session_id=session_id,
         steps=[
@@ -379,7 +413,10 @@ def run_workflow(
             "session_id": session_id,
             "dataset_handle": dataset_handle,
             "sample_path": sample_path,
+            "use_remote": use_remote,
+            "endpoint": endpoint,
         },
+        venue=(f"hpc:{endpoint}" if use_remote and endpoint else "local"),
     )