plato-sdk-v2 2.3.11__tar.gz → 2.6.1__tar.gz

{plato_sdk_v2-2.3.11 → plato_sdk_v2-2.6.1}/PKG-INFO

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

plato_sdk_v2-2.6.1/VERSION

@@ -0,0 +1 @@
+2.6.1

{plato_sdk_v2-2.3.11 → plato_sdk_v2-2.6.1}/plato/_generated/__init__.py

@@ -1,4 +1,4 @@
-"""Plato API SDK - v0.37.6"""
+"""Plato API SDK - v0.41.4"""
 
 from . import api, errors, models
 from .client import AsyncClient, Client

{plato_sdk_v2-2.3.11 → plato_sdk_v2-2.6.1}/plato/_generated/api/v1/evals/get_scores_by_user.py

@@ -15,6 +15,7 @@ def _build_request_args(
     page_size: int | None = None,
     days: float | None = None,
     include_human_results: bool | None = False,
+    date: str | None = None,
     authorization: str | None = None,
     x_api_key: str | None = None,
 ) -> dict[str, Any]:
@@ -32,6 +33,8 @@ def _build_request_args(
         params["days"] = days
     if include_human_results is not None:
         params["include_human_results"] = include_human_results
+    if date is not None:
+        params["date"] = date
 
     headers: dict[str, str] = {}
     if authorization is not None:
@@ -54,6 +57,7 @@ def sync(
     page_size: int | None = None,
     days: float | None = None,
     include_human_results: bool | None = False,
+    date: str | None = None,
     authorization: str | None = None,
     x_api_key: str | None = None,
 ) -> Any:
@@ -65,6 +69,7 @@ def sync(
         page_size=page_size,
         days=days,
         include_human_results=include_human_results,
+        date=date,
         authorization=authorization,
         x_api_key=x_api_key,
     )
@@ -81,6 +86,7 @@ async def asyncio(
     page_size: int | None = None,
     days: float | None = None,
     include_human_results: bool | None = False,
+    date: str | None = None,
     authorization: str | None = None,
     x_api_key: str | None = None,
 ) -> Any:
@@ -92,6 +98,7 @@ async def asyncio(
         page_size=page_size,
         days=days,
         include_human_results=include_human_results,
+        date=date,
         authorization=authorization,
         x_api_key=x_api_key,
     )

{plato_sdk_v2-2.3.11 → plato_sdk_v2-2.6.1}/plato/_generated/api/v1/testcases/get_testcases.py

@@ -25,6 +25,8 @@ def _build_request_args(
     is_sample: bool | None = None,
     rejected: bool | None = None,
     exclude_assigned_to_annotators: bool | None = None,
+    workorder: str | None = None,
+    infeasible: bool | None = None,
     authorization: str | None = None,
     x_api_key: str | None = None,
 ) -> dict[str, Any]:
@@ -62,6 +64,10 @@ def _build_request_args(
         params["rejected"] = rejected
     if exclude_assigned_to_annotators is not None:
         params["exclude_assigned_to_annotators"] = exclude_assigned_to_annotators
+    if workorder is not None:
+        params["workorder"] = workorder
+    if infeasible is not None:
+        params["infeasible"] = infeasible
 
     headers: dict[str, str] = {}
     if authorization is not None:
@@ -94,6 +100,8 @@ def sync(
     is_sample: bool | None = None,
     rejected: bool | None = None,
     exclude_assigned_to_annotators: bool | None = None,
+    workorder: str | None = None,
+    infeasible: bool | None = None,
     authorization: str | None = None,
     x_api_key: str | None = None,
 ) -> Any:
@@ -115,6 +123,8 @@ def sync(
         is_sample=is_sample,
         rejected=rejected,
         exclude_assigned_to_annotators=exclude_assigned_to_annotators,
+        workorder=workorder,
+        infeasible=infeasible,
         authorization=authorization,
         x_api_key=x_api_key,
     )
@@ -141,6 +151,8 @@ async def asyncio(
     is_sample: bool | None = None,
     rejected: bool | None = None,
     exclude_assigned_to_annotators: bool | None = None,
+    workorder: str | None = None,
+    infeasible: bool | None = None,
     authorization: str | None = None,
     x_api_key: str | None = None,
 ) -> Any:
@@ -162,6 +174,8 @@ async def asyncio(
         is_sample=is_sample,
         rejected=rejected,
         exclude_assigned_to_annotators=exclude_assigned_to_annotators,
+        workorder=workorder,
+        infeasible=infeasible,
         authorization=authorization,
         x_api_key=x_api_key,
     )

{plato_sdk_v2-2.3.11 → plato_sdk_v2-2.6.1}/plato/_generated/api/v2/sessions/setup_sandbox.py

@@ -53,7 +53,7 @@ def sync(
     - Mounting /dev/vdb to /mnt/docker for Docker storage
     - Configuring Docker with overlay2 storage driver
     - Setting up ECR and Docker Hub authentication
-    - Creating a docker-user service for non-root Docker access"""
+    - Adding plato user to docker group for shared Docker access"""
 
     request_args = _build_request_args(
         session_id=session_id,
@@ -84,7 +84,7 @@ async def asyncio(
     - Mounting /dev/vdb to /mnt/docker for Docker storage
     - Configuring Docker with overlay2 storage driver
     - Setting up ECR and Docker Hub authentication
-    - Creating a docker-user service for non-root Docker access"""
+    - Adding plato user to docker group for shared Docker access"""
 
     request_args = _build_request_args(
         session_id=session_id,

{plato_sdk_v2-2.3.11 → plato_sdk_v2-2.6.1}/plato/_generated/models/__init__.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
-#   filename:  tmp28thllk8.json
-#   timestamp: 2026-01-17T04:45:09+00:00
+#   filename:  tmppwt3ublb.json
+#   timestamp: 2026-01-23T22:08:30+00:00
 
 from __future__ import annotations
 
@@ -840,6 +840,14 @@ class CreateSnapshotResult(BaseModel):
     """
     ID of the created snapshot artifact
     """
+    success: Annotated[bool | None, Field(title="Success")] = True
+    """
+    Whether snapshot creation succeeded
+    """
+    error: Annotated[str | None, Field(title="Error")] = None
+    """
+    Error message if failed
+    """
 
 
 class CreateTestCaseFromLabelsRequest(BaseModel):
@@ -1714,6 +1722,20 @@ class NodeNatsConfig(BaseModel):
     subject_prefix: Annotated[str | None, Field(title="Subject Prefix")] = "firecracker"
 
 
+class NodeNebulaConfig(BaseModel):
+    model_config = ConfigDict(
+        extra="allow",
+    )
+    lighthouse_upstream: Annotated[str | None, Field(title="Lighthouse Upstream")] = "100.64.1.1:4242"
+    """
+    Nebula lighthouse upstream address (host:port) for mesh connectivity.
+    """
+    lighthouse_ip: Annotated[str | None, Field(title="Lighthouse Ip")] = "100.64.1.1"
+    """
+    Nebula lighthouse mesh IP address.
+    """
+
+
 class NodePolicyConfig(BaseModel):
     model_config = ConfigDict(
         extra="allow",
@@ -1808,6 +1830,10 @@ class NodeSnapshotStoreConfig(BaseModel):
     """
     Worker threads for snapshot-store compression.
     """
+    upload_workers: Annotated[int | None, Field(title="Upload Workers")] = 6
+    """
+    Number of concurrent snapshot upload jobs.
+    """
     upload_max_attempts: Annotated[int | None, Field(title="Upload Max Attempts")] = 3
     """
     Max upload attempts for snapshot-store uploads.
@@ -1846,6 +1872,12 @@ class NodeStreamConfig(BaseModel):
     resource_matcher_key_prefix: Annotated[str | None, Field(title="Resource Matcher Key Prefix")] = (
         "vm-resource-matcher"
     )
+    artifact_upload_notification_channel: Annotated[str | None, Field(title="Artifact Upload Notification Channel")] = (
+        "artifact-upload-notifications"
+    )
+    """
+    Pubsub channel for artifact upload status updates.
+    """
 
 
 class OODRequestLogInput(BaseModel):
@@ -4358,6 +4390,10 @@ class NodeConfig(BaseModel):
     """
     Build configuration including SSH keys for VMs
     """
+    nebula: NodeNebulaConfig | None = None
+    """
+    Nebula mesh VPN configuration for lighthouse connectivity
+    """
 
 
 class QueueStatusResponse(BaseModel):
@@ -4501,6 +4537,8 @@ class TestCaseCreateRequest(BaseModel):
     simulatorId: Annotated[int | None, Field(title="Simulatorid")] = None
     simulatorArtifactId: Annotated[str | None, Field(title="Simulatorartifactid")] = None
     simulatorArtifactIds: Annotated[list[str] | None, Field(title="Simulatorartifactids")] = None
+    workorder: Annotated[str | None, Field(title="Workorder")] = None
+    infeasible: Annotated[bool | None, Field(title="Infeasible")] = None
 
 
 class TestCaseUpdateRequest(BaseModel):
@@ -4525,6 +4563,8 @@ class TestCaseUpdateRequest(BaseModel):
     simulatorArtifactId: Annotated[str | None, Field(title="Simulatorartifactid")] = None
     simulatorArtifactIds: Annotated[list[str] | None, Field(title="Simulatorartifactids")] = None
     mutationIgnoreConfig: DatabaseIgnoreConfig | None = None
+    workorder: Annotated[str | None, Field(title="Workorder")] = None
+    infeasible: Annotated[bool | None, Field(title="Infeasible")] = None
 
 
 class WaitForReadyResponse(BaseModel):

{plato_sdk_v2-2.3.11 → plato_sdk_v2-2.6.1}/plato/agents/config.py

@@ -18,7 +18,6 @@ Example:
 from __future__ import annotations
 
 import json
-from pathlib import Path
 from typing import Any
 
 from pydantic_settings import BaseSettings, SettingsConfigDict
@@ -147,9 +146,18 @@ class AgentConfig(BaseSettings):
         return result
 
     @classmethod
-    def from_file(cls, path: str | Path) -> AgentConfig:
-        """Load config from a JSON file."""
-        path = Path(path)
-        with open(path) as f:
-            data = json.load(f)
+    def from_env(cls) -> AgentConfig:
+        """Load config from AGENT_CONFIG_B64 environment variable.
+
+        The runner passes config as base64-encoded JSON in the
+        AGENT_CONFIG_B64 environment variable.
+        """
+        import base64
+        import os
+
+        config_b64 = os.environ.get("AGENT_CONFIG_B64")
+        if not config_b64:
+            raise ValueError("AGENT_CONFIG_B64 environment variable not set")
+        config_json = base64.b64decode(config_b64).decode()
+        data = json.loads(config_json)
         return cls(**data)

{plato_sdk_v2-2.3.11 → plato_sdk_v2-2.6.1}/plato/agents/otel.py

@@ -164,8 +164,12 @@ def init_tracing(
         _module_logger.error(f"Failed to initialize tracing: {e}")
 
 
-def shutdown_tracing() -> None:
-    """Shutdown the tracer provider and flush spans."""
+def shutdown_tracing(timeout_millis: int = 30000) -> None:
+    """Shutdown the tracer provider and flush spans.
+
+    Args:
+        timeout_millis: Timeout in milliseconds to wait for flush (default 30s)
+    """
     global _tracer_provider, _initialized, _log_handler
 
     # Remove log handler
@@ -179,9 +183,18 @@ def shutdown_tracing() -> None:
 
     if _tracer_provider:
         try:
+            # Force flush all pending spans before shutdown
+            print(f"[OTel] Flushing spans (timeout={timeout_millis}ms)...")
+            flush_success = _tracer_provider.force_flush(timeout_millis=timeout_millis)
+            if flush_success:
+                print("[OTel] Span flush completed successfully")
+            else:
+                print("[OTel] Span flush timed out or failed")
+
             _tracer_provider.shutdown()
-            _module_logger.info("OTel tracing shutdown complete")
+            print("[OTel] Tracing shutdown complete")
         except Exception as e:
+            print(f"[OTel] Error shutting down tracer: {e}")
             _module_logger.warning(f"Error shutting down tracer: {e}")
 
     _tracer_provider = None

{plato_sdk_v2-2.3.11 → plato_sdk_v2-2.6.1}/plato/agents/runner.py

@@ -10,44 +10,45 @@ Agents emit their own OTel spans for trajectory events. This runner:
 from __future__ import annotations
 
 import asyncio
+import base64
 import json
 import logging
 import os
 import platform
-import tempfile
+import uuid
 
 from opentelemetry import trace
 
-from plato.agents.artifacts import upload_artifacts
-
 logger = logging.getLogger(__name__)
 
 
 async def run_agent(
     image: str,
     config: dict,
-    secrets: dict[str, str],
     instruction: str,
-    workspace: str,
+    workspace: str | None = None,
     logs_dir: str | None = None,
     pull: bool = True,
-) -> None:
+) -> str:
     """Run an agent in a Docker container.
 
     Args:
         image: Docker image URI
-        config: Agent configuration dict
-        secrets: Secret values (API keys, etc.)
+        config: Agent configuration dict (includes secrets)
         instruction: Task instruction for the agent
-        workspace: Host directory to mount as /workspace
-        logs_dir: Host directory for logs (temp dir if None)
+        workspace: Docker volume name for workspace (created if None)
+        logs_dir: Ignored (kept for backwards compatibility)
         pull: Whether to pull the image first
 
+    Returns:
+        The container name that was created (for cleanup purposes)
+
     Note: Agents handle their own OTel tracing. This runner only passes
     the trace context (TRACEPARENT) so agent spans link to the parent step.
-    """
-    logs_dir = logs_dir or tempfile.mkdtemp(prefix="agent_logs_")
 
+    Note: This uses Docker volumes (not bind mounts) for DIND compatibility.
+    The workspace parameter should be a Docker volume name.
+    """
     # Get session info from environment variables
     session_id = os.environ.get("SESSION_ID")
     otel_url = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT")
@@ -64,15 +65,41 @@ async def run_agent(
         )
         await pull_proc.wait()
 
-    # Setup
-    os.makedirs(os.path.join(logs_dir, "agent"), exist_ok=True)
-    config_file = tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False)
-    json.dump(config, config_file)
-    config_file.close()
+    # Encode config as base64 to pass via environment variable
+    # This avoids file mount issues in Docker-in-Docker scenarios
+    config_json = json.dumps(config)
+    config_b64 = base64.b64encode(config_json.encode()).decode()
+
+    # Generate a unique container name for inspection
+    container_name = f"agent-{uuid.uuid4().hex[:8]}"
+
+    # Use WORKSPACE_VOLUME env var if set (for DIND compatibility)
+    # Otherwise create a new volume
+    workspace_volume = os.environ.get("WORKSPACE_VOLUME") or workspace or f"workspace-{uuid.uuid4().hex[:8]}"
+    if not os.environ.get("WORKSPACE_VOLUME") and not workspace:
+        await asyncio.create_subprocess_exec(
+            "docker",
+            "volume",
+            "create",
+            workspace_volume,
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+
+    # Create logs volume
+    logs_volume = f"logs-{uuid.uuid4().hex[:8]}"
+    await asyncio.create_subprocess_exec(
+        "docker",
+        "volume",
+        "create",
+        logs_volume,
+        stdout=asyncio.subprocess.DEVNULL,
+        stderr=asyncio.subprocess.DEVNULL,
+    )
 
     try:
         # Build docker command
-        docker_cmd = ["docker", "run", "--rm", "--privileged"]
+        docker_cmd = ["docker", "run", "--rm", "--privileged", "--name", container_name]
 
         # Determine if we need host networking
         use_host_network = False
@@ -97,18 +124,19 @@ async def run_agent(
         if use_host_network:
             docker_cmd.extend(["--network=host", "--add-host=localhost:127.0.0.1"])
 
+        # Use Docker volumes instead of bind mounts for DIND compatibility
         docker_cmd.extend(
             [
                 "-v",
-                f"{workspace}:/workspace",
-                "-v",
-                f"{logs_dir}:/logs",
+                f"{workspace_volume}:/workspace",
                 "-v",
-                f"{config_file.name}:/config.json:ro",
+                f"{logs_volume}:/logs",
                 "-v",
                 "/var/run/docker.sock:/var/run/docker.sock",
                 "-w",
                 "/workspace",
+                "-e",
+                f"AGENT_CONFIG_B64={config_b64}",
             ]
         )
 
@@ -143,14 +171,13 @@ async def run_agent(
                 ]
             )
 
-        for key, value in secrets.items():
-            docker_cmd.extend(["-e", f"{key.upper()}={value}"])
-
         docker_cmd.append(image)
 
         # Pass instruction via CLI arg
         docker_cmd.extend(["--instruction", instruction])
 
+        logger.debug(f"Starting container: {container_name}")
+
         # 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(
@@ -160,7 +187,7 @@ async def run_agent(
             limit=100 * 1024 * 1024,  # 100MB buffer limit
         )
 
-        # Capture output for error reporting using chunked reads to handle large lines
+        # Stream and capture output for error reporting using chunked reads to handle large lines
         output_lines: list[str] = []
         assert process.stdout is not None
         buffer = ""
@@ -176,10 +203,13 @@ async def run_agent(
             while "\n" in buffer:
                 line, buffer = buffer.split("\n", 1)
                 output_lines.append(line)
+                # Print agent output in real-time
+                print(f"[agent] {line}")
 
         # Handle any remaining content in buffer
         if buffer.strip():
             output_lines.append(buffer)
+            print(f"[agent] {buffer}")
 
         await process.wait()
 
@@ -189,8 +219,16 @@ async def run_agent(
             raise RuntimeError(f"Agent failed with exit code {exit_code}\n\nAgent output:\n{error_context}")
 
     finally:
-        os.unlink(config_file.name)
+        # Clean up volumes
+        await asyncio.create_subprocess_exec(
+            "docker",
+            "volume",
+            "rm",
+            "-f",
+            logs_volume,
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        # Note: workspace_volume is not cleaned up as it may be shared
 
-        # Upload artifacts if we have upload URL configured
-        if upload_url:
-            await upload_artifacts(upload_url, logs_dir)
+    return container_name

plato_sdk_v2-2.6.1/plato/chronos/api/admin/__init__.py

@@ -0,0 +1,17 @@
+"""API endpoints."""
+
+from . import (
+    clear_database_api_admin_clear_db_post,
+    sync_agents_api_admin_sync_agents_post,
+    sync_all_api_admin_sync_all_post,
+    sync_runtimes_api_admin_sync_runtimes_post,
+    sync_worlds_api_admin_sync_worlds_post,
+)
+
+__all__ = [
+    "sync_agents_api_admin_sync_agents_post",
+    "sync_worlds_api_admin_sync_worlds_post",
+    "sync_runtimes_api_admin_sync_runtimes_post",
+    "sync_all_api_admin_sync_all_post",
+    "clear_database_api_admin_clear_db_post",
+]

plato_sdk_v2-2.6.1/plato/chronos/api/admin/clear_database_api_admin_clear_db_post.py

@@ -0,0 +1,57 @@
+"""Clear Database"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import ClearDbResult
+
+
+def _build_request_args(
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = "/api/admin/clear-db"
+
+    headers: dict[str, str] = {}
+    if x_api_key is not None:
+        headers["X-API-Key"] = x_api_key
+
+    return {
+        "method": "POST",
+        "url": url,
+        "headers": headers,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    x_api_key: str | None = None,
+) -> ClearDbResult:
+    """Clear ALL data from the database. Only available in local environment."""
+
+    request_args = _build_request_args(
+        x_api_key=x_api_key,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return ClearDbResult.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    x_api_key: str | None = None,
+) -> ClearDbResult:
+    """Clear ALL data from the database. Only available in local environment."""
+
+    request_args = _build_request_args(
+        x_api_key=x_api_key,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return ClearDbResult.model_validate(response.json())

plato_sdk_v2-2.6.1/plato/chronos/api/admin/sync_agents_api_admin_sync_agents_post.py

@@ -0,0 +1,67 @@
+"""Sync Agents"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import SyncResult
+
+
+def _build_request_args(
+    source_url: str,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = "/api/admin/sync/agents"
+
+    params: dict[str, Any] = {}
+    if source_url is not None:
+        params["source_url"] = source_url
+
+    headers: dict[str, str] = {}
+    if x_api_key is not None:
+        headers["X-API-Key"] = x_api_key
+
+    return {
+        "method": "POST",
+        "url": url,
+        "params": params,
+        "headers": headers,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    source_url: str,
+    x_api_key: str | None = None,
+) -> SyncResult:
+    """Sync agents from source Chronos to local database."""
+
+    request_args = _build_request_args(
+        source_url=source_url,
+        x_api_key=x_api_key,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return SyncResult.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    source_url: str,
+    x_api_key: str | None = None,
+) -> SyncResult:
+    """Sync agents from source Chronos to local database."""
+
+    request_args = _build_request_args(
+        source_url=source_url,
+        x_api_key=x_api_key,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return SyncResult.model_validate(response.json())