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

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

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

plato_sdk_v2-2.5.0/VERSION

@@ -0,0 +1 @@
+2.5.0

{plato_sdk_v2-2.4.1 → plato_sdk_v2-2.5.0}/plato/v1/cli/agent.py

@@ -757,8 +757,8 @@ def agent_schema(
     console.print(json.dumps(schema, indent=2))
 
 
-@agent_app.command(name="push")
-def agent_push(
+@agent_app.command(name="publish")
+def agent_publish(
     target: str = typer.Argument(".", help="Path to agent directory OR Harbor agent name"),
     all_agents: bool = typer.Option(False, "--all", "-a", help="Publish all agents in directory"),
     dry_run: bool = typer.Option(False, "--dry-run", help="Build without pushing to ECR"),
@@ -776,10 +776,10 @@ def agent_push(
     - Harbor agents: from installed Harbor package version
 
     Examples:
-        plato agent push ./agents/my-agent      # Custom agent
-        plato agent push claude-code            # Harbor built-in
-        plato agent push --all ./agents         # All agents in directory
-        plato agent push claude-code --dry-run  # Dry run
+        plato agent publish ./agents/my-agent      # Custom agent
+        plato agent publish claude-code            # Harbor built-in
+        plato agent publish --all ./agents         # All agents in directory
+        plato agent publish claude-code --dry-run  # Dry run
     """
 
     # Handle --all flag with directory
@@ -964,7 +964,7 @@ def agent_images():
     agents = data.get("agents", [])
     if not agents:
         console.print("[yellow]No published agents found[/yellow]")
-        console.print("\n[dim]Publish with: plato agent push <path-or-name>[/dim]")
+        console.print("\n[dim]Publish with: plato agent publish <path-or-name>[/dim]")
         return
 
     console.print("[bold]Published Agent Images:[/bold]\n")

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

@@ -51,41 +51,27 @@ def launch(
     """
     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": { ... }
+    Config format:
+        {
+            "world": {
+                "package": "plato-world-structured-execution:0.1.17",
+                "config": {
+                    "skill_runner": {
+                        "image": "computer-use:1.1.0",
+                        "config": { ... }
+                    },
+                    "secrets": { ... }
+                }
+            },
+            "runtime": {
+                "artifact_id": "..."  // optional
+            }
         }
-      },
-      "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
-
-    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
 
@@ -107,22 +93,19 @@ def launch(
         raise typer.Exit(1)
 
     # Validate required fields
-    if "world_package" not in job_config:
-        console.print("[red]❌ Missing required field: world_package[/red]")
+    if "world" not in job_config or "package" not in job_config.get("world", {}):
+        console.print("[red]❌ Missing required field: world.package[/red]")
         raise typer.Exit(1)
 
-    # Build request - simplified format (agents/secrets in world_config)
+    # Build request
     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"),
+        "world": job_config["world"],
+        "runtime": job_config.get("runtime", {}),
     }
 
+    world_package = job_config["world"]["package"]
     console.print("[blue]🚀 Launching job...[/blue]")
-    console.print(f"   World: {request_body['world_package']}")
-    if request_body.get("world_version"):
-        console.print(f"   Version: {request_body['world_version']}")
+    console.print(f"   World: {world_package}")
 
     try:
         with httpx.Client(timeout=60) as client:
@@ -489,22 +472,22 @@ async def _run_dev_impl(
     with open(config_path) as f:
         raw_config = json.load(f)
 
-    # Handle Chronos-style config format
-    if "world_config" in raw_config:
-        config_data = raw_config["world_config"].copy()
-        top_level_secrets = raw_config.get("secrets", {})
-        if top_level_secrets:
-            config_data.setdefault("secrets", {})
-            config_data["secrets"].update(top_level_secrets)
-    else:
-        config_data = raw_config.copy()
+    # Validate config format: { world: { package, config }, runtime: { artifact_id } }
+    if "world" not in raw_config or "package" not in raw_config.get("world", {}):
+        raise ValueError("Invalid config: missing world.package")
 
-    # Determine world name from config
-    world_package = raw_config.get("world_package", "")
-    if world_package.startswith("plato-world-"):
-        world_name = world_package[len("plato-world-") :]
+    world_package = raw_config["world"]["package"]
+    config_data = raw_config["world"].get("config", {}).copy()
+    runtime_artifact_id = raw_config.get("runtime", {}).get("artifact_id")
+    if runtime_artifact_id:
+        config_data["runtime_artifact_id"] = runtime_artifact_id
+
+    # Parse world name from package (e.g., "plato-world-structured-execution:0.1.17")
+    world_package_name = world_package.split(":")[0] if ":" in world_package else world_package
+    if world_package_name.startswith("plato-world-"):
+        world_name = world_package_name[len("plato-world-") :]
     else:
-        world_name = world_package or "unknown"
+        world_name = world_package_name or "unknown"
 
     # Build local agent images if agents_dir is provided
     if agents_dir:
@@ -553,8 +536,8 @@ async def _run_dev_impl(
             plato_session_id = session.session_id
             console.print(f"[green]✅ Created Plato session: {plato_session_id}[/green]")
 
-            # Add session to config
-            config_data["plato_session"] = session.dump()
+            # Add session to config (convert Pydantic model to dict for JSON serialization)
+            config_data["plato_session"] = session.dump().model_dump()
 
         # Create Chronos session
         console.print("[blue]Creating Chronos session...[/blue]")
@@ -748,27 +731,23 @@ def dev(
     \b
     Config format (same as Chronos launch):
     {
-        "world_package": "plato-world-structured-execution",
-        "world_config": {
-            "sim_name": "my-task",
-            "steps": [...],
-            "agents": {
+        "world": {
+            "package": "plato-world-structured-execution:0.1.17",
+            "config": {
                 "skill_runner": {
-                    "image": "computer-use:latest",
-                    "config": {"model_name": "..."}
-                }
+                    "image": "computer-use:1.1.0",
+                    "config": { ... }
+                },
+                "secrets": { ... }
             }
         },
-        "secrets": {
-            "gemini_api_key": "...",
-            "plato_api_key": "..."
+        "runtime": {
+            "artifact_id": "..."
         }
     }
 
-    Examples:
-        plato chronos dev config.json --world-dir ~/worlds/my-world
-        plato chronos dev config.json -w ~/worlds/my-world -a ~/agents
-        plato chronos dev config.json -w ~/worlds/my-world --platform linux/amd64
+    Example:
+        plato chronos dev config.json -w ~/worlds/my-world -a ~/agents --platform linux/amd64
     """
     logging.basicConfig(
         level=logging.INFO,

{plato_sdk_v2-2.4.1 → plato_sdk_v2-2.5.0}/plato/v1/cli/world.py

@@ -62,41 +62,6 @@ def _extract_schema_from_wheel(wheel_path: Path, module_name: str) -> dict | Non
     return None
 
 
-def _register_world_schema(
-    api_url: str,
-    api_key: str,
-    package_name: str,
-    version: str,
-    schema_data: dict,
-) -> bool:
-    """Register world schema with plato.so registry."""
-    import httpx
-
-    try:
-        with httpx.Client(base_url=api_url, timeout=30.0) as client:
-            response = client.post(
-                f"/v2/pypi/worlds/packages/{package_name}/schema",
-                json={
-                    "version": version,
-                    "config_schema": schema_data,
-                },
-                headers={"X-API-Key": api_key},
-            )
-
-            if response.status_code in (200, 201):
-                return True
-            elif response.status_code == 404:
-                # Endpoint doesn't exist yet - that's ok
-                console.print("[dim]Schema registration endpoint not available[/dim]")
-                return False
-            else:
-                console.print(f"[yellow]Warning: Schema registration returned {response.status_code}[/yellow]")
-                return False
-    except Exception as e:
-        console.print(f"[yellow]Warning: Could not register schema: {e}[/yellow]")
-        return False
-
-
 @world_app.command(name="publish")
 def world_publish(
     path: str = typer.Argument(".", help="Path to the world package directory (default: current directory)"),
@@ -218,11 +183,19 @@ def world_publish(
     schema_data = _extract_schema_from_wheel(wheel_file, module_name)
     if schema_data:
         props = schema_data.get("properties", {})
-        console.print(f"[green]Schema found:[/green] {len(props)} properties")
+        agents = schema_data.get("agents", [])
+        secrets = schema_data.get("secrets", [])
+        console.print(
+            f"[green]Schema found:[/green] {len(props)} properties, {len(agents)} agents, {len(secrets)} secrets"
+        )
         console.print(f"[dim]  Properties: {', '.join(props.keys()) if props else 'none'}[/dim]")
+        if agents:
+            console.print(f"[dim]  Agents: {', '.join(a.get('name', '?') for a in agents)}[/dim]")
     else:
-        console.print("[yellow]Warning: No schema.json found in wheel[/yellow]")
+        console.print("[red]Error: No schema.json found in wheel[/red]")
         console.print("[dim]  Add a hatch build hook to generate schema.json from get_schema()[/dim]")
+        console.print("[dim]  See: https://docs.plato.so/worlds/publishing#schema-generation[/dim]")
+        raise SystemExit(1)
 
     if dry_run:
         console.print("\n[yellow]Dry run - skipping upload[/yellow]")
@@ -272,11 +245,5 @@ def world_publish(
         console.print(f"[red]Upload error: {e}[/red]")
         raise typer.Exit(1) from e
 
-    # Register schema if we have one
-    if schema_data:
-        console.print("\n[cyan]Registering schema...[/cyan]")
-        if _register_world_schema(api_url, api_key, package_name, version, schema_data):
-            console.print("[green]Schema registered![/green]")
-
     console.print("\n[bold]Install with:[/bold]")
     console.print(f"  uv add {package_name} --index-url {api_url}/v2/pypi/worlds/simple/")

{plato_sdk_v2-2.4.1 → plato_sdk_v2-2.5.0}/plato/worlds/__init__.py

@@ -52,7 +52,17 @@ from plato.worlds.base import (
     get_world,
     register_world,
 )
-from plato.worlds.config import Agent, AgentConfig, CheckpointConfig, Env, EnvConfig, RunConfig, Secret, StateConfig
+from plato.worlds.config import (
+    Agent,
+    AgentConfig,
+    CheckpointConfig,
+    Env,
+    EnvConfig,
+    EnvList,
+    RunConfig,
+    Secret,
+    StateConfig,
+)
 from plato.worlds.runner import run_world
 
 __all__ = [
@@ -72,6 +82,7 @@ __all__ = [
     "Agent",
     "Secret",
     "Env",
+    "EnvList",
     "EnvConfig",
     # Env types (re-exported from generated models)
     "EnvFromArtifact",

{plato_sdk_v2-2.4.1 → plato_sdk_v2-2.5.0}/plato/worlds/config.py

@@ -55,7 +55,7 @@ class Secret:
 
 
 class Env:
-    """Annotation marker for environment fields.
+    """Annotation marker for single environment fields.
 
     Environments are VMs that run alongside the world's runtime.
     They can be specified by artifact ID, simulator name, or resource config.
@@ -72,6 +72,24 @@ class Env:
         self.required = required
 
 
+class EnvList:
+    """Annotation marker for a list of arbitrary environments.
+
+    Use this when the world accepts a dynamic list of environments
+    rather than named, fixed environment fields.
+
+    Usage:
+        envs: Annotated[
+            list[EnvFromSimulator | EnvFromArtifact | EnvFromResource],
+            EnvList(description="Environments to create for this task"),
+            Field(discriminator="type"),
+        ] = []
+    """
+
+    def __init__(self, description: str = ""):
+        self.description = description
+
+
 class StateConfig(BaseModel):
     """Configuration for world state persistence.
 
@@ -92,12 +110,12 @@ class CheckpointConfig(BaseModel):
     """Configuration for automatic checkpointing during world execution.
 
     Attributes:
-        enabled: Whether to enable automatic checkpoints after steps.
+        enabled: Whether to enable automatic checkpoints after steps (default: False).
         interval: Create checkpoint every N steps (default: 1 = every step).
         exclude_envs: Environment aliases to exclude from checkpoints (default: ["runtime"]).
     """
 
-    enabled: bool = True
+    enabled: bool = False
     interval: int = 1
     exclude_envs: list[str] = Field(default_factory=lambda: ["runtime"])
 
@@ -150,16 +168,16 @@ class RunConfig(BaseModel):
     model_config = {"extra": "allow"}
 
     @classmethod
-    def get_field_annotations(cls) -> dict[str, Agent | Secret | Env | None]:
-        """Get Agent/Secret/Env annotations for each field."""
-        result: dict[str, Agent | Secret | Env | None] = {}
+    def get_field_annotations(cls) -> dict[str, Agent | Secret | Env | EnvList | None]:
+        """Get Agent/Secret/Env/EnvList annotations for each field."""
+        result: dict[str, Agent | Secret | Env | EnvList | None] = {}
 
         for field_name, field_info in cls.model_fields.items():
             marker = None
 
             # Pydantic stores Annotated metadata in field_info.metadata
             for meta in field_info.metadata:
-                if isinstance(meta, (Agent, Secret, Env)):
+                if isinstance(meta, (Agent, Secret, Env, EnvList)):
                     marker = meta
                     break
 
@@ -182,6 +200,7 @@ class RunConfig(BaseModel):
         agents = []
         secrets = []
         envs = []
+        env_list_field: dict | None = None  # For EnvList marker (arbitrary envs)
 
         # Skip runtime fields
         runtime_fields = {"session_id", "otel_url", "upload_url", "all_secrets", "plato_session", "checkpoint", "state"}
@@ -228,6 +247,12 @@ class RunConfig(BaseModel):
                         "default": default_value,
                     }
                 )
+            elif isinstance(marker, EnvList):
+                # Field marked as a list of arbitrary environments
+                env_list_field = {
+                    "name": field_name,
+                    "description": marker.description,
+                }
             else:
                 world_properties[field_name] = prop_schema
 
@@ -236,7 +261,7 @@ class RunConfig(BaseModel):
             r for r in full_schema.get("required", []) if r not in runtime_fields and annotations.get(r) is None
         ]
 
-        return {
+        result = {
             "properties": world_properties,
             "required": required,
             "agents": agents,
@@ -244,6 +269,16 @@ class RunConfig(BaseModel):
             "envs": envs,
         }
 
+        # Include $defs if present (for nested type references)
+        if "$defs" in full_schema:
+            result["$defs"] = full_schema["$defs"]
+
+        # Add env_list if present (for worlds with arbitrary environment lists)
+        if env_list_field:
+            result["env_list"] = env_list_field
+
+        return result
+
     def get_envs(self) -> list[EnvConfig]:
         """Get all environment configurations from this config.
 
@@ -287,8 +322,13 @@ class RunConfig(BaseModel):
         # Handle secrets dict -> individual secret fields
         secrets_dict = data.pop("secrets", {})
 
-        # Handle envs dict -> individual env fields
-        envs_dict = data.pop("envs", {})
+        # Check if there's an EnvList field - if so, don't pop envs as a dict
+        has_env_list = any(isinstance(m, EnvList) for m in annotations.values())
+
+        # Handle envs dict -> individual env fields (only for named Env pattern)
+        envs_dict: dict = {}
+        if not has_env_list:
+            envs_dict = data.pop("envs", {})
 
         # Merge world_config into top-level
         parsed.update(world_config)
@@ -310,6 +350,11 @@ class RunConfig(BaseModel):
                     parsed[field_name] = _parse_env_config(env_data)
                 else:
                     parsed[field_name] = env_data
+            elif isinstance(marker, EnvList) and field_name in parsed:
+                # Parse list of env configs
+                env_list = parsed[field_name]
+                if isinstance(env_list, list):
+                    parsed[field_name] = [_parse_env_config(e) if isinstance(e, dict) else e for e in env_list]
 
         # Store all secrets for agent use
         parsed["all_secrets"] = secrets_dict

plato_sdk_v2-2.4.1/VERSION

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