Upload folder using huggingface_hub

__init__.py

@@ -5,13 +5,14 @@ the OpenCode CLI agent against a caller-supplied LLM endpoint, runs the
 caller-supplied verifier script, and returns reward + proxy trace +
 workdir contents as a JSON-serialized :class:`RolloutResult`.
 
-Import either the :class:`OpenCodeEnv` HTTP client (for training scripts
-talking to a deployed server) or the models (for type-safe parsing of
-rollout results).
+The directory name (``openenv``) matches the installed ``openenv-core``
+namespace package, so we use lazy ``__getattr__`` resolution to avoid
+eager imports that would collide with the installed package when this
+folder is on ``sys.path`` (pytest rootdir, etc.).
 """
 
-from .client import OpenCodeEnv
-from .models import OpenCodeState, RolloutResult, RolloutTurn
+from __future__ import annotations
+
 
 __all__ = [
     "OpenCodeEnv",
@@ -19,3 +20,15 @@ __all__ = [
     "RolloutResult",
     "RolloutTurn",
 ]
+
+
+def __getattr__(name):
+    if name == "OpenCodeEnv":
+        from .client import OpenCodeEnv
+
+        return OpenCodeEnv
+    if name in ("OpenCodeState", "RolloutResult", "RolloutTurn"):
+        from . import models
+
+        return getattr(models, name)
+    raise AttributeError(f"module 'opencode_env_server' has no attribute {name!r}")

models.py

@@ -54,6 +54,12 @@ class RolloutResult(BaseModel):
     # Errors (if any) surfacing from sandbox/proxy/verifier path
     error: str | None = None
 
+    # Diagnostic tails — populated when the primitive or verifier misbehaves so
+    # the client can see WHAT happened inside the sandbox without a second
+    # round-trip. Each is truncated to a few KB.
+    proxy_log_tail: str = ""
+    install_log_tail: str = ""
+
 
 class OpenCodeState(State):
     """Persistent env state across calls to the single environment instance.

opencode_openenv.egg-info/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: opencode-openenv
 Version: 0.1.0
-Summary: OpenEnv OpenCode environment — spawns an E2B sandbox per rollout, runs OpenCode against a caller-supplied LLM endpoint, returns reward + proxy trace.
+Summary: OpenEnv environment running the OpenCode coding agent inside an E2B sandbox, returning reward and per-turn trace.
 Author-email: adithya-s-k <adithyaskolavi@gmail.com>
 Requires-Python: >=3.10
-Requires-Dist: openenv-core[core] @ git+https://github.com/adithya-s-k/OpenEnv.git@opencode-harness
-Requires-Dist: openenv-opencode_env @ git+https://github.com/adithya-s-k/OpenEnv.git@opencode-harness#subdirectory=envs/opencode_env
+Requires-Dist: openenv-core[core] @ file:///fsx/adithyaskolavi/projects/exp_rl/OpenEnv
+Requires-Dist: openenv-opencode_env @ file:///fsx/adithyaskolavi/projects/exp_rl/OpenEnv/envs/opencode_env
 Requires-Dist: fastmcp>=3.0.0
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: uvicorn>=0.24.0

opencode_openenv.egg-info/SOURCES.txt

@@ -18,4 +18,5 @@ server/__init__.py
 server/app.py
 server/gradio_ui.py
 server/opencode_environment.py
-server/requirements.txt
+server/requirements.txt
+tests/test_client.py

opencode_openenv.egg-info/requires.txt

@@ -1,5 +1,5 @@
-openenv-core[core] @ git+https://github.com/adithya-s-k/OpenEnv.git@opencode-harness
-openenv-opencode_env @ git+https://github.com/adithya-s-k/OpenEnv.git@opencode-harness#subdirectory=envs/opencode_env
+openenv-core[core] @ file:///fsx/adithyaskolavi/projects/exp_rl/OpenEnv
+openenv-opencode_env @ file:///fsx/adithyaskolavi/projects/exp_rl/OpenEnv/envs/opencode_env
 fastmcp>=3.0.0
 fastapi>=0.115.0
 uvicorn>=0.24.0

pyproject.toml

@@ -11,9 +11,8 @@ authors = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-    # NOTE: openenv-core must come from the same branch as the primitive —
-    # the ``openenv.core.harness`` module doesn't exist on PyPI yet (it lives
-    # on PR #471 and our opencode-harness branch stacked on top of it).
+    # Pull both from the same branch so ``openenv.core.harness`` (only on
+    # PR #471's stack) is available alongside the primitive.
     "openenv-core[core] @ git+https://github.com/adithya-s-k/OpenEnv.git@opencode-harness",
     "openenv-opencode_env @ git+https://github.com/adithya-s-k/OpenEnv.git@opencode-harness#subdirectory=envs/opencode_env",
     "fastmcp>=3.0.0",

server/opencode_environment.py

@@ -33,6 +33,14 @@ from openenv.core.env_server.types import Action, Observation
 load_dotenv()
 
 
+# One rollout (sandbox create + opencode install + opencode run + verifier)
+# typically takes 30-180s and can spike to 600s under load. Override
+# OpenEnv's 30s MCP tool-call default so the server doesn't cut our tool
+# off mid-flight. This default still defers to an explicit ``timeout_s``
+# on the StepRequest when the client specifies one.
+_RUN_ROLLOUT_TIMEOUT_S = 900.0
+
+
 # Default test-script and reward paths inside the sandbox. The server writes
 # the caller-supplied ``test_script`` text to this path; the verifier reads
 # the reward file back out after it finishes.
@@ -180,6 +188,27 @@ class OpenCodeEnvironment(MCPEnvironment):
             },
         )
 
+    def step(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> Observation:
+        """Override the MCP 30s default with a rollout-friendly budget."""
+        if timeout_s is None:
+            timeout_s = _RUN_ROLLOUT_TIMEOUT_S
+        return super().step(action, timeout_s=timeout_s, **kwargs)
+
+    async def step_async(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> Observation:
+        if timeout_s is None:
+            timeout_s = _RUN_ROLLOUT_TIMEOUT_S
+        return await super().step_async(action, timeout_s=timeout_s, **kwargs)
+
     @property
     def state(self) -> Any:
         return self._state
@@ -270,8 +299,20 @@ class OpenCodeEnvironment(MCPEnvironment):
             }
             for raw in summary.proxy_turns:
                 result.proxy_turns.append(self._turn_cls(**_clamp_turn(raw)))
+
+            # Diagnostic capture — always try to grab the in-sandbox proxy log.
+            # Useful when productive_turns=0 or opencode exits abnormally.
+            result.proxy_log_tail = _read_safe(
+                session.sandbox, "/home/user/logs/agent/proxy.log", tail_chars=4000
+            )
         except Exception as exc:
             result.error = f"{type(exc).__name__}: {exc}"
+            # Even on failure, try to pull the proxy log if the sandbox still
+            # exists — it often contains the actual upstream HTTP error.
+            if session is not None:
+                result.proxy_log_tail = _read_safe(
+                    session.sandbox, "/home/user/logs/agent/proxy.log", tail_chars=4000
+                )
         finally:
             if session is not None:
                 try:
@@ -294,12 +335,17 @@ class OpenCodeEnvironment(MCPEnvironment):
 
 
 def _qualify_model(provider: str, model: str) -> str:
-    """Return a ``<provider>/<model>`` string acceptable to the primitive.
+    """Return a ``<provider>/<model>`` string the primitive can split cleanly.
 
-    If the caller already prefixed the model, leave it alone; otherwise
-    prepend the provider so OpenCode's config file is well-formed.
+    The primitive splits ``config.model`` on the first ``/`` to recover the
+    upstream model id. If the caller passes a model that already contains a
+    slash (e.g. ``Qwen/Qwen3.5-4B``), we still prepend the provider so the
+    split separates provider from model and the model part round-trips
+    intact (``openai_compatible/Qwen/Qwen3.5-4B`` → upstream ``Qwen/Qwen3.5-4B``).
     """
-    if "/" in model:
+    # Strip an existing <provider>/ prefix only if it matches the configured
+    # provider verbatim — otherwise treat the whole string as the model id.
+    if model.startswith(provider + "/"):
         return model
     return f"{provider}/{model}"
 
@@ -320,13 +366,19 @@ def _read_reward(sandbox: Any, reward_path: str) -> Optional[float]:
 def _clamp_turn(turn: dict[str, Any]) -> dict[str, Any]:
     """Clamp per-turn payload sizes to keep responses under a reasonable cap."""
     out = dict(turn)
-    # Compact ``response`` — we already captured tokens/logps explicitly.
-    out["response"] = {
-        "finish_reason": (out.get("response") or {}).get("choices", [{}])[0].get(
-            "finish_reason"
-        ),
-        "usage": (out.get("response") or {}).get("usage"),
+    raw_response = out.get("response") or {}
+    choices = raw_response.get("choices") or []
+    first_choice = choices[0] if choices else {}
+    compact: dict[str, Any] = {
+        "finish_reason": first_choice.get("finish_reason"),
+        "usage": raw_response.get("usage"),
     }
+    # Surface upstream errors captured by the proxy so they reach the client.
+    if raw_response.get("upstream_error") is not None:
+        compact["upstream_error"] = raw_response["upstream_error"]
+    if raw_response.get("upstream_status") is not None:
+        compact["upstream_status"] = raw_response["upstream_status"]
+    out["response"] = compact
     req = out.get("request") or {}
     messages = req.get("messages") or []
     # Keep request messages (trainer needs them) but drop very long tool schemas.
@@ -350,3 +402,16 @@ def _tail(events: list[dict[str, Any]], n: int) -> str:
     if not events:
         return ""
     return "\n".join(json.dumps(e) for e in events[-n:])
+
+
+def _read_safe(sandbox: Any, path: str, *, tail_chars: int = 4000) -> str:
+    """Read a file from the sandbox, returning its last ``tail_chars`` chars.
+
+    Returns empty string if the file is missing or unreadable. Used for
+    diagnostic tails so we never mask a real failure with a read error.
+    """
+    try:
+        content = sandbox.read_text(path) or ""
+    except Exception:
+        return ""
+    return content[-tail_chars:]

tests/conftest.py

@@ -0,0 +1,45 @@
+"""Conftest for opencode-openenv tests.
+
+The env directory is named ``openenv`` which collides with the installed
+``openenv-core`` namespace when pytest adds the parent directory
+(``…/opencode``) to ``sys.path``. Strip the shadowing entries and evict
+any already-loaded stale modules so ``import openenv.core`` resolves to
+the installed package.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+
+_OPENENV_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_OPENCODE_PARENT = os.path.dirname(_OPENENV_DIR)
+
+for _entry in (_OPENCODE_PARENT, _OPENENV_DIR):
+    while _entry in sys.path:
+        sys.path.remove(_entry)
+
+_stale_candidates = [
+    k
+    for k in list(sys.modules)
+    if (k == "openenv" or k.startswith("openenv."))
+    and not k.startswith("openenv.tests")  # keep the conftest's own module
+]
+for _stale in _stale_candidates:
+    module = sys.modules[_stale]
+    module_file = getattr(module, "__file__", None) or ""
+    # Only evict the modules that resolved to our shadow env directory.
+    if module_file.startswith(_OPENENV_DIR + os.sep) or (
+        _OPENENV_DIR in module_file and "/.venv/" not in module_file
+    ):
+        sys.modules.pop(_stale, None)
+
+# Sanity check — fail loudly at collection time if the import still breaks.
+try:
+    import openenv.core  # noqa: F401
+except ImportError as exc:
+    raise ImportError(
+        "openenv.core still not importable after sys.path scrub; check that "
+        "openenv-core is installed in the env's .venv."
+    ) from exc

uv.lock

@@ -223,11 +223,11 @@ wheels = [
 
 [[package]]
 name = "cachetools"
-version = "7.0.5"
+version = "7.0.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/dd/57fe3fdb6e65b25a5987fd2cdc7e22db0aef508b91634d2e57d22928d41b/cachetools-7.0.5.tar.gz", hash = "sha256:0cd042c24377200c1dcd225f8b7b12b0ca53cc2c961b43757e774ebe190fd990", size = 37367, upload-time = "2026-03-09T20:51:29.451Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/7b/1755ed2c6bfabd1d98b37ae73152f8dcf94aa40fee119d163c19ed484704/cachetools-7.0.6.tar.gz", hash = "sha256:e5d524d36d65703a87243a26ff08ad84f73352adbeafb1cde81e207b456aaf24", size = 37526, upload-time = "2026-04-20T19:02:23.289Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/06/f3/39cf3367b8107baa44f861dc802cbf16263c945b62d8265d36034fc07bea/cachetools-7.0.5-py3-none-any.whl", hash = "sha256:46bc8ebefbe485407621d0a4264b23c080cedd913921bad7ac3ed2f26c183114", size = 13918, upload-time = "2026-03-09T20:51:27.33Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c4/cf76242a5da1410917107ff14551764aa405a5fd10cd10cf9a5ca8fa77f4/cachetools-7.0.6-py3-none-any.whl", hash = "sha256:4e94956cfdd3086f12042cdd29318f5ced3893014f7d0d059bf3ead3f85b7f8b", size = 13976, upload-time = "2026-04-20T19:02:21.187Z" },
 ]
 
 [[package]]
@@ -1710,7 +1710,7 @@ dev = [
 [[package]]
 name = "openenv-core"
 version = "0.2.3"
-source = { git = "https://github.com/adithya-s-k/OpenEnv.git?rev=opencode-harness#048362e400ba87a95eb2aa7332abdce354078c17" }
+source = { git = "https://github.com/adithya-s-k/OpenEnv.git?rev=opencode-harness#4f8bc23dc0e860ac990d8fd0ebdac7a5498e56a3" }
 dependencies = [
     { name = "fastapi" },
     { name = "fastmcp" },
@@ -1741,7 +1741,7 @@ core = [
 [[package]]
 name = "openenv-opencode-env"
 version = "0.1.0"
-source = { git = "https://github.com/adithya-s-k/OpenEnv.git?subdirectory=envs%2Fopencode_env&rev=opencode-harness#048362e400ba87a95eb2aa7332abdce354078c17" }
+source = { git = "https://github.com/adithya-s-k/OpenEnv.git?subdirectory=envs%2Fopencode_env&rev=opencode-harness#4f8bc23dc0e860ac990d8fd0ebdac7a5498e56a3" }
 dependencies = [
     { name = "e2b" },
     { name = "fastapi" },