plato-sdk-v2 2.2.2__py3-none-any.whl → 2.2.3__py3-none-any.whl

plato/agents/runner.py

@@ -6,6 +6,7 @@ import asyncio
 import json
 import logging
 import os
+import platform
 import tempfile
 from pathlib import Path
 
@@ -62,21 +63,29 @@ async def run_agent(
             # Build docker command
             docker_cmd = ["docker", "run", "--rm"]
 
-            # Check if iptables is available for network isolation
-            try:
-                proc = await asyncio.create_subprocess_exec(
-                    "iptables",
-                    "-L",
-                    "-n",
-                    stdout=asyncio.subprocess.DEVNULL,
-                    stderr=asyncio.subprocess.DEVNULL,
-                )
-                await proc.wait()
-                has_iptables = proc.returncode == 0
-            except (FileNotFoundError, PermissionError):
-                has_iptables = False
-
-            if not has_iptables:
+            # Determine if we need host networking:
+            # - Required on Linux without iptables for connectivity
+            # - Skip on macOS where --network=host doesn't work properly
+            use_host_network = False
+            is_macos = platform.system() == "Darwin"
+
+            if not is_macos:
+                try:
+                    proc = await asyncio.create_subprocess_exec(
+                        "iptables",
+                        "-L",
+                        "-n",
+                        stdout=asyncio.subprocess.DEVNULL,
+                        stderr=asyncio.subprocess.DEVNULL,
+                    )
+                    await proc.wait()
+                    has_iptables = proc.returncode == 0
+                except (FileNotFoundError, PermissionError):
+                    has_iptables = False
+
+                use_host_network = not has_iptables
+
+            if use_host_network:
                 docker_cmd.extend(["--network=host", "--add-host=localhost:127.0.0.1"])
 
             docker_cmd.extend(
@@ -96,6 +105,8 @@ async def run_agent(
                 docker_cmd.extend(["-e", f"{key.upper()}={value}"])
 
             docker_cmd.append(image)
+
+            # Pass instruction via CLI arg (agents expect --instruction flag)
             docker_cmd.extend(["--instruction", instruction])
 
             # Run container and stream output

plato/worlds/base.py

@@ -145,6 +145,7 @@ class BaseWorld(ABC, Generic[ConfigT]):
             "required": schema.get("required", []),
             "agents": schema.get("agents", []),
             "secrets": schema.get("secrets", []),
+            "envs": schema.get("envs", []),
         }
 
     @abstractmethod

plato/worlds/runner.py

@@ -6,6 +6,7 @@ import asyncio
 import json
 import logging
 import os
+import platform
 from pathlib import Path
 from typing import Annotated
 
@@ -135,18 +136,143 @@ def list_worlds(
         typer.echo(f"  {name} (v{version}): {desc}")
 
 
+async def _build_agent_image(
+    agent_name: str,
+    agents_dir: Path,
+    plato_client_root: Path | None = None,
+) -> bool:
+    """Build a local agent Docker image.
+
+    Args:
+        agent_name: Name of the agent (e.g., "openhands")
+        agents_dir: Directory containing agent subdirectories
+        plato_client_root: Root of plato-client repo (for dev builds), or None for prod builds
+
+    Returns:
+        True if build succeeded, False otherwise
+    """
+    import subprocess
+
+    # Resolve paths to absolute
+    agents_dir = agents_dir.expanduser().resolve()
+    agent_path = agents_dir / agent_name
+    dockerfile_path = agent_path / "Dockerfile"
+
+    if not dockerfile_path.exists():
+        logger.warning(f"No Dockerfile found for agent '{agent_name}' at {dockerfile_path}")
+        return False
+
+    image_tag = f"{agent_name}:latest"
+
+    # Determine build context and target
+    if plato_client_root:
+        plato_client_root = plato_client_root.expanduser().resolve()
+
+    if plato_client_root and plato_client_root.exists():
+        # Dev build from plato-client root (includes local python-sdk)
+        build_context = str(plato_client_root)
+        dockerfile_abs = str(dockerfile_path)
+        target = "dev"
+        logger.info(f"Building {image_tag} (dev mode from {build_context})...")
+    else:
+        # Prod build from agent directory
+        build_context = str(agent_path)
+        dockerfile_abs = str(dockerfile_path)
+        target = "prod"
+        logger.info(f"Building {image_tag} (prod mode from {build_context})...")
+
+    cmd = [
+        "docker",
+        "build",
+        "--target",
+        target,
+        "-t",
+        image_tag,
+        "-f",
+        dockerfile_abs,
+    ]
+
+    # Use native platform for local dev on ARM Macs (avoids slow emulation)
+    if platform.machine() == "arm64":
+        cmd.extend(["--build-arg", "PLATFORM=linux/arm64"])
+
+    cmd.append(build_context)
+
+    logger.debug(f"Build command: {' '.join(cmd)}")
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+
+    if result.returncode != 0:
+        logger.error(f"Failed to build {image_tag}:\n{result.stderr}")
+        return False
+
+    logger.info(f"Successfully built {image_tag}")
+    return True
+
+
+def _extract_agent_images_from_config(config_data: dict) -> list[str]:
+    """Extract agent image names from config data.
+
+    Args:
+        config_data: Raw config dictionary
+
+    Returns:
+        List of image names (without tags) that are local (not from a registry)
+    """
+    images = []
+
+    # Check agents section
+    agents = config_data.get("agents", {})
+    for agent_config in agents.values():
+        if isinstance(agent_config, dict):
+            image = agent_config.get("image", "")
+            # Only include local images (no registry prefix like ghcr.io/)
+            if image and "/" not in image.split(":")[0]:
+                # Extract name without tag
+                name = image.split(":")[0]
+                if name not in images:
+                    images.append(name)
+
+    # Also check direct coder/verifier fields
+    for field in ["coder", "verifier"]:
+        agent_config = config_data.get(field, {})
+        if isinstance(agent_config, dict):
+            image = agent_config.get("image", "")
+            if image and "/" not in image.split(":")[0]:
+                name = image.split(":")[0]
+                if name not in images:
+                    images.append(name)
+
+    return images
+
+
 async def _run_dev(
     world_name: str,
     config_path: Path,
     env_timeout: int = 600,
+    chronos_url: str | None = None,
+    api_key: str | None = None,
+    agents_dir: Path | None = None,
 ) -> None:
     """Run a world locally with automatic environment creation.
 
     This mimics what Chronos does but runs locally for debugging:
     1. Load and parse the config
-    2. Create Plato session with all environments
-    3. Run the world with the session attached
+    2. Build local agent images if --agents-dir is provided
+    3. Create Plato session with all environments
+    4. Optionally initialize Chronos logging for callbacks
+    5. Run the world with the session attached
+
+    Args:
+        world_name: Name of the world to run
+        config_path: Path to the config JSON file
+        env_timeout: Timeout for environment creation (seconds)
+        chronos_url: Optional Chronos base URL for sending log events
+        api_key: Optional Plato API key (used for Chronos session creation)
+        agents_dir: Optional directory containing agent source code
     """
+    from uuid import uuid4
+
     from plato.v2 import AsyncPlato
     from plato.worlds.base import get_world
 
@@ -167,6 +293,23 @@ async def _run_dev(
     # Parse the config to get typed access
     run_config = config_class._from_dict(config_data.copy())
 
+    # Build local agent images if agents_dir is provided
+    if agents_dir:
+        # Resolve agents_dir to absolute path
+        agents_dir = agents_dir.expanduser().resolve()
+        agent_images = _extract_agent_images_from_config(config_data)
+        if agent_images:
+            logger.info(f"Building local agent images: {agent_images}")
+            # Determine if we're in a plato-client repo for dev builds
+            # (agents_dir is something like /path/to/plato-client/agents)
+            plato_client_root = agents_dir.parent if agents_dir.name == "agents" else None
+            for agent_name in agent_images:
+                success = await _build_agent_image(agent_name, agents_dir, plato_client_root)
+                if not success:
+                    raise RuntimeError(f"Failed to build agent image: {agent_name}")
+        else:
+            logger.info("No local agent images found in config")
+
     # Get environment configs from the parsed config
     env_configs: list[EnvConfig] = run_config.get_envs()
 
@@ -174,6 +317,23 @@ async def _run_dev(
     plato = AsyncPlato()
     session = None
 
+    # Initialize Chronos logging if URL provided
+    chronos_session_id: str | None = None
+    if chronos_url:
+        from plato.agents import init_logging
+
+        chronos_session_id = f"dev-{uuid4().hex[:8]}"
+        callback_url = f"{chronos_url.rstrip('/')}/api/v1/callback"
+        init_logging(
+            callback_url=callback_url,
+            session_id=chronos_session_id,
+        )
+        logger.info(f"Chronos logging enabled: {callback_url} (session: {chronos_session_id})")
+
+        # Update run_config with session info for agents
+        run_config.session_id = chronos_session_id
+        run_config.callback_url = callback_url
+
     try:
         if env_configs:
             logger.info(f"Creating {len(env_configs)} environments...")
@@ -199,12 +359,66 @@ async def _run_dev(
             await session.close()
         await plato.close()
 
+        # Reset logging
+        if chronos_url:
+            from plato.agents import reset_logging
+
+            reset_logging()
+
+
+def _setup_colored_logging(verbose: bool = False) -> None:
+    """Setup colored logging with filtered noisy loggers."""
+    log_level = logging.DEBUG if verbose else logging.INFO
+
+    # Define colors for different log levels
+    colors = {
+        "DEBUG": "\033[36m",  # Cyan
+        "INFO": "\033[32m",  # Green
+        "WARNING": "\033[33m",  # Yellow
+        "ERROR": "\033[31m",  # Red
+        "CRITICAL": "\033[35m",  # Magenta
+    }
+    reset = "\033[0m"
+
+    class ColoredFormatter(logging.Formatter):
+        def format(self, record: logging.LogRecord) -> str:
+            color = colors.get(record.levelname, "")
+            record.levelname = f"{color}{record.levelname}{reset}"
+            record.name = f"\033[34m{record.name}{reset}"  # Blue for logger name
+            return super().format(record)
+
+    # Create handler with colored formatter
+    handler = logging.StreamHandler()
+    handler.setFormatter(
+        ColoredFormatter(
+            "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+            datefmt="%H:%M:%S",
+        )
+    )
+
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(log_level)
+    root_logger.handlers = [handler]
+
+    # Silence noisy HTTP loggers
+    for noisy_logger in ["httpcore", "httpx", "urllib3", "hpack"]:
+        logging.getLogger(noisy_logger).setLevel(logging.WARNING)
+
 
 @app.command("dev")
 def dev(
     world: Annotated[str, typer.Option("--world", "-w", help="World name to run")],
     config: Annotated[Path, typer.Option("--config", "-c", help="Path to config JSON file")],
     env_timeout: Annotated[int, typer.Option("--env-timeout", help="Timeout for environment creation (seconds)")] = 600,
+    chronos_url: Annotated[
+        str | None, typer.Option("--chronos-url", help="Chronos base URL for log events (e.g., http://localhost:8000)")
+    ] = None,
+    api_key: Annotated[str | None, typer.Option("--api-key", help="Plato API key for Chronos authentication")] = None,
+    agents_dir: Annotated[
+        Path | None,
+        typer.Option("--agents-dir", "-a", help="Directory containing agent source code (builds local images)"),
+    ] = None,
     verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Enable verbose logging")] = False,
 ) -> None:
     """Run a world locally for development/debugging.
@@ -212,30 +426,35 @@ def dev(
     This creates Plato environments automatically (like Chronos does)
     and runs the world with the session attached.
 
+    Optionally sends log events to a Chronos server for real-time monitoring.
+
     Example config.json:
     {
-        "repository_url": "https://github.com/user/repo",
-        "prompt": "Fix the bug in main.py",
-        "agents": {
-            "coder": {
-                "image": "openhands:latest",
-                "config": {"model_name": "claude-sonnet-4"}
-            }
+        "instruction": "Create a git repo and upload files to S3",
+        "coder": {
+            "image": "openhands:latest",
+            "config": {"model_name": "gemini/gemini-3-flash-preview"}
         },
         "secrets": {
-            "anthropic_api_key": "sk-..."
+            "gemini_api_key": "..."
         }
     }
 
     Environment variables:
         PLATO_API_KEY: API key for Plato (required)
+
+    Examples:
+        # Basic usage
+        plato-world-runner dev -w code -c config.json
+
+        # With local agent builds (from plato-client repo)
+        plato-world-runner dev -w code -c config.json --agents-dir ~/plato-client/agents
+
+        # With Chronos logging
+        plato-world-runner dev -w code -c config.json --chronos-url http://localhost:8000
     """
-    # Setup logging
-    log_level = logging.DEBUG if verbose else logging.INFO
-    logging.basicConfig(
-        level=log_level,
-        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-    )
+    # Setup colored logging with filtered noisy loggers
+    _setup_colored_logging(verbose)
 
     if not config.exists():
         typer.echo(f"Error: Config file not found: {config}", err=True)
@@ -246,7 +465,7 @@ def dev(
         raise typer.Exit(1)
 
     try:
-        asyncio.run(_run_dev(world, config, env_timeout))
+        asyncio.run(_run_dev(world, config, env_timeout, chronos_url, api_key, agents_dir))
     except Exception as e:
         logger.exception(f"World execution failed: {e}")
         raise typer.Exit(1)

{plato_sdk_v2-2.2.2.dist-info → plato_sdk_v2-2.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plato-sdk-v2
-Version: 2.2.2
+Version: 2.2.3
 Summary: Python SDK for the Plato API
 Author-email: Plato <support@plato.so>
 License-Expression: MIT

{plato_sdk_v2-2.2.2.dist-info → plato_sdk_v2-2.2.3.dist-info}/RECORD

@@ -302,7 +302,7 @@ plato/agents/base.py,sha256=vUbPQuNSo6Ka2lIB_ZOXgi4EoAjtAD7GIj9LnNotam0,4577
 plato/agents/build.py,sha256=CNMbVQFs2_pYit1dA29Davve28Yi4c7TNK9wBB7odrE,1621
 plato/agents/config.py,sha256=VZVMdCmEQnoR0VkrGdScG8p6zSKVFe7BZPd2h8lKNjI,5460
 plato/agents/logging.py,sha256=z9rDlGPbrpcTS8PephbK2rDqT7thC1KyLkua4ypUkv4,12210
-plato/agents/runner.py,sha256=rOWYTSAhdola_FdrbviP955NBusNtBUy-q_c5fDA9to,5123
+plato/agents/runner.py,sha256=YoqG1QdNScIjSSH0vPgnm42LlqeAeVsFT01VL77ony0,5565
 plato/agents/trajectory.py,sha256=WdiBmua0KvCrNaM3qgPI7-7B4xmSkfbP4oZ_9_8qHzU,10529
 plato/chronos/__init__.py,sha256=RHMvSrQS_-vkKOyTRuAkp2gKDP1HEuBLDnw8jcZs1Jg,739
 plato/chronos/client.py,sha256=YcOGtHWERyOD9z8LKt8bRMVL0cEwL2hiAP4qQgdZlUI,5495
@@ -464,11 +464,11 @@ plato/v2/utils/models.py,sha256=PwehSSnIRG-tM3tWL1PzZEH77ZHhIAZ9R0UPs6YknbM,1441
 plato/v2/utils/proxy_tunnel.py,sha256=8ZTd0jCGSfIHMvSv1fgEyacuISWnGPHLPbDglWroTzY,10463
 plato/worlds/README.md,sha256=TgG4aidude0ouJSCfY81Ev45hsUxPkO85HUIiWNqkcc,5463
 plato/worlds/__init__.py,sha256=crzpXFh4XD8eS4pYFTEUf3XgUf0wapFPT4npAu8sWwk,2078
-plato/worlds/base.py,sha256=McV2QAuHYztSMfG8EXQML1kEPbdeADLt8tgiYpH35n4,10751
+plato/worlds/base.py,sha256=5_BAad_w0l4DkgnNYojSDNfOWHXLmD0Q39cLSUuGYJw,10795
 plato/worlds/build_hook.py,sha256=KSoW0kqa5b7NyZ7MYOw2qsZ_2FkWuz0M3Ru7AKOP7Qw,3486
 plato/worlds/config.py,sha256=ggDcySspfeFry2KBUwhgnS6Po2KssYzwZNIDmVeGhPQ,9460
-plato/worlds/runner.py,sha256=07fKyPYxem1vIKfPRo4le7eKWTkY3euDXugObVyAsf4,7858
-plato_sdk_v2-2.2.2.dist-info/METADATA,sha256=1kiU4THegqudfEb-uvUEujXQzCP6EIRL97Y_LsWq1kg,8508
-plato_sdk_v2-2.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-plato_sdk_v2-2.2.2.dist-info/entry_points.txt,sha256=upGMbJCx6YWUTKrPoYvYUYfFCqYr75nHDwhA-45m6p8,136
-plato_sdk_v2-2.2.2.dist-info/RECORD,,
+plato/worlds/runner.py,sha256=RNnWFQ7rfEWE7TQ_tqgLHgLm1a4VxtP0mR7beALx4f0,15781
+plato_sdk_v2-2.2.3.dist-info/METADATA,sha256=18iVpDD44_fE6Sy6U19MKBNCI1zDY-0fk7CZ0SlC8ak,8508
+plato_sdk_v2-2.2.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+plato_sdk_v2-2.2.3.dist-info/entry_points.txt,sha256=upGMbJCx6YWUTKrPoYvYUYfFCqYr75nHDwhA-45m6p8,136
+plato_sdk_v2-2.2.3.dist-info/RECORD,,