import asyncio
import os
from opencode_env import OpenCodeEnv
from opencode_env.client import _extract_text
from opencode_env.models import RolloutResult


async def main():
    SPACE = "https://adithyask-opencode-env.hf.space"

    async with OpenCodeEnv(base_url=SPACE) as env:
        await env.reset()

        # The MCP tool returns JSON; deserialize via the typed model.
        raw = await env.call_tool(
            "run_rollout",
            endpoint="openai",                          # vllm | openai | hf_router
            api_key=os.environ["OPENAI_API_KEY"],       # or set as a Space secret
            instruction=(
                "Create binary_search.py exposing def binary_search(arr, target) -> int "
                "that returns the index of target in arr, or -1 if absent. Use a "
                "relative path."
            ),
            setup=[],
            verify=[
                "test -f /home/user/workdir/binary_search.py",
                "python -c \"import sys; sys.path.insert(0, '/home/user/workdir'); "
                "import binary_search; "
                "assert binary_search.binary_search([1,2,3], 2) == 1; print('OK')\"",
            ],
            template="opencode-rl",                     # prebaked E2B template
            task_id="binary_search_v1",
        )
        result = RolloutResult.model_validate_json(_extract_text(raw))

        print("reward:", result.reward)
        print("turns:", len(result.proxy_turns))
        print("files:", list(result.files.keys()))
        print("wall:", result.wall_s, "s")


asyncio.run(main())

reward: 1.0
turns: 3
files: ['/home/user/workdir/binary_search.py', ...]
wall: 19.8 s

import os
from opencode_env import OpenCodeEnv

# .sync() returns a synchronous wrapper around the async client.
with OpenCodeEnv(base_url="https://adithyask-opencode-env.hf.space").sync() as env:
    env.reset()
    # MCP tools are reachable via env.call_tool(...) / env.step(...) sync-wrapped.
    # See the async example above for the full run_rollout signature.

import os
from opencode_env import (
    OpenCodeConfig, OpenCodeSessionFactory, OpenCodeTask, E2BSandboxBackend,
)

factory = OpenCodeSessionFactory(
    config=OpenCodeConfig(
        provider="openai_compatible",
        base_url="https://api.openai.com/v1",
        api_key=os.environ["OPENAI_API_KEY"],
        model="gpt-4o-mini",
    ),
    sandbox_backend=E2BSandboxBackend(),
    mode="transparent_proxy",                   # captures per-token logprobs
)
session = factory.create(task=OpenCodeTask(instruction="..."))
session.wait_for_completion()
turns = session.fetch_proxy_trace()             # per-turn (tokens, logprobs)
session.close()

cd envs/opencode_env

openenv validate               # check pyproject.toml + openenv.yaml + server/app.py + uv.lock
openenv build -t opencode-env  # builds the image (uses server/Dockerfile)

# run locally with E2B credentials
docker run -p 8000:8000 -e E2B_API_KEY=e2b_... opencode-env

# push to HF Spaces (Docker variant)
openenv push --repo-id <user>/opencode-env

docker build -t opencode-env -f envs/opencode_env/server/Dockerfile envs/opencode_env

.venv/bin/python envs/opencode_env/sandbox/build_template.py
# → builds `opencode-rl` template in your E2B account (~1m20s, one-time)

opencode_env/
├── README.md                       # this file
├── openenv.yaml                    # OpenEnv space spec
├── pyproject.toml                  # deps + ``server`` entrypoint
├── uv.lock                         # frozen deps (required by ``openenv validate``)
├── .gitignore / .dockerignore      # excludes .env / __pycache__
├── __init__.py                     # re-exports primitive + client + models
│
├── client.py                       # OpenCodeEnv(MCPToolClient)
├── models.py                       # RolloutResult / RolloutTurn / OpenCodeState
│
├── config.py                       # OpenCodeConfig (primitive)
├── harness.py                      # OpenCodeSession / OpenCodeSessionFactory (CLI-only)
├── opencode_runtime.py             # opencode.json builder + cmds
├── task.py                         # OpenCodeTask
│
├── server/
│   ├── __init__.py
│   ├── app.py                      # FastAPI factory; mounts Gradio at /web
│   ├── opencode_environment.py     # MCPEnvironment with single ``run_rollout`` tool
│   ├── gradio_ui.py                # the /web Gradio Blocks UI
│   ├── catalog.py                  # endpoint shorthand resolver
│   └── Dockerfile                  # multi-stage uv build (used by ``openenv build``)
│
└── sandbox/
    ├── __init__.py
    ├── base.py                     # SandboxBackend / SandboxHandle Protocols
    ├── e2b.py                      # E2B implementation
    ├── interception.py             # in-sandbox FastAPI proxy (logprob capture)
    └── build_template.py           # one-time E2B template builder