plato-sdk-v2 2.4.0__tar.gz → 2.4.1__tar.gz

{plato_sdk_v2-2.4.0 → plato_sdk_v2-2.4.1}/PKG-INFO

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

plato_sdk_v2-2.4.1/VERSION

@@ -0,0 +1 @@
+2.4.1

{plato_sdk_v2-2.4.0 → plato_sdk_v2-2.4.1}/plato/v1/cli/chronos.py

@@ -71,12 +71,24 @@ def launch(
         plato chronos launch config.json
         plato chronos launch config.json --wait
         plato chronos launch config.json --url https://chronos.example.com
+
+    Config format (simplified - agents/secrets embedded in world_config):
+        {
+            "world_package": "plato-world-structured-execution",
+            "world_version": "latest",  // optional
+            "world_config": {
+                "skill_runner": {
+                    "image": "claude-code:2.1.5",
+                    "config": { ... }
+                },
+                "plato_api_key": "pk_xxx",  // secrets embedded
+                ...
+            },
+            "runtime_artifact_id": "..."  // optional
+        }
     """
     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"
@@ -99,53 +111,34 @@ def launch(
         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"),
-    )
+    # Build request - simplified format (agents/secrets in world_config)
+    request_body = {
+        "world_package": job_config["world_package"],
+        "world_version": job_config.get("world_version"),
+        "world_config": job_config.get("world_config", {}),
+        "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())}")
+    console.print(f"   World: {request_body['world_package']}")
+    if request_body.get("world_version"):
+        console.print(f"   Version: {request_body['world_version']}")
 
     try:
-        with httpx.Client(base_url=chronos_url, timeout=60) as client:
-            response = launch_job.sync(client, request, x_api_key=api_key)
+        with httpx.Client(timeout=60) as client:
+            response = client.post(
+                f"{chronos_url.rstrip('/')}/api/jobs/launch",
+                json=request_body,
+                headers={"X-API-Key": api_key},
+            )
+            response.raise_for_status()
+            result = response.json()
 
         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]")
+        console.print(f"   Session ID: {result['session_id']}")
+        console.print(f"   Plato Session: {result.get('plato_session_id', 'N/A')}")
+        console.print(f"   Status: {result['status']}")
+        console.print(f"\n[dim]View at: {chronos_url}/sessions/{result['session_id']}[/dim]")
 
         if wait:
             console.print("\n[yellow]--wait not yet implemented[/yellow]")
@@ -178,7 +171,7 @@ def example(
     examples = {
         "structured-execution": {
             "world_package": "plato-world-structured-execution",
-            "world_version": "0.1.13",
+            "world_version": "latest",
             "world_config": {
                 "sim_name": "my-sim",
                 "github_url": "https://github.com/example/repo",
@@ -188,25 +181,22 @@ def example(
                     "image": "claude-code:2.1.5",
                     "config": {"model_name": "anthropic/claude-sonnet-4-20250514", "max_turns": 100},
                 },
+                "plato_api_key": "pk_xxx",
+                "anthropic_api_key": "sk-ant-xxx",
             },
-            "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)",
+            "_comment": "Agents and secrets are embedded directly in world_config",
         },
         "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"}}
+            "world_config": {
+                "task": "Fix the bug in src/main.py",
+                "repo_url": "https://github.com/example/repo",
+                "coder": {
+                    "image": "claude-code:latest",
+                    "config": {"model_name": "anthropic/claude-sonnet-4-20250514"},
+                },
             },
-            "secret_ids": [],
-            "_comment": "version is optional - uses latest if not specified",
+            "_comment": "world_version is optional - uses latest if not specified",
         },
     }
 
@@ -437,6 +427,34 @@ async def _close_chronos_session(
         logger.warning(f"Failed to close Chronos session: {e}")
 
 
+async def _complete_chronos_session(
+    chronos_url: str,
+    api_key: str,
+    session_id: str,
+    status: str,
+    exit_code: int | None = None,
+    error_message: str | None = None,
+) -> None:
+    """Complete a Chronos session with final status."""
+    import httpx
+
+    url = f"{chronos_url.rstrip('/')}/api/sessions/{session_id}/complete"
+
+    payload = {"status": status}
+    if exit_code is not None:
+        payload["exit_code"] = exit_code
+    if error_message:
+        payload["error_message"] = error_message
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(url, headers={"x-api-key": api_key}, json=payload)
+            response.raise_for_status()
+            logger.info(f"Completed Chronos session: {session_id} with status: {status}")
+    except Exception as e:
+        logger.warning(f"Failed to complete Chronos session: {e}")
+
+
 async def _run_dev_impl(
     world_dir: Path,
     config_path: Path,
@@ -655,9 +673,10 @@ async def _run_dev_impl(
                     print(line, end="")
 
             process.wait()
+            world_exit_code = process.returncode
 
-            if process.returncode != 0:
-                raise RuntimeError(f"World execution failed with exit code {process.returncode}")
+            if world_exit_code != 0:
+                raise RuntimeError(f"World execution failed with exit code {world_exit_code}")
 
         finally:
             os.unlink(container_config_path)
@@ -668,15 +687,34 @@ async def _run_dev_impl(
             )
             console.print(f"[dim]Cleaned up workspace volume: {workspace_volume}[/dim]")
 
+    except Exception as e:
+        # Complete session as failed
+        if chronos_session_id:
+            await _complete_chronos_session(
+                chronos_url,
+                api_key,
+                chronos_session_id,
+                status="failed",
+                exit_code=getattr(e, "exit_code", 1),
+                error_message=str(e)[:500],
+            )
+        raise
+    else:
+        # Complete session as successful
+        if chronos_session_id:
+            await _complete_chronos_session(
+                chronos_url,
+                api_key,
+                chronos_session_id,
+                status="completed",
+                exit_code=0,
+            )
     finally:
         if session:
             console.print("[blue]Closing Plato session...[/blue]")
             await session.close()
         await plato.close()
 
-        if chronos_session_id:
-            await _close_chronos_session(chronos_url, api_key, chronos_session_id)
-
 
 @chronos_app.command()
 def dev(

plato_sdk_v2-2.4.0/VERSION

@@ -1 +0,0 @@
-2.4.0