Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=vc_gemini_v0
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+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
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -1,10 +1,255 @@
 ---
-title: Vc Gemini V0
-emoji: 🏆
-colorFrom: gray
-colorTo: gray
+title: Vc Gemini V0 Environment Server
+emoji: 🎵
+colorFrom: indigo
+colorTo: blue
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Vc Gemini V0 Environment
+
+A simple test environment that echoes back messages. Perfect for testing the env APIs as well as demonstrating environment usage patterns.
+
+## Quick Start
+
+The simplest way to use the Vc Gemini V0 environment is through the `VcGeminiV0Env` class:
+
+```python
+from vc_gemini_v0 import VcGeminiV0Action, VcGeminiV0Env
+
+try:
+    # Create environment from Docker image
+    vc_gemini_v0env = VcGeminiV0Env.from_docker_image("vc_gemini_v0-env:latest")
+
+    # Reset
+    result = vc_gemini_v0env.reset()
+    print(f"Reset: {result.observation.echoed_message}")
+
+    # Send multiple messages
+    messages = ["Hello, World!", "Testing echo", "Final message"]
+
+    for msg in messages:
+        result = vc_gemini_v0env.step(VcGeminiV0Action(message=msg))
+        print(f"Sent: '{msg}'")
+        print(f"  → Echoed: '{result.observation.echoed_message}'")
+        print(f"  → Length: {result.observation.message_length}")
+        print(f"  → Reward: {result.reward}")
+
+finally:
+    # Always clean up
+    vc_gemini_v0env.close()
+```
+
+That's it! The `VcGeminiV0Env.from_docker_image()` method handles:
+- Starting the Docker container
+- Waiting for the server to be ready
+- Connecting to the environment
+- Container cleanup when you call `close()`
+
+## Building the Docker Image
+
+Before using the environment, you need to build the Docker image:
+
+```bash
+# From project root
+docker build -t vc_gemini_v0-env:latest -f server/Dockerfile .
+```
+
+## Deploying to Hugging Face Spaces
+
+You can easily deploy your OpenEnv environment to Hugging Face Spaces using the `openenv push` command:
+
+```bash
+# From the environment directory (where openenv.yaml is located)
+openenv push
+
+# Or specify options
+openenv push --namespace my-org --private
+```
+
+The `openenv push` command will:
+1. Validate that the directory is an OpenEnv environment (checks for `openenv.yaml`)
+2. Prepare a custom build for Hugging Face Docker space (enables web interface)
+3. Upload to Hugging Face (ensuring you're logged in)
+
+### Prerequisites
+
+- Authenticate with Hugging Face: The command will prompt for login if not already authenticated
+
+### Options
+
+- `--directory`, `-d`: Directory containing the OpenEnv environment (defaults to current directory)
+- `--repo-id`, `-r`: Repository ID in format 'username/repo-name' (defaults to 'username/env-name' from openenv.yaml)
+- `--base-image`, `-b`: Base Docker image to use (overrides Dockerfile FROM)
+- `--private`: Deploy the space as private (default: public)
+
+### Examples
+
+```bash
+# Push to your personal namespace (defaults to username/env-name from openenv.yaml)
+openenv push
+
+# Push to a specific repository
+openenv push --repo-id my-org/my-env
+
+# Push with a custom base image
+openenv push --base-image ghcr.io/meta-pytorch/openenv-base:latest
+
+# Push as a private space
+openenv push --private
+
+# Combine options
+openenv push --repo-id my-org/my-env --base-image custom-base:latest --private
+```
+
+After deployment, your space will be available at:
+`https://huggingface.co/spaces/<repo-id>`
+
+The deployed space includes:
+- **Web Interface** at `/web` - Interactive UI for exploring the environment
+- **API Documentation** at `/docs` - Full OpenAPI/Swagger interface
+- **Health Check** at `/health` - Container health monitoring
+- **WebSocket** at `/ws` - Persistent session endpoint for low-latency interactions
+
+## Environment Details
+
+### Action
+**VcGeminiV0Action**: Contains a single field
+- `message` (str) - The message to echo back
+
+### Observation
+**VcGeminiV0Observation**: Contains the echo response and metadata
+- `echoed_message` (str) - The message echoed back
+- `message_length` (int) - Length of the message
+- `reward` (float) - Reward based on message length (length × 0.1)
+- `done` (bool) - Always False for echo environment
+- `metadata` (dict) - Additional info like step count
+
+### Reward
+The reward is calculated as: `message_length × 0.1`
+- "Hi" → reward: 0.2
+- "Hello, World!" → reward: 1.3
+- Empty message → reward: 0.0
+
+## Advanced Usage
+
+### Connecting to an Existing Server
+
+If you already have a Vc Gemini V0 environment server running, you can connect directly:
+
+```python
+from vc_gemini_v0 import VcGeminiV0Env
+
+# Connect to existing server
+vc_gemini_v0env = VcGeminiV0Env(base_url="<ENV_HTTP_URL_HERE>")
+
+# Use as normal
+result = vc_gemini_v0env.reset()
+result = vc_gemini_v0env.step(VcGeminiV0Action(message="Hello!"))
+```
+
+Note: When connecting to an existing server, `vc_gemini_v0env.close()` will NOT stop the server.
+
+### Using the Context Manager
+
+The client supports context manager usage for automatic connection management:
+
+```python
+from vc_gemini_v0 import VcGeminiV0Action, VcGeminiV0Env
+
+# Connect with context manager (auto-connects and closes)
+with VcGeminiV0Env(base_url="http://localhost:8000") as env:
+    result = env.reset()
+    print(f"Reset: {result.observation.echoed_message}")
+    # Multiple steps with low latency
+    for msg in ["Hello", "World", "!"]:
+        result = env.step(VcGeminiV0Action(message=msg))
+        print(f"Echoed: {result.observation.echoed_message}")
+```
+
+The client uses WebSocket connections for:
+- **Lower latency**: No HTTP connection overhead per request
+- **Persistent session**: Server maintains your environment state
+- **Efficient for episodes**: Better for many sequential steps
+
+### Concurrent WebSocket Sessions
+
+The server supports multiple concurrent WebSocket connections. To enable this,
+modify `server/app.py` to use factory mode:
+
+```python
+# In server/app.py - use factory mode for concurrent sessions
+app = create_app(
+    VcGeminiV0Environment,  # Pass class, not instance
+    VcGeminiV0Action,
+    VcGeminiV0Observation,
+    max_concurrent_envs=4,  # Allow 4 concurrent sessions
+)
+```
+
+Then multiple clients can connect simultaneously:
+
+```python
+from vc_gemini_v0 import VcGeminiV0Action, VcGeminiV0Env
+from concurrent.futures import ThreadPoolExecutor
+
+def run_episode(client_id: int):
+    with VcGeminiV0Env(base_url="http://localhost:8000") as env:
+        result = env.reset()
+        for i in range(10):
+            result = env.step(VcGeminiV0Action(message=f"Client {client_id}, step {i}"))
+        return client_id, result.observation.message_length
+
+# Run 4 episodes concurrently
+with ThreadPoolExecutor(max_workers=4) as executor:
+    results = list(executor.map(run_episode, range(4)))
+```
+
+## Development & Testing
+
+### Direct Environment Testing
+
+Test the environment logic directly without starting the HTTP server:
+
+```bash
+# From the server directory
+python3 server/vc_gemini_v0_environment.py
+```
+
+This verifies that:
+- Environment resets correctly
+- Step executes actions properly
+- State tracking works
+- Rewards are calculated correctly
+
+### Running Locally
+
+Run the server locally for development:
+
+```bash
+uvicorn server.app:app --reload
+```
+
+## Project Structure
+
+```
+vc_gemini_v0/
+├── .dockerignore         # Docker build exclusions
+├── __init__.py            # Module exports
+├── README.md              # This file
+├── openenv.yaml           # OpenEnv manifest
+├── pyproject.toml         # Project metadata and dependencies
+├── uv.lock                # Locked dependencies (generated)
+├── client.py              # VcGeminiV0Env client
+├── models.py              # Action and Observation models
+└── server/
+    ├── __init__.py        # Server module exports
+    ├── vc_gemini_v0_environment.py  # Core environment logic
+    ├── app.py             # FastAPI application (HTTP + WebSocket endpoints)
+    └── Dockerfile         # Container image definition
+```

__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Vc Gemini V0 Environment."""
+
+from .client import VcGeminiV0Env
+from .models import VcGeminiV0Action, VcGeminiV0Observation
+
+__all__ = [
+    "VcGeminiV0Action",
+    "VcGeminiV0Observation",
+    "VcGeminiV0Env",
+]

client.py

@@ -0,0 +1,89 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Vc Gemini V0 Environment Client."""
+
+from typing import Dict
+
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+from openenv.core import EnvClient
+
+from .models import VcGeminiV0Action, VcGeminiV0Observation
+
+
+class VcGeminiV0Env(
+    EnvClient[VcGeminiV0Action, VcGeminiV0Observation]
+):
+    """
+    Client for the Vc Gemini V0 Environment.
+
+    This client maintains a persistent WebSocket connection to the environment server,
+    enabling efficient multi-step interactions with lower latency.
+    Each client instance has its own dedicated environment session on the server.
+
+    Example:
+        >>> # Connect to a running server
+        >>> with VcGeminiV0Env(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.echoed_message)
+        ...
+        ...     result = client.step(VcGeminiV0Action(message="Hello!"))
+        ...     print(result.observation.echoed_message)
+
+    Example with Docker:
+        >>> # Automatically start container and connect
+        >>> client = VcGeminiV0Env.from_docker_image("vc_gemini_v0-env:latest")
+        >>> try:
+        ...     result = client.reset()
+        ...     result = client.step(VcGeminiV0Action(message="Test"))
+        ... finally:
+        ...     client.close()
+    """
+
+    def _step_payload(self, action: VcGeminiV0Action) -> Dict:
+        """
+        Convert VcGeminiV0Action to JSON payload for step message.
+        """
+        return {
+            "action_type": action.action_type,
+            "parameters": action.parameters,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[VcGeminiV0Observation]:
+        """
+        Parse server response into StepResult[VcGeminiV0Observation].
+        """
+        obs_data = payload.get("observation", {})
+        observation = VcGeminiV0Observation(
+            observation_text=obs_data.get("observation_text", ""),
+            inbox=obs_data.get("inbox", []),
+            data=obs_data.get("data", {}),
+            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) -> State:
+        """
+        Parse server response into State object.
+
+        Args:
+            payload: JSON response from state request
+
+        Returns:
+            State object with episode_id and step_count
+        """
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

competitors.json

@@ -0,0 +1,38 @@
+[
+  {
+    "id": "sequoia_bot",
+    "name": "Sequoia Capital",
+    "speed_modifier": 0.9,
+    "valuation_cap": 1.5,
+    "primary_sectors": [
+      "Enterprise SaaS"
+    ],
+    "secondary_sectors": [
+      "Consumer Social"
+    ]
+  },
+  {
+    "id": "a16z_bot",
+    "name": "Andreessen Horowitz",
+    "speed_modifier": 0.8,
+    "valuation_cap": 2.0,
+    "primary_sectors": [
+      "FinTech / Web3"
+    ],
+    "secondary_sectors": [
+      "Enterprise SaaS"
+    ]
+  },
+  {
+    "id": "benchmark_bot",
+    "name": "Benchmark",
+    "speed_modifier": 1.5,
+    "valuation_cap": 1.1,
+    "primary_sectors": [
+      "Consumer Social"
+    ],
+    "secondary_sectors": [
+      "FinTech / Web3"
+    ]
+  }
+]

evaluate_v0_models.py

@@ -0,0 +1,138 @@
+import os
+import time
+from openai import OpenAI
+
+from test_reward_v0 import strategy_succeeds, env
+
+# ===================================================================
+# Hugging Face Router API Configuration
+# ===================================================================
+BASE_URL = "https://router.huggingface.co/v1"
+API_KEY = os.environ.get("HF_TOKEN", "")
+
+# Testing large models on the V0 environment
+MODELS_TO_TEST = [
+    "Qwen/Qwen3.5-397B-A17B:novita", 
+    "moonshotai/Kimi-K2.5:novita",
+    "meta-llama/Llama-3.1-70B-Instruct:scaleway",
+]
+
+# Initialize OpenAI compatible client
+client = OpenAI(
+    base_url=BASE_URL,
+    api_key=API_KEY
+)
+
+# Reference Prompt adapted for V0
+PROMPT = """Create a short Python VC strategy.
+
+You have to plan for 4 quarters, and each quarter you have 5 turns.
+You must maximize your TVPI (Total Value to Paid In Capital) by Quarter 4. 
+If your TVPI goes below 1.20x at the end, you get fired (penalty of -10.0 reward).
+
+There will be 12 startups arriving in your inbox over 4 quarters (3 per quarter, drawn from 10 sectors like AI/ML, BioTech, DeepTech, Robotics, etc.).
+There is 1 competitive VC actively playing against you. 
+
+At each turn, a valid action looks exactly like one of these JSON dictionaries:
+
+1. READ FILE (Consume 1 turn to diligence):
+{"action_type": "read_file", "parameters": {"path": "pitch_deck.txt", "startup_name": "Aura Labs"}}
+
+2. EMAIL FOUNDER (Consume 1 turn to ask for hints on valuation/board seats):
+{"action_type": "email_founder", "parameters": {"startup_name": "Aura Labs", "body": "What valuation are you looking for?"}}
+
+3. PASS ON DEAL (Reject a startup, saves capital):
+{"action_type": "pass_on_deal", "parameters": {"startup_name": "Aura Labs"}}
+
+4. SUBMIT TERM SHEET (Invest your capital):
+{"action_type": "submit_term_sheet", "parameters": {"startup_name": "Aura Labs", "valuation": 15000000.0, "amount": 5000000.0, "board_seats": 1}}
+
+5. WAIT (Do nothing this turn):
+{"action_type": "wait", "parameters": {}}
+
+Your task is write a python function `vc_strategy(observation)` to outline your strategy. 
+
+IMPORTANT FORMATTING RULES:
+1. All your helper functions must be defined *inside* the `def vc_strategy(observation):` block.
+2. The function must return a valid action dictionary.
+3. You must output the code block wrapped in ```python backticks.
+4. You MUST extract the actual target names from `observation.get("observation_text")`.
+
+Here is an example policy:
+```python
+def vc_strategy(observation):
+    text = observation.get("observation_text", "")
+    data = observation.get("data", {})
+    
+    # Save capital if budget is low
+    if data.get("budget", 100000000) < 5000000:
+        return {"action_type": "wait", "parameters": {}}
+
+    safe_sectors = ["AI/ML Foundation Models", "Agentic AI / Automation", "Robotics / Automation"]
+    for sector in safe_sectors:
+        if sector in text:
+            # Dynamically extract the startup name from "New Pitches in Inbox:\n- StartupName (Sector)"
+            lines = text.split("\\n")
+            for line in lines:
+                if sector in line and line.startswith("- "):
+                    actual_name = line[2:line.find("(")].strip()
+                    # Make a reasonable term sheet offer
+                    return {"action_type": "submit_term_sheet", "parameters": {"startup_name": actual_name, "valuation": 20000000.0, "amount": 10000000.0, "board_seats": 1}}
+        
+    return {"action_type": "wait", "parameters": {}}
+```
+
+Only output the short function `vc_strategy`!
+"""
+
+def evaluate_model(model_name):
+    print(f"\n{'='*80}")
+    print(f"EVALUATING MODEL ON VC_GEMINI_V0: {model_name}")
+    print(f"{'='*80}")
+    
+    try:
+        response = client.chat.completions.create(
+            model=model_name,
+            messages=[{"role": "user", "content": PROMPT}],
+            temperature=0.7,
+            max_tokens=4096,
+        )
+        
+        generated_text = response.choices[0].message.content
+        print("\n--- GENERATED CODE/RESPONSE ---")
+        print(generated_text)
+        print("-------------------------------\n")
+        
+        mock_completion = [[{"content": generated_text}]]
+        print("Executing generated strategy locally...")
+        scores = strategy_succeeds(mock_completion)
+        
+        final_score = scores[0] if scores else -4.0
+        print(f"Final Reward Score for {model_name}: {final_score}")
+        return final_score
+        
+    except Exception as e:
+        print(f"Failed to evaluate {model_name}: {e}")
+        return -5.0
+
+def main():
+    if not API_KEY:
+        print("WARNING: HF_TOKEN is not set.")
+        time.sleep(2)
+        
+    results = {}
+    for model in MODELS_TO_TEST:
+        score = evaluate_model(model)
+        results[model] = score
+        time.sleep(3)
+        
+    print("\n\n" + "#"*60)
+    print("V0 MODEL EVALUATION LEADERBOARD")
+    print("#"*60)
+    
+    sorted_results = sorted(results.items(), key=lambda x: x[1], reverse=True)
+    for i, (model, score) in enumerate(sorted_results, 1):
+        print(f"{i}. {model:<40} | Score: {score}")
+
+if __name__ == "__main__":
+    main()

models.py

@@ -0,0 +1,18 @@
+from typing import Dict, Any
+
+from pydantic import Field
+
+from openenv.core.env_server.types import Action, Observation
+
+
+class VcGeminiV0Action(Action):
+    """Action for the Multi-Agent VC Negotiator (V0 Curriculum)."""
+    action_type: str = Field(..., description="Type of action: 'read_file', 'email_founder', 'submit_term_sheet', 'pass_on_deal', 'wait'")
+    parameters: Dict[str, Any] = Field(default_factory=dict, description="Parameters for the specific action type.")
+
+
+class VcGeminiV0Observation(Observation):
+    """Observation from the VC Environment (V0 Curriculum)."""
+    observation_text: str = Field(..., description="The immediate result or narrative of your action.")
+    inbox: list = Field(default_factory=list, description="Any new emails or messages received in your inbox this turn.")
+    data: Dict[str, Any] = Field(default_factory=dict, description="Structured data returned (e.g. file contents).")

openenv.yaml

@@ -0,0 +1,7 @@
+spec_version: 1
+name: vc_gemini_v0
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+

openenv_vc_gemini_v0.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: openenv-vc_gemini_v0
+Version: 0.1.0
+Summary: Vc Gemini V0 environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_vc_gemini_v0.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+./__init__.py
+./client.py
+./evaluate_v0_models.py
+./models.py
+./test_reward_v0.py
+openenv_vc_gemini_v0.egg-info/PKG-INFO
+openenv_vc_gemini_v0.egg-info/SOURCES.txt
+openenv_vc_gemini_v0.egg-info/dependency_links.txt
+openenv_vc_gemini_v0.egg-info/entry_points.txt
+openenv_vc_gemini_v0.egg-info/requires.txt
+openenv_vc_gemini_v0.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/generate_dataset.py
+server/vc_gemini_v0_environment.py

openenv_vc_gemini_v0.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_vc_gemini_v0.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = vc_gemini_v0.server.app:main

openenv_vc_gemini_v0.egg-info/requires.txt

@@ -0,0 +1,5 @@
+openenv-core[core]>=0.2.0
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_vc_gemini_v0.egg-info/top_level.txt

@@ -0,0 +1 @@
+vc_gemini_v0

pyproject.toml

@@ -0,0 +1,45 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-vc_gemini_v0"
+version = "0.1.0"
+description = "Vc Gemini V0 environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]>=0.2.0",
+    # Environment-specific dependencies
+    # Add all dependencies needed for your environment here
+    # Examples:
+    # "numpy>=1.19.0",
+    # "torch>=2.0.0",
+    # "gymnasium>=0.29.0",
+    # "openspiel>=1.0.0",
+    # "smolagents>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m vc_gemini_v0.server.app
+server = "vc_gemini_v0.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["vc_gemini_v0", "vc_gemini_v0.server"]
+package-dir = { "vc_gemini_v0" = ".", "vc_gemini_v0.server" = "server" }

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Vc Gemini V0 environment server components."""
+
+from .vc_gemini_v0_environment import VcGeminiV0Environment
+
+__all__ = ["VcGeminiV0Environment"]

server/app.py

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Vc Gemini V0 Environment.
+
+This module creates an HTTP server that exposes the VcGeminiV0Environment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+# Import from local models.py (PYTHONPATH includes /app/env in Docker)
+from models import VcGeminiV0Action, VcGeminiV0Observation
+from .vc_gemini_v0_environment import VcGeminiV0Environment
+
+
+# Create the app with web interface and README integration
+app = create_app(
+    VcGeminiV0Environment,
+    VcGeminiV0Action,
+    VcGeminiV0Observation,
+    env_name="vc_gemini_v0",
+    max_concurrent_envs=1,  # increase this number to allow more concurrent WebSocket sessions
+)
+
+
+def main(host: str = "0.0.0.0", port: int = 8000):
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        uv run --project . server --port 8001
+        python -m vc_gemini_v0.server.app
+
+    Args:
+        host: Host address to bind to (default: "0.0.0.0")
+        port: Port number to listen on (default: 8000)
+
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn vc_gemini_v0.server.app:app --workers 4
+    """
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    main(port=args.port)

server/generate_dataset.py

@@ -0,0 +1,102 @@
+import json
+import random
+import uuid
+
+def generate_competitors():
+    competitors = [
+        {"id": "sequoia_bot", "name": "Sequoia Capital", "speed_modifier": 0.9, "valuation_cap": 1.5, "primary_sectors": ["Enterprise SaaS"], "secondary_sectors": ["Consumer Social"]},
+        {"id": "a16z_bot", "name": "Andreessen Horowitz", "speed_modifier": 0.8, "valuation_cap": 2.0, "primary_sectors": ["FinTech / Web3"], "secondary_sectors": ["Enterprise SaaS"]},
+        {"id": "benchmark_bot", "name": "Benchmark", "speed_modifier": 1.5, "valuation_cap": 1.1, "primary_sectors": ["Consumer Social"], "secondary_sectors": ["FinTech / Web3"]}
+    ]
+    with open("competitors.json", "w") as f:
+        json.dump(competitors, f, indent=2)
+    print(f"Generated {len(competitors)} competitors.")
+
+def generate_fund_scenarios(count=100):
+    sectors = [
+        "Enterprise SaaS",
+        "Consumer Social",
+        "FinTech / Web3",
+    ]
+    
+    first_names = ["Alice", "Bob", "Charlie", "Diana", "Ethan", "Faye", "George", "Hannah", "Ian", "Jane", "Kevin", "Laura", "Mike", "Nina", "Oscar", "Peggy", "Uma", "Viktor", "Wendy", "Zane"]
+    company_prefixes = ["Quantum", "Aura", "Nebula", "Apex", "Vanguard", "Zenith", "Nova", "Stratos", "Omni", "Nex", "Data", "Bio", "Cranium", "Cyber", "Astro", "Alpha", "Flux", "Core", "Grid", "Pioneer"]
+    company_suffixes = ["AI", "Dynamics", "Systems", "Labs", "Networks", "Technologies", "Solutions", "Health", "Space", "Genomics", "Robotics", "Analytics", "Agents", "Finance", "Energy", "Chip"]
+
+    scenarios = []
+    
+    for _ in range(count):
+        sector = random.choice(sectors)
+        
+        # Valuation logic based on sector
+        if sector in ["Enterprise SaaS"]:
+            raise_amount = random.randint(1, 4) * 1000000
+            fair_eval = raise_amount * random.uniform(3.0, 6.0)
+            true_potential_mult = random.uniform(0.5, 4.0) # Moderate variance
+        elif sector in ["Consumer Social", "FinTech / Web3"]:
+            raise_amount = random.randint(1, 5) * 1000000
+            fair_eval = raise_amount * random.uniform(2.0, 6.0)
+            true_potential_mult = random.choice([0.0, 0.0, 0.0, 0.5, 1.0, 10.0])
+
+        fair_eval = round(fair_eval, -5) # Round to nearest 100k
+            
+        founder_name = random.choice(first_names)
+        company_name = f"{random.choice(company_prefixes)} {random.choice(company_suffixes)}"
+        
+        # Founder Priorities
+        priority_roll = random.random()
+        if priority_roll < 0.33:
+            p_val, p_board, p_speed = True, False, False
+            hint = f"I'm looking for a premium valuation. We won't take less than ${int((fair_eval * 0.9)/1000000)}M pre-money."
+        elif priority_roll < 0.66:
+            p_val, p_board, p_speed = False, True, False
+            hint = "We aren't optimizing for every last dollar of valuation. We just want to retain 2 board seats so we control our destiny."
+        else:
+            p_val, p_board, p_speed = False, False, True
+            hint = "We are running low on runway. We need to close this round extremely fast. We will take a fair price if you move now."
+
+        # Cap Table logic (30% chance of messy options trap)
+        cap_table = [
+            {"Shareholder": f"Founder {founder_name}", "Shares": random.randint(4000000, 8000000), "Type": "Common"}
+        ]
+        if random.random() > 0.5:
+            cap_table.append({"Shareholder": "Seed Investors", "Shares": random.randint(1000000, 3000000), "Type": "Preferred"})
+            
+        if random.random() > 0.7:
+             cap_table.append({"Shareholder": "Unissued Option Pool", "Shares": random.randint(1000000, 2500000), "Type": "Options"})
+        else:
+             cap_table.append({"Shareholder": "Employee Option Pool", "Shares": random.randint(500000, 1000000), "Type": "Options"})
+
+        scenario = {
+            "startup_id": str(uuid.uuid4())[:8],
+            "startup_name": company_name,
+            "sector": sector,
+            "raise_amount_str": f"${int(raise_amount/1000000)}M",
+            "raise_amount": raise_amount,
+            "true_potential_multiplier": round(true_potential_mult, 2),
+            "cap_table": cap_table,
+            "founder_priorities": {
+                "prioritize_valuation": p_val,
+                "prioritize_board_control": p_board,
+                "prioritize_speed": p_speed
+            },
+            "founder_hints": {
+                "valuation_hint": hint
+            },
+            "win_conditions": {
+                "max_board_seats": 1 if p_board else 3,
+                "min_valuation": fair_eval * (0.9 if p_val else 0.6),
+                "fair_valuation": fair_eval,
+                "overpaid_valuation": fair_eval * 1.3,
+                "max_turns": 4 if p_speed else 8
+            }
+        }
+        scenarios.append(scenario)
+
+    with open("fund_scenarios.json", "w") as f:
+        json.dump(scenarios, f, indent=2)
+    print(f"Generated {count} fund scenarios.")
+
+if __name__ == "__main__":
+    generate_competitors()
+    generate_fund_scenarios(100)

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+

server/vc_gemini_v0_environment.py

@@ -0,0 +1,320 @@
+import os
+import json
+import random
+import tempfile
+import csv
+import shutil
+from uuid import uuid4
+from typing import Dict, Any, List
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+from models import VcGeminiV0Action, VcGeminiV0Observation
+
+class VcGeminiV0Environment(Environment):
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self.workspace_dir = tempfile.mkdtemp(prefix="vc_env_v0_")
+        
+        self.fund_budget = 100000000.0
+        self.portfolio = []
+        self.quarter = 1
+        self.MAX_QUARTERS = 5  # Reduced from 11 to 5 (4 playable quarters)
+        self.MAX_TURNS_PER_QUARTER = 5  # Reduced from 10 to 5 turns
+        self.turns_remaining = self.MAX_TURNS_PER_QUARTER
+        
+        # Load Datasets
+        base_dir = os.path.dirname(os.path.dirname(__file__))
+        scenario_path = os.path.join(base_dir, "fund_scenarios.json")
+        with open(scenario_path, "r") as f:
+            self.scenarios = json.load(f)
+            
+        comp_path = os.path.join(base_dir, "competitors.json")
+        with open(comp_path, "r") as f:
+            self.competitors = json.load(f)
+            
+        self.available_scenarios = []  
+        self.active_competitors = []
+        self.inbox_pitches = []
+
+    def reset(self) -> VcGeminiV0Observation:
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self.fund_budget = 100000000.0
+        self.portfolio = []
+        self.quarter = 1
+        
+        # 1 random rival for the episode (Curriculum V0 simplification)
+        self.active_competitors = random.sample(self.competitors, 1)
+        # 12 random startups for the deal flow (3 per quarter for 4 quarters)
+        self.available_scenarios = random.sample(self.scenarios, 12)
+        
+        return self._setup_quarter()
+
+    def _mark_to_market(self):
+        """Updates the paper valuation of the portfolio and returns the interim reward (RVPI)."""
+        interim_reward = 0.0
+        
+        for inv in self.portfolio:
+            if not inv["active"]:
+                continue
+                
+            # Simulate a funding round event every quarter
+            if random.random() < 0.3:  # 30% chance for a valuation event
+                # Up round vs Down round bias based on their true potential
+                if inv["true_potential_multiplier"] > 1.0:
+                    rvpi_bump = random.uniform(0.1, 0.5)
+                    inv["paper_multiplier"] += rvpi_bump
+                    interim_reward += (rvpi_bump * 0.1) # Soft reward for good paper marks
+                elif inv["true_potential_multiplier"] == 0.0:
+                    rvpi_drop = random.uniform(-0.1, -0.9)
+                    inv["paper_multiplier"] = max(0.1, inv["paper_multiplier"] + rvpi_drop)
+                    interim_reward += (rvpi_drop * 0.1)
+        
+        return interim_reward
+        
+    def _setup_quarter(self) -> VcGeminiV0Observation:
+        if self.quarter >= self.MAX_QUARTERS:
+            return self._calculate_final_tvpi()
+            
+        # Clean up old Data Rooms
+        if os.path.exists(self.workspace_dir):
+            shutil.rmtree(self.workspace_dir, ignore_errors=True)
+            
+        self.workspace_dir = tempfile.mkdtemp(prefix=f"vc_q{self.quarter}_")
+        self.turns_remaining = self.MAX_TURNS_PER_QUARTER
+        
+        # Draw 3 Pitches for this quarter
+        start_idx = (self.quarter - 1) * 3
+        self.inbox_pitches = self.available_scenarios[start_idx:start_idx+3]
+        
+        pitch_names = []
+        # Setup Data Rooms for the 3 Pitches
+        for scenario in self.inbox_pitches:
+            startup_dir = os.path.join(self.workspace_dir, scenario["startup_name"].replace(" ", "_"))
+            os.makedirs(startup_dir)
+            
+            cap_table_path = os.path.join(startup_dir, "cap_table.csv")
+            with open(cap_table_path, "w", newline='') as f:
+                writer = csv.writer(f)
+                writer.writerow(["Shareholder", "Shares", "Type"])
+                for row in scenario["cap_table"]:
+                    writer.writerow([row["Shareholder"], row["Shares"], row["Type"]])
+                
+            deck_path = os.path.join(startup_dir, "pitch_deck.txt")
+            with open(deck_path, "w") as f:
+                f.write(f"{scenario['startup_name']} Pitch Deck\n")
+                f.write(f"Sector: {scenario['sector']}\n")
+                f.write(f"We are raising {scenario['raise_amount_str']}.\n")
+                f.write("Note: Email the founder if you have diligence questions.\n")
+                
+            pitch_names.append(f"- {scenario['startup_name']} ({scenario['sector']})")
+            
+        # Build Portfolio Status String
+        port_status = "Empty"
+        if self.portfolio:
+            port_items = []
+            for p in self.portfolio:
+                status = "ACTIVE" if p["active"] else "SOLD"
+                val = p['invested_amount'] * p['paper_multiplier']
+                port_items.append(f"{p['startup_name']} [{status}]: Paper Value ${val:,.2f} ({p['paper_multiplier']:.2f}x)")
+            port_status = "\n".join(port_items)
+            
+        comps_str = ", ".join([c["name"] for c in self.active_competitors])
+        obs_text = (
+            f"--- QUARTER {self.quarter} (Turns Remaining: {self.turns_remaining}) ---\n"
+            f"Fund Budget Remaining: ${self.fund_budget:,.2f}\n"
+            f"Active Portfolio:\n{port_status}\n\n"
+            f"Market Rumor: Active Rival Funds this decade are {comps_str}.\n\n"
+            f"New Pitches in Inbox:\n" + "\n".join(pitch_names) + "\n\n"
+            f"Their Data Rooms are mounted inside: {self.workspace_dir}. "
+            f"You can 'read_file', 'email_founder', 'submit_term_sheet', 'pass_on_deal', or 'wait'."
+        )
+        
+        # Calculate Mark to Market for interim rewards
+        interim_reward = self._mark_to_market() if self.quarter > 1 else 0.0
+        
+        return VcGeminiV0Observation(
+            observation_text=obs_text,
+            inbox=[],
+            data={"workspace_dir": self.workspace_dir, "quarter": self.quarter, "budget": self.fund_budget, "turns_left": self.turns_remaining},
+            done=False,
+            reward=interim_reward
+        )
+        
+    def _calculate_final_tvpi(self) -> VcGeminiV0Observation:
+        total_returned_capital = self._run_ipo_phase()
+        
+        total_fund_value = total_returned_capital + self.fund_budget
+        tvpi = total_fund_value / 100000000.0  
+        
+        # Opportunity Cost / Hurdle Penalty
+        if tvpi < 1.20:
+            final_reward = -10.0  # Failed to beat 10-year hurdle rate or index fund.
+        else:
+            final_reward = tvpi
+
+        summary = "\n=== FUND LIFE COMPLETE (4 QUARTERS) ===\n"
+        summary += f"Total Liquid Capital Returned: ${total_fund_value:,.2f}\n"
+        summary += f"Gross Fund TVPI: {tvpi:.2f}x\n"
+        if final_reward == -10.0:
+            summary += "\nLPs are furious. You failed to beat the hurdle rate. You are fired from the partnership."
+        else:
+            summary += "\nLPs are ecstatic. You successfully managed the fund!"
+        
+        return VcGeminiV0Observation(
+            observation_text=summary,
+            inbox=[],
+            data={"tvpi": tvpi, "final_reward": final_reward, "portfolio": self.portfolio},
+            done=True,
+            reward=final_reward
+        )
+        
+    def _run_ipo_phase(self) -> float:
+        total = 0.0
+        for p in self.portfolio:
+            if p["active"]:
+                exit_value = p["invested_amount"] * p["true_potential_multiplier"]
+                total += exit_value
+                p["active"] = False
+                p["paper_multiplier"] = p["true_potential_multiplier"]
+            else:
+                pass
+        return total
+
+    def _get_target_scenario(self, target_name: str):
+        target = target_name.lower().replace(" ", "")
+        for s in self.inbox_pitches:
+            if s["startup_name"].lower().replace(" ", "") in target:
+                return s
+        return None
+
+    def step(self, action: VcGeminiV0Action) -> VcGeminiV0Observation:
+        self._state.step_count += 1
+        
+        a_type = action.action_type
+        params = action.parameters
+        obs_text = ""
+        inbox_msgs = []
+        data_res = {}
+        
+        # Consume Turn Budget
+        self.turns_remaining -= 1
+        
+        if self.turns_remaining <= 0:
+            # Time's up for the quarter
+            obs_text = "You ran out of Time (Turns) for this Quarter. The remaining startups in your inbox raised capital from Rivals. "
+            self.quarter += 1
+            obs = self._setup_quarter()
+            obs.observation_text = obs_text + "\n\n" + obs.observation_text
+            return obs
+
+        # Ensure action targets a specific startup if required
+        startup_name = params.get("startup_name", "")
+        scen = self._get_target_scenario(startup_name)
+        
+        if a_type in ["email_founder", "submit_term_sheet", "pass_on_deal"]:
+            if not scen:
+                return VcGeminiV0Observation(
+                    observation_text=f"Error: Could not find startup matching '{startup_name}' in your current Quarter inbox.",
+                    inbox=[], data={}, done=False, reward=0.0
+                )
+        
+        if a_type == "pass_on_deal":
+            self.inbox_pitches = [p for p in self.inbox_pitches if p["startup_id"] != scen["startup_id"]]
+            obs_text = f"You passed on {scen['startup_name']}. Saved capital."
+            
+            if not self.inbox_pitches:
+                # Passed on everyone, end quarter early
+                self.quarter += 1
+                obs = self._setup_quarter()
+                obs.observation_text = obs_text + "\n\n" + obs.observation_text
+                return obs
+
+        elif a_type == "read_file":
+            path = params.get("path", "")
+            if not os.path.isabs(path):
+                path = os.path.join(self.workspace_dir, path)
+                
+            if os.path.exists(path) and os.path.isfile(path):
+                with open(path, "r") as f:
+                    content = f.read()
+                obs_text = f"Read {path} successfully."
+                data_res["file_content"] = content
+            else:
+                obs_text = f"File not found: {path}"
+
+        elif a_type == "email_founder":
+            body = params.get("body", "").lower()
+            if "valuation" in body or "price" in body or "expectations" in body:
+                inbox_msgs.append({
+                    "from": f"{scen['startup_name']} Founder",
+                    "subject": "Re: Diligence",
+                    "body": scen["founder_hints"]["valuation_hint"]
+                })
+                obs_text = "You emailed the founder. They replied instantly."
+            else:
+                inbox_msgs.append({
+                    "from": f"{scen['startup_name']} Founder",
+                    "subject": "Re: Diligence",
+                    "body": "Happy to answer any specific questions! Are you wondering about our Valuation expectations or Board dynamics?"
+                })
+                obs_text = "You emailed the founder. They replied."
+
+        elif a_type == "submit_term_sheet":
+            pre_money = float(params.get("valuation", 0.0))
+            amount = float(params.get("amount", 0.0))
+            board_seats = int(params.get("board_seats", 1))
+            win_conds = scen["win_conditions"]
+            
+            if amount > self.fund_budget:
+                obs_text = f"You don't have ${amount} left in your fund! You only have ${self.fund_budget}. The deal fell through."
+            elif amount < (self.fund_budget * 0.10):
+                obs_text = f"Founder says: 'We need a Lead VC to buy at least a 10% chunk. Your check size is too small.' Deal lost."
+                self.inbox_pitches = [p for p in self.inbox_pitches if p["startup_id"] != scen["startup_id"]]
+            elif board_seats > win_conds["max_board_seats"]:
+                obs_text = f"Founder says: 'We can't sign this. We only allow {win_conds['max_board_seats']} board seats.' Deal lost."
+                self.inbox_pitches = [p for p in self.inbox_pitches if p["startup_id"] != scen["startup_id"]]
+            elif pre_money < win_conds["min_valuation"]:
+                obs_text = f"Founder says: 'This valuation is insulting. We are passing.' Deal lost."
+                self.inbox_pitches = [p for p in self.inbox_pitches if p["startup_id"] != scen["startup_id"]]
+            else:
+                # Deal won! Add to portfolio
+                equity_percent = amount / (pre_money + amount)
+                self.portfolio.append({
+                    "startup_name": scen["startup_name"],
+                    "invested_amount": amount,
+                    "equity_percent": equity_percent,
+                    "paper_multiplier": 1.0, # Starts at 1.0x Cost
+                    "true_potential_multiplier": scen["true_potential_multiplier"],
+                    "active": True
+                })
+                self.fund_budget -= amount
+                self.inbox_pitches = [p for p in self.inbox_pitches if p["startup_id"] != scen["startup_id"]]
+                obs_text = f"Founder says: 'We accept your term sheet!' You invested ${amount:,.2f} for {equity_percent*100:.1f}% equity in {scen['startup_name']}."
+            
+            if not self.inbox_pitches:
+                self.quarter += 1
+                obs = self._setup_quarter()
+                obs.observation_text = obs_text + "\n\n" + obs.observation_text
+                return obs
+
+        elif a_type == "wait":
+            obs_text = "You waited a turn."
+        else:
+            obs_text = f"Invalid action_type: {a_type}"
+
+        return VcGeminiV0Observation(
+            observation_text=obs_text,
+            inbox=inbox_msgs,
+            data=data_res,
+            done=False,
+            reward=0.0,
+            metadata={"step": self._state.step_count, "quarter": self.quarter, "turns_left": self.turns_remaining}
+        )
+
+    @property
+    def state(self) -> State:
+        return self._state

test_reward_v0.py

@@ -0,0 +1,78 @@
+import sys
+import json
+from server.vc_gemini_v0_environment import VcGeminiV0Environment
+from models import VcGeminiV0Action
+
+# Directly instantiate the environment for fast local testing!
+env = VcGeminiV0Environment()
+
+def extract_function(text):
+    if text.count("```") >= 2:
+        first = text.find("```") + 3
+        second = text.find("```", first)
+        fx = text[first : second].strip()
+        fx = fx.removeprefix("python\n").removeprefix("python\r\n")
+        fx = fx[fx.find("def"):]
+        if fx.startswith("def vc_strategy(observation):"): 
+            return fx
+    return None
+
+def strategy_succeeds(completions, **kwargs):
+    scores = []
+    
+    for completion in completions:
+        text_str = completion[0]["content"] if isinstance(completion, list) else completion
+        function = extract_function(text_str)
+        
+        if function is None:
+            scores.append(-2.0) 
+            continue
+            
+        local_scope = {}
+        try:
+            exec(function, globals(), local_scope)
+            new_strategy = local_scope.get("vc_strategy")
+        except Exception as e:
+            scores.append(-1.0) 
+            continue
+            
+        if not callable(new_strategy):
+            scores.append(-1.0)
+            continue
+            
+        try:
+            res = env.reset()
+            done = False
+            
+            step_count = 0
+            while not done:
+                # Pass state to the dynamically generated function
+                action_dict = new_strategy(res.model_dump())
+                if not isinstance(action_dict, dict):
+                    action_dict = {"action_type": "wait", "parameters": {}}
+                    
+                action = VcGeminiV0Action(**action_dict)
+                res = env.step(action)
+                done = getattr(res, "done", False)
+                step_count += 1
+            
+            final_reward = float(res.reward or 0.0)
+            scores.append(final_reward)
+            print(f"✅ Simulation Successfully Reached Q4 (Takes {step_count} steps) | Final Reward: {final_reward}")
+                
+        except Exception as e:
+            print(f"Crash during rollout: {e}")
+            scores.append(-3.0)
+            
+    return scores
+
+if __name__ == "__main__":
+    # Create a dummy payload mimicking LLaMA generation
+    mock_llm_generation = [[{"content": '''```python
+def vc_strategy(observation):
+    return {"action_type": "wait", "parameters": {}}
+```'''}]]
+    
+    print("Testing GRPO Reward Hook with Dummy Code...")
+    scores = strategy_succeeds(mock_llm_generation)
+    print("Resulting Scores:", scores)