plato-sdk-v2 2.3.10__py3-none-any.whl → 2.4.0__py3-none-any.whl

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/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/agents/runner.py

@@ -10,16 +10,15 @@ 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__)
 
 
@@ -28,10 +27,10 @@ async def run_agent(
     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:
@@ -39,15 +38,19 @@ async def run_agent(
         config: Agent configuration dict
         secrets: Secret values (API keys, etc.)
         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 +67,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 +126,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}",
             ]
         )
 
@@ -151,6 +181,8 @@ async def run_agent(
         # Pass instruction via CLI arg
         docker_cmd.extend(["--instruction", instruction])
 
+        logger.info(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 +192,33 @@ async def run_agent(
             limit=100 * 1024 * 1024,  # 100MB buffer limit
         )
 
-        # Capture output for error reporting using chunked reads to handle large lines
+        # Get and print container IP in background
+        async def print_container_ip():
+            await asyncio.sleep(3)  # Wait for container to start
+            try:
+                inspect_proc = await asyncio.create_subprocess_exec(
+                    "docker",
+                    "inspect",
+                    "-f",
+                    "{{.NetworkSettings.IPAddress}}",
+                    container_name,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, _ = await inspect_proc.communicate()
+                container_ip = stdout.decode().strip()
+                if container_ip:
+                    logger.info("=" * 50)
+                    logger.info(f"Container: {container_name}")
+                    logger.info(f"Container IP: {container_ip}")
+                    logger.info(f"noVNC: http://{container_ip}:6080")
+                    logger.info("=" * 50)
+            except Exception:
+                pass
+
+        asyncio.create_task(print_container_ip())
+
+        # 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 +234,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 +250,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