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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plato-sdk-v2
-Version: 2.4.2
+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.2 → plato_sdk_v2-2.5.0}/plato/v1/cli/chronos.py

@@ -536,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]")

{plato_sdk_v2-2.4.2 → 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.2 → 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.2 → 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.2/VERSION

@@ -1 +0,0 @@
-2.4.2