adk-code-mode-sandbox 1.2.0__tar.gz → 1.3.0__tar.gz

{adk_code_mode_sandbox-1.2.0 → adk_code_mode_sandbox-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adk-code-mode-sandbox
-Version: 1.2.0
+Version: 1.3.0
 Summary: In-sandbox runtime shim for adk-code-mode. Installs inside the container image the host runtime launches.
 Project-URL: Documentation, https://github.com/A2ANet/adk-code-mode#readme
 Project-URL: Issues, https://github.com/A2ANet/adk-code-mode/issues

{adk_code_mode_sandbox-1.2.0 → adk_code_mode_sandbox-1.3.0}/src/adk_code_mode_sandbox/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present A2A Net <hello@a2anet.com>
 #
 # SPDX-License-Identifier: Apache-2.0
-__version__ = "1.2.0"  # x-release-please-version
+__version__ = "1.3.0"  # x-release-please-version

{adk_code_mode_sandbox-1.2.0 → adk_code_mode_sandbox-1.3.0}/src/adk_code_mode_sandbox/_entry.py

@@ -23,8 +23,10 @@ its stdout/stderr captured and shipped back in a per-block ``OutputFrame``; any
 
 from __future__ import annotations
 
+import importlib.metadata
 import io
 import os
+import platform
 import socket
 import sys
 import traceback
@@ -40,6 +42,11 @@ from adk_code_mode_sandbox.protocol import (
     ShutdownFrame,
 )
 
+# Distributions that ship with the sandbox itself rather than being installed by
+# whoever built the image. Reporting them would tell the model it has tools it
+# was never meant to use (`websockets` is this wheel's only dependency).
+_PACKAGE_DENYLIST = frozenset({"adk-code-mode-sandbox", "websockets", "pip", "setuptools", "wheel"})
+
 CONTROL_FD_ENV = "ADK_CODE_MODE_CONTROL_FD"
 CONTROL_SOCKET_ENV = "ADK_CODE_MODE_CONTROL_SOCKET"
 CONTROL_TCP_ENV = "ADK_CODE_MODE_CONTROL_TCP"
@@ -50,6 +57,35 @@ TOOLS_DIR = os.environ.get(TOOLS_DIR_ENV, "/tools")
 WORKDIR = os.environ.get(WORKDIR_ENV, "/workspace")
 
 
+def ready_frame() -> ReadyFrame:
+    """Build the ``ReadyFrame`` announcing this image's Python and packages.
+
+    Both transports send this, so image introspection stays in one place.
+    """
+    distributions = {
+        dist.name.casefold(): (dist.name, dist.version)
+        for dist in sorted(
+            importlib.metadata.distributions(),
+            key=lambda dist: (dist.name.casefold(), dist.name, dist.version),
+        )
+        if dist.name.casefold() not in _PACKAGE_DENYLIST
+    }
+    packages: dict[str, dict[str, str]] = {}
+    package_distributions = importlib.metadata.packages_distributions()
+    for import_name in sorted(package_distributions, key=lambda name: (name.casefold(), name)):
+        providers: dict[str, str] = {}
+        for distribution_name in sorted(
+            package_distributions[import_name],
+            key=lambda name: (name.casefold(), name),
+        ):
+            distribution = distributions.get(distribution_name.casefold())
+            if distribution is not None:
+                providers[distribution[0]] = distribution[1]
+        if providers:
+            packages[import_name] = providers
+    return ReadyFrame(python_version=platform.python_version(), packages=packages)
+
+
 def _open_control_streams() -> tuple[Any, Any]:
     """Open the host control pipe as a (reader, writer) pair."""
     tcp_endpoint = os.environ.get(CONTROL_TCP_ENV)
@@ -204,7 +240,7 @@ def main() -> int:
     # One persistent globals dict + one /workspace for the whole connection, so
     # variables and files carry across the turn's successive code blocks.
     globs = _make_globals()
-    client.send(ReadyFrame())
+    client.send(ready_frame())
 
     while True:
         frame = client.recv()

{adk_code_mode_sandbox-1.2.0 → adk_code_mode_sandbox-1.3.0}/src/adk_code_mode_sandbox/_http_server.py

@@ -49,6 +49,7 @@ from adk_code_mode_sandbox._entry import (
     _prepare_sys_path,
     _prepare_workdir,
     _sanitize_environ,
+    ready_frame,
     run_block,
 )
 from adk_code_mode_sandbox._rpc_client import RpcClient
@@ -57,7 +58,6 @@ from adk_code_mode_sandbox.protocol import (
     DoneFrame,
     OutputFrame,
     ProtocolError,
-    ReadyFrame,
     RunFrame,
     ShutdownFrame,
     decode,
@@ -188,8 +188,9 @@ async def _handle_connection(ws: Any) -> None:
         globs = _make_globals()
         loop = asyncio.get_running_loop()
 
-        # 4. Announce readiness once (carries the protocol version).
-        await ws.send(encode(ReadyFrame()).decode("utf-8"))
+        # 4. Announce readiness once (carries the protocol version, Python
+        #    version, and installed packages).
+        await ws.send(encode(ready_frame()).decode("utf-8"))
 
         # 5. Run code blocks until the client ends the turn or disconnects.
         while await _run_one_block(ws, loop, globs, workspace_dir, max_workspace):

{adk_code_mode_sandbox-1.2.0 → adk_code_mode_sandbox-1.3.0}/src/adk_code_mode_sandbox/protocol.py

@@ -39,10 +39,20 @@ FrameKind = Literal[
 
 @dataclass(frozen=True)
 class ReadyFrame:
-    """Sandbox → host. Sent once after boot."""
+    """Sandbox → host. Sent once after boot.
+
+    ``python_version`` / ``packages`` describe the image the sandbox runs in so
+    the host can tell the model what it can import. ``packages`` maps each
+    top-level import name to the distributions that provide it and their
+    versions. Both are additive fields with defaults, so a host and a sandbox
+    on different releases still speak: ``decode`` drops unknown keys, and an
+    older sandbox that sends neither just leaves them empty.
+    """
 
     kind: Literal["ready"] = "ready"
     protocol_version: int = PROTOCOL_VERSION
+    python_version: str = ""
+    packages: dict[str, dict[str, str]] = field(default_factory=dict)
 
 
 @dataclass(frozen=True)