plato-sdk-v2 2.3.8__py3-none-any.whl → 2.3.11__py3-none-any.whl

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/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/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.6",
+                    "config": {"model_name": "anthropic/claude-sonnet-4-20250514", "max_turns": 100},
+                },
+            },
+            "agent_configs": {
+                "skill_runner": {
+                    "agent": "claude-code",
+                    "version": "2.1.6",
+                    "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/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/v1/cli/pm.py

@@ -753,16 +753,16 @@ def review_data(
     is_installed = "site-packages" in str(package_dir)
 
     if is_installed:
-        extension_source_path = package_dir / "extensions" / "envgen-recorder"
+        extension_source_path = package_dir / "extensions" / "envgen-recorder-old"
     else:
         repo_root = package_dir.parent.parent.parent  # plato-client/
-        extension_source_path = repo_root / "extensions" / "envgen-recorder"
+        extension_source_path = repo_root / "extensions" / "envgen-recorder-old"
 
     # Fallback to env var
     if not extension_source_path.exists():
         plato_client_dir_env = os.getenv("PLATO_CLIENT_DIR")
         if plato_client_dir_env:
-            env_path = Path(plato_client_dir_env) / "extensions" / "envgen-recorder"
+            env_path = Path(plato_client_dir_env) / "extensions" / "envgen-recorder-old"
             if env_path.exists():
                 extension_source_path = env_path
 

plato/v1/cli/sandbox.py

@@ -1819,8 +1819,6 @@ def sandbox_clear_audit(
 
     for name, db_config in db_listeners:
         db_type = db_config.get("db_type", "postgresql").lower()
-        db_host = db_config.get("db_host", "127.0.0.1")
-        db_port = db_config.get("db_port", 5432 if db_type == "postgresql" else 3306)
         db_user = db_config.get("db_user", "postgres" if db_type == "postgresql" else "root")
         db_password = db_config.get("db_password", "")
         db_database = db_config.get("db_database", "postgres")
@@ -1829,10 +1827,15 @@ def sandbox_clear_audit(
             console.print(f"[cyan]Clearing audit_log for listener '{name}' ({db_type})...[/cyan]")
 
         # Build SQL command based on db_type
+        # Use docker exec since psql/mysql aren't installed on the VM directly
         if db_type == "postgresql":
-            sql_cmd = f"PGPASSWORD='{db_password}' psql -h {db_host} -p {db_port} -U {db_user} -d {db_database} -c 'TRUNCATE TABLE audit_log RESTART IDENTITY CASCADE'"
+            # Find the postgres container and truncate all audit_log tables across all schemas
+            # Use $body$ delimiter instead of $$ to avoid shell expansion
+            truncate_sql = "DO \\$body\\$ DECLARE r RECORD; BEGIN FOR r IN SELECT schemaname FROM pg_tables WHERE tablename = 'audit_log' LOOP EXECUTE format('TRUNCATE TABLE %I.audit_log RESTART IDENTITY CASCADE', r.schemaname); END LOOP; END \\$body\\$;"
+            sql_cmd = f"CONTAINER=$(docker ps --format '{{{{.Names}}}}\\t{{{{.Image}}}}' | grep -i postgres | head -1 | cut -f1) && docker exec $CONTAINER psql -U {db_user} -d {db_database} -c \"{truncate_sql}\""
         elif db_type in ("mysql", "mariadb"):
-            sql_cmd = f"mysql -h {db_host} -P {db_port} -u {db_user} -p'{db_password}' {db_database} -e 'SET FOREIGN_KEY_CHECKS=0; DELETE FROM audit_log; SET FOREIGN_KEY_CHECKS=1;'"
+            # Find the mysql/mariadb container and exec into it
+            sql_cmd = f"CONTAINER=$(docker ps --format '{{{{.Names}}}}\\t{{{{.Image}}}}' | grep -iE 'mysql|mariadb' | head -1 | cut -f1) && docker exec $CONTAINER mysql -u {db_user} -p'{db_password}' {db_database} -e 'SET FOREIGN_KEY_CHECKS=0; DELETE FROM audit_log; SET FOREIGN_KEY_CHECKS=1;'"
         else:
             if not json_output:
                 console.print(f"[yellow]⚠ Unsupported db_type '{db_type}' for listener '{name}'[/yellow]")

{plato_sdk_v2-2.3.8.dist-info → plato_sdk_v2-2.3.11.dist-info}/METADATA

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

{plato_sdk_v2-2.3.8.dist-info → plato_sdk_v2-2.3.11.dist-info}/RECORD

@@ -303,7 +303,7 @@ plato/agents/base.py,sha256=vUbPQuNSo6Ka2lIB_ZOXgi4EoAjtAD7GIj9LnNotam0,4577
 plato/agents/build.py,sha256=CNMbVQFs2_pYit1dA29Davve28Yi4c7TNK9wBB7odrE,1621
 plato/agents/config.py,sha256=CmRS6vOAg7JeqX4Hgp_KpA1YWBX_LuMicHm7SBjQEbs,5077
 plato/agents/otel.py,sha256=UOEBeMyyfbffsC3tRXlHAydoj9bXwJupA_UeLZ5h97w,8585
-plato/agents/runner.py,sha256=Ei20Ib-Fn5XOaS6V1Rtw0UEw34XflEWaXMpazPjmnrE,6061
+plato/agents/runner.py,sha256=ZzEK-O0tCZMBb-y-d2Y8f0BkfPgC-vKkZVOnHfZd7e8,6560
 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
@@ -367,7 +367,7 @@ plato/chronos/api/worlds/create_world.py,sha256=H6yl5QIazNXgryOR5rvscSIMf8Y9kjc6
 plato/chronos/api/worlds/delete_world.py,sha256=UETu3Zk0e2VkDdAyMilv1ev-0g_j-oujH1Dc8DBqQOc,1239
 plato/chronos/api/worlds/get_world.py,sha256=eHTM1U5JiNTaZwYLh7x4QVBoRQeI5kaJ9o6xSi4-nos,1356
 plato/chronos/api/worlds/list_worlds.py,sha256=hBAuGb69tlasyn-kV_LNr9x6Rr7SHhST5hXJn1uqMf8,1253
-plato/chronos/models/__init__.py,sha256=5Hil8v_jFX1YU6LpOfqyJM4WV867Ckv6CX052Q4SCso,20996
+plato/chronos/models/__init__.py,sha256=t9Kn9qwMBm2S9qs9weF0-CBCg4o1-u_W_3kDFQb-aDU,21328
 plato/sims/README.md,sha256=FIbJhNVNAV-SO6dq_cXX3Rg0C7HdQCfEY9YxGlkCmsM,6902
 plato/sims/__init__.py,sha256=tnoCGKZwNx6h22tEWLujdpLv6K4PpFU2RnDOhL1o-Uc,1494
 plato/sims/agent_helpers.py,sha256=kITvQywoTCS8mGhro3jZWuPJHDlje-UZujhjoahqhd0,10291
@@ -387,9 +387,10 @@ plato/v1/sync_flow_executor.py,sha256=kgvNYOtA9FHeNfP7qb8ZPUIlTsfIss_Z98W8uX5vec
 plato/v1/sync_sdk.py,sha256=2sedg1QJiSxr1I3kCyfaLAnlAgHlbblc3QQP_47O30k,25697
 plato/v1/cli/__init__.py,sha256=om4b7PxgsoI7rEwuQelmQkqPdhMVn53_5qEN8kvksYw,105
 plato/v1/cli/agent.py,sha256=G6TV3blG_BqMDBWS-CG7GwzqoqcJTMsIKQ88jvLXb4k,43745
-plato/v1/cli/main.py,sha256=ktPtBvMwykR7AjXmTQ6bmZkHdzpAjhX5Fq66cDbGSzA,6844
-plato/v1/cli/pm.py,sha256=uLM6WszKqxq9Czg1FraDyWb9_INUuHZq63imvRYfRLw,49734
-plato/v1/cli/sandbox.py,sha256=N7DIpXsxExtZB47tWKxp-3cV0_gLnI7C-mTKW3tTi8Y,95360
+plato/v1/cli/chronos.py,sha256=QfVLbnFxhJcVdLNvaJkIyAlb-QgLlUdgvH3P4MfgJT8,7335
+plato/v1/cli/main.py,sha256=iKUz6Mu-4-dgr29qOUmDqBaumOCzNQKZsHAalVtaH0Q,6932
+plato/v1/cli/pm.py,sha256=TIvXBIWFDjr4s1girMMCuvHWQJkjpmsS-igAamddIWE,49746
+plato/v1/cli/sandbox.py,sha256=22WbT66hFlpGIpN9V8NlNdncKpd098hY5WJxicTnggo,95944
 plato/v1/cli/ssh.py,sha256=enrf7Y01ZeRIyHDEX0Yt7up5zEe7MCvE9u8SP4Oqiz4,6926
 plato/v1/cli/utils.py,sha256=ba7Crv4OjDmgCv4SeB8UeZDin-iOdQw_3N6fd-g5XVk,4572
 plato/v1/cli/verify.py,sha256=7QmQwfOOkr8a51f8xfVIr2zif7wGl2E8HOZTbOaIoV0,20671
@@ -462,7 +463,7 @@ plato/worlds/base.py,sha256=kIX02gMQR43ZsZK25vZvCoNkYtICVRMeofNk-im5IRM,28215
 plato/worlds/build_hook.py,sha256=KSoW0kqa5b7NyZ7MYOw2qsZ_2FkWuz0M3Ru7AKOP7Qw,3486
 plato/worlds/config.py,sha256=a5frj3mt06rSlT25kE-L8Q2b2MTWkR-8cUoBKpC8tG4,11036
 plato/worlds/runner.py,sha256=2H5EV77bTYrMyI7qez0kwxOp9EApQxG19Ob9a_GTdbw,19383
-plato_sdk_v2-2.3.8.dist-info/METADATA,sha256=GnoZAAlPmFfWxSwHFjkab7s6MmWfk8rXOvOynTb2r28,8652
-plato_sdk_v2-2.3.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-plato_sdk_v2-2.3.8.dist-info/entry_points.txt,sha256=upGMbJCx6YWUTKrPoYvYUYfFCqYr75nHDwhA-45m6p8,136
-plato_sdk_v2-2.3.8.dist-info/RECORD,,
+plato_sdk_v2-2.3.11.dist-info/METADATA,sha256=31I2bshYErJviipSAqW8gMKPoOk3z2Xef7ULUO7rSds,8653
+plato_sdk_v2-2.3.11.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+plato_sdk_v2-2.3.11.dist-info/entry_points.txt,sha256=upGMbJCx6YWUTKrPoYvYUYfFCqYr75nHDwhA-45m6p8,136
+plato_sdk_v2-2.3.11.dist-info/RECORD,,