plato-sdk-v2 2.3.5__py3-none-any.whl → 2.3.7__py3-none-any.whl

plato/agents/otel.py

@@ -1,7 +1,7 @@
 """OpenTelemetry integration for Plato agents and worlds.
 
-Provides tracing and logging utilities using OpenTelemetry SDK. Traces and logs
-are sent directly to the Chronos OTLP endpoint.
+Provides tracing utilities using OpenTelemetry SDK. Traces are sent directly
+to the Chronos OTLP endpoint.
 
 Usage:
     from plato.agents.otel import init_tracing, get_tracer, shutdown_tracing
@@ -19,11 +19,6 @@ Usage:
         span.set_attribute("key", "value")
         # ... do work ...
 
-    # All Python logging is automatically sent to Chronos
-    import logging
-    logger = logging.getLogger(__name__)
-    logger.info("This will appear in the trajectory viewer!")
-
     # Cleanup
     shutdown_tracing()
 """
@@ -39,74 +34,42 @@ _module_logger = logging.getLogger(__name__)
 
 # Global state
 _tracer_provider = None
-_logging_handler = None
 _initialized = False
+_log_handler = None
 
 
-class OTelLoggingHandler(logging.Handler):
-    """Logging handler that emits OTel spans for log messages.
+class OTelSpanLogHandler(logging.Handler):
+    """Logging handler that creates OTel spans for log messages.
 
-    Each log message becomes a span with:
-    - span.type: "log"
-    - log.level: DEBUG/INFO/WARNING/ERROR/CRITICAL
-    - content: the log message
-    - source: the logger name
+    Converts Python log records to OTel spans with log attributes.
     """
 
-    def __init__(self, tracer_name: str = "plato.logging"):
-        super().__init__()
-        self._tracer_name = tracer_name
-        # Filter out noisy loggers
-        self._ignored_loggers = {
-            "httpx",
-            "httpcore",
-            "urllib3",
-            "asyncio",
-            "opentelemetry",
-            "plato.agents.otel",  # Avoid recursion
-        }
+    def __init__(self, tracer: Tracer, level: int = logging.INFO):
+        super().__init__(level)
+        self.tracer = tracer
 
     def emit(self, record: logging.LogRecord) -> None:
         """Emit a log record as an OTel span."""
-        # Skip ignored loggers
-        logger_name = record.name
-        for ignored in self._ignored_loggers:
-            if logger_name.startswith(ignored):
-                return
-
         try:
-            tracer = trace.get_tracer(self._tracer_name)
-
-            # Format the message
-            try:
-                msg = self.format(record)
-            except Exception:
-                msg = record.getMessage()
-
             # Create a span for the log message
-            with tracer.start_as_current_span(
-                f"log.{record.levelname.lower()}",
-                end_on_exit=True,
-            ) as span:
-                span.set_attribute("span.type", "log")
+            with self.tracer.start_as_current_span(f"log.{record.levelname.lower()}") as span:
                 span.set_attribute("log.level", record.levelname)
-                span.set_attribute("content", msg)
-                span.set_attribute("source", logger_name)
+                span.set_attribute("log.message", record.getMessage())
+                span.set_attribute("log.logger", record.name)
+                span.set_attribute("source", "world")
+                span.set_attribute("content", record.getMessage()[:1000])
 
-                # Add extra context if available
                 if record.funcName:
                     span.set_attribute("log.function", record.funcName)
-                if record.pathname:
-                    span.set_attribute("log.file", record.pathname)
                 if record.lineno:
-                    span.set_attribute("log.line", record.lineno)
+                    span.set_attribute("log.lineno", record.lineno)
 
-                # If there's an exception, record it
-                if record.exc_info and record.exc_info[1]:
-                    span.record_exception(record.exc_info[1])
+                # Mark errors
+                if record.levelno >= logging.ERROR:
+                    span.set_attribute("error", True)
 
         except Exception:
-            # Don't let logging failures break the application
+            # Don't let logging errors crash the application
             pass
 
 
@@ -114,66 +77,77 @@ def init_tracing(
     service_name: str,
     session_id: str,
     otlp_endpoint: str,
-    capture_logging: bool = True,
-    log_level: int = logging.INFO,
+    parent_trace_id: str | None = None,
+    parent_span_id: str | None = None,
 ) -> None:
-    """Initialize OpenTelemetry tracing and optionally capture Python logging.
+    """Initialize OpenTelemetry tracing.
 
     Args:
         service_name: Name of the service (e.g., world name or agent name)
         session_id: Chronos session ID (added as resource attribute)
         otlp_endpoint: Chronos OTLP endpoint (e.g., http://chronos/api/otel)
-        capture_logging: If True, install handler to capture Python logs as OTel spans
-        log_level: Minimum log level to capture (default: INFO)
+        parent_trace_id: Optional parent trace ID for linking (hex string)
+        parent_span_id: Optional parent span ID for linking (hex string)
     """
-    global _tracer_provider, _logging_handler, _initialized
+    global _tracer_provider, _initialized, _log_handler
 
     if _initialized:
         _module_logger.debug("Tracing already initialized")
         return
 
     try:
+        from opentelemetry import context as context_api
         from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
             OTLPSpanExporter,
         )
         from opentelemetry.sdk.resources import Resource
         from opentelemetry.sdk.trace import TracerProvider
-        from opentelemetry.sdk.trace.export import BatchSpanProcessor
+        from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+        from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags
 
         # Create resource with session ID
         resource = Resource.create(
             {
                 "service.name": service_name,
-                "session.id": session_id,
+                "plato.session.id": session_id,
             }
         )
 
         # Create tracer provider
         _tracer_provider = TracerProvider(resource=resource)
 
-        # Add OTLP exporter pointing to Chronos
+        # Add OTLP exporter pointing to Chronos (use SimpleSpanProcessor for immediate export)
         otlp_exporter = OTLPSpanExporter(endpoint=f"{otlp_endpoint.rstrip('/')}/v1/traces")
-        _tracer_provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
+        _tracer_provider.add_span_processor(SimpleSpanProcessor(otlp_exporter))
 
         # Set as global tracer provider
         trace.set_tracer_provider(_tracer_provider)
 
-        _initialized = True
+        # If parent context is provided, set it as the current context
+        # This allows new spans to automatically link to the parent
+        if parent_trace_id and parent_span_id:
+            parent_context = SpanContext(
+                trace_id=int(parent_trace_id, 16),
+                span_id=int(parent_span_id, 16),
+                is_remote=True,
+                trace_flags=TraceFlags(0x01),  # Sampled
+            )
+            parent_span = NonRecordingSpan(parent_context)
+            ctx = trace.set_span_in_context(parent_span)
+            context_api.attach(ctx)
+            print(f"[OTel] Using parent context: trace_id={parent_trace_id}, span_id={parent_span_id}")
+
+        # Add OTel logging handler to capture world logs
+        tracer = trace.get_tracer(service_name)
+        _log_handler = OTelSpanLogHandler(tracer, level=logging.INFO)
+
+        # Add handler to plato.worlds loggers
+        plato_worlds_logger = logging.getLogger("plato.worlds")
+        plato_worlds_logger.addHandler(_log_handler)
 
-        # Install logging handler to capture Python logs
-        if capture_logging:
-            _logging_handler = OTelLoggingHandler()
-            _logging_handler.setLevel(log_level)
-            # Add to root logger to capture all logs
-            logging.getLogger().addHandler(_logging_handler)
+        _initialized = True
 
-        # Use print to ensure this shows regardless of logging config
         print(f"[OTel] Tracing initialized: service={service_name}, session={session_id}, endpoint={otlp_endpoint}")
-        _module_logger.info(
-            f"OTel tracing initialized: service={service_name}, "
-            f"session={session_id}, endpoint={otlp_endpoint}, "
-            f"capture_logging={capture_logging}"
-        )
 
     except ImportError as e:
         print(f"[OTel] OpenTelemetry SDK not installed: {e}")
@@ -184,16 +158,17 @@ def init_tracing(
 
 
 def shutdown_tracing() -> None:
-    """Shutdown the tracer provider, flush spans, and remove logging handler."""
-    global _tracer_provider, _logging_handler, _initialized
+    """Shutdown the tracer provider and flush spans."""
+    global _tracer_provider, _initialized, _log_handler
 
-    # Remove logging handler first
-    if _logging_handler:
+    # Remove log handler
+    if _log_handler:
         try:
-            logging.getLogger().removeHandler(_logging_handler)
+            plato_worlds_logger = logging.getLogger("plato.worlds")
+            plato_worlds_logger.removeHandler(_log_handler)
         except Exception:
             pass
-        _logging_handler = None
+        _log_handler = None
 
     if _tracer_provider:
         try:
@@ -229,6 +204,8 @@ def instrument(service_name: str = "plato-agent") -> Tracer:
     Reads the following env vars:
     - OTEL_EXPORTER_OTLP_ENDPOINT: Chronos OTLP endpoint (required for tracing)
     - SESSION_ID: Chronos session ID (default: "local")
+    - OTEL_TRACE_ID: Parent trace ID for linking spans (optional)
+    - OTEL_PARENT_SPAN_ID: Parent span ID for linking spans (optional)
 
     If OTEL_EXPORTER_OTLP_ENDPOINT is not set, returns a no-op tracer.
 
@@ -242,17 +219,20 @@ def instrument(service_name: str = "plato-agent") -> Tracer:
 
     otel_endpoint = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT")
     session_id = os.environ.get("SESSION_ID", "local")
+    parent_trace_id = os.environ.get("OTEL_TRACE_ID")
+    parent_span_id = os.environ.get("OTEL_PARENT_SPAN_ID")
 
     if not otel_endpoint:
         # Return default tracer (no-op if no provider configured)
         return trace.get_tracer(service_name)
 
-    # Initialize tracing
+    # Initialize tracing with parent context if provided
     init_tracing(
         service_name=service_name,
         session_id=session_id,
         otlp_endpoint=otel_endpoint,
-        capture_logging=True,
+        parent_trace_id=parent_trace_id,
+        parent_span_id=parent_span_id,
     )
 
     return trace.get_tracer(service_name)

plato/agents/runner.py

@@ -1,4 +1,11 @@
-"""Agent runner - run agents in Docker containers."""
+"""Agent runner - run agents in Docker containers.
+
+Agents emit their own OTel spans for trajectory events. This runner:
+1. Runs agents in Docker containers
+2. Streams stdout/stderr for logging
+3. Passes OTel environment variables for trace context propagation
+4. Uploads artifacts to S3 when complete
+"""
 
 from __future__ import annotations
 
@@ -8,12 +15,10 @@ import logging
 import os
 import platform
 import tempfile
-from pathlib import Path
 
 from opentelemetry import trace
 
 from plato.agents.artifacts import upload_artifacts
-from plato.agents.otel import get_tracer
 
 logger = logging.getLogger(__name__)
 
@@ -37,310 +42,142 @@ async def run_agent(
         workspace: Host directory to mount as /workspace
         logs_dir: Host directory for logs (temp dir if None)
         pull: Whether to pull the image first
+
+    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_")
-    agent_name = image.split("/")[-1].split(":")[0]
 
     # Get session info from environment variables
     session_id = os.environ.get("SESSION_ID")
     otel_url = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT")
     upload_url = os.environ.get("UPLOAD_URL")
 
-    tracer = get_tracer("plato.agent")
-
-    with tracer.start_as_current_span(agent_name) as agent_span:
-        agent_span.set_attribute("span.type", "agent")
-        agent_span.set_attribute("source", "agent")
-        agent_span.set_attribute("image", image)
-        agent_span.set_attribute("content", f"Starting agent: {agent_name}")
-
-        # Pull image if requested
-        if pull:
-            with tracer.start_as_current_span("docker_pull") as pull_span:
-                pull_span.set_attribute("span.type", "docker_pull")
-                pull_span.set_attribute("image", image)
-                pull_proc = await asyncio.create_subprocess_exec(
-                    "docker",
-                    "pull",
-                    image,
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.STDOUT,
+    # Pull image if requested
+    if pull:
+        pull_proc = await asyncio.create_subprocess_exec(
+            "docker",
+            "pull",
+            image,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+        )
+        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()
+
+    try:
+        # Build docker command
+        docker_cmd = ["docker", "run", "--rm", "--privileged"]
+
+        # Determine if we need host networking
+        use_host_network = False
+        is_macos = platform.system() == "Darwin"
+
+        if not is_macos:
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    "iptables",
+                    "-L",
+                    "-n",
+                    stdout=asyncio.subprocess.DEVNULL,
+                    stderr=asyncio.subprocess.DEVNULL,
                 )
-                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()
-
-        try:
-            # Build docker command
-            docker_cmd = ["docker", "run", "--rm"]
-
-            # Determine if we need host networking
-            use_host_network = False
-            is_macos = platform.system() == "Darwin"
-
-            if not is_macos:
-                try:
-                    proc = await asyncio.create_subprocess_exec(
-                        "iptables",
-                        "-L",
-                        "-n",
-                        stdout=asyncio.subprocess.DEVNULL,
-                        stderr=asyncio.subprocess.DEVNULL,
-                    )
-                    await proc.wait()
-                    has_iptables = proc.returncode == 0
-                except (FileNotFoundError, PermissionError):
-                    has_iptables = False
-
-                use_host_network = not has_iptables
-
-            if use_host_network:
-                docker_cmd.extend(["--network=host", "--add-host=localhost:127.0.0.1"])
-
+                await proc.wait()
+                has_iptables = proc.returncode == 0
+            except (FileNotFoundError, PermissionError):
+                has_iptables = False
+
+            use_host_network = not has_iptables
+
+        if use_host_network:
+            docker_cmd.extend(["--network=host", "--add-host=localhost:127.0.0.1"])
+
+        docker_cmd.extend(
+            [
+                "-v",
+                f"{workspace}:/workspace",
+                "-v",
+                f"{logs_dir}:/logs",
+                "-v",
+                f"{config_file.name}:/config.json:ro",
+                "-v",
+                "/var/run/docker.sock:/var/run/docker.sock",
+                "-w",
+                "/workspace",
+            ]
+        )
+
+        # Pass session info to agent
+        if otel_url:
+            traces_endpoint = f"{otel_url.rstrip('/')}/v1/traces"
+            docker_cmd.extend(["-e", f"OTEL_EXPORTER_OTLP_ENDPOINT={otel_url}"])
+            docker_cmd.extend(["-e", f"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT={traces_endpoint}"])
+            docker_cmd.extend(["-e", "OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf"])
+        if session_id:
+            docker_cmd.extend(["-e", f"SESSION_ID={session_id}"])
+        if upload_url:
+            docker_cmd.extend(["-e", f"UPLOAD_URL={upload_url}"])
+
+        # Pass trace context to agent for parent linking
+        # Agent spans will be children of the current step span
+        current_span = trace.get_current_span()
+        span_context = current_span.get_span_context()
+        if span_context.is_valid:
+            trace_id = format(span_context.trace_id, "032x")
+            span_id = format(span_context.span_id, "016x")
+            # W3C Trace Context format for TRACEPARENT
+            traceparent = f"00-{trace_id}-{span_id}-01"
             docker_cmd.extend(
                 [
-                    "-v",
-                    f"{workspace}:/workspace",
-                    "-v",
-                    f"{logs_dir}:/logs",
-                    "-v",
-                    f"{config_file.name}:/config.json:ro",
-                    "-v",
-                    "/var/run/docker.sock:/var/run/docker.sock",
-                    "-w",
-                    "/workspace",
+                    "-e",
+                    f"TRACEPARENT={traceparent}",
+                    "-e",
+                    f"OTEL_TRACE_ID={trace_id}",
+                    "-e",
+                    f"OTEL_PARENT_SPAN_ID={span_id}",
                 ]
             )
 
-            # Pass session info to agent
-            if otel_url:
-                docker_cmd.extend(["-e", f"OTEL_EXPORTER_OTLP_ENDPOINT={otel_url}"])
-                # Use JSON protocol (not protobuf) for OTLP exports
-                docker_cmd.extend(["-e", "OTEL_EXPORTER_OTLP_PROTOCOL=http/json"])
-            if session_id:
-                docker_cmd.extend(["-e", f"SESSION_ID={session_id}"])
-            if upload_url:
-                docker_cmd.extend(["-e", f"UPLOAD_URL={upload_url}"])
-
-            # Pass trace context to agent for parent linking
-            current_span = trace.get_current_span()
-            span_context = current_span.get_span_context()
-            if span_context.is_valid:
-                trace_id = format(span_context.trace_id, "032x")
-                span_id = format(span_context.span_id, "016x")
-                docker_cmd.extend(
-                    [
-                        "-e",
-                        f"OTEL_TRACE_ID={trace_id}",
-                        "-e",
-                        f"OTEL_PARENT_SPAN_ID={span_id}",
-                    ]
-                )
-
-            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])
-
-            # Run container and stream output
-            with tracer.start_as_current_span("agent_execution") as exec_span:
-                exec_span.set_attribute("span.type", "agent_execution")
-                exec_span.set_attribute("content", f"Running {agent_name}")
-
-                process = await asyncio.create_subprocess_exec(
-                    *docker_cmd,
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.STDOUT,
-                )
-
-                # Stream output line by line
-                output_lines: list[str] = []
-                turn_count = 0
-                assert process.stdout is not None
-                while True:
-                    line = await process.stdout.readline()
-                    if not line:
-                        break
-                    decoded_line = line.decode().rstrip()
-                    output_lines.append(decoded_line)
-
-                    # Try to parse JSON output from agent for structured trajectory spans
-                    try:
-                        data = json.loads(decoded_line)
-                        event_type = data.get("type", "")
-
-                        if event_type == "assistant":
-                            # Agent response - create a turn span
-                            turn_count += 1
-                            msg = data.get("message", {})
-                            content_items = msg.get("content", [])
-
-                            # Extract text and tool calls with full details
-                            text_parts = []
-                            tool_calls = []
-                            for item in content_items:
-                                if item.get("type") == "text":
-                                    text_parts.append(item.get("text", "")[:2000])
-                                elif item.get("type") == "tool_use":
-                                    tool_input = item.get("input", {})
-                                    # Truncate large inputs
-                                    input_str = json.dumps(tool_input) if tool_input else ""
-                                    if len(input_str) > 2000:
-                                        input_str = input_str[:2000] + "..."
-                                    tool_calls.append(
-                                        {
-                                            "tool": item.get("name"),
-                                            "id": item.get("id"),
-                                            "input": input_str,
-                                        }
-                                    )
-
-                            with tracer.start_as_current_span(f"turn_{turn_count}") as turn_span:
-                                turn_span.set_attribute("span.type", "agent_turn")
-                                turn_span.set_attribute("source", "agent")
-                                turn_span.set_attribute("turn_number", turn_count)
-                                turn_span.set_attribute("model", msg.get("model", "unknown"))
-
-                                if text_parts:
-                                    turn_span.set_attribute("content", "\n".join(text_parts)[:4000])
-                                if tool_calls:
-                                    turn_span.set_attribute("tool_calls", json.dumps(tool_calls))
-                                    # If no text content, show tool calls summary
-                                    if not text_parts:
-                                        turn_span.set_attribute(
-                                            "content", f"Tool calls: {', '.join(t['tool'] for t in tool_calls)}"
-                                        )
-
-                                # Usage info
-                                usage = msg.get("usage", {})
-                                if usage:
-                                    turn_span.set_attribute("input_tokens", usage.get("input_tokens", 0))
-                                    turn_span.set_attribute("output_tokens", usage.get("output_tokens", 0))
-
-                        elif event_type == "user":
-                            # Tool result
-                            tool_results = data.get("message", {}).get("content", [])
-                            for result in tool_results:
-                                if result.get("type") == "tool_result":
-                                    tool_id = result.get("tool_use_id", "")
-                                    content = result.get("content", "")
-                                    # Handle content that might be a list of content blocks
-                                    if isinstance(content, list):
-                                        text_parts = []
-                                        for item in content:
-                                            if isinstance(item, dict) and item.get("type") == "text":
-                                                text_parts.append(item.get("text", ""))
-                                            elif isinstance(item, str):
-                                                text_parts.append(item)
-                                        content = "\n".join(text_parts)
-                                    if isinstance(content, str):
-                                        content = content[:2000]  # Truncate large results
-                                    with tracer.start_as_current_span("tool_result") as tr_span:
-                                        tr_span.set_attribute("span.type", "tool_result")
-                                        tr_span.set_attribute("source", "agent")
-                                        tr_span.set_attribute("tool_use_id", tool_id)
-                                        tr_span.set_attribute("content", f"Tool result for {tool_id}")
-                                        tr_span.set_attribute("result", content if content else "")
-
-                        elif event_type == "result":
-                            # Final result
-                            result_text = data.get("result", "")[:1000]
-                            is_error = data.get("is_error", False)
-                            duration_ms = data.get("duration_ms", 0)
-                            total_cost = data.get("total_cost_usd", 0)
-
-                            with tracer.start_as_current_span("agent_result") as res_span:
-                                res_span.set_attribute("span.type", "agent_result")
-                                res_span.set_attribute("source", "agent")
-                                res_span.set_attribute("content", result_text if result_text else "Agent completed")
-                                res_span.set_attribute("is_error", is_error)
-                                res_span.set_attribute("duration_ms", duration_ms)
-                                res_span.set_attribute("total_cost_usd", total_cost)
-                                res_span.set_attribute("num_turns", data.get("num_turns", turn_count))
-
-                        elif event_type == "system" and data.get("subtype") == "init":
-                            # Agent initialization
-                            with tracer.start_as_current_span("agent_init") as init_span:
-                                init_span.set_attribute("span.type", "agent_init")
-                                init_span.set_attribute("source", "agent")
-                                init_span.set_attribute("model", data.get("model", "unknown"))
-                                init_span.set_attribute("tools", json.dumps(data.get("tools", [])))
-                                init_span.set_attribute("content", f"Agent initialized: {data.get('model', 'unknown')}")
-
-                        else:
-                            # Other output - just log it without creating a span
-                            logger.debug(f"[agent] {decoded_line}")
-                            continue
-
-                    except json.JSONDecodeError:
-                        # Not JSON - just log it
-                        logger.info(f"[agent] {decoded_line}")
-
-                await process.wait()
-
-                exit_code = process.returncode or 0
-                if exit_code != 0:
-                    error_context = "\n".join(output_lines[-50:]) if output_lines else "No output captured"
-
-                    exec_span.set_attribute("error", True)
-                    exec_span.set_attribute("exit_code", exit_code)
-                    exec_span.add_event(
-                        "agent_error",
-                        {
-                            "exit_code": exit_code,
-                            "output": error_context[:4000],
-                        },
-                    )
+        for key, value in secrets.items():
+            docker_cmd.extend(["-e", f"{key.upper()}={value}"])
 
-                    agent_span.set_attribute("error", True)
-                    agent_span.set_attribute("exit_code", exit_code)
+        docker_cmd.append(image)
 
-                    raise RuntimeError(f"Agent failed with exit code {exit_code}")
+        # Pass instruction via CLI arg
+        docker_cmd.extend(["--instruction", instruction])
 
-                exec_span.set_attribute("success", True)
+        # Run container - agents emit their own OTel spans
+        process = await asyncio.create_subprocess_exec(
+            *docker_cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+        )
 
-        finally:
-            os.unlink(config_file.name)
+        # Capture output for error reporting
+        output_lines: list[str] = []
+        assert process.stdout is not None
+        while True:
+            line = await process.stdout.readline()
+            if not line:
+                break
+            decoded_line = line.decode().rstrip()
+            output_lines.append(decoded_line)
 
-            # Load trajectory and log as event
-            trajectory_path = Path(logs_dir) / "agent" / "trajectory.json"
-            if trajectory_path.exists():
-                try:
-                    with open(trajectory_path) as f:
-                        trajectory = json.load(f)
-                    if isinstance(trajectory, dict) and "schema_version" in trajectory:
-                        # Add agent image to trajectory
-                        agent_data = trajectory.get("agent", {})
-                        extra = agent_data.get("extra") or {}
-                        extra["image"] = image
-                        agent_data["extra"] = extra
-                        trajectory["agent"] = agent_data
+        await process.wait()
 
-                        # Log trajectory as span event
-                        with tracer.start_as_current_span("trajectory") as traj_span:
-                            traj_span.set_attribute("span.type", "trajectory")
-                            traj_span.set_attribute("log_type", "atif")
-                            traj_span.set_attribute("source", "agent")
-                            # Store trajectory in span (truncated for OTel limits)
-                            traj_json = json.dumps(trajectory)
-                            if len(traj_json) > 10000:
-                                traj_span.set_attribute("trajectory_truncated", True)
-                                traj_span.set_attribute("trajectory_size", len(traj_json))
-                            else:
-                                traj_span.set_attribute("trajectory", traj_json)
-                except Exception as e:
-                    logger.warning(f"Failed to load trajectory: {e}")
+        exit_code = process.returncode or 0
+        if exit_code != 0:
+            error_context = "\n".join(output_lines[-50:]) if output_lines else "No output captured"
+            raise RuntimeError(f"Agent failed with exit code {exit_code}\n\nAgent output:\n{error_context}")
 
-            # Upload artifacts if we have upload URL configured
-            if upload_url:
-                await upload_artifacts(upload_url, logs_dir)
+    finally:
+        os.unlink(config_file.name)
 
-        agent_span.set_attribute("success", True)
-        agent_span.set_attribute("content", f"Agent {agent_name} completed successfully")
+        # Upload artifacts if we have upload URL configured
+        if upload_url:
+            await upload_artifacts(upload_url, logs_dir)

plato/worlds/base.py

@@ -417,7 +417,7 @@ class BaseWorld(ABC, Generic[ConfigT]):
             content_type=content_type,
         )
 
-    async def _create_and_upload_checkpoint(self) -> bool:
+    async def _create_and_upload_checkpoint(self) -> tuple[dict[str, str], bool]:
         """Create a full checkpoint including env snapshots and state bundle.
 
         This method:
@@ -426,7 +426,7 @@ class BaseWorld(ABC, Generic[ConfigT]):
         3. Creates and uploads state bundle to S3
 
         Returns:
-            True if successful, False otherwise
+            Tuple of (env_snapshots dict, state_bundle_uploaded bool)
         """
         # Commit state changes first
         self._commit_state(f"Checkpoint at step {self._step_count}")
@@ -436,6 +436,8 @@ class BaseWorld(ABC, Generic[ConfigT]):
         if env_snapshots is None:
             env_snapshots = {}
 
+        state_bundle_uploaded = True  # Default to True if state not enabled
+
         # Create and upload state bundle
         if self.config.state.enabled:
             bundle_data = self._create_state_bundle()
@@ -446,12 +448,12 @@ class BaseWorld(ABC, Generic[ConfigT]):
                 )
                 if success:
                     self.logger.info(f"Uploaded state bundle at step {self._step_count}")
-                    return True
+                    state_bundle_uploaded = True
                 else:
                     self.logger.warning(f"Failed to upload state bundle at step {self._step_count}")
-                    return False
+                    state_bundle_uploaded = False
 
-        return True
+        return env_snapshots, state_bundle_uploaded
 
     def get_env(self, alias: str) -> Environment | None:
         """Get an environment by alias.
@@ -646,25 +648,30 @@ The following services are available for your use:
         if config.session_id:
             self._session_id = config.session_id
 
-            # Set environment variables for agent runners
+            # Set environment variables for agent runners (which run in Docker)
             os.environ["SESSION_ID"] = config.session_id
             if config.otel_url:
-                os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = config.otel_url
-                # Use JSON protocol (not protobuf) for the OTLP exporter
-                os.environ["OTEL_EXPORTER_OTLP_PROTOCOL"] = "http/json"
+                # For agents in Docker, convert localhost to host.docker.internal
+                # so they can reach the host machine's Chronos instance
+                agent_otel_url = config.otel_url
+                if "localhost" in agent_otel_url or "127.0.0.1" in agent_otel_url:
+                    agent_otel_url = agent_otel_url.replace("localhost", "host.docker.internal")
+                    agent_otel_url = agent_otel_url.replace("127.0.0.1", "host.docker.internal")
+                os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = agent_otel_url
+                os.environ["OTEL_EXPORTER_OTLP_PROTOCOL"] = "http/protobuf"
             if config.upload_url:
                 os.environ["UPLOAD_URL"] = config.upload_url
 
-            # Initialize OTel tracing if otel_url is provided
-            print(f"[World] OTel URL from config: {config.otel_url!r}")
+            # Initialize OTel tracing for the world itself (runs on host, not in Docker)
             if config.otel_url:
+                logger.debug(f"Initializing OTel tracing with endpoint: {config.otel_url}")
                 init_tracing(
                     service_name=f"world-{self.name}",
                     session_id=config.session_id,
                     otlp_endpoint=config.otel_url,
                 )
             else:
-                print("[World] No otel_url in config - OTel tracing disabled")
+                logger.debug("No otel_url in config - OTel tracing disabled")
 
         # Connect to Plato session if configured (for heartbeats)
         await self._connect_plato_session()
@@ -672,72 +679,72 @@ The following services are available for your use:
         # Get tracer for spans
         tracer = get_tracer("plato.world")
 
-        # Log session start
-        with tracer.start_as_current_span("session_start") as span:
-            span.set_attribute("span.type", "session_start")
-            span.set_attribute("source", "world")
-            span.set_attribute("world_name", self.name)
-            span.set_attribute("world_version", self.get_version())
-            span.set_attribute("content", f"World '{self.name}' started")
-
-        try:
-            # Execute reset with OTel span
-            with tracer.start_as_current_span("reset") as reset_span:
-                reset_span.set_attribute("span.type", "reset")
-                reset_span.set_attribute("source", "world")
-                reset_span.set_attribute("content", f"Resetting world '{self.name}'")
-                obs = await self.reset()
-                obs_data = obs.model_dump() if hasattr(obs, "model_dump") else str(obs)
-                reset_span.set_attribute("observation", str(obs_data)[:1000])  # Truncate for OTel
-            self.logger.info(f"World reset complete: {obs}")
-
-            while True:
-                self._step_count += 1
-
-                # Execute step with OTel span
-                with tracer.start_as_current_span(f"step_{self._step_count}") as step_span:
-                    step_span.set_attribute("span.type", "step")
-                    step_span.set_attribute("source", "world")
-                    step_span.set_attribute("step_number", self._step_count)
-                    step_span.set_attribute("content", f"Step {self._step_count} started")
-
-                    # Store span context for nested agent spans
-
-                    self._current_step_id = format(step_span.get_span_context().span_id, "016x")
-
-                    result = await self.step()
-
-                    step_span.set_attribute("done", result.done)
-                    obs_data = (
-                        result.observation.model_dump()
-                        if hasattr(result.observation, "model_dump")
-                        else str(result.observation)
-                    )
-                    step_span.set_attribute("observation", str(obs_data)[:1000])
-
-                self.logger.info(f"Step {self._step_count}: done={result.done}")
+        # Create root session span that encompasses everything
+        # This ensures all child spans share the same trace_id
+        with tracer.start_as_current_span("session") as session_span:
+            session_span.set_attribute("plato.world.name", self.name)
+            session_span.set_attribute("plato.world.version", self.get_version())
+            session_span.set_attribute("plato.session.id", config.session_id)
 
-                # Create checkpoint if enabled and interval matches
-                if self.config.checkpoint.enabled and self._step_count % self.config.checkpoint.interval == 0:
-                    self.logger.info(f"Creating checkpoint after step {self._step_count}")
-                    await self._create_and_upload_checkpoint()
-
-                if result.done:
-                    break
-
-        finally:
-            await self.close()
-            await self._disconnect_plato_session()
-
-            # Log session end
-            with tracer.start_as_current_span("session_end") as span:
-                span.set_attribute("span.type", "session_end")
-                span.set_attribute("source", "world")
-                span.set_attribute("total_steps", self._step_count)
-                span.set_attribute("content", f"World '{self.name}' completed after {self._step_count} steps")
-
-            # Shutdown OTel tracing and clear session info
-            shutdown_tracing()
-            self._session_id = None
-
-            self.logger.info(f"World '{self.name}' completed after {self._step_count} steps")
+            try:
+                # Execute reset with OTel span
+                with tracer.start_as_current_span("reset") as reset_span:
+                    obs = await self.reset()
+                    obs_data = obs.model_dump() if hasattr(obs, "model_dump") else str(obs)
+                    reset_span.set_attribute("plato.observation", str(obs_data)[:1000])
+                self.logger.info(f"World reset complete: {obs}")
+
+                while True:
+                    self._step_count += 1
+
+                    # Execute step with OTel span
+                    with tracer.start_as_current_span(f"step_{self._step_count}") as step_span:
+                        step_span.set_attribute("plato.step.number", self._step_count)
+
+                        # Store span context for nested agent spans
+                        self._current_step_id = format(step_span.get_span_context().span_id, "016x")
+
+                        result = await self.step()
+
+                        step_span.set_attribute("plato.step.done", result.done)
+                        obs_data = (
+                            result.observation.model_dump()
+                            if hasattr(result.observation, "model_dump")
+                            else str(result.observation)
+                        )
+                        step_span.set_attribute("plato.step.observation", str(obs_data)[:1000])
+
+                    self.logger.info(f"Step {self._step_count}: done={result.done}")
+
+                    # Create checkpoint if enabled and interval matches
+                    if self.config.checkpoint.enabled and self._step_count % self.config.checkpoint.interval == 0:
+                        self.logger.info(f"Creating checkpoint after step {self._step_count}")
+                        with tracer.start_as_current_span("checkpoint") as checkpoint_span:
+                            checkpoint_span.set_attribute("plato.checkpoint.step", self._step_count)
+                            env_snapshots, state_bundle_uploaded = await self._create_and_upload_checkpoint()
+
+                            checkpoint_span.set_attribute("plato.checkpoint.success", len(env_snapshots) > 0)
+                            checkpoint_span.set_attribute(
+                                "plato.checkpoint.state_bundle_uploaded", state_bundle_uploaded
+                            )
+
+                            if env_snapshots:
+                                checkpoint_span.set_attribute(
+                                    "plato.checkpoint.environments", list(env_snapshots.keys())
+                                )
+                                checkpoint_span.set_attribute(
+                                    "plato.checkpoint.artifact_ids", list(env_snapshots.values())
+                                )
+
+                    if result.done:
+                        break
+
+            finally:
+                await self.close()
+                await self._disconnect_plato_session()
+
+        # Shutdown OTel tracing and clear session info (outside the span)
+        shutdown_tracing()
+        self._session_id = None
+
+        self.logger.info(f"World '{self.name}' completed after {self._step_count} steps")

plato/worlds/runner.py

@@ -6,7 +6,6 @@ import asyncio
 import json
 import logging
 import os
-import platform
 from pathlib import Path
 from typing import Annotated
 
@@ -136,6 +135,28 @@ def list_worlds(
         typer.echo(f"  {name} (v{version}): {desc}")
 
 
+def _get_docker_platform() -> str:
+    """Get the appropriate Docker platform for the current system.
+
+    Returns:
+        Docker platform string (e.g., "linux/arm64" or "linux/amd64")
+    """
+    import platform as plat
+
+    system = plat.system()
+    machine = plat.machine().lower()
+
+    # On macOS with Apple Silicon (arm64/aarch64), use linux/arm64
+    if system == "Darwin" and machine in ("arm64", "aarch64"):
+        return "linux/arm64"
+    # On Linux ARM
+    elif system == "Linux" and machine in ("arm64", "aarch64"):
+        return "linux/arm64"
+    # Default to amd64 for x86_64 or other architectures
+    else:
+        return "linux/amd64"
+
+
 async def _build_agent_image(
     agent_name: str,
     agents_dir: Path,
@@ -181,9 +202,17 @@ async def _build_agent_image(
         target = "prod"
         logger.info(f"Building {image_tag} (prod mode from {build_context})...")
 
+    # Detect platform for ARM Mac support
+    docker_platform = _get_docker_platform()
+    logger.info(f"Building for platform: {docker_platform}")
+
     cmd = [
         "docker",
         "build",
+        "--platform",
+        docker_platform,
+        "--build-arg",
+        f"PLATFORM={docker_platform}",
         "--target",
         target,
         "-t",
@@ -192,10 +221,6 @@ async def _build_agent_image(
         dockerfile_abs,
     ]
 
-    # Use native platform for local dev on ARM Macs (avoids slow emulation)
-    if platform.machine() == "arm64":
-        cmd.extend(["--build-arg", "PLATFORM=linux/arm64"])
-
     cmd.append(build_context)
 
     logger.debug(f"Build command: {' '.join(cmd)}")
@@ -405,6 +430,7 @@ async def _run_dev(
     plato = AsyncPlato()
     session = None
     plato_session_id: str | None = None
+    chronos_session_id: str | None = None
 
     try:
         if env_configs:
@@ -435,18 +461,10 @@ async def _run_dev(
 
         # Update run_config with session info from Chronos
         run_config.session_id = chronos_session_id
-        run_config.otel_url = chronos_session.otel_url
+        # Use base chronos URL for OTEL endpoint (more reliable than session-provided URL)
+        run_config.otel_url = f"{chronos_url.rstrip('/')}/api/otel"
         run_config.upload_url = chronos_session.upload_url
 
-        # For local dev, override otel_url to use localhost directly
-        # (Chronos may return a tunnel URL that's meant for remote VMs)
-        if "localhost" in chronos_url or "127.0.0.1" in chronos_url:
-            run_config.otel_url = f"{chronos_url.rstrip('/')}/api/otel"
-            logger.info(f"Local dev: using OTel URL {run_config.otel_url}")
-
-        print(f"[Runner] run_config.otel_url = {run_config.otel_url!r}")
-        print(f"[Runner] run_config.upload_url = {run_config.upload_url!r}")
-
         # Run the world
         logger.info(f"Starting world '{world_name}'...")
         world_instance = world_cls()
@@ -509,11 +527,16 @@ def dev(
     world: Annotated[str, typer.Option("--world", "-w", help="World name to run")],
     config: Annotated[Path, typer.Option("--config", "-c", help="Path to config JSON file")],
     env_timeout: Annotated[
-        int, typer.Option("--env-timeout", help="Timeout for environment creation (seconds)")
+        int,
+        typer.Option("--env-timeout", help="Timeout for environment creation (seconds)"),
     ] = 7200,
     agents_dir: Annotated[
         Path | None,
-        typer.Option("--agents-dir", "-a", help="Directory containing agent source code (builds local images)"),
+        typer.Option(
+            "--agents-dir",
+            "-a",
+            help="Directory containing agent source code (builds local images)",
+        ),
     ] = None,
     verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Enable verbose logging")] = False,
 ) -> None:

{plato_sdk_v2-2.3.5.dist-info → plato_sdk_v2-2.3.7.dist-info}/METADATA

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

{plato_sdk_v2-2.3.5.dist-info → plato_sdk_v2-2.3.7.dist-info}/RECORD

@@ -302,8 +302,8 @@ plato/agents/artifacts.py,sha256=ljeI0wzsp7Q6uKqMb-k7kTb680Vizs54ohtM-d7zvOg,292
 plato/agents/base.py,sha256=vUbPQuNSo6Ka2lIB_ZOXgi4EoAjtAD7GIj9LnNotam0,4577
 plato/agents/build.py,sha256=CNMbVQFs2_pYit1dA29Davve28Yi4c7TNK9wBB7odrE,1621
 plato/agents/config.py,sha256=CmRS6vOAg7JeqX4Hgp_KpA1YWBX_LuMicHm7SBjQEbs,5077
-plato/agents/otel.py,sha256=xhsqJrfD9s3tyiSyZPFkTPS0wma71v_TS5BbGiL6lmQ,8168
-plato/agents/runner.py,sha256=1qOCYVgT6m4zsRM8f0JXOYIg6smCyI-cuGZgVVae7aM,16244
+plato/agents/otel.py,sha256=LI5ZK4lwoDD2AnXhSubbv6ONP2VayOsNIk-F1hQ6968,7991
+plato/agents/runner.py,sha256=Ei20Ib-Fn5XOaS6V1Rtw0UEw34XflEWaXMpazPjmnrE,6061
 plato/agents/trajectory.py,sha256=WdiBmua0KvCrNaM3qgPI7-7B4xmSkfbP4oZ_9_8qHzU,10529
 plato/chronos/__init__.py,sha256=RHMvSrQS_-vkKOyTRuAkp2gKDP1HEuBLDnw8jcZs1Jg,739
 plato/chronos/client.py,sha256=YcOGtHWERyOD9z8LKt8bRMVL0cEwL2hiAP4qQgdZlUI,5495
@@ -458,11 +458,11 @@ plato/v2/utils/models.py,sha256=PwehSSnIRG-tM3tWL1PzZEH77ZHhIAZ9R0UPs6YknbM,1441
 plato/v2/utils/proxy_tunnel.py,sha256=8ZTd0jCGSfIHMvSv1fgEyacuISWnGPHLPbDglWroTzY,10463
 plato/worlds/README.md,sha256=XFOkEA3cNNcrWkk-Cxnsl-zn-y0kvUENKQRSqFKpdqw,5479
 plato/worlds/__init__.py,sha256=ALoou3l5lXvs_YZc5eH6HdMHpvhnpzKWqz__aSC1jFc,2152
-plato/worlds/base.py,sha256=E_E5Y1FgcCghAIFWtTkqFXpf2tAKVKVNRKDtKXoHMac,26777
+plato/worlds/base.py,sha256=_svL9RBp3dTIhHqcvZB1F7qEFrZvAuQ-XjZkTa3L6zo,27750
 plato/worlds/build_hook.py,sha256=KSoW0kqa5b7NyZ7MYOw2qsZ_2FkWuz0M3Ru7AKOP7Qw,3486
 plato/worlds/config.py,sha256=a5frj3mt06rSlT25kE-L8Q2b2MTWkR-8cUoBKpC8tG4,11036
-plato/worlds/runner.py,sha256=J4u0PiMAs_tG5rBaIQtLmoqGnlxvbTyPIXDBbMMA8DY,18967
-plato_sdk_v2-2.3.5.dist-info/METADATA,sha256=YuzNDUss8gxSTa1XH86sb3etwlKd92o3GJXv6j_SWDA,8653
-plato_sdk_v2-2.3.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-plato_sdk_v2-2.3.5.dist-info/entry_points.txt,sha256=upGMbJCx6YWUTKrPoYvYUYfFCqYr75nHDwhA-45m6p8,136
-plato_sdk_v2-2.3.5.dist-info/RECORD,,
+plato/worlds/runner.py,sha256=2H5EV77bTYrMyI7qez0kwxOp9EApQxG19Ob9a_GTdbw,19383
+plato_sdk_v2-2.3.7.dist-info/METADATA,sha256=7T1hf9Y8o0lFSrSx35VozfobEdwM097kfZQT6rEIn68,8653
+plato_sdk_v2-2.3.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+plato_sdk_v2-2.3.7.dist-info/entry_points.txt,sha256=upGMbJCx6YWUTKrPoYvYUYfFCqYr75nHDwhA-45m6p8,136
+plato_sdk_v2-2.3.7.dist-info/RECORD,,