Sync physix/ to merged tree (post train/ merge, pre 4ep/500step run)

physix/client.py

@@ -41,3 +41,11 @@ class PhysiXEnv(EnvClient[PhysiXAction, PhysiXObservation, PhysiXState]):
 
     def _parse_state(self, payload: dict[str, Any]) -> PhysiXState:
         return PhysiXState(**payload)
+
+
+# Alias for OpenEnv auto-discovery: the convention Pascal-cases the
+# manifest `name` field ("physix" -> "Physix"), so AutoEnv looks up
+# `physix.client.PhysixEnv`. The actual class is `PhysiXEnv` (capital
+# X in the brand). This alias makes both lookups succeed without
+# duplicating the implementation.
+PhysixEnv = PhysiXEnv

physix/server/interactive.py

@@ -6,7 +6,6 @@ import logging
 import threading
 import time
 import uuid
-from collections.abc import Callable
 from typing import Optional
 
 import numpy as np
@@ -19,12 +18,30 @@ from physix.models import (
     PhysiXObservation,
 )
 from physix.server.environment import PhysiXEnvironment
+from physix.server.providers import (
+    LlmModelInfo,
+    LlmModelsLister,
+    LlmModelsResponse,
+    LlmPolicyFactory,
+    LlmStepRequest,
+    default_ollama_models_lister,
+    default_openai_compat_policy_factory,
+)
 from physix.systems import list_supported_systems, list_systems
 from physix.systems.base import PhysicalSystem, TrajectoryData
 from physix.training.prompt import build_prompt, parse_completion
 from physix.verifier.parser import parse_equation
 from physix.verifier.simulator import simulate_hypothesis
 
+__all__ = [
+    "InteractiveSessionStore",
+    "LlmModelInfo",
+    "LlmModelsResponse",
+    "LlmStepRequest",
+    "LlmStepResponse",
+    "build_interactive_router",
+]
+
 
 _log = logging.getLogger(__name__)
 
@@ -54,33 +71,6 @@ class InteractiveStartResponse(BaseModel):
     max_turns: int
 
 
-class LlmStepRequest(BaseModel):
-    """Server-side LLM call. Browser names a model tag; server hits Ollama."""
-
-    model_config = ConfigDict(extra="forbid")
-
-    model: str = "qwen2.5:1.5b-instruct"
-    temperature: float = Field(default=0.4, ge=0.0, le=2.0)
-    max_tokens: int = Field(default=2048, ge=64, le=8192)
-    host: Optional[str] = None
-
-
-class LlmModelInfo(BaseModel):
-    """A single locally-pulled Ollama model tag."""
-
-    model_config = ConfigDict(frozen=True)
-
-    name: str
-    size_bytes: Optional[int] = None
-    parameter_size: Optional[str] = None
-    family: Optional[str] = None
-
-
-class LlmModelsResponse(BaseModel):
-    models: list[LlmModelInfo] = Field(default_factory=list)
-    error: Optional[str] = None
-
-
 class LlmStepResponse(BaseModel):
     observation: PhysiXObservation
     predicted_trajectory: list[dict[str, float]] = Field(default_factory=list)
@@ -147,118 +137,10 @@ class InteractiveSessionStore:
             return len(self._sessions)
 
 
-LlmPolicy = Callable[[list[dict[str, str]]], str]
-LlmPolicyFactory = Callable[[LlmStepRequest], LlmPolicy]
-LlmModelsLister = Callable[[], LlmModelsResponse]
-
-
-def default_ollama_models_lister() -> LlmModelsResponse:
-    try:
-        import ollama  # type: ignore[import-not-found]
-    except ImportError:
-        return LlmModelsResponse(
-            models=[],
-            error=(
-                "The 'ollama' Python package is not installed on the server. "
-                "Install with: pip install -e '.[demo]'"
-            ),
-        )
-
-    try:
-        response = ollama.Client().list()
-    except Exception as exc:  # noqa: BLE001 — surfaced in the response body
-        return LlmModelsResponse(
-            models=[],
-            error=(
-                f"Could not reach the local Ollama daemon ({exc}). "
-                "Is 'ollama serve' running?"
-            ),
-        )
-
-    raw_models = getattr(response, "models", None)
-    if raw_models is None and isinstance(response, dict):
-        raw_models = response.get("models", [])
-    raw_models = raw_models or []
-
-    out: list[LlmModelInfo] = []
-    for entry in raw_models:
-        name = _model_attr(entry, "model") or _model_attr(entry, "name")
-        if not isinstance(name, str) or not name:
-            continue
-        details = _model_attr(entry, "details")
-        out.append(
-            LlmModelInfo(
-                name=name,
-                size_bytes=_coerce_int(_model_attr(entry, "size")),
-                parameter_size=_model_attr(details, "parameter_size"),
-                family=_model_attr(details, "family"),
-            )
-        )
-
-    out.sort(key=lambda m: m.name)
-    return LlmModelsResponse(models=out)
-
-
-def _model_attr(obj: object, key: str) -> object:
-    if obj is None:
-        return None
-    if isinstance(obj, dict):
-        return obj.get(key)
-    return getattr(obj, key, None)
-
-
-def _coerce_int(value: object) -> Optional[int]:
-    if value is None:
-        return None
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return None
-
-
-def default_ollama_policy_factory(request: LlmStepRequest) -> LlmPolicy:
-    try:
-        import ollama  # type: ignore[import-not-found]
-    except ImportError as exc:  # pragma: no cover
-        raise HTTPException(
-            status_code=503,
-            detail=(
-                "The 'ollama' Python package is not installed on the server. "
-                "Install with: pip install -e '.[demo]'"
-            ),
-        ) from exc
-
-    client = ollama.Client(host=request.host) if request.host else ollama.Client()
-
-    def _policy(prompt: list[dict[str, str]]) -> str:
-        try:
-            response = client.chat(
-                model=request.model,
-                messages=prompt,
-                format="json",
-                options={
-                    "temperature": request.temperature,
-                    "num_predict": request.max_tokens,
-                },
-            )
-        except Exception as exc:  # noqa: BLE001 — surfaced as 502
-            raise HTTPException(
-                status_code=502,
-                detail=(
-                    f"Ollama call failed for model {request.model!r}: {exc}. "
-                    "Is 'ollama serve' running and the model pulled "
-                    f"('ollama pull {request.model}')?"
-                ),
-            ) from exc
-        return str(response["message"]["content"])
-
-    return _policy
-
-
 def build_interactive_router(
     store: Optional[InteractiveSessionStore] = None,
     *,
-    policy_factory: LlmPolicyFactory = default_ollama_policy_factory,
+    policy_factory: LlmPolicyFactory = default_openai_compat_policy_factory,
     models_lister: LlmModelsLister = default_ollama_models_lister,
 ) -> APIRouter:
     sessions = store if store is not None else InteractiveSessionStore()

physix/server/providers.py

@@ -0,0 +1,280 @@
+"""LLM provider abstraction for the interactive demo.
+
+The demo points at any OpenAI-compatible ``/v1/chat/completions`` endpoint:
+local Ollama, Hugging Face's Inference Providers router, OpenAI itself,
+vLLM, OpenRouter, etc. Everything funnels through one factory so the UI
+only has to learn one shape.
+
+The browser passes ``base_url``, ``model``, and (optionally) ``api_key``
+on every request. If ``api_key`` is missing we fall back to a per-provider
+env var so a Hugging Face Space can ship a default working config without
+hard-coding secrets in client bundles.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Callable
+from typing import Optional
+
+from fastapi import HTTPException
+from pydantic import BaseModel, ConfigDict, Field
+
+_log = logging.getLogger(__name__)
+
+
+# Public preset URLs. Mirror these in the frontend connection panel so the
+# two stay in sync; the values themselves only matter when the browser
+# hands one back to us in `LlmStepRequest.base_url`.
+HF_ROUTER_BASE_URL = "https://router.huggingface.co/v1"
+OPENAI_BASE_URL = "https://api.openai.com/v1"
+OLLAMA_OPENAI_BASE_URL = "http://localhost:11434/v1"
+
+
+class LlmStepRequest(BaseModel):
+    """Provider-agnostic step payload.
+
+    The browser names a base URL + model + (optional) key. The server
+    fans these into an ``openai.OpenAI`` client. ``base_url`` is required
+    so we never silently default to the wrong endpoint when the user
+    swaps providers mid-session.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    base_url: str = Field(
+        description=(
+            "OpenAI-compatible /v1 base URL. E.g. http://localhost:11434/v1, "
+            "https://router.huggingface.co/v1, https://api.openai.com/v1."
+        ),
+    )
+    model: str = Field(
+        description=(
+            "Model id understood by the chosen base URL. For HF this is the "
+            "repo id (optionally suffixed with :provider, e.g. ':fastest'); "
+            "for Ollama it's the local tag; for OpenAI it's the model name."
+        ),
+    )
+    api_key: Optional[str] = Field(
+        default=None,
+        description=(
+            "Bearer token forwarded as Authorization header. Falls back to "
+            "HF_TOKEN / OPENAI_API_KEY / OLLAMA_API_KEY env vars on the "
+            "server based on `base_url` if omitted."
+        ),
+    )
+    temperature: float = Field(default=0.4, ge=0.0, le=2.0)
+    max_tokens: int = Field(default=2048, ge=64, le=8192)
+    request_timeout_s: float = Field(default=120.0, ge=5.0, le=600.0)
+
+
+# A policy is "give me prompt messages, get back the assistant content".
+LlmPolicy = Callable[[list[dict[str, str]]], str]
+LlmPolicyFactory = Callable[[LlmStepRequest], LlmPolicy]
+
+
+def resolve_api_key(request: LlmStepRequest) -> Optional[str]:
+    """Pick the bearer token to use for this request.
+
+    Browser-supplied keys win. When the browser sends nothing we fall
+    back to a server-side env var picked from the URL — this lets a
+    public Hugging Face Space ship a usable default by setting
+    ``HF_TOKEN`` as a Space secret while still letting power users
+    bring their own.
+    """
+
+    if request.api_key:
+        return request.api_key
+
+    base_url = (request.base_url or "").lower()
+    if "huggingface" in base_url:
+        return os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_API_KEY")
+    if "openai.com" in base_url:
+        return os.environ.get("OPENAI_API_KEY")
+    if "openrouter" in base_url:
+        return os.environ.get("OPENROUTER_API_KEY")
+    if "localhost" in base_url or "127.0.0.1" in base_url:
+        # Ollama doesn't require a key; the SDK still wants something
+        # truthy in some versions, so we hand it a placeholder.
+        return os.environ.get("OLLAMA_API_KEY", "ollama")
+    return None
+
+
+def default_openai_compat_policy_factory(request: LlmStepRequest) -> LlmPolicy:
+    """Build a chat policy backed by any OpenAI-compatible endpoint.
+
+    Used by the interactive router for every demo turn. Failures bubble
+    up as ``HTTPException(502)`` so the UI can surface a clear "your
+    provider is unhappy" banner instead of a stack trace.
+    """
+
+    try:
+        from openai import OpenAI  # type: ignore[import-not-found]
+    except ImportError as exc:  # pragma: no cover
+        raise HTTPException(
+            status_code=503,
+            detail=(
+                "The 'openai' Python package is not installed on the server. "
+                "Install with: pip install -e '.[demo]'"
+            ),
+        ) from exc
+
+    api_key = resolve_api_key(request)
+    client = OpenAI(
+        base_url=request.base_url,
+        api_key=api_key or "missing",
+        timeout=request.request_timeout_s,
+    )
+
+    def _policy(prompt: list[dict[str, str]]) -> str:
+        try:
+            response = client.chat.completions.create(
+                model=request.model,
+                messages=prompt,  # type: ignore[arg-type]
+                temperature=request.temperature,
+                max_tokens=request.max_tokens,
+                # Encourages JSON output where supported (OpenAI, vLLM,
+                # Ollama-OpenAI). HF router silently ignores this on
+                # providers that don't support it, which is fine — our
+                # parser tolerates Markdown-fenced JSON too.
+                response_format={"type": "json_object"},
+            )
+        except TypeError:
+            # Some providers reject `response_format`; retry without it.
+            response = client.chat.completions.create(
+                model=request.model,
+                messages=prompt,  # type: ignore[arg-type]
+                temperature=request.temperature,
+                max_tokens=request.max_tokens,
+            )
+        except Exception as exc:  # noqa: BLE001 — surfaced to the UI
+            raise HTTPException(
+                status_code=502,
+                detail=_format_provider_error(request, exc),
+            ) from exc
+
+        choice = response.choices[0] if response.choices else None
+        content = (choice.message.content if choice and choice.message else "") or ""
+        return str(content)
+
+    return _policy
+
+
+def _format_provider_error(request: LlmStepRequest, exc: Exception) -> str:
+    """Make the most common failure modes self-diagnosing in the UI."""
+
+    base_msg = f"Chat completion failed via {request.base_url} for model {request.model!r}: {exc}"
+    text = str(exc).lower()
+    if "401" in text or "unauthorized" in text or "invalid api key" in text:
+        return (
+            f"{base_msg}\n\n"
+            "Hint: the API key is missing or rejected. Open the connection "
+            "panel and paste a valid token, or set the matching env var on "
+            "the server (HF_TOKEN, OPENAI_API_KEY, etc.)."
+        )
+    if "404" in text or "not found" in text or "no such model" in text:
+        return (
+            f"{base_msg}\n\n"
+            "Hint: the chosen model isn't reachable through this endpoint. "
+            "For Hugging Face, verify the repo id is public and that "
+            "Inference Providers is enabled for it. For Ollama, run "
+            f"'ollama pull {request.model}'."
+        )
+    if "connection" in text or "refused" in text or "timeout" in text:
+        return (
+            f"{base_msg}\n\n"
+            "Hint: the endpoint isn't reachable. For Ollama, make sure "
+            "'ollama serve' is running on the host you pointed at."
+        )
+    return base_msg
+
+
+# -----------------------------------------------------------------------
+# Ollama-only model lister (kept for the local-dev convenience dropdown).
+# -----------------------------------------------------------------------
+
+
+class LlmModelInfo(BaseModel):
+    """A single locally-pulled Ollama model tag."""
+
+    model_config = ConfigDict(frozen=True)
+
+    name: str
+    size_bytes: Optional[int] = None
+    parameter_size: Optional[str] = None
+    family: Optional[str] = None
+
+
+class LlmModelsResponse(BaseModel):
+    models: list[LlmModelInfo] = Field(default_factory=list)
+    error: Optional[str] = None
+
+
+LlmModelsLister = Callable[[], LlmModelsResponse]
+
+
+def default_ollama_models_lister() -> LlmModelsResponse:
+    """Enumerate locally-pulled Ollama tags. Best-effort."""
+
+    try:
+        import ollama  # type: ignore[import-not-found]
+    except ImportError:
+        return LlmModelsResponse(
+            models=[],
+            error=(
+                "The 'ollama' Python package is not installed on the server. "
+                "Install with: pip install -e '.[demo]'"
+            ),
+        )
+
+    try:
+        response = ollama.Client().list()
+    except Exception as exc:  # noqa: BLE001 — surfaced in the response body
+        return LlmModelsResponse(
+            models=[],
+            error=(
+                f"Could not reach the local Ollama daemon ({exc}). "
+                "Is 'ollama serve' running?"
+            ),
+        )
+
+    raw_models = getattr(response, "models", None)
+    if raw_models is None and isinstance(response, dict):
+        raw_models = response.get("models", [])
+    raw_models = raw_models or []
+
+    out: list[LlmModelInfo] = []
+    for entry in raw_models:
+        name = _model_attr(entry, "model") or _model_attr(entry, "name")
+        if not isinstance(name, str) or not name:
+            continue
+        details = _model_attr(entry, "details")
+        out.append(
+            LlmModelInfo(
+                name=name,
+                size_bytes=_coerce_int(_model_attr(entry, "size")),
+                parameter_size=_model_attr(details, "parameter_size"),
+                family=_model_attr(details, "family"),
+            )
+        )
+
+    out.sort(key=lambda m: m.name)
+    return LlmModelsResponse(models=out)
+
+
+def _model_attr(obj: object, key: str) -> object:
+    if obj is None:
+        return None
+    if isinstance(obj, dict):
+        return obj.get(key)
+    return getattr(obj, key, None)
+
+
+def _coerce_int(value: object) -> Optional[int]:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None

physix/training/dataset.py

@@ -7,7 +7,7 @@ whose rows contain everything the training loop needs:
 - ``prompt``: the chat-format string passed to the model
 - ``system_id``, ``state_variables``, ``parameters``, ``initial_conditions``,
   ``timestamps``, ``observed``: the system context the scorer needs
-- ``previous_total``: 0.0 at turn-0 (we train on first-turn prompts; the
+- ``previous_r_match``: 0.0 at turn-0 (we train on first-turn prompts; the
   iterative refinement skill emerges from the model's general ability to
   read history at inference time)
 

physix/training/reward_fns.py

@@ -42,11 +42,6 @@ from physix.verifier.reward import correctness_bonus, match_dense
 RewardFunction = Callable[..., list[float]]
 
 
-#: Components that read directly from the :class:`RewardBreakdown` produced
-#: by :class:`Scorer.score`. ``progress`` is omitted (see module docstring).
-_BREAKDOWN_COMPONENTS: tuple[str, ...] = ("match", "simplicity", "format")
-
-
 def make_reward_funcs(
     scorer: Scorer | None = None,
 ) -> dict[str, RewardFunction]:
@@ -56,10 +51,13 @@ def make_reward_funcs(
     logs them individually to W&B under
     ``train/rewards/reward_<component>/mean``.
 
-    The scorer is shared across all functions; calling ``scorer.reset()``
-    between steps avoids unbounded cache growth and ensures each
-    completion is parsed + simulated exactly once per step regardless of
-    how many reward functions query it.
+    The scorer is shared across all functions. TRL calls reward functions
+    one-by-one for the same batch (same ``completions`` list, same indices).
+    The ``match`` function resets the cache and populates it; the
+    remaining functions (``match_dense``, ``correctness``, ``simplicity``,
+    ``format``) reuse the cached results via ``cache_key=i``. This means
+    each completion is parsed + simulated exactly once per step regardless
+    of how many reward functions query it.
 
     Returns a dict whose keys are:
 
@@ -74,14 +72,15 @@ def make_reward_funcs(
     """
     shared = scorer if scorer is not None else Scorer()
 
-    def _make_breakdown_reader(component: str) -> RewardFunction:
+    def _make_breakdown_reader(component: str, *, reset_cache: bool) -> RewardFunction:
         def _reward_fn(
             prompts: Sequence[Any],
             completions: Sequence[str],
             **kwargs: Any,
         ) -> list[float]:
             del prompts  # kept for TRL API conformance; unused here.
-            shared.reset()
+            if reset_cache:
+                shared.reset()
             contexts = _hydrate_contexts(len(completions), kwargs)
             out: list[float] = []
             for i, completion in enumerate(completions):
@@ -102,7 +101,6 @@ def make_reward_funcs(
         **kwargs: Any,
     ) -> list[float]:
         del prompts
-        shared.reset()
         contexts = _hydrate_contexts(len(completions), kwargs)
         out: list[float] = []
         for i, completion in enumerate(completions):
@@ -118,7 +116,6 @@ def make_reward_funcs(
         **kwargs: Any,
     ) -> list[float]:
         del prompts
-        shared.reset()
         contexts = _hydrate_contexts(len(completions), kwargs)
         out: list[float] = []
         for i, completion in enumerate(completions):
@@ -128,8 +125,12 @@ def make_reward_funcs(
 
     _reward_correctness.__name__ = "reward_correctness"
 
+    # ``match`` is always the first function TRL calls; it resets the cache
+    # so subsequent functions get fresh results for this step's completions.
     funcs: dict[str, RewardFunction] = {
-        name: _make_breakdown_reader(name) for name in _BREAKDOWN_COMPONENTS
+        "match": _make_breakdown_reader("match", reset_cache=True),
+        "simplicity": _make_breakdown_reader("simplicity", reset_cache=False),
+        "format": _make_breakdown_reader("format", reset_cache=False),
     }
     funcs["match_dense"] = _reward_match_dense
     funcs["correctness"] = _reward_correctness

physix/training/scorer.py

@@ -92,7 +92,7 @@ class SystemContext(BaseModel):
             initial_conditions=_drop_none(row.get("initial_conditions", {})),
             timestamps=np.asarray(row.get("timestamps", []), dtype=float),
             observed=observed,
-            previous_r_match=float(row.get("previous_r_match", row.get("previous_total", 0.0))),
+            previous_r_match=float(row.get("previous_r_match", 0.0)),
         )
 
 

physix/training/sft.py

@@ -153,7 +153,7 @@ def train_sft(
 
     # Heavy imports: only available in [train] env.
     import wandb
-    from unsloth import FastLanguageModel, PatchFastRL  # noqa: F401
+    from unsloth import FastLanguageModel
     from trl import SFTTrainer, SFTConfig
 
     # Force a fresh W&B run for SFT regardless of any inherited WANDB_RUN_ID