Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,22 @@
+ARG BASE_IMAGE=ghcr.io/huggingface/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app/env
+COPY . /app/env
+
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+RUN --mount=type=cache,target=/root/.cache/uv uv sync --frozen --no-editable
+
+FROM ${BASE_IMAGE}
+WORKDIR /app/env
+COPY --from=builder /app/env /app/env
+ENV PATH="/app/env/.venv/bin:$PATH"
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+HEALTHCHECK --interval=30s --timeout=5s --start-period=30s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,10 +1,85 @@
 ---
-title: Reasoning Core Openenv
-emoji: 🏃
-colorFrom: indigo
-colorTo: green
+title: Reasoning Core Environment Server
+emoji: 🧠
+colorFrom: green
+colorTo: blue
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+  - agent-environment
+  - reasoning
+  - reinforcement-learning
+  - evaluation
+  - symbolic-reasoning
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Reasoning Core Environment
+
+An [OpenEnv](https://github.com/huggingface/openenv) environment for formally
+verifiable symbolic reasoning across logic, mathematics, planning, syntax, and
+related procedural domains.
+
+Tasks come from
+[`reasoning-core/formal-reasoning-env`](https://huggingface.co/datasets/reasoning-core/formal-reasoning-env)
+and are scored by the task-specific evaluators in
+[`reasoning-core`](https://github.com/sileod/reasoning_core).
+
+## Use The Hosted Environment
+
+```python
+from reasoning_core_env import ReasoningCoreAction, ReasoningCoreEnv
+
+with ReasoningCoreEnv(
+    base_url="https://sileod-reasoning-core-openenv.hf.space"
+) as env:
+    result = env.reset(split="train", seed=42, size=1000)
+    print(result.observation.prompt)
+
+    result = env.step(ReasoningCoreAction(answer="<answer>...</answer>"))
+    print(result.reward)
+```
+
+Each episode has one action:
+
+1. `reset()` returns a symbolic reasoning prompt.
+2. `step(ReasoningCoreAction(answer=...))` scores the answer and ends the episode.
+
+Plain answers and answers wrapped in `<answer>...</answer>` are accepted. Rewards
+are task-specific scores in the range 0 to 1.
+
+Set `RC_DISABLE_HF_DATASET=1` to skip Hub loading and generate tasks
+procedurally at runtime.
+
+## Local Development
+
+```bash
+uv sync
+uv run openenv validate
+uv run openenv build -t reasoning-core-openenv
+```
+
+Run without Docker:
+
+```bash
+uv run server
+```
+
+The service exposes the interactive UI at `/web`, API documentation at `/docs`,
+health information at `/health`, and the persistent environment API at `/ws`.
+
+## Citation
+
+If you use this environment, cite the Reasoning Core paper:
+
+```bibtex
+@article{reasoningcore2026,
+  title={Reasoning Core: A Scalable Procedural Data Generation Suite for Symbolic Pre-training and Post-Training},
+  author={Lacombe, Valentin and Quesnel, Valentin and Sileo, Damien},
+  journal={arXiv preprint arXiv:2603.02208},
+  year={2026},
+  url={https://arxiv.org/abs/2603.02208}
+}
+```

__init__.py

@@ -0,0 +1,10 @@
+"""Reasoning Core environment for OpenEnv."""
+
+from .client import ReasoningCoreEnv
+from .models import ReasoningCoreAction, ReasoningCoreObservation
+
+__all__ = [
+    "ReasoningCoreAction",
+    "ReasoningCoreEnv",
+    "ReasoningCoreObservation",
+]

client.py

@@ -0,0 +1,45 @@
+"""Client for the Reasoning Core OpenEnv server."""
+
+from typing import Any
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from .models import ReasoningCoreAction, ReasoningCoreObservation
+
+
+class ReasoningCoreEnv(
+    EnvClient[ReasoningCoreAction, ReasoningCoreObservation, State]
+):
+    """HTTP/WebSocket client for Reasoning Core."""
+
+    def _step_payload(self, action: ReasoningCoreAction) -> dict[str, Any]:
+        return {"answer": action.answer}
+
+    def _parse_result(
+        self,
+        payload: dict[str, Any],
+    ) -> StepResult[ReasoningCoreObservation]:
+        obs_data = payload.get("observation", {})
+        observation = ReasoningCoreObservation(
+            prompt=obs_data.get("prompt"),
+            score=obs_data.get("score"),
+            correct_answer=obs_data.get("correct_answer"),
+            task_name=obs_data.get("task_name"),
+            dataset_metadata=obs_data.get("dataset_metadata"),
+            done=payload.get("done", False),
+            reward=payload.get("reward"),
+            metadata=obs_data.get("metadata", {}),
+        )
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: dict[str, Any]) -> State:
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

models.py

@@ -0,0 +1,28 @@
+"""Action and observation models for the Reasoning Core environment."""
+
+from typing import Any
+
+from openenv.core.env_server.types import Action, Observation
+from pydantic import Field
+
+
+class ReasoningCoreAction(Action):
+    """Submit an answer to the current symbolic reasoning problem."""
+
+    answer: str = Field(..., description="The final answer to the current problem")
+
+
+class ReasoningCoreObservation(Observation):
+    """A symbolic reasoning problem or its scored result."""
+
+    prompt: str | None = Field(default=None, description="Problem to solve")
+    score: float | None = Field(default=None, description="Answer score from 0 to 1")
+    correct_answer: str | None = Field(
+        default=None,
+        description="Reference answer, revealed after submission",
+    )
+    task_name: str | None = Field(default=None, description="Reasoning task family")
+    dataset_metadata: dict[str, Any] | None = Field(
+        default=None,
+        description="Metadata associated with the dataset example",
+    )

openenv.yaml

@@ -0,0 +1,11 @@
+spec_version: 1
+name: reasoning_core
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+variables:
+  MAX_CONCURRENT_ENVS: "16"
+  RC_DATASET_SIZE: "1000"
+  RC_HF_DATASET: reasoning-core/formal-reasoning-env
+  RC_SEED: "42"

pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=75", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-reasoning-core"
+version = "0.1.0"
+description = "Formally verifiable symbolic reasoning tasks for OpenEnv"
+requires-python = ">=3.11"
+dependencies = [
+    "datasets>=3.0",
+    "easydict>=1.13",
+    "openenv[core]>=0.3.1",
+    "reasoning-core>=0.4.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[project.scripts]
+server = "reasoning_core_env.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["reasoning_core_env", "reasoning_core_env.server"]
+package-dir = { "reasoning_core_env" = ".", "reasoning_core_env.server" = "server" }

server/__init__.py

@@ -0,0 +1,5 @@
+"""Server components for the Reasoning Core environment."""
+
+from .reasoning_core_environment import ReasoningCoreEnvironment
+
+__all__ = ["ReasoningCoreEnvironment"]

server/app.py

@@ -0,0 +1,35 @@
+"""FastAPI application for the Reasoning Core environment."""
+
+import os
+
+from openenv.core.env_server.http_server import create_app
+
+try:
+    from ..models import ReasoningCoreAction, ReasoningCoreObservation
+    from .reasoning_core_environment import ReasoningCoreEnvironment
+except ImportError:
+    from models import ReasoningCoreAction, ReasoningCoreObservation
+    from server.reasoning_core_environment import ReasoningCoreEnvironment
+
+
+def create_reasoning_core_environment() -> ReasoningCoreEnvironment:
+    return ReasoningCoreEnvironment()
+
+
+app = create_app(
+    create_reasoning_core_environment,
+    ReasoningCoreAction,
+    ReasoningCoreObservation,
+    env_name="reasoning_core",
+    max_concurrent_envs=int(os.getenv("MAX_CONCURRENT_ENVS", "16")),
+)
+
+
+def main(host: str = "0.0.0.0", port: int = 8000) -> None:
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

server/reasoning_core_environment.py

@@ -0,0 +1,210 @@
+"""Single-step OpenEnv environment backed by reasoning-core scorers."""
+
+from __future__ import annotations
+
+import json
+import os
+import random
+import re
+from itertools import islice
+from typing import Any
+from uuid import uuid4
+
+import numpy as np
+from easydict import EasyDict as edict
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+from reasoning_core import get_task, list_tasks, score_answer
+
+try:
+    from ..models import ReasoningCoreAction, ReasoningCoreObservation
+except ImportError:
+    from models import ReasoningCoreAction, ReasoningCoreObservation
+
+
+DEFAULT_DATASET = os.getenv(
+    "RC_HF_DATASET",
+    "reasoning-core/formal-reasoning-env",
+)
+DEFAULT_SIZE = int(os.getenv("RC_DATASET_SIZE", "1000"))
+DEFAULT_SEED = int(os.getenv("RC_SEED", "42"))
+DISABLE_HF_DATASET = os.getenv("RC_DISABLE_HF_DATASET", "").lower() in {
+    "1",
+    "true",
+    "yes",
+}
+XML_ANSWER_PATTERN = re.compile(
+    r"<answer>(.*?)</answer>",
+    flags=re.IGNORECASE | re.DOTALL,
+)
+
+
+def _metadata_dict(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str) and value.strip():
+        try:
+            parsed = json.loads(value)
+        except json.JSONDecodeError:
+            return {"raw_metadata": value}
+        return parsed if isinstance(parsed, dict) else {}
+    return {}
+
+
+def _task_name(entry: dict[str, Any]) -> str | None:
+    metadata = _metadata_dict(entry.get("metadata"))
+    value = metadata.get("_task") or entry.get("task") or metadata.get("task")
+    return str(value) if value is not None else None
+
+
+def _normalize_entry(entry: dict[str, Any], index: int) -> dict[str, Any] | None:
+    task_name = _task_name(entry)
+    if task_name not in set(list_tasks()):
+        return None
+    return {
+        "id": str(entry.get("id", index)),
+        "prompt": str(entry["prompt"]),
+        "answer": str(entry["answer"]),
+        "metadata": {"task": task_name, **_metadata_dict(entry.get("metadata"))},
+    }
+
+
+def _load_hub_entries(
+    dataset_name: str,
+    split: str,
+    seed: int,
+    size: int,
+) -> list[dict[str, Any]]:
+    from datasets import get_dataset_split_names, load_dataset
+
+    split_names = get_dataset_split_names(dataset_name)
+    source_split = split
+    if source_split not in split_names:
+        source_split = next(
+            (name for name in ("test", "validation", "eval", "dev") if name in split_names),
+            "train",
+        )
+
+    stream = load_dataset(dataset_name, split=source_split, streaming=True)
+    stream = stream.shuffle(seed=seed, buffer_size=max(size * 4, 1000))
+    entries: list[dict[str, Any]] = []
+    for index, row in enumerate(islice(stream, size * 4)):
+        normalized = _normalize_entry(dict(row), index)
+        if normalized is not None:
+            entries.append(normalized)
+        if len(entries) >= size:
+            break
+    if not entries:
+        raise RuntimeError(f"No supported tasks found in {dataset_name}:{source_split}")
+    return entries
+
+
+def _generate_entries(seed: int, size: int) -> list[dict[str, Any]]:
+    task_names = sorted(list_tasks())
+    entries: list[dict[str, Any]] = []
+    for index in range(size):
+        random.seed(seed + index)
+        np.random.seed(seed + index)
+        task_name = task_names[index % len(task_names)]
+        example = get_task(task_name).generate_example()
+        entries.append(
+            {
+                "id": f"{task_name}-{index}",
+                "prompt": str(example.prompt),
+                "answer": str(example.answer),
+                "metadata": {"task": task_name, **dict(example.metadata)},
+            }
+        )
+    return entries
+
+
+def _extract_answer(answer: str) -> str:
+    match = XML_ANSWER_PATTERN.search(answer)
+    return match.group(1).strip() if match else answer.strip()
+
+
+class ReasoningCoreEnvironment(Environment):
+    """Formally scored symbolic reasoning tasks from reasoning-core."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._entries: list[dict[str, Any]] = []
+        self._entry_index = 0
+        self._current_entry: dict[str, Any] | None = None
+        self._configuration: tuple[str, str, int, int] | None = None
+
+    def _configure(
+        self,
+        dataset_name: str,
+        split: str,
+        seed: int,
+        size: int,
+    ) -> None:
+        configuration = (dataset_name, split, seed, size)
+        if configuration == self._configuration:
+            return
+        if DISABLE_HF_DATASET:
+            self._entries = _generate_entries(seed, size)
+            self._configuration = configuration
+            self._entry_index = 0
+            return
+        try:
+            self._entries = _load_hub_entries(dataset_name, split, seed, size)
+        except Exception as exc:
+            print(f"Dataset loading failed ({exc}); using procedural tasks.")
+            self._entries = _generate_entries(seed, size)
+        self._configuration = configuration
+        self._entry_index = 0
+
+    def reset(
+        self,
+        dataset_name: str = DEFAULT_DATASET,
+        split: str = "train",
+        seed: int = DEFAULT_SEED,
+        size: int = DEFAULT_SIZE,
+        episode_id: str | None = None,
+    ) -> ReasoningCoreObservation:
+        if size <= 0:
+            raise ValueError("size must be positive")
+        self._configure(dataset_name, split, seed, size)
+        self._current_entry = self._entries[self._entry_index % len(self._entries)]
+        self._entry_index += 1
+        self._state = State(
+            episode_id=episode_id or str(uuid4()),
+            step_count=0,
+        )
+        return ReasoningCoreObservation(
+            prompt=self._current_entry["prompt"],
+            score=None,
+            correct_answer=None,
+            task_name=_task_name(self._current_entry),
+            dataset_metadata=None,
+            done=False,
+            reward=0.0,
+        )
+
+    def step(self, action: ReasoningCoreAction) -> ReasoningCoreObservation:
+        self._state.step_count += 1
+        if self._current_entry is None:
+            raise RuntimeError("Call reset() before step().")
+
+        entry = edict(
+            answer=self._current_entry["answer"],
+            metadata=self._current_entry["metadata"],
+        )
+        score = float(score_answer(_extract_answer(action.answer), entry))
+        return ReasoningCoreObservation(
+            prompt=None,
+            score=score,
+            correct_answer=self._current_entry["answer"],
+            task_name=_task_name(self._current_entry),
+            dataset_metadata=self._current_entry["metadata"],
+            done=True,
+            reward=score,
+        )
+
+    @property
+    def state(self) -> State:
+        return self._state