feat: add support for lammps problem size validator

Signed-off-by: vsoch <vsoch@users.noreply.github.com>

Author: vsoch

resource_secretary/apps/__init__.py

@@ -11,6 +11,19 @@ def get_applications():
     return get_providers(root_path=path)
 
 
+def discover_applications():
+    """
+    Analogous to discover_providers, but add prefix. Leave out general.
+    """
+    apps = {}
+    for name, app in get_applications().items():
+        if name == "general":
+            continue
+        # This should prevent any potential namespace conflicts.
+        apps[f"app_{name}"] = app
+    return apps
+
+
 def get_application(name):
     """
     Finds an application by name and returns an instance.

resource_secretary/apps/app.py

@@ -1,5 +1,6 @@
 # Note that this base provides probe, etc.
 from dataclasses import dataclass
+from typing import Callable, Dict
 
 from resource_secretary.providers import get_providers
 from resource_secretary.providers.provider import BaseProvider
@@ -17,10 +18,10 @@ class PromptMatrix:
 class BaseApplication(BaseProvider):
     is_provider = True
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
         self.category = "application"
         self.default_workload = None
+        super().__init__(*args, **kwargs)
 
     def get_prompt_matrix(self, flatten=False, filters=None, **params) -> dict:
         """

resource_secretary/apps/molecular_dynamics/lammps.py

@@ -1,6 +1,9 @@
+import shlex
+from typing import Annotated, Any, Dict
+
 from resource_secretary.apps.app import BaseApplication
 from resource_secretary.apps.prompts import AppPromptGenerator
-from resource_secretary.providers import get_providers
+from resource_secretary.providers.provider import dispatch_tool
 
 LAMMPS_WORKLOADS = {
     "reaxff": {
@@ -45,12 +48,130 @@ class LammpsApplication(BaseApplication):
     def name(self):
         return "lammps"
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
+    def __init__(self):
+        super().__init__()
         self.workloads = LAMMPS_WORKLOADS
         self.modifiers = LAMMPS_MODIFIERS
+        self.tools = {}
         self.default_workload = "reaxff"
 
+    @dispatch_tool
+    def validate_lmp_problem_size(
+        self,
+        command: Annotated[str, "The full LAMMPS command string generated by the agent."],
+        expected_x: Annotated[
+            int, "The required replication size or grid count in the X dimension."
+        ],
+        expected_y: Annotated[
+            int, "The required replication size or grid count in the Y dimension."
+        ],
+        expected_z: Annotated[
+            int, "The required replication size or grid count in the Z dimension."
+        ],
+    ) -> Annotated[
+        Dict[str, Any], "A dictionary containing validation results and diagnostic messages."
+    ]:
+        """
+        Parses a generated LAMMPS command string to verify that the required scientific
+        problem size variables (X, Y, Z) are present and match the expected values.
+
+        Use case for Agent:
+        1. Pre-Submission Check: After generating a complex command, call this tool to ensure no vital variables were dropped.
+
+        Returns:
+            A dictionary with:
+            - is_valid (bool): True if all variables are present and match exactly.
+            - message (str): A human-readable description of what was found or missing.
+            - parsed_dimensions (Dict[str, float]): The values of x, y, and z parsed from the command.
+            - missing_dimensions (List[str]): List of missing required variables.
+            - mismatched_dimensions (List[str]): List of variables that were present but didn't match the expectation.
+        """
+        if not command:
+            return {
+                "is_valid": False,
+                "message": "Command string is empty.",
+                "parsed_dimensions": {},
+                "missing_dimensions": ["x", "y", "z"],
+                "mismatched_dimensions": [],
+            }
+
+        try:
+            tokens = shlex.split(command)
+        except Exception as e:
+            return {
+                "is_valid": False,
+                "message": f"Failed to parse command string tokens: {str(e)}",
+                "parsed_dimensions": {},
+                "missing_dimensions": [],
+                "mismatched_dimensions": [],
+            }
+
+        parsed_vars = {}
+        i = 0
+
+        # Scan through tokens to find LAMMPS variable setting patterns
+        while i < len(tokens):
+            token = tokens[i]
+
+            # Standard LAMMPS: -v x X OR -var x Y OR --variable x 32
+            if token in ("-v", "-var", "--variable") and i + 2 < len(tokens):
+                var_name = tokens[i + 1]
+                var_val = tokens[i + 2]
+                if var_name in ("x", "y", "z"):
+                    try:
+                        parsed_vars[var_name] = float(var_val)
+                    except ValueError:
+                        pass  # Handle non-numeric edge cases gracefully
+                i += 3
+
+            # Support direct flags if asked for: -x 32, -y 32, -z 32
+            elif token in ("-x", "-y", "-z") and i + 1 < len(tokens):
+                return {
+                    "is_valid": False,
+                    "message": f"Parameters for -x, -y, -z are not Valid. Should be -v x X -v y Y -v z Z",
+                    "parsed_dimensions": {},
+                    "missing_dimensions": [],
+                    "mismatched_dimensions": [],
+                }
+            else:
+                i += 1
+
+        # Compare parsed against expected
+        expected = {"x": float(expected_x), "y": float(expected_y), "z": float(expected_z)}
+        missing = []
+        mismatched = []
+
+        for dim, expected_val in expected.items():
+            if dim not in parsed_vars:
+                missing.append(dim)
+            elif parsed_vars[dim] != expected_val:
+                mismatched.append(dim)
+
+        # Compile the resulting status
+        if not missing and not mismatched:
+            return {
+                "is_valid": True,
+                "message": f"Perfect match! Command correctly contains x={expected_x}, y={expected_y}, z={expected_z}.",
+                "parsed_dimensions": parsed_vars,
+                "missing_dimensions": [],
+                "mismatched_dimensions": [],
+            }
+
+        # Build failure messaging
+        error_parts = []
+        if missing:
+            error_parts.append(f"Missing variable(s): {', '.join(missing)}")
+        if mismatched:
+            error_parts.append(f"Mismatched variable(s): {', '.join(mismatched)}")
+
+        return {
+            "is_valid": False,
+            "message": f"Validation failed. " + " | ".join(error_parts),
+            "parsed_dimensions": parsed_vars,
+            "missing_dimensions": missing,
+            "mismatched_dimensions": mismatched,
+        }
+
     def get_prompt_matrix(
         self, workload="reaxff", manager="flux", flatten=False, filters=None, count=None, **params
     ):

resource_secretary/providers/provider.py

@@ -78,7 +78,7 @@ class BaseProvider:
 
     is_provider = True
 
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
         self.tools: Dict[str, Callable] = {}
         self.category: str = "unknown"
 

resource_secretary/providers/workload/flux.py

@@ -249,14 +249,14 @@ def submit_job(
         import flux.job
 
         # Sets this wrong a lot
-        affinity_options = ["null", "None", "per-task"]
-        if gpu_affinity and isinstance(gpu_affinity, str) and gpu_affinity not in affinity_options:
+        affinity_options = ["per-task"]
+        if gpu_affinity is not None and gpu_affinity not in affinity_options:
             return {
                 "success": False,
                 "error": "gpu_affinity must be unset or set to per-task",
                 "job_id": None,
             }
-        if cpu_affinity and isinstance(cpu_affinity, str) and cpu_affinity not in affinity_options:
+        if cpu_affinity is not None and cpu_affinity not in affinity_options:
             return {
                 "success": False,
                 "error": "cpu_affinity must be unset or set to per-task",