plato-sdk-v2 2.1.17__py3-none-any.whl → 2.2.2__py3-none-any.whl

plato/_sims_generator/instruction.py

@@ -157,7 +157,8 @@ class InstructionGenerator:
     def _copy_instructions_yaml(self):
         """Bundle the instructions.yaml config with the package."""
         # We'll generate a cleaned version of the config
-        config_data = {
+        env_vars: dict[str, dict[str, str | int]] = {}
+        config_data: dict[str, str | dict] = {
             "type": "instruction",
             "env_prefix": self.config.env_prefix,
             "title": self.config.title,
@@ -166,7 +167,7 @@ class InstructionGenerator:
             "services": {
                 name: {"port": svc.port, "description": svc.description} for name, svc in self.config.services.items()
             },
-            "env_vars": {},
+            "env_vars": env_vars,
             "instructions": self.config.instructions,
         }
 
@@ -178,7 +179,7 @@ class InstructionGenerator:
                 var_data["default"] = var.default
             if var.env_key:
                 var_data["env_key"] = var.env_key
-            config_data["env_vars"][name] = var_data
+            env_vars[name] = var_data
 
         with open(self.output / "instructions.yaml", "w") as f:
             yaml.dump(config_data, f, default_flow_style=False, sort_keys=False)

plato/agents/trajectory.py

@@ -9,7 +9,7 @@ Spec: https://harborframework.com/docs/trajectory-format
 
 from __future__ import annotations
 
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Literal
 
 from pydantic import BaseModel, Field
@@ -115,7 +115,7 @@ class Step(BaseModel):
         """Create a user step."""
         return cls(
             step_id=step_id,
-            timestamp=datetime.utcnow().isoformat() + "Z",
+            timestamp=datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
             source="user",
             message=message,
             **kwargs,
@@ -136,7 +136,7 @@ class Step(BaseModel):
         """Create an agent step."""
         return cls(
             step_id=step_id,
-            timestamp=datetime.utcnow().isoformat() + "Z",
+            timestamp=datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
             source="agent",
             message=message,
             model_name=model_name,
@@ -152,7 +152,7 @@ class Step(BaseModel):
         """Create a system step."""
         return cls(
             step_id=step_id,
-            timestamp=datetime.utcnow().isoformat() + "Z",
+            timestamp=datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
             source="system",
             message=message,
             **kwargs,

plato/chronos/models/__init__.py

@@ -4,7 +4,7 @@
 
 from __future__ import annotations
 
-from typing import Annotated, Any, Dict, List
+from typing import Annotated, Any
 
 from pydantic import AwareDatetime, BaseModel, ConfigDict, Field
 

plato/sims/cli.py

@@ -241,9 +241,11 @@ def _get_function_info(
         }
 
         # Extract parameters
+        params_list = result["params"]
+        assert isinstance(params_list, list)  # type narrowing for ty
         for param_name, param in sig.parameters.items():
             if param_name == "client":
-                result["params"].append("client.httpx")
+                params_list.append("client.httpx")
                 continue
 
             # Get type from hints or annotation
@@ -251,10 +253,10 @@ def _get_function_info(
             type_str = _format_type_annotation(param_type)
 
             if param.default is inspect.Parameter.empty:
-                result["params"].append(f"{param_name}: {type_str}")
+                params_list.append(f"{param_name}: {type_str}")
             else:
                 default_repr = repr(param.default) if param.default is not None else "None"
-                result["params"].append(f"{param_name}: {type_str} = {default_repr}")
+                params_list.append(f"{param_name}: {type_str} = {default_repr}")
 
             # Check if this is the body parameter
             if param_name == "body" and param_type is not inspect.Parameter.empty:
@@ -1162,7 +1164,8 @@ def cmd_publish(
                         generator_version_file.write_text(f"{generator_version}\n")
                         print(f"  Updated {generator_version_file}")
 
-                # Load spec
+                # Load spec (spec_file is guaranteed non-None after check above)
+                assert spec_file is not None
                 with open(spec_file) as f:
                     if spec_file.suffix == ".json":
                         spec = json.load(f)

plato/sims/registry.py

@@ -186,7 +186,6 @@ class SimsRegistry:
         import importlib.resources
 
         services = getattr(mod, "SERVICES", {})
-        env_prefix = getattr(mod, "ENV_PREFIX", "")
 
         # Try to load full config from bundled instructions.yaml
         env_vars_config: dict[str, dict[str, Any]] = {}

plato/v1/cli/agent.py

@@ -7,11 +7,15 @@ import shutil
 import subprocess
 import sys
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import typer
 
 from plato.v1.cli.utils import console, require_api_key
 
+if TYPE_CHECKING:
+    from plato.agents.build import BuildConfig
+
 
 def _extract_schemas(pkg_path: Path, package_name: str) -> tuple[dict | None, dict | None, dict | None]:
     """Extract Config, BuildConfig, and SecretsConfig schemas from the agent package.
@@ -325,6 +329,9 @@ def _publish_agent_image(
 
     # Stream build output
     build_output = []
+    if process.stdout is None:
+        console.print("[red]Error: Failed to capture Docker build output[/red]")
+        raise typer.Exit(1)
     for line in iter(process.stdout.readline, ""):
         line = line.rstrip()
         if line:
@@ -562,6 +569,8 @@ def _publish_package(path: str, repo: str, dry_run: bool = False):
     upload_url = f"{api_url}/v2/pypi/{repo}/"
     console.print(f"\n[cyan]Uploading to {upload_url}...[/cyan]")
 
+    # api_key is guaranteed to be set (checked earlier when not dry_run)
+    assert api_key is not None, "api_key must be set when not in dry_run mode"
     try:
         result = subprocess.run(
             [
@@ -577,6 +586,7 @@ def _publish_package(path: str, repo: str, dry_run: bool = False):
             ],
             capture_output=True,
             text=True,
+            check=False,
         )
 
         if result.returncode == 0:

plato/v1/cli/main.py

@@ -11,6 +11,7 @@ from dotenv import load_dotenv
 from plato.v1.cli.agent import agent_app
 from plato.v1.cli.pm import pm_app
 from plato.v1.cli.sandbox import sandbox_app
+from plato.v1.cli.sim import sim_app
 from plato.v1.cli.utils import console
 from plato.v1.cli.world import world_app
 
@@ -69,6 +70,7 @@ app = typer.Typer(help="[bold blue]Plato CLI[/bold blue] - Manage Plato environm
 # Register sub-apps
 app.add_typer(sandbox_app, name="sandbox")
 app.add_typer(pm_app, name="pm")
+app.add_typer(sim_app, name="sim")
 app.add_typer(agent_app, name="agent")
 app.add_typer(world_app, name="world")
 

plato/v1/cli/pm.py

@@ -7,18 +7,11 @@ import re
 import shutil
 import tempfile
 from pathlib import Path
-from typing import TYPE_CHECKING
 
 import httpx
 import typer
 from rich.table import Table
 
-# UUID pattern for detecting artifact IDs in sim:artifact notation
-UUID_PATTERN = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE)
-
-if TYPE_CHECKING:
-    pass
-
 from plato._generated.api.v1.env import get_simulator_by_name, get_simulators
 from plato._generated.api.v1.organization import get_organization_members
 from plato._generated.api.v1.simulator import (
@@ -46,9 +39,17 @@ from plato.v1.cli.utils import (
     require_sandbox_field,
     require_sandbox_state,
 )
+from plato.v1.cli.verify import pm_verify_app
 from plato.v2.async_.client import AsyncPlato
 from plato.v2.types import Env
 
+# =============================================================================
+# CONSTANTS
+# =============================================================================
+
+# UUID pattern for detecting artifact IDs in sim:artifact notation
+UUID_PATTERN = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE)
+
 # =============================================================================
 # APP STRUCTURE
 # =============================================================================
@@ -61,6 +62,7 @@ submit_app = typer.Typer(help="Submit simulator artifacts for review")
 pm_app.add_typer(list_app, name="list")
 pm_app.add_typer(review_app, name="review")
 pm_app.add_typer(submit_app, name="submit")
+pm_app.add_typer(pm_verify_app, name="verify")
 
 
 # =============================================================================
@@ -343,6 +345,9 @@ def review_base(
         try:
             http_client = plato._http
 
+            # simulator_name is guaranteed set by parse_simulator_artifact (or we exit)
+            assert simulator_name is not None, "simulator_name must be set"
+
             # Get simulator by name
             sim = await get_simulator_by_name.asyncio(
                 client=http_client,
@@ -356,7 +361,7 @@ def review_base(
             console.print(f"[cyan]Current status:[/cyan] {current_status}")
 
             # Use provided artifact ID or fall back to base_artifact_id from server config
-            artifact_id = artifact_id_input if artifact_id_input else current_config.get("base_artifact_id")
+            artifact_id: str | None = artifact_id_input if artifact_id_input else current_config.get("base_artifact_id")
             if not artifact_id:
                 console.print("[red]❌ No artifact ID provided.[/red]")
                 console.print(
@@ -408,44 +413,57 @@ def review_base(
                     if public_url:
                         await page.goto(public_url)
 
-                # If skip_review, check state and exit without interactive loop
-                if skip_review:
-                    console.print("\n[cyan]Checking environment state after login...[/cyan]")
-                    try:
-                        state_response = await sessions_state.asyncio(
-                            client=http_client,
-                            session_id=session.session_id,
-                            merge_mutations=True,
-                            x_api_key=api_key,
-                        )
-                        if state_response and state_response.results:
-                            has_mutations = False
-                            for jid, result in state_response.results.items():
-                                state_data = result.state if hasattr(result, "state") else result
-                                if isinstance(state_data, dict):
-                                    mutations = state_data.pop("mutations", [])
-                                    console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
-                                    console.print("\n[bold]State:[/bold]")
-                                    console.print(json.dumps(state_data, indent=2, default=str))
-                                    if mutations:
-                                        has_mutations = True
-                                        console.print(f"\n[bold red]Mutations ({len(mutations)}):[/bold red]")
-                                        console.print(json.dumps(mutations, indent=2, default=str))
-                                    else:
-                                        console.print("\n[green]No mutations recorded[/green]")
-
-                            if has_mutations:
-                                console.print("\n[bold red]⚠️  WARNING: Login flow created mutations![/bold red]")
-                                console.print("[yellow]The login flow should NOT modify database state.[/yellow]")
+                # ALWAYS check state after login to verify no mutations
+                console.print("\n[cyan]Checking environment state after login...[/cyan]")
+                has_mutations = False
+                has_errors = False
+                try:
+                    state_response = await sessions_state.asyncio(
+                        client=http_client,
+                        session_id=session.session_id,
+                        merge_mutations=True,
+                        x_api_key=api_key,
+                    )
+                    if state_response and state_response.results:
+                        for jid, result in state_response.results.items():
+                            state_data = result.state if hasattr(result, "state") else result
+                            console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
+
+                            if isinstance(state_data, dict):
+                                # Check for error in state response
+                                if "error" in state_data:
+                                    has_errors = True
+                                    console.print("\n[bold red]❌ State API Error:[/bold red]")
+                                    console.print(f"[red]{state_data['error']}[/red]")
+                                    continue
+
+                                mutations = state_data.pop("mutations", [])
+                                console.print("\n[bold]State:[/bold]")
+                                console.print(json.dumps(state_data, indent=2, default=str))
+                                if mutations:
+                                    has_mutations = True
+                                    console.print(f"\n[bold red]Mutations ({len(mutations)}):[/bold red]")
+                                    console.print(json.dumps(mutations, indent=2, default=str))
+                                else:
+                                    console.print("\n[green]No mutations recorded[/green]")
                             else:
-                                console.print(
-                                    "\n[bold green]✅ Login flow verified - no mutations created[/bold green]"
-                                )
+                                console.print(f"[yellow]Unexpected state format: {type(state_data)}[/yellow]")
+
+                        if has_errors:
+                            console.print("\n[bold red]❌ State check failed due to errors![/bold red]")
+                            console.print("[yellow]The worker may not be properly connected.[/yellow]")
+                        elif has_mutations:
+                            console.print("\n[bold red]⚠️  WARNING: Login flow created mutations![/bold red]")
+                            console.print("[yellow]The login flow should NOT modify database state.[/yellow]")
                         else:
-                            console.print("[yellow]No state data available[/yellow]")
-                    except Exception as e:
-                        console.print(f"[red]❌ Error getting state: {e}[/red]")
+                            console.print("\n[bold green]✅ Login flow verified - no mutations created[/bold green]")
+                    else:
+                        console.print("[yellow]No state data available[/yellow]")
+                except Exception as e:
+                    console.print(f"[red]❌ Error getting state: {e}[/red]")
 
+                # If skip_review, exit without interactive loop
+                if skip_review:
                     console.print("\n[cyan]Skipping interactive review (--skip-review)[/cyan]")
                     return
 
@@ -497,9 +515,16 @@ def review_base(
                                 if state_response and state_response.results:
                                     for jid, result in state_response.results.items():
                                         state_data = result.state if hasattr(result, "state") else result
+                                        console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
+
                                         if isinstance(state_data, dict):
+                                            # Check for error in state response
+                                            if "error" in state_data:
+                                                console.print("\n[bold red]❌ State API Error:[/bold red]")
+                                                console.print(f"[red]{state_data['error']}[/red]")
+                                                continue
+
                                             mutations = state_data.pop("mutations", [])
-                                            console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
                                             console.print("\n[bold]State:[/bold]")
                                             console.print(json.dumps(state_data, indent=2, default=str))
                                             if mutations:
@@ -508,7 +533,6 @@ def review_base(
                                             else:
                                                 console.print("\n[yellow]No mutations recorded[/yellow]")
                                         else:
-                                            console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
                                             console.print(json.dumps(state_data, indent=2, default=str))
                                 else:
                                     console.print("[yellow]No state data available[/yellow]")
@@ -584,9 +608,11 @@ def review_base(
             console.print(f"[cyan]Status:[/cyan] {current_status} → {new_status}")
 
             # If passed, automatically tag artifact as prod-latest
-            if outcome == "pass":
+            if outcome == "pass" and artifact_id:
                 console.print("\n[cyan]Tagging artifact as prod-latest...[/cyan]")
                 try:
+                    # simulator_name and artifact_id are guaranteed to be set at this point
+                    assert simulator_name is not None
                     await update_tag.asyncio(
                         client=http_client,
                         body=UpdateTagRequest(
@@ -686,6 +712,9 @@ def review_data(
 
     async def _fetch_artifact_info():
         nonlocal artifact_id
+        # simulator_name is guaranteed set by parse_simulator_artifact (or we exit)
+        assert simulator_name is not None, "simulator_name must be set"
+
         base_url = _get_base_url()
         async with httpx.AsyncClient(base_url=base_url, timeout=60.0) as client:
             try:
@@ -1087,6 +1116,10 @@ def submit_data(
     )
 
     async def _submit_data():
+        # simulator_name and artifact_id are guaranteed set by parse_simulator_artifact with require_artifact=True
+        assert simulator_name is not None, "simulator_name must be set"
+        assert artifact_id is not None, "artifact_id must be set"
+
         base_url = _get_base_url()
 
         async with httpx.AsyncClient(base_url=base_url, timeout=60.0) as client:
@@ -1117,7 +1150,7 @@ def submit_data(
                 x_api_key=api_key,
             )
 
-            # Set data_artifact_id via tag update
+            # Set data_artifact_id via tag update (simulator_name and artifact_id already asserted above)
             try:
                 await update_tag.asyncio(
                     client=client,

plato/v1/cli/sandbox.py

@@ -13,19 +13,12 @@ import tempfile
 import time
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import TYPE_CHECKING
 from urllib.parse import quote
 
 import typer
 import yaml
 from rich.logging import RichHandler
 
-if TYPE_CHECKING:
-    pass
-
-# UUID pattern for detecting artifact IDs in colon notation
-UUID_PATTERN = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE)
-
 from plato._generated.api.v1.gitea import (
     create_simulator_repository,
     get_accessible_simulators,
@@ -77,11 +70,16 @@ from plato.v1.cli.utils import (
     require_sandbox_state,
     save_sandbox_state,
 )
+from plato.v1.cli.verify import sandbox_verify_app
 from plato.v2.async_.flow_executor import FlowExecutor
 from plato.v2.sync.client import Plato as PlatoV2
 from plato.v2.types import Env, SimConfigCompute
 
+# UUID pattern for detecting artifact IDs in colon notation
+UUID_PATTERN = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE)
+
 sandbox_app = typer.Typer(help="Manage sandboxes for simulator development")
+sandbox_app.add_typer(sandbox_verify_app, name="verify")
 
 
 def format_public_url_with_router_target(public_url: str | None, service_name: str | None) -> str | None:
@@ -426,9 +424,10 @@ def sandbox_start(
                         listeners=listeners_dict,
                     )
 
+                    dataset_value = dataset_name or state_extras.get("dataset", "base")
                     setup_request = AppSchemasBuildModelsSetupSandboxRequest(
                         service=sim_name or "",
-                        dataset=dataset_name or state_extras.get("dataset", "base") or "",
+                        dataset=str(dataset_value) if dataset_value else "",
                         plato_dataset_config=dataset_config_obj,
                         ssh_public_key=ssh_public_key,
                     )
@@ -1050,6 +1049,9 @@ def sandbox_start_worker(
                     console.print(f"[cyan]Waiting for worker to be ready (timeout: {wait_timeout}s)...[/cyan]")
 
                 session_id = state.get("session_id")
+                if not session_id:
+                    console.print("[red]Session ID not found in .sandbox.yaml[/red]")
+                    raise typer.Exit(1)
                 start_time = time.time()
                 poll_interval = 10  # seconds between polls
                 worker_ready = False
@@ -1533,9 +1535,21 @@ def sandbox_flow(
             console.print(f"[red]❌ Failed to fetch flows from API: {e}[/red]")
             raise typer.Exit(1) from e
 
+    # At this point, url and flow_obj must be set (validated above)
+    if not url:
+        console.print("[red]❌ URL is not set[/red]")
+        raise typer.Exit(1)
+    if not flow_obj:
+        console.print("[red]❌ Flow object could not be loaded[/red]")
+        raise typer.Exit(1)
+
     console.print(f"[cyan]URL: {url}[/cyan]")
     console.print(f"[cyan]Flow name: {flow_name}[/cyan]")
 
+    # Capture for closure (narrowed types)
+    _url: str = url
+    _flow_obj: Flow = flow_obj
+
     async def _run():
         from playwright.async_api import async_playwright
 
@@ -1544,8 +1558,8 @@ def sandbox_flow(
             async with async_playwright() as p:
                 browser = await p.chromium.launch(headless=False)
                 page = await browser.new_page()
-                await page.goto(url)
-                executor = FlowExecutor(page, flow_obj, screenshots_dir, log=_flow_logger)
+                await page.goto(_url)
+                executor = FlowExecutor(page, _flow_obj, screenshots_dir, log=_flow_logger)
                 await executor.execute()
                 console.print("[green]✅ Flow executed successfully[/green]")
         except Exception as e:
@@ -1606,8 +1620,23 @@ def sandbox_state_cmd(
     def check_mutations(result_dict: dict) -> tuple[bool, bool, str | None]:
         """Check if result has mutations or errors. Returns (has_mutations, has_error, error_msg)."""
         if isinstance(result_dict, dict):
-            if "error" in result_dict:
-                return False, True, result_dict.get("error")
+            # Check for state
+            state = result_dict.get("state", {})
+            if isinstance(state, dict):
+                # Check for error wrapped in state (from API layer transformation)
+                if "error" in state:
+                    return False, True, state["error"]
+                # Check for db state
+                db_state = state.get("db", {})
+                if isinstance(db_state, dict):
+                    mutations = db_state.get("mutations", [])
+                    if mutations:
+                        return True, False, None
+                    # Also check audit_log_count
+                    audit_count = db_state.get("audit_log_count", 0)
+                    if audit_count > 0:
+                        return True, False, None
+            # Check top-level mutations as fallback
             mutations = result_dict.get("mutations", [])
             if mutations:
                 return True, False, None
@@ -2009,6 +2038,10 @@ def sandbox_start_services(
             if not json_output:
                 console.print("[cyan]Step 3: Getting/creating repository...[/cyan]")
 
+            if sim_id is None:
+                console.print("[red]❌ Simulator ID not available[/red]")
+                raise typer.Exit(1)
+
             if has_repo:
                 repo = get_simulator_repository.sync(client=client, simulator_id=sim_id, x_api_key=api_key)
             else:

plato/v1/cli/sim.py

@@ -0,0 +1,11 @@
+"""Plato CLI - Simulator commands (stub)."""
+
+import typer
+
+sim_app = typer.Typer(help="Simulator management commands (coming soon)")
+
+
+@sim_app.command()
+def list():
+    """List available simulators."""
+    typer.echo("Simulator list command not yet implemented.")