openenv-agent 0.1.0__tar.gz

openenv_agent-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Croma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

openenv_agent-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: openenv-agent
+Version: 0.1.0
+Summary: Agent client for OpenEnv environments - connects RL agents to OpenEnv servers for inference and training
+Author: Croma
+License: MIT
+Keywords: openenv,reinforcement-learning,agent,rl,content-moderation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.3.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: click>=8.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# OpenEnv Agent
+
+Python client library for connecting RL agents to OpenEnv servers.
+
+## Installation
+
+```bash
+pip install openenv-agent
+```
+
+## Quick Start
+
+```python
+from openenv_agent import OpenEnvClient, ModerationAgent
+
+# Connect to an OpenEnv server
+client = OpenEnvClient(base_url="http://localhost:8000")
+
+# Reset environment
+obs = client.reset()
+
+# Use the moderation agent
+agent = ModerationAgent()
+action = agent.predict(obs)
+
+# Step the environment
+next_obs, reward, done, info = client.step(action)
+```
+
+## CLI Usage
+
+```bash
+# Run agent against a server
+openenv-agent run http://localhost:8000
+
+# Interactive mode
+openenv-agent interactive http://localhost:8000
+
+# Evaluate on a dataset
+openenv-agent eval http://localhost:8000 --dataset ./data.json
+```
+
+## Features
+
+- Async/sync OpenEnv client with Gymnasium-style API
+- Built-in ModerationAgent for content moderation environments
+- Environment loader from openenv.yaml configs
+- CLI tool for easy server interaction

openenv_agent-0.1.0/README.md

@@ -0,0 +1,48 @@
+# OpenEnv Agent
+
+Python client library for connecting RL agents to OpenEnv servers.
+
+## Installation
+
+```bash
+pip install openenv-agent
+```
+
+## Quick Start
+
+```python
+from openenv_agent import OpenEnvClient, ModerationAgent
+
+# Connect to an OpenEnv server
+client = OpenEnvClient(base_url="http://localhost:8000")
+
+# Reset environment
+obs = client.reset()
+
+# Use the moderation agent
+agent = ModerationAgent()
+action = agent.predict(obs)
+
+# Step the environment
+next_obs, reward, done, info = client.step(action)
+```
+
+## CLI Usage
+
+```bash
+# Run agent against a server
+openenv-agent run http://localhost:8000
+
+# Interactive mode
+openenv-agent interactive http://localhost:8000
+
+# Evaluate on a dataset
+openenv-agent eval http://localhost:8000 --dataset ./data.json
+```
+
+## Features
+
+- Async/sync OpenEnv client with Gymnasium-style API
+- Built-in ModerationAgent for content moderation environments
+- Environment loader from openenv.yaml configs
+- CLI tool for easy server interaction

openenv_agent-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "openenv-agent"
+version = "0.1.0"
+description = "Agent client for OpenEnv environments - connects RL agents to OpenEnv servers for inference and training"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "Croma"}
+]
+keywords = ["openenv", "reinforcement-learning", "agent", "rl", "content-moderation"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "openai>=1.3.0",
+    "httpx>=0.25.0",
+    "pyyaml>=6.0",
+    "click>=8.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21.0",
+    "ruff>=0.1.0",
+]
+
+[project.scripts]
+openenv-agent = "openenv_agent.cli:main"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

openenv_agent-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

openenv_agent-0.1.0/src/openenv_agent/__init__.py

@@ -0,0 +1,14 @@
+"""OpenEnv Agent - Client library for OpenEnv RL environments."""
+
+from openenv_agent.client import OpenEnvClient
+from openenv_agent.agent import BaseAgent
+from openenv_agent.moderation_agent import ModerationAgent
+from openenv_agent.env_loader import load_env_from_yaml
+
+__version__ = "0.1.0"
+__all__ = [
+    "OpenEnvClient",
+    "BaseAgent",
+    "ModerationAgent",
+    "load_env_from_yaml",
+]

openenv_agent-0.1.0/src/openenv_agent/agent.py

@@ -0,0 +1,64 @@
+"""Base agent class for OpenEnv."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class AgentConfig:
+    """Configuration for an agent."""
+    name: str = "BaseAgent"
+    temperature: float = 0.0
+    max_tokens: int = 200
+    timeout: float = 10.0
+
+
+class BaseAgent(ABC):
+    """
+    Abstract base class for OpenEnv agents.
+
+    Subclasses must implement the `predict` method.
+    """
+
+    def __init__(self, config: Optional[AgentConfig] = None):
+        """
+        Initialize the agent.
+
+        Args:
+            config: Agent configuration
+        """
+        self.config = config or AgentConfig()
+
+    @abstractmethod
+    def predict(self, observation: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Given an observation, return an action.
+
+        Args:
+            observation: Environment observation dict
+
+        Returns:
+            Action dict to send to the environment
+        """
+        pass
+
+    def reset(self):
+        """Reset agent state between episodes."""
+        pass
+
+    def train(self, episode_data: List[Dict[str, Any]]) -> Dict[str, float]:
+        """
+        Train the agent on episode data.
+
+        Args:
+            episode_data: List of (observation, action, reward, done, info) tuples
+
+        Returns:
+            Dict of training metrics
+        """
+        # Default implementation - override for actual training
+        return {"status": "no-op"}
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.config.name})"

openenv_agent-0.1.0/src/openenv_agent/cli.py

@@ -0,0 +1,170 @@
+"""CLI for openenv-agent."""
+
+import sys
+import logging
+from typing import Optional
+
+import click
+
+from openenv_agent.client import OpenEnvClient
+from openenv_agent.moderation_agent import ModerationAgent
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+@click.version_option(version="0.1.0")
+def main():
+    """OpenEnv Agent - Connect RL agents to OpenEnv servers."""
+    pass
+
+
+@main.command()
+@click.argument("url")
+@click.option("--max-steps", type=int, default=None, help="Max steps to run")
+def run(url: str, max_steps: Optional[int]):
+    """Run the moderation agent against an OpenEnv server."""
+    client = OpenEnvClient(base_url=url)
+    agent = ModerationAgent()
+
+    click.echo(f"[START] Connecting to {url}")
+
+    try:
+        obs = client.reset()
+        click.echo(f"[RESET] Initial observation received")
+
+        step = 0
+        total_reward = 0.0
+
+        while True:
+            if max_steps and step >= max_steps:
+                break
+
+            action = agent.predict(obs)
+            next_obs, reward, done, info = client.step(action)
+
+            total_reward += reward
+            step += 1
+
+            click.echo(
+                f"[STEP] step={step} action={action['decision']} "
+                f"reward={reward:.2f} done={done}"
+            )
+
+            if done:
+                break
+
+            obs = next_obs
+
+        avg_reward = total_reward / max(step, 1)
+        click.echo(f"[END] steps={step} avg_reward={avg_reward:.4f}")
+
+    except Exception as e:
+        click.echo(f"[ERROR] {e}", err=True)
+        sys.exit(1)
+    finally:
+        client.close()
+
+
+@main.command()
+@click.argument("url")
+def interactive(url: str):
+    """Run the agent in interactive debug mode."""
+    client = OpenEnvClient(base_url=url)
+    agent = ModerationAgent()
+
+    click.echo(f"Interactive mode - connecting to {url}")
+    click.echo("Press Ctrl+C to exit\n")
+
+    try:
+        obs = client.reset()
+        click.echo(f"Initial observation:\n{obs}\n")
+
+        step = 0
+        while True:
+            click.echo(f"--- Step {step} ---")
+            action = agent.predict(obs)
+            click.echo(f"Action: {action}")
+
+            next_obs, reward, done, info = client.step(action)
+            click.echo(f"Reward: {reward:.2f}, Done: {done}")
+
+            if done:
+                click.echo("Episode complete!")
+                break
+
+            if click.confirm("Continue?"):
+                obs = next_obs
+                step += 1
+            else:
+                break
+
+    except KeyboardInterrupt:
+        click.echo("\nExiting...")
+    finally:
+        client.close()
+
+
+@main.command()
+@click.argument("url")
+@click.option("--dataset", type=click.Path(), help="Path to dataset JSON")
+def eval(url: str, dataset: Optional[str]):
+    """Evaluate the agent on a dataset."""
+    client = OpenEnvClient(base_url=url)
+    agent = ModerationAgent()
+
+    click.echo(f"[EVAL] Starting evaluation against {url}")
+
+    total_reward = 0.0
+    total_steps = 0
+    episodes = 0
+
+    try:
+        while True:
+            obs = client.reset()
+            step = 0
+            episode_reward = 0.0
+
+            while True:
+                action = agent.predict(obs)
+                next_obs, reward, done, info = client.step(action)
+                episode_reward += reward
+                step += 1
+
+                if done:
+                    break
+
+                obs = next_obs
+
+            total_reward += episode_reward
+            total_steps += step
+            episodes += 1
+
+            click.echo(f"[EPISODE] {episodes}: steps={step} reward={episode_reward:.2f}")
+
+            # In real eval, would check against ground truth here
+            if dataset:
+                # TODO: evaluate against dataset
+                pass
+
+            if episodes >= 10:  # Eval on 10 episodes by default
+                break
+
+        click.echo(f"\n[EVAL COMPLETE]")
+        click.echo(f"Episodes: {episodes}")
+        click.echo(f"Total steps: {total_steps}")
+        click.echo(f"Average reward: {total_reward / episodes:.4f}")
+
+    except Exception as e:
+        click.echo(f"[ERROR] {e}", err=True)
+        sys.exit(1)
+    finally:
+        client.close()
+
+
+if __name__ == "__main__":
+    main()

openenv_agent-0.1.0/src/openenv_agent/client.py

@@ -0,0 +1,209 @@
+"""OpenEnv client for connecting to OpenEnv servers."""
+
+import json
+import logging
+from dataclasses import dataclass
+from typing import Any, Optional, Tuple
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class EnvResponse:
+    """Response from an OpenEnv environment step."""
+    observation: dict
+    reward: float
+    done: bool
+    info: dict
+
+
+class OpenEnvClient:
+    """
+    Client for connecting to OpenEnv servers.
+
+    Provides a Gymnasium-style API (reset, step, state) for interacting
+    with OpenEnv RL environments over HTTP.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        timeout: float = 30.0,
+        api_key: Optional[str] = None,
+    ):
+        """
+        Initialize the OpenEnv client.
+
+        Args:
+            base_url: Base URL of the OpenEnv server (e.g., "http://localhost:8000")
+            timeout: Request timeout in seconds
+            api_key: Optional API key for authentication
+        """
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._client = httpx.Client(timeout=timeout)
+        if api_key:
+            self._client.headers["Authorization"] = f"Bearer {api_key}"
+
+    def reset(self) -> dict:
+        """
+        Reset the environment and return the initial observation.
+
+        Returns:
+            dict: Initial observation from the environment
+        """
+        try:
+            response = self._client.post(f"{self.base_url}/reset")
+            response.raise_for_status()
+            data = response.json()
+            return data.get("observation", data)
+        except httpx.HTTPError as e:
+            logger.error(f"Failed to reset environment: {e}")
+            raise
+
+    def step(self, action: Any) -> Tuple[dict, float, bool, dict]:
+        """
+        Execute an action in the environment.
+
+        Args:
+            action: Action to take (dict or object with as_dict method)
+
+        Returns:
+            Tuple of (observation, reward, done, info)
+        """
+        if hasattr(action, "as_dict"):
+            action_dict = action.as_dict()
+        elif isinstance(action, dict):
+            action_dict = action
+        else:
+            raise ValueError(f"Action must be dict or have as_dict() method, got {type(action)}")
+
+        try:
+            response = self._client.post(
+                f"{self.base_url}/step",
+                json={"action": action_dict},
+            )
+            response.raise_for_status()
+            data = response.json()
+            return (
+                data.get("observation", {}),
+                data.get("reward", 0.0),
+                data.get("done", False),
+                data.get("info", {}),
+            )
+        except httpx.HTTPError as e:
+            logger.error(f"Failed to step environment: {e}")
+            raise
+
+    def state(self) -> dict:
+        """
+        Get the current state of the environment without taking an action.
+
+        Returns:
+            dict: Current environment state
+        """
+        try:
+            response = self._client.get(f"{self.base_url}/state")
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as e:
+            logger.error(f"Failed to get state: {e}")
+            raise
+
+    def health(self) -> bool:
+        """
+        Check if the environment server is healthy.
+
+        Returns:
+            bool: True if server is healthy, False otherwise
+        """
+        try:
+            response = self._client.get(f"{self.base_url}/health")
+            return response.status_code == 200
+        except httpx.HTTPError:
+            return False
+
+    def close(self):
+        """Close the HTTP client."""
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False
+
+
+class AsyncOpenEnvClient:
+    """
+    Async client for connecting to OpenEnv servers.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        timeout: float = 30.0,
+        api_key: Optional[str] = None,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._client = httpx.AsyncClient(timeout=timeout)
+        if api_key:
+            self._client.headers["Authorization"] = f"Bearer {api_key}"
+
+    async def reset(self) -> dict:
+        try:
+            response = await self._client.post(f"{self.base_url}/reset")
+            response.raise_for_status()
+            data = response.json()
+            return data.get("observation", data)
+        except httpx.HTTPError as e:
+            logger.error(f"Failed to reset environment: {e}")
+            raise
+
+    async def step(self, action: Any) -> Tuple[dict, float, bool, dict]:
+        if hasattr(action, "as_dict"):
+            action_dict = action.as_dict()
+        elif isinstance(action, dict):
+            action_dict = action
+        else:
+            raise ValueError(f"Action must be dict or have as_dict() method, got {type(action)}")
+
+        try:
+            response = await self._client.post(
+                f"{self.base_url}/step",
+                json={"action": action_dict},
+            )
+            response.raise_for_status()
+            data = response.json()
+            return (
+                data.get("observation", {}),
+                data.get("reward", 0.0),
+                data.get("done", False),
+                data.get("info", {}),
+            )
+        except httpx.HTTPError as e:
+            logger.error(f"Failed to step environment: {e}")
+            raise
+
+    async def state(self) -> dict:
+        try:
+            response = await self._client.get(f"{self.base_url}/state")
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as e:
+            logger.error(f"Failed to get state: {e}")
+            raise
+
+    async def aclose(self):
+        await self._client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.aclose()
+        return False

openenv_agent-0.1.0/src/openenv_agent/env_loader.py

@@ -0,0 +1,76 @@
+"""Utility for loading OpenEnv environments from YAML config."""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+from openenv_agent.client import OpenEnvClient
+
+logger = logging.getLogger(__name__)
+
+
+def load_env_from_yaml(
+    yaml_path: str | Path,
+    **client_kwargs
+) -> Dict[str, Any]:
+    """
+    Load an OpenEnv environment configuration from a YAML file.
+
+    Args:
+        yaml_path: Path to openenv.yaml
+        **client_kwargs: Additional arguments for OpenEnvClient
+
+    Returns:
+        Dict with keys:
+            - client: OpenEnvClient instance
+            - config: Parsed environment config
+            - schemas: Observation and action schemas
+    """
+    yaml_path = Path(yaml_path)
+    if not yaml_path.exists():
+        raise FileNotFoundError(f"YAML file not found: {yaml_path}")
+
+    with open(yaml_path) as f:
+        config = yaml.safe_load(f)
+
+    env_config = config.get("environment", {})
+    api_config = config.get("api", {})
+    environment_config = config.get("environment_config", {})
+    schemas = config.get("schemas", {})
+
+    # Build base URL
+    port = api_config.get("port", 8000)
+    base_url = f"http://localhost:{port}"
+
+    client = OpenEnvClient(base_url=base_url, **client_kwargs)
+
+    return {
+        "client": client,
+        "config": {
+            "name": env_config.get("name", "unknown"),
+            "version": env_config.get("version", "unknown"),
+            "description": env_config.get("description", ""),
+        },
+        "environment_config": environment_config,
+        "schemas": schemas,
+        "metadata": config.get("metadata", {}),
+    }
+
+
+def load_env_from_url(
+    base_url: str,
+    api_key: Optional[str] = None
+) -> OpenEnvClient:
+    """
+    Load an OpenEnv environment from a URL.
+
+    Args:
+        base_url: Base URL of the OpenEnv server
+        api_key: Optional API key
+
+    Returns:
+        OpenEnvClient instance
+    """
+    return OpenEnvClient(base_url=base_url, api_key=api_key)

openenv_agent-0.1.0/src/openenv_agent/moderation_agent.py

@@ -0,0 +1,192 @@
+"""Content moderation agent using OpenAI API."""
+
+import os
+import logging
+from typing import Any, Dict, Optional
+
+from openai import OpenAI, APIError, RateLimitError
+
+from openenv_agent.agent import BaseAgent, AgentConfig
+
+logger = logging.getLogger(__name__)
+
+
+# Valid decisions and categories from OpenEnv schema
+VALID_DECISIONS = ["ALLOW", "FLAG", "REMOVE", "ESCALATE"]
+VALID_CATEGORIES = ["SPAM", "HATE_SPEECH", "MISINFORMATION", "HARASSMENT", "SAFE"]
+
+DECISION_MAP = {
+    "allow": "ALLOW",
+    "flag": "FLAG",
+    "remove": "REMOVE",
+    "escalate": "ESCALATE",
+}
+
+CATEGORY_MAP = {
+    "allow": "SAFE",
+    "flag": "SAFE",
+    "remove": "HARASSMENT",
+    "escalate": "SAFE",
+}
+
+
+class ModerationAgent(BaseAgent):
+    """
+    Content moderation agent using OpenAI API via OpenRouter.
+
+    Connects to OpenEnv content_moderation_env servers and makes
+    moderation decisions (ALLOW, FLAG, REMOVE, ESCALATE).
+    """
+
+    def __init__(self, config: Optional[AgentConfig] = None):
+        super().__init__(config or AgentConfig(name="ModerationAgent"))
+        self.api_key = os.getenv("HF_TOKEN") or os.getenv("OPENROUTER_API_KEY")
+        self.use_api = bool(self.api_key)
+
+        if self.use_api:
+            self.client = OpenAI(
+                api_key=self.api_key,
+                base_url="https://openrouter.ai/api/v1"
+            )
+        else:
+            logger.warning("No API key found. Using fallback mode.")
+            self.client = None
+
+    def predict(self, observation: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Predict a moderation action from an observation.
+
+        Args:
+            observation: Observation dict with post_body, metadata, context
+
+        Returns:
+            Action dict with decision, content_category, reasoning, confidence_score
+        """
+        if self.use_api:
+            try:
+                return self._call_api(observation)
+            except (APIError, RateLimitError) as e:
+                logger.warning(f"API failed: {e}. Using fallback.")
+                return self._fallback_decision(observation)
+        else:
+            return self._fallback_decision(observation)
+
+    def _call_api(self, obs: Dict[str, Any]) -> Dict[str, Any]:
+        """Call OpenAI API for moderation decision."""
+        post_body = obs.get("post_body", "")
+        metadata = obs.get("metadata", {})
+        context = obs.get("context", [])
+
+        user_prompt = self._build_prompt(post_body, metadata, context)
+
+        response = self.client.chat.completions.create(
+            model="openai/gpt-4.1",
+            messages=[
+                {
+                    "role": "system",
+                    "content": self._get_system_prompt()
+                },
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=self.config.temperature,
+            max_tokens=self.config.max_tokens,
+            timeout=self.config.timeout
+        )
+
+        content = response.choices[0].message.content.strip().lower()
+
+        # Parse response
+        decision_found = None
+        for decision in ["allow", "flag", "remove", "escalate"]:
+            if decision in content:
+                decision_found = decision
+                break
+
+        if not decision_found:
+            decision_found = "escalate"
+            logger.warning(f"Unexpected API response: {content}")
+
+        decision = DECISION_MAP.get(decision_found, "ESCALATE")
+        category = CATEGORY_MAP.get(decision_found, "SAFE")
+
+        return {
+            "decision": decision,
+            "content_category": category,
+            "reasoning": f"API decision: {decision_found}",
+            "confidence_score": 0.8
+        }
+
+    def _get_system_prompt(self) -> str:
+        return """You are a content moderation agent. Analyze the post and decide:
+- ALLOW: Safe content
+- FLAG: Suspicious content needing review
+- REMOVE: Harmful content
+- ESCALATE: Complex cases requiring human review
+
+Respond with only ONE decision word."""
+
+    def _build_prompt(
+        self,
+        post_body: str,
+        metadata: Dict[str, Any],
+        context: list
+    ) -> str:
+        lines = [
+            f"Post: {post_body}",
+            f"Author Trust: {metadata.get('author_trust_score', 'N/A')}",
+            f"Account Age: {metadata.get('account_age_days', 0)} days",
+            f"Reports: {metadata.get('reports_count', 0)}",
+            f"Virality: {metadata.get('virality_score', 0)}",
+            f"Context: {', '.join(context) if context else 'None'}",
+            "",
+            "Decide: allow, flag, remove, or escalate?"
+        ]
+        return "\n".join(lines)
+
+    def _fallback_decision(self, obs: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Keyword-based fallback when API is unavailable.
+        """
+        post_body = obs.get("post_body", "").lower()
+        metadata = obs.get("metadata", {})
+        harmful_keywords = {
+            "remove": ["kill", "bomb", "explode", "shoot", "murder"],
+            "flag": ["hate", "stupid", "dumb", "idiotic", "scum"],
+            "spam": ["click here", "earn money", "buy now", "http://", "https://"]
+        }
+
+        for keyword in harmful_keywords["remove"]:
+            if keyword in post_body:
+                return {
+                    "decision": "REMOVE",
+                    "content_category": "HARASSMENT",
+                    "reasoning": f"Fallback: detected '{keyword}'",
+                    "confidence_score": 0.6
+                }
+
+        for keyword in harmful_keywords["flag"]:
+            if keyword in post_body:
+                return {
+                    "decision": "FLAG",
+                    "content_category": "HATE_SPEECH",
+                    "reasoning": f"Fallback: detected '{keyword}'",
+                    "confidence_score": 0.5
+                }
+
+        # Check trust and reports
+        trust = metadata.get("author_trust_score", 0.5)
+        reports = metadata.get("reports_count", 0)
+        if trust < 0.3 and reports > 5:
+            return {
+                "decision": "FLAG",
+                "content_category": "SAFE",
+                "reasoning": "Fallback: low-trust user with many reports",
+                "confidence_score": 0.4
+            }
+
+        return {
+            "decision": "ALLOW",
+            "content_category": "SAFE",
+            "reasoning": "Fallback: no harmful patterns",
+            "confidence_score": 0.8
+        }

openenv_agent-0.1.0/src/openenv_agent.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: openenv-agent
+Version: 0.1.0
+Summary: Agent client for OpenEnv environments - connects RL agents to OpenEnv servers for inference and training
+Author: Croma
+License: MIT
+Keywords: openenv,reinforcement-learning,agent,rl,content-moderation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.3.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: click>=8.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# OpenEnv Agent
+
+Python client library for connecting RL agents to OpenEnv servers.
+
+## Installation
+
+```bash
+pip install openenv-agent
+```
+
+## Quick Start
+
+```python
+from openenv_agent import OpenEnvClient, ModerationAgent
+
+# Connect to an OpenEnv server
+client = OpenEnvClient(base_url="http://localhost:8000")
+
+# Reset environment
+obs = client.reset()
+
+# Use the moderation agent
+agent = ModerationAgent()
+action = agent.predict(obs)
+
+# Step the environment
+next_obs, reward, done, info = client.step(action)
+```
+
+## CLI Usage
+
+```bash
+# Run agent against a server
+openenv-agent run http://localhost:8000
+
+# Interactive mode
+openenv-agent interactive http://localhost:8000
+
+# Evaluate on a dataset
+openenv-agent eval http://localhost:8000 --dataset ./data.json
+```
+
+## Features
+
+- Async/sync OpenEnv client with Gymnasium-style API
+- Built-in ModerationAgent for content moderation environments
+- Environment loader from openenv.yaml configs
+- CLI tool for easy server interaction

openenv_agent-0.1.0/src/openenv_agent.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/openenv_agent/__init__.py
+src/openenv_agent/agent.py
+src/openenv_agent/cli.py
+src/openenv_agent/client.py
+src/openenv_agent/env_loader.py
+src/openenv_agent/moderation_agent.py
+src/openenv_agent.egg-info/PKG-INFO
+src/openenv_agent.egg-info/SOURCES.txt
+src/openenv_agent.egg-info/dependency_links.txt
+src/openenv_agent.egg-info/entry_points.txt
+src/openenv_agent.egg-info/requires.txt
+src/openenv_agent.egg-info/top_level.txt

openenv_agent-0.1.0/src/openenv_agent.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_agent-0.1.0/src/openenv_agent.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+openenv-agent = openenv_agent.cli:main

openenv_agent-0.1.0/src/openenv_agent.egg-info/requires.txt

@@ -0,0 +1,9 @@
+openai>=1.3.0
+httpx>=0.25.0
+pyyaml>=6.0
+click>=8.0.0
+
+[dev]
+pytest>=7.0
+pytest-asyncio>=0.21.0
+ruff>=0.1.0

openenv_agent-0.1.0/src/openenv_agent.egg-info/top_level.txt

@@ -0,0 +1 @@
+openenv_agent