plato-sdk-v2 2.3.7__tar.gz → 2.3.10__tar.gz

{plato_sdk_v2-2.3.7 → plato_sdk_v2-2.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plato-sdk-v2
-Version: 2.3.7
+Version: 2.3.10
 Summary: Python SDK for the Plato API
 Author-email: Plato <support@plato.so>
 License-Expression: MIT
@@ -47,7 +47,6 @@ Description-Content-Type: text/markdown
 
 # Plato Python SDK
 
-
 Python SDK for the Plato platform. Uses [Harbor](https://harborframework.com) for agent execution.
 
 ## Installation

{plato_sdk_v2-2.3.7 → plato_sdk_v2-2.3.10}/README.md

@@ -1,6 +1,5 @@
 # Plato Python SDK
 
-
 Python SDK for the Plato platform. Uses [Harbor](https://harborframework.com) for agent execution.
 
 ## Installation

plato_sdk_v2-2.3.10/VERSION

@@ -0,0 +1 @@
+2.3.10

{plato_sdk_v2-2.3.7 → plato_sdk_v2-2.3.10}/plato/agents/otel.py

@@ -51,6 +51,8 @@ class OTelSpanLogHandler(logging.Handler):
     def emit(self, record: logging.LogRecord) -> None:
         """Emit a log record as an OTel span."""
         try:
+            # Debug: print that we're emitting a log span
+            print(f"[OTel] Emitting log span: {record.name} - {record.getMessage()[:100]}")
             # Create a span for the log message
             with self.tracer.start_as_current_span(f"log.{record.levelname.lower()}") as span:
                 span.set_attribute("log.level", record.levelname)
@@ -137,13 +139,18 @@ def init_tracing(
             context_api.attach(ctx)
             print(f"[OTel] Using parent context: trace_id={parent_trace_id}, span_id={parent_span_id}")
 
-        # Add OTel logging handler to capture world logs
+        # Add OTel logging handler to capture logs from plato SDK
         tracer = trace.get_tracer(service_name)
         _log_handler = OTelSpanLogHandler(tracer, level=logging.INFO)
 
-        # Add handler to plato.worlds loggers
-        plato_worlds_logger = logging.getLogger("plato.worlds")
-        plato_worlds_logger.addHandler(_log_handler)
+        # Add handler to plato loggers (worlds and agents)
+        # Set level to INFO to ensure logs propagate from child loggers
+        plato_logger = logging.getLogger("plato")
+        plato_logger.setLevel(logging.INFO)
+        plato_logger.addHandler(_log_handler)
+        print(
+            f"[OTel] Added log handler to 'plato' logger (level={plato_logger.level}, handlers={len(plato_logger.handlers)})"
+        )
 
         _initialized = True
 
@@ -164,8 +171,8 @@ def shutdown_tracing() -> None:
     # Remove log handler
     if _log_handler:
         try:
-            plato_worlds_logger = logging.getLogger("plato.worlds")
-            plato_worlds_logger.removeHandler(_log_handler)
+            plato_logger = logging.getLogger("plato")
+            plato_logger.removeHandler(_log_handler)
         except Exception:
             pass
         _log_handler = None
@@ -222,8 +229,11 @@ def instrument(service_name: str = "plato-agent") -> Tracer:
     parent_trace_id = os.environ.get("OTEL_TRACE_ID")
     parent_span_id = os.environ.get("OTEL_PARENT_SPAN_ID")
 
+    print(f"[OTel] instrument() called: service={service_name}, endpoint={otel_endpoint}, session={session_id}")
+
     if not otel_endpoint:
         # Return default tracer (no-op if no provider configured)
+        print("[OTel] No OTEL_EXPORTER_OTLP_ENDPOINT set, returning no-op tracer")
         return trace.get_tracer(service_name)
 
     # Initialize tracing with parent context if provided

{plato_sdk_v2-2.3.7 → plato_sdk_v2-2.3.10}/plato/agents/runner.py

@@ -152,21 +152,34 @@ async def run_agent(
         docker_cmd.extend(["--instruction", instruction])
 
         # Run container - agents emit their own OTel spans
+        # Use large limit to handle agents that output long lines (e.g., JSON with file contents)
         process = await asyncio.create_subprocess_exec(
             *docker_cmd,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.STDOUT,
+            limit=100 * 1024 * 1024,  # 100MB buffer limit
         )
 
-        # Capture output for error reporting
+        # Capture output for error reporting using chunked reads to handle large lines
         output_lines: list[str] = []
         assert process.stdout is not None
+        buffer = ""
         while True:
-            line = await process.stdout.readline()
-            if not line:
+            try:
+                chunk = await process.stdout.read(65536)
+            except Exception:
+                break
+            if not chunk:
                 break
-            decoded_line = line.decode().rstrip()
-            output_lines.append(decoded_line)
+            buffer += chunk.decode(errors="replace")
+
+            while "\n" in buffer:
+                line, buffer = buffer.split("\n", 1)
+                output_lines.append(line)
+
+        # Handle any remaining content in buffer
+        if buffer.strip():
+            output_lines.append(buffer)
 
         await process.wait()
 

{plato_sdk_v2-2.3.7 → plato_sdk_v2-2.3.10}/plato/chronos/models/__init__.py

@@ -10,10 +10,18 @@ from pydantic import AwareDatetime, BaseModel, ConfigDict, Field
 
 
 class AgentConfig(BaseModel):
+    """Agent config - supports multiple formats.
+
+    New format: agent + version (version optional, defaults to latest)
+    Legacy format: agent_id (public_id)
+    """
+
     model_config = ConfigDict(
         extra="allow",
     )
-    agent_id: Annotated[str, Field(title="Agent Id")]
+    agent: Annotated[str | None, Field(title="Agent")] = None
+    version: Annotated[str | None, Field(title="Version")] = None
+    agent_id: Annotated[str | None, Field(title="Agent Id")] = None  # backwards compat
     config: Annotated[dict[str, Any] | None, Field(title="Config")] = {}
 
 

plato_sdk_v2-2.3.10/plato/v1/cli/chronos.py

@@ -0,0 +1,219 @@
+"""Plato Chronos CLI - Launch and manage Chronos jobs."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from plato.v1.cli.utils import console
+
+chronos_app = typer.Typer(help="Chronos job management commands.")
+
+
+@chronos_app.command()
+def launch(
+    config: Path = typer.Argument(
+        ...,
+        help="Path to job config JSON file",
+        exists=True,
+        readable=True,
+    ),
+    chronos_url: str = typer.Option(
+        None,
+        "--url",
+        "-u",
+        envvar="CHRONOS_URL",
+        help="Chronos API URL (default: https://chronos.plato.so)",
+    ),
+    api_key: str = typer.Option(
+        None,
+        "--api-key",
+        "-k",
+        envvar="PLATO_API_KEY",
+        help="Plato API key for authentication",
+    ),
+    wait: bool = typer.Option(
+        False,
+        "--wait",
+        "-w",
+        help="Wait for job completion and stream logs",
+    ),
+):
+    """
+    Launch a Chronos job from a config file.
+
+    The config file should be a JSON file with the following structure:
+
+    \b
+    {
+      "world_package": "plato-world-structured-execution",
+      "world_version": "0.1.13",  // optional, uses latest if not specified
+      "world_config": { ... },
+      "agent_configs": {
+        "skill_runner": {
+          "agent_id": "claude-code:2.1.5",
+          "config": { ... }
+        }
+      },
+      "secret_ids": [1, 2, 3]  // IDs of secrets from Chronos
+    }
+
+    Examples:
+        plato chronos launch config.json
+        plato chronos launch config.json --wait
+        plato chronos launch config.json --url https://chronos.example.com
+    """
+    import httpx
+
+    from plato.chronos.api.jobs import launch_job
+    from plato.chronos.models import AgentConfig, LaunchJobRequest
+
+    # Set defaults
+    if not chronos_url:
+        chronos_url = "https://chronos.plato.so"
+
+    if not api_key:
+        console.print("[red]❌ No API key provided[/red]")
+        console.print("Set PLATO_API_KEY environment variable or use --api-key")
+        raise typer.Exit(1)
+
+    # Load config
+    try:
+        with open(config) as f:
+            job_config = json.load(f)
+    except json.JSONDecodeError as e:
+        console.print(f"[red]❌ Invalid JSON in config file: {e}[/red]")
+        raise typer.Exit(1)
+
+    # Validate required fields
+    if "world_package" not in job_config:
+        console.print("[red]❌ Missing required field: world_package[/red]")
+        raise typer.Exit(1)
+
+    if "agent_configs" not in job_config:
+        console.print("[red]❌ Missing required field: agent_configs[/red]")
+        raise typer.Exit(1)
+
+    # Build agent configs - supports both formats:
+    # - {"agent": "claude-code", "version": "2.1.5"} (new)
+    # - {"agent_id": "ag_xxxxx"} (backwards compat)
+    agent_configs = {}
+    for slot_name, agent_cfg in job_config.get("agent_configs", {}).items():
+        if "agent" not in agent_cfg and "agent_id" not in agent_cfg:
+            console.print(f"[red]❌ Missing 'agent' or 'agent_id' for slot: {slot_name}[/red]")
+            raise typer.Exit(1)
+
+        config_kwargs = {"config": agent_cfg.get("config", {})}
+        if "agent" in agent_cfg:
+            config_kwargs["agent"] = agent_cfg["agent"]
+            config_kwargs["version"] = agent_cfg.get("version")
+        else:
+            config_kwargs["agent_id"] = agent_cfg["agent_id"]
+
+        agent_configs[slot_name] = AgentConfig(**config_kwargs)
+
+    # Build request
+    request = LaunchJobRequest(
+        world_package=job_config["world_package"],
+        world_version=job_config.get("world_version"),
+        world_config=job_config.get("world_config"),
+        agent_configs=agent_configs,
+        secret_ids=job_config.get("secret_ids"),
+        runtime_artifact_id=job_config.get("runtime_artifact_id"),
+    )
+
+    console.print("[blue]🚀 Launching job...[/blue]")
+    console.print(f"   World: {request.world_package}")
+    if request.world_version:
+        console.print(f"   Version: {request.world_version}")
+    console.print(f"   Agents: {list(agent_configs.keys())}")
+
+    try:
+        with httpx.Client(base_url=chronos_url, timeout=60) as client:
+            response = launch_job.sync(client, request, x_api_key=api_key)
+
+        console.print("\n[green]✅ Job launched successfully![/green]")
+        console.print(f"   Session ID: {response.session_id}")
+        console.print(f"   Plato Session: {response.plato_session_id}")
+        console.print(f"   Status: {response.status}")
+        console.print(f"\n[dim]View at: {chronos_url}/sessions/{response.session_id}[/dim]")
+
+        if wait:
+            console.print("\n[yellow]--wait not yet implemented[/yellow]")
+
+    except Exception as e:
+        console.print(f"[red]❌ Failed to launch job: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@chronos_app.command()
+def example(
+    world: str = typer.Argument(
+        "structured-execution",
+        help="World to generate example config for",
+    ),
+    output: Path = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file path (prints to stdout if not specified)",
+    ),
+):
+    """
+    Generate an example job config file.
+
+    Examples:
+        plato chronos example
+        plato chronos example structured-execution -o config.json
+    """
+    examples = {
+        "structured-execution": {
+            "world_package": "plato-world-structured-execution",
+            "world_version": "0.1.13",
+            "world_config": {
+                "sim_name": "my-sim",
+                "github_url": "https://github.com/example/repo",
+                "max_attempts": 3,
+                "use_backtrack": True,
+                "skill_runner": {
+                    "image": "claude-code:2.1.5",
+                    "config": {"model_name": "anthropic/claude-sonnet-4-20250514", "max_turns": 100},
+                },
+            },
+            "agent_configs": {
+                "skill_runner": {
+                    "agent": "claude-code",
+                    "version": "2.1.5",
+                    "config": {"model_name": "anthropic/claude-sonnet-4-20250514", "max_turns": 100},
+                }
+            },
+            "secret_ids": [],
+            "_comment": "Add secret IDs from Chronos. Secrets should include: plato_api_key, anthropic_api_key (or claude_oauth_credentials for the agent)",
+        },
+        "code-world": {
+            "world_package": "plato-world-code",
+            "world_config": {"task": "Fix the bug in src/main.py", "repo_url": "https://github.com/example/repo"},
+            "agent_configs": {
+                "coder": {"agent": "claude-code", "config": {"model_name": "anthropic/claude-sonnet-4-20250514"}}
+            },
+            "secret_ids": [],
+            "_comment": "version is optional - uses latest if not specified",
+        },
+    }
+
+    if world not in examples:
+        console.print(f"[red]❌ Unknown world: {world}[/red]")
+        console.print(f"Available examples: {list(examples.keys())}")
+        raise typer.Exit(1)
+
+    example_config = examples[world]
+    json_output = json.dumps(example_config, indent=2)
+
+    if output:
+        with open(output, "w") as f:
+            f.write(json_output)
+        console.print(f"[green]✅ Example config written to {output}[/green]")
+    else:
+        console.print(json_output)

{plato_sdk_v2-2.3.7 → plato_sdk_v2-2.3.10}/plato/v1/cli/main.py

@@ -9,6 +9,7 @@ import typer
 from dotenv import load_dotenv
 
 from plato.v1.cli.agent import agent_app
+from plato.v1.cli.chronos import chronos_app
 from plato.v1.cli.pm import pm_app
 from plato.v1.cli.sandbox import sandbox_app
 from plato.v1.cli.utils import console
@@ -71,6 +72,7 @@ app.add_typer(sandbox_app, name="sandbox")
 app.add_typer(pm_app, name="pm")
 app.add_typer(agent_app, name="agent")
 app.add_typer(world_app, name="world")
+app.add_typer(chronos_app, name="chronos")
 
 
 # =============================================================================

{plato_sdk_v2-2.3.7 → plato_sdk_v2-2.3.10}/plato/v1/cli/sandbox.py

@@ -131,6 +131,9 @@ def sandbox_start(
     timeout: int = typer.Option(1800, "--timeout", help="VM lifetime in seconds (default: 30 minutes)"),
     no_reset: bool = typer.Option(False, "--no-reset", help="Skip initial reset after ready"),
     json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+    working_dir: Path = typer.Option(
+        None, "--working-dir", "-w", help="Working directory for .sandbox.yaml and .plato/"
+    ),
 ):
     """
     Start a sandbox environment.
@@ -377,7 +380,7 @@ def sandbox_start(
                     console.print("[cyan]  Generating SSH key pair...[/cyan]")
 
                 base_url = os.getenv("PLATO_BASE_URL", "https://plato.so")
-                ssh_info = setup_ssh_for_sandbox(base_url, job_id, username=ssh_username)
+                ssh_info = setup_ssh_for_sandbox(base_url, job_id, username=ssh_username, working_dir=working_dir)
                 ssh_host = ssh_info["ssh_host"]
                 ssh_config_path = ssh_info["config_path"]
                 ssh_private_key_path = ssh_info["private_key_path"]
@@ -489,7 +492,7 @@ def sandbox_start(
         # Add heartbeat PID
         if heartbeat_pid:
             state["heartbeat_pid"] = heartbeat_pid
-        save_sandbox_state(state)
+        save_sandbox_state(state, working_dir)
 
         # Close the plato client (heartbeat process keeps session alive)
         plato.close()

{plato_sdk_v2-2.3.7 → plato_sdk_v2-2.3.10}/plato/v1/cli/ssh.py

@@ -9,21 +9,21 @@ from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import ed25519
 
 
-def get_plato_dir() -> Path:
+def get_plato_dir(working_dir: Path | str | None = None) -> Path:
     """Get the directory for plato config/SSH files.
 
-    Uses /workspace/.plato if /workspace exists (container environment),
-    otherwise uses ~/.plato (local development).
+    Args:
+        working_dir: If provided, returns working_dir/.plato (for container/agent use).
+                     If None, returns ~/.plato (local development).
     """
-    workspace = Path("/workspace")
-    if workspace.exists() and workspace.is_dir():
-        return workspace / ".plato"
+    if working_dir is not None:
+        return Path(working_dir) / ".plato"
     return Path.home() / ".plato"
 
 
-def get_next_sandbox_number() -> int:
+def get_next_sandbox_number(working_dir: Path | str | None = None) -> int:
     """Find next available sandbox number by checking existing config files."""
-    plato_dir = get_plato_dir()
+    plato_dir = get_plato_dir(working_dir)
     if not plato_dir.exists():
         return 1
 
@@ -41,13 +41,13 @@ def get_next_sandbox_number() -> int:
     return max_num + 1
 
 
-def generate_ssh_key_pair(sandbox_num: int) -> tuple[str, str]:
+def generate_ssh_key_pair(sandbox_num: int, working_dir: Path | str | None = None) -> tuple[str, str]:
     """
     Generate a new ed25519 SSH key pair for a specific sandbox.
 
     Returns (public_key_str, private_key_path).
     """
-    plato_dir = get_plato_dir()
+    plato_dir = get_plato_dir(working_dir)
     plato_dir.mkdir(mode=0o700, exist_ok=True)
 
     private_key_path = plato_dir / f"ssh_{sandbox_num}_key"
@@ -136,6 +136,7 @@ def create_ssh_config(
     username: str,
     private_key_path: str,
     sandbox_num: int,
+    working_dir: Path | str | None = None,
 ) -> str:
     """
     Create a temporary SSH config file for a specific sandbox.
@@ -172,7 +173,7 @@ def create_ssh_config(
     TCPKeepAlive yes
 """
 
-    plato_dir = get_plato_dir()
+    plato_dir = get_plato_dir(working_dir)
     plato_dir.mkdir(mode=0o700, exist_ok=True)
 
     config_path = plato_dir / f"ssh_{sandbox_num}.conf"
@@ -182,7 +183,12 @@ def create_ssh_config(
     return str(config_path)
 
 
-def setup_ssh_for_sandbox(base_url: str, job_public_id: str, username: str = "plato") -> dict:
+def setup_ssh_for_sandbox(
+    base_url: str,
+    job_public_id: str,
+    username: str = "plato",
+    working_dir: Path | str | None = None,
+) -> dict:
     """
     Set up SSH access for a sandbox - generates keys and creates config.
 
@@ -190,14 +196,14 @@ def setup_ssh_for_sandbox(base_url: str, job_public_id: str, username: str = "pl
 
     Returns dict with: ssh_host, config_path, public_key, private_key_path
     """
-    sandbox_num = get_next_sandbox_number()
+    sandbox_num = get_next_sandbox_number(working_dir)
     ssh_host = f"sandbox-{sandbox_num}"
 
     # Choose random port between 2200 and 2299
     local_port = random.randint(2200, 2299)
 
     # Generate SSH key pair
-    public_key, private_key_path = generate_ssh_key_pair(sandbox_num)
+    public_key, private_key_path = generate_ssh_key_pair(sandbox_num, working_dir)
 
     # Create SSH config file
     config_path = create_ssh_config(
@@ -208,6 +214,7 @@ def setup_ssh_for_sandbox(base_url: str, job_public_id: str, username: str = "pl
         username=username,
         private_key_path=private_key_path,
         sandbox_num=sandbox_num,
+        working_dir=working_dir,
     )
 
     return {

{plato_sdk_v2-2.3.7 → plato_sdk_v2-2.3.10}/plato/v1/cli/utils.py

@@ -15,32 +15,52 @@ console = Console()
 SANDBOX_FILE = ".sandbox.yaml"
 
 
-def get_sandbox_state() -> dict | None:
-    """Read sandbox state from .sandbox.yaml in current directory."""
-    sandbox_file = Path.cwd() / SANDBOX_FILE
+def get_sandbox_state(working_dir: Path | str | None = None) -> dict | None:
+    """Read sandbox state from .sandbox.yaml.
+
+    Args:
+        working_dir: Directory containing .sandbox.yaml. If None, uses cwd.
+    """
+    base_dir = Path(working_dir) if working_dir else Path.cwd()
+    sandbox_file = base_dir / SANDBOX_FILE
     if not sandbox_file.exists():
         return None
     with open(sandbox_file) as f:
         return yaml.safe_load(f)
 
 
-def save_sandbox_state(state: dict) -> None:
-    """Save sandbox state to .sandbox.yaml in current directory."""
-    sandbox_file = Path.cwd() / SANDBOX_FILE
+def save_sandbox_state(state: dict, working_dir: Path | str | None = None) -> None:
+    """Save sandbox state to .sandbox.yaml.
+
+    Args:
+        state: State dict to save.
+        working_dir: Directory to save .sandbox.yaml in. If None, uses cwd.
+    """
+    base_dir = Path(working_dir) if working_dir else Path.cwd()
+    sandbox_file = base_dir / SANDBOX_FILE
     with open(sandbox_file, "w") as f:
         yaml.dump(state, f, default_flow_style=False)
 
 
-def remove_sandbox_state() -> None:
-    """Remove .sandbox.yaml from current directory."""
-    sandbox_file = Path.cwd() / SANDBOX_FILE
+def remove_sandbox_state(working_dir: Path | str | None = None) -> None:
+    """Remove .sandbox.yaml.
+
+    Args:
+        working_dir: Directory containing .sandbox.yaml. If None, uses cwd.
+    """
+    base_dir = Path(working_dir) if working_dir else Path.cwd()
+    sandbox_file = base_dir / SANDBOX_FILE
     if sandbox_file.exists():
         sandbox_file.unlink()
 
 
-def require_sandbox_state() -> dict:
-    """Get sandbox state or exit with error."""
-    state = get_sandbox_state()
+def require_sandbox_state(working_dir: Path | str | None = None) -> dict:
+    """Get sandbox state or exit with error.
+
+    Args:
+        working_dir: Directory containing .sandbox.yaml. If None, uses cwd.
+    """
+    state = get_sandbox_state(working_dir)
     if not state:
         console.print("[red]No sandbox found in current directory[/red]")
         console.print("\n[yellow]Start a sandbox with:[/yellow]")

{plato_sdk_v2-2.3.7 → plato_sdk_v2-2.3.10}/plato/worlds/base.py

@@ -28,6 +28,17 @@ from plato.agents.otel import (
 
 logger = logging.getLogger(__name__)
 
+
+def _get_plato_version() -> str:
+    """Get the installed plato SDK version."""
+    try:
+        from importlib.metadata import version
+
+        return version("plato")
+    except Exception:
+        return "unknown"
+
+
 # Global registry of worlds
 _WORLD_REGISTRY: dict[str, type[BaseWorld]] = {}
 
@@ -673,6 +684,11 @@ The following services are available for your use:
             else:
                 logger.debug("No otel_url in config - OTel tracing disabled")
 
+        # Log version info (goes to OTel after init_tracing)
+        plato_version = _get_plato_version()
+        world_version = self.get_version()
+        self.logger.info(f"World version: {world_version}, Plato SDK version: {plato_version}")
+
         # Connect to Plato session if configured (for heartbeats)
         await self._connect_plato_session()
 

plato_sdk_v2-2.3.7/VERSION

@@ -1 +0,0 @@
-2.3.7