plato-sdk-v2 2.3.6__py3-none-any.whl → 2.3.8__py3-none-any.whl

plato/worlds/base.py

@@ -28,6 +28,17 @@ from plato.agents.otel import (
 
 logger = logging.getLogger(__name__)
 
+
+def _get_plato_version() -> str:
+    """Get the installed plato SDK version."""
+    try:
+        from importlib.metadata import version
+
+        return version("plato")
+    except Exception:
+        return "unknown"
+
+
 # Global registry of worlds
 _WORLD_REGISTRY: dict[str, type[BaseWorld]] = {}
 
@@ -417,7 +428,7 @@ class BaseWorld(ABC, Generic[ConfigT]):
             content_type=content_type,
         )
 
-    async def _create_and_upload_checkpoint(self) -> dict[str, str] | None:
+    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 +437,7 @@ class BaseWorld(ABC, Generic[ConfigT]):
         3. Creates and uploads state bundle to S3
 
         Returns:
-            Dict mapping env alias to artifact_id if successful, None 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 +447,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,11 +459,12 @@ class BaseWorld(ABC, Generic[ConfigT]):
                 )
                 if success:
                     self.logger.info(f"Uploaded state bundle at step {self._step_count}")
+                    state_bundle_uploaded = True
                 else:
                     self.logger.warning(f"Failed to upload state bundle at step {self._step_count}")
-                    return None
+                    state_bundle_uploaded = False
 
-        return env_snapshots
+        return env_snapshots, state_bundle_uploaded
 
     def get_env(self, alias: str) -> Environment | None:
         """Get an environment by alias.
@@ -645,25 +659,35 @@ 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")
+
+        # Log version info (goes to OTel after init_tracing)
+        plato_version = _get_plato_version()
+        world_version = self.get_version()
+        self.logger.info(f"World version: {world_version}, Plato SDK version: {plato_version}")
 
         # Connect to Plato session if configured (for heartbeats)
         await self._connect_plato_session()
@@ -671,85 +695,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")
+        # 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)
 
-        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 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}")
-                    env_snapshots = await self._create_and_upload_checkpoint()
-
-                    # Emit checkpoint span for UI visibility
-                    with tracer.start_as_current_span(f"checkpoint_{self._step_count}") as checkpoint_span:
-                        checkpoint_span.set_attribute("span.type", "checkpoint")
-                        checkpoint_span.set_attribute("source", "world")
-                        checkpoint_span.set_attribute("step_number", self._step_count)
-                        checkpoint_span.set_attribute("content", f"Checkpoint created at step {self._step_count}")
-                        if env_snapshots:
-                            # Serialize env_snapshots for OTel attribute
-                            import json
-
-                            checkpoint_span.set_attribute("env_snapshots", json.dumps(env_snapshots))
-                        checkpoint_span.set_attribute("success", env_snapshots is not None)
-
-                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()

{plato_sdk_v2-2.3.6.dist-info → plato_sdk_v2-2.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plato-sdk-v2
-Version: 2.3.6
+Version: 2.3.8
 Summary: Python SDK for the Plato API
 Author-email: Plato <support@plato.so>
 License-Expression: MIT
@@ -47,7 +47,6 @@ Description-Content-Type: text/markdown
 
 # Plato Python SDK
 
-
 Python SDK for the Plato platform. Uses [Harbor](https://harborframework.com) for agent execution.
 
 ## Installation

{plato_sdk_v2-2.3.6.dist-info → plato_sdk_v2-2.3.8.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=UOEBeMyyfbffsC3tRXlHAydoj9bXwJupA_UeLZ5h97w,8585
+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
@@ -389,9 +389,9 @@ plato/v1/cli/__init__.py,sha256=om4b7PxgsoI7rEwuQelmQkqPdhMVn53_5qEN8kvksYw,105
 plato/v1/cli/agent.py,sha256=G6TV3blG_BqMDBWS-CG7GwzqoqcJTMsIKQ88jvLXb4k,43745
 plato/v1/cli/main.py,sha256=ktPtBvMwykR7AjXmTQ6bmZkHdzpAjhX5Fq66cDbGSzA,6844
 plato/v1/cli/pm.py,sha256=uLM6WszKqxq9Czg1FraDyWb9_INUuHZq63imvRYfRLw,49734
-plato/v1/cli/sandbox.py,sha256=5rth_jL73L72GC0VJ0meXRgZo2EpsJ_qI3ipFjfXzJY,95185
-plato/v1/cli/ssh.py,sha256=10ag6S1sxMcAmvcg24qy-yYwXb1miWfqxkXOs4QX8u0,6623
-plato/v1/cli/utils.py,sha256=be-llK6T6NHnIQl_Kfs-8EPu9JhIuZ_k9tJ3Ts-AKt4,3887
+plato/v1/cli/sandbox.py,sha256=N7DIpXsxExtZB47tWKxp-3cV0_gLnI7C-mTKW3tTi8Y,95360
+plato/v1/cli/ssh.py,sha256=enrf7Y01ZeRIyHDEX0Yt7up5zEe7MCvE9u8SP4Oqiz4,6926
+plato/v1/cli/utils.py,sha256=ba7Crv4OjDmgCv4SeB8UeZDin-iOdQw_3N6fd-g5XVk,4572
 plato/v1/cli/verify.py,sha256=7QmQwfOOkr8a51f8xfVIr2zif7wGl2E8HOZTbOaIoV0,20671
 plato/v1/cli/world.py,sha256=yBUadOJs1QYm6Jmx_ACDzogybRq5x4B-BnTvGO_ulQk,9757
 plato/v1/examples/doordash_tasks.py,sha256=8Sz9qx-vTmiOAiCAbrDRvZGsA1qQQBr1KHbxXdjr7OI,23233
@@ -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=pYBuXn7zZ3n-ys4XkEVEUL1poq1lWTNH9qYbMzWRLfE,27694
+plato/worlds/base.py,sha256=kIX02gMQR43ZsZK25vZvCoNkYtICVRMeofNk-im5IRM,28215
 plato/worlds/build_hook.py,sha256=KSoW0kqa5b7NyZ7MYOw2qsZ_2FkWuz0M3Ru7AKOP7Qw,3486
 plato/worlds/config.py,sha256=a5frj3mt06rSlT25kE-L8Q2b2MTWkR-8cUoBKpC8tG4,11036
-plato/worlds/runner.py,sha256=vrgKStT8fs3HuOGcPL5obZt-BLdLlQ0CVBUQZWyOOis,19023
-plato_sdk_v2-2.3.6.dist-info/METADATA,sha256=mt3gSWRwTjcgKse_WxVlNF1_bRtZjdjzWiIdJJ2ecFU,8653
-plato_sdk_v2-2.3.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-plato_sdk_v2-2.3.6.dist-info/entry_points.txt,sha256=upGMbJCx6YWUTKrPoYvYUYfFCqYr75nHDwhA-45m6p8,136
-plato_sdk_v2-2.3.6.dist-info/RECORD,,
+plato/worlds/runner.py,sha256=2H5EV77bTYrMyI7qez0kwxOp9EApQxG19Ob9a_GTdbw,19383
+plato_sdk_v2-2.3.8.dist-info/METADATA,sha256=GnoZAAlPmFfWxSwHFjkab7s6MmWfk8rXOvOynTb2r28,8652
+plato_sdk_v2-2.3.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+plato_sdk_v2-2.3.8.dist-info/entry_points.txt,sha256=upGMbJCx6YWUTKrPoYvYUYfFCqYr75nHDwhA-45m6p8,136
+plato_sdk_v2-2.3.8.dist-info/RECORD,,