aip-agents-binary 0.0.0__py3-none-any.whl

aip_agents/sandbox/providers/bedrock.py

@@ -0,0 +1,28 @@
+"""Bedrock AgentCore sandbox provider factory."""
+
+import os
+
+from gllm_tools.code_interpreter.code_sandbox.bedrock_agentcore_sandbox import BedrockAgentCoreSandbox
+
+from aip_agents.sandbox.providers.base import BaseSandboxProvider, SandboxConfig, SandboxCreateResult
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class BedrockProvider(BaseSandboxProvider):
+    """Bedrock AgentCore sandbox provider."""
+
+    async def create(self, config: SandboxConfig) -> SandboxCreateResult:
+        """Create a Bedrock AgentCore sandbox."""
+        if config.template:
+            logger.warning("Bedrock has no template build; ignoring requested template %r", config.template)
+        region = os.environ.get("AWS_REGION", "us-east-1")
+        sandbox = BedrockAgentCoreSandbox(region=region)
+        logger.info("Bedrock sandbox created (region=%s)", region)
+        return SandboxCreateResult(sandbox=sandbox, created_with_template=False)
+
+
+async def create(config: SandboxConfig) -> SandboxCreateResult:
+    """Compatibility wrapper for the old module-level provider factory."""
+    return await BedrockProvider().create(config)

aip_agents/sandbox/providers/e2b.py

@@ -0,0 +1,230 @@
+"""E2B sandbox provider factory.
+
+Owns the E2B-specific create flow: create-with-template, transient placement
+retry, the 404 → auto-build → retry sequence, and fail-fast surfacing of real
+template/configuration errors.
+
+Env config:
+    E2B_API_KEY  E2B API key (used unless passed via ``SandboxConfig.api_key``).
+    E2B_DOMAIN   Optional E2B domain override (used unless passed via ``SandboxConfig.domain``).
+
+When auto-build is enabled (``SandboxConfig.auto_build_template``), template
+building additionally uses the image-registry env (``AIP_SANDBOX_IMAGE_REGISTRY`` /
+``AIP_SANDBOX_REGISTRY_AUTH``) — see ``aip_agents.sandbox.image_registry``.
+"""
+
+import asyncio
+import math
+import os
+from typing import Any
+
+from gllm_tools.code_interpreter.code_sandbox.e2b_sandbox import E2BSandbox
+from gllm_tools.code_interpreter.code_sandbox.sandbox import CodeInterpreterSandbox
+
+from aip_agents.sandbox import image_registry
+from aip_agents.sandbox.providers.base import (
+    BaseSandboxProvider,
+    SandboxConfig,
+    SandboxCreateResult,
+    SandboxPlacementError,
+    create_with_placement_retry,
+)
+from aip_agents.sandbox.template_builder import (
+    DockerfileNotFoundError,
+    ensure_sandbox_template,
+    get_sandbox_dockerfile_path,
+)
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+AUTO_BUILD_TEMPLATE_CREATE_RETRY_ATTEMPTS = 5
+AUTO_BUILD_TEMPLATE_CREATE_RETRY_DELAY_SECONDS = 5.0
+
+# E2B provider markers for transient sandbox placement-capacity failures.
+_PLACEMENT_FAILURE_MARKERS = (
+    "failed to place sandbox",
+    "sandbox placement",
+    "placement failed",
+)
+
+
+def is_placement_failure(error: Exception) -> bool:
+    """Classify transient E2B placement-capacity failures as retryable."""
+    message = str(error).lower()
+    return any(marker in message for marker in _PLACEMENT_FAILURE_MARKERS)
+
+
+def _normalize_e2b_timeout(execution_timeout: float) -> int:
+    """Normalize E2B timeout values to integer seconds."""
+    timeout_seconds = float(execution_timeout)
+    if timeout_seconds <= 0:
+        return 0
+    return math.ceil(timeout_seconds)
+
+
+def _credentials(config: SandboxConfig) -> tuple[str | None, str | None]:
+    """Resolve E2B credentials with explicit values taking precedence over env."""
+    api_key = config.api_key if config.api_key is not None else os.environ.get("E2B_API_KEY")
+    domain = config.domain if config.domain is not None else os.environ.get("E2B_DOMAIN")
+    return api_key, domain
+
+
+def _create_kwargs(config: SandboxConfig, *, template: str | None = None) -> dict[str, Any]:
+    """Build E2B create kwargs, preserving timeout/domain behavior."""
+    api_key, domain = _credentials(config)
+    kwargs: dict[str, Any] = {
+        "api_key": api_key,
+        "domain": domain,
+        "timeout": _normalize_e2b_timeout(config.sandbox_timeout),
+    }
+    if template is not None:
+        kwargs["template"] = template
+    return kwargs
+
+
+class E2BProvider(BaseSandboxProvider):
+    """E2B sandbox provider."""
+
+    async def create(self, config: SandboxConfig) -> SandboxCreateResult:
+        """Create an E2B sandbox, honoring template/auto-build/fail-fast rules."""
+        if config.template:
+            return await _create_with_template(config, config.template)
+        sandbox = await _create_default(config)
+        return SandboxCreateResult(sandbox=sandbox, created_with_template=False)
+
+
+async def create(config: SandboxConfig) -> SandboxCreateResult:
+    """Compatibility wrapper for the old module-level provider factory."""
+    return await E2BProvider().create(config)
+
+
+async def _create_default(config: SandboxConfig) -> CodeInterpreterSandbox:
+    """Create a sandbox using the default no-template path with placement retry."""
+    domain = _credentials(config)[1]
+    sandbox = await create_with_placement_retry(
+        lambda: E2BSandbox.create(**_create_kwargs(config)),
+        is_placement_failure=is_placement_failure,
+        template=None,
+        domain=domain,
+        timeout_budget_seconds=config.timeout_budget_seconds,
+    )
+    logger.info("E2B sandbox created (default): %s", _sandbox_identifier(sandbox))
+    return sandbox
+
+
+async def _create_with_template(config: SandboxConfig, template: str) -> SandboxCreateResult:
+    """Attempt to create a sandbox using *template*, surfacing failures explicitly."""
+    domain = _credentials(config)[1]
+    try:
+        sandbox = await create_with_placement_retry(
+            lambda: E2BSandbox.create(**_create_kwargs(config, template=template)),
+            is_placement_failure=is_placement_failure,
+            template=template,
+            domain=domain,
+            timeout_budget_seconds=config.timeout_budget_seconds,
+        )
+        logger.info("E2B sandbox created: %s", _sandbox_identifier(sandbox))
+        return SandboxCreateResult(sandbox=sandbox, created_with_template=True)
+    except Exception as e:
+        return await _handle_template_failure(config, template, e)
+
+
+async def _handle_template_failure(config: SandboxConfig, template: str, error: Exception) -> SandboxCreateResult:
+    """Decide whether to auto-build or fail fast for template creation errors.
+
+    Placement failures are propagated as ``SandboxPlacementError``. 404 errors
+    trigger auto-build (when enabled). All other template/config errors fail
+    fast instead of silently falling back to a default sandbox.
+    """
+    if isinstance(error, SandboxPlacementError):
+        raise error
+    is_not_found = "404" in str(error) or "not found" in str(error).lower()
+    if is_not_found and config.auto_build_template:
+        logger.info("Template %r not found; attempting to build it automatically", template)
+        return await _try_auto_build_and_retry(config, template)
+    logger.warning("Template creation failed (%s): %s", template, error)
+    raise RuntimeError(f"Template creation failed ({template}): {error}") from error
+
+
+async def _try_auto_build_and_retry(config: SandboxConfig, template: str) -> SandboxCreateResult:
+    """Auto-build *template* and retry sandbox creation, surfacing failures explicitly.
+
+    Newly built E2B aliases can take a short time to become ready for sandbox
+    creation, so retry a few times before surfacing the failure.
+    """
+    built = await _auto_build(config, template)
+    if not built:
+        logger.warning("Auto-build failed for template %r", template)
+        raise RuntimeError(f"Template creation failed after auto-build ({template})")
+
+    domain = _credentials(config)[1]
+    last_error: Exception | None = None
+    for attempt in range(1, AUTO_BUILD_TEMPLATE_CREATE_RETRY_ATTEMPTS + 1):
+        try:
+            sandbox = await create_with_placement_retry(
+                lambda: E2BSandbox.create(**_create_kwargs(config, template=template)),
+                is_placement_failure=is_placement_failure,
+                template=template,
+                domain=domain,
+                timeout_budget_seconds=config.timeout_budget_seconds,
+            )
+            logger.info("E2B sandbox created after auto-build: %s", _sandbox_identifier(sandbox))
+            return SandboxCreateResult(sandbox=sandbox, created_with_template=True)
+        except Exception as e2:
+            last_error = e2
+            if attempt == AUTO_BUILD_TEMPLATE_CREATE_RETRY_ATTEMPTS:
+                break
+            logger.info(
+                "Template creation not ready after auto-build (%s, attempt %s/%s): %s. Retrying in %.1fs",
+                template,
+                attempt,
+                AUTO_BUILD_TEMPLATE_CREATE_RETRY_ATTEMPTS,
+                e2,
+                AUTO_BUILD_TEMPLATE_CREATE_RETRY_DELAY_SECONDS,
+            )
+            await asyncio.sleep(AUTO_BUILD_TEMPLATE_CREATE_RETRY_DELAY_SECONDS)
+
+    logger.warning("Template creation failed after auto-build (%s): %s", template, last_error)
+    raise RuntimeError(f"Template creation failed after auto-build ({template}): {last_error}") from last_error
+
+
+async def _auto_build(config: SandboxConfig, template_id: str) -> bool:
+    """Attempt to build an E2B template that does not exist yet."""
+    config_packages = list(config.packages) if config.packages else None
+    if image_registry.resolve_image_ref() is not None:
+        dockerfile = None
+        packages = config_packages
+    else:
+        dockerfile = _resolve_auto_build_dockerfile(template_id)
+        packages = None if dockerfile else config_packages
+    loop = asyncio.get_event_loop()
+    result = await loop.run_in_executor(
+        None,
+        lambda: ensure_sandbox_template(
+            template_id,
+            config.build_base_template,
+            packages,
+            dockerfile=dockerfile,
+        ),
+    )
+    return result is not None
+
+
+def _resolve_auto_build_dockerfile(template_id: str) -> str | None:
+    """Resolve the packaged Dockerfile path for auto-build."""
+    try:
+        return str(get_sandbox_dockerfile_path(template_id))
+    except DockerfileNotFoundError:
+        return None
+
+
+def _sandbox_identifier(sandbox: Any) -> str:
+    """Return a best-effort sandbox identifier across wrapper versions."""
+    sandbox_id = getattr(sandbox, "sandbox_id", None)
+    if sandbox_id is None:
+        nested_sandbox = getattr(sandbox, "sandbox", None)
+        sandbox_id = getattr(nested_sandbox, "sandbox_id", None) or getattr(nested_sandbox, "id", None)
+    if sandbox_id is None:
+        sandbox_id = getattr(sandbox, "id", None)
+    return str(sandbox_id or "unknown")

aip_agents/sandbox/providers/opensandbox.py

@@ -0,0 +1,163 @@
+"""OpenSandbox provider factory.
+
+Creates an OpenSandbox session from env config, mapping the requested template
+alias to a snapshot name and supplying the boot entrypoint. Transient
+placement-capacity failures (pool acquire/empty) are retried with bounded
+backoff via the shared placement-retry helper, giving OpenSandbox parity with
+the E2B provider. The OpenSandbox SDK is imported lazily so it stays an optional
+dependency.
+
+Env config:
+    OPENSANDBOX_API_KEY            API key for the OpenSandbox server (optional).
+    OPENSANDBOX_DOMAIN             host:port of the server (required).
+    OPENSANDBOX_PROTOCOL           "http" | "https" (default "http").
+    OPENSANDBOX_ENTRYPOINT         Shell-split boot command; defaults to the code-interpreter entrypoint.
+    OPENSANDBOX_SERVER_PROXY       "1"/"true"/"yes"/"on" enables server-proxy mode (default "true").
+    GLCU_OPENSANDBOX_SERVER_PROXY  GLCU-specific override for the same flag.
+"""
+
+import os
+import shlex
+
+from gllm_tools.code_interpreter.code_sandbox.opensandbox_sandbox import OpenSandbox
+from gllm_tools.code_interpreter.code_sandbox.sandbox import CodeInterpreterSandbox
+
+from aip_agents.sandbox.providers.base import (
+    BaseSandboxProvider,
+    SandboxConfig,
+    SandboxCreateResult,
+    SandboxPlacementError,
+    create_with_placement_retry,
+)
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+_DOMAIN_REQUIRED_ERROR = "OPENSANDBOX_DOMAIN is required for the OpenSandbox provider"
+
+# OpenSandbox SDK exception types that signal transient placement-capacity
+# failures (the pool could not allocate a sandbox right now). Classified by class
+# name so the optional SDK is not imported at module load. gllm_tools wraps
+# create errors as RuntimeError(...) from <cause>, so the cause chain is walked.
+_RETRYABLE_PLACEMENT_TYPES = frozenset(
+    {
+        "PoolAcquireFailedException",
+        "PoolEmptyException",
+        "PoolStateStoreUnavailableException",
+        "PoolStateStoreContentionException",
+    }
+)
+
+
+def is_placement_failure(error: Exception) -> bool:
+    """Classify transient OpenSandbox pool-capacity failures as retryable."""
+    candidates = [error]
+    cause = error.__cause__
+    if cause is not None:
+        candidates.append(cause)
+    return any(type(candidate).__name__ in _RETRYABLE_PLACEMENT_TYPES for candidate in candidates)
+
+
+def _env_value(*names: str) -> str | None:
+    """Return the first non-empty env value among ``names``."""
+    for name in names:
+        value = os.environ.get(name)
+        if value is not None and value.strip() != "":
+            return value
+    return None
+
+
+def _resolve_server_proxy() -> bool:
+    """Resolve the server-proxy flag, defaulting to True when unset.
+
+    Mirrors ``computer_use_tool._resolve_opensandbox_server_proxy`` but defaults
+    to True to preserve the OpenSandbox runtime's established behavior.
+    """
+    raw = _env_value("GLCU_OPENSANDBOX_SERVER_PROXY", "OPENSANDBOX_SERVER_PROXY")
+    if raw is None:
+        return True
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _build_create_kwargs(config: SandboxConfig) -> dict:
+    """Resolve OpenSandbox.create() kwargs from config and environment.
+
+    Unset optional values are omitted so the SDK applies its own defaults
+    (api_key, protocol, entrypoint).
+
+    Raises:
+        ValueError: If no domain is configured.
+    """
+    domain = config.domain if config.domain is not None else os.environ.get("OPENSANDBOX_DOMAIN")
+    if not domain:
+        raise ValueError(_DOMAIN_REQUIRED_ERROR)
+
+    entrypoint_cmd = os.environ.get("OPENSANDBOX_ENTRYPOINT")
+    kwargs = {
+        "domain": domain,
+        "use_server_proxy": _resolve_server_proxy(),
+        "api_key": config.api_key if config.api_key is not None else os.environ.get("OPENSANDBOX_API_KEY"),
+        "protocol": os.environ.get("OPENSANDBOX_PROTOCOL"),
+        "entrypoint": shlex.split(entrypoint_cmd) if entrypoint_cmd else None,
+    }
+    return {k: v for k, v in kwargs.items() if v is not None}
+
+
+async def _create_with_retry(
+    config: SandboxConfig, create_kwargs: dict, *, snapshot_name: str | None
+) -> CodeInterpreterSandbox:
+    """Create an OpenSandbox session with transient placement retry."""
+    kwargs = dict(create_kwargs)
+    if snapshot_name is not None:
+        kwargs["snapshot_name"] = snapshot_name
+    return await create_with_placement_retry(
+        lambda: OpenSandbox.create(**kwargs),
+        is_placement_failure=is_placement_failure,
+        template=snapshot_name,
+        domain=create_kwargs.get("domain"),
+        timeout_budget_seconds=config.timeout_budget_seconds,
+    )
+
+
+class OpenSandboxProvider(BaseSandboxProvider):
+    """OpenSandbox provider."""
+
+    async def create(self, config: SandboxConfig) -> SandboxCreateResult:
+        """Create an OpenSandbox session, falling back to the default image on snapshot failure.
+
+        Transient placement-capacity failures are retried (and surface as
+        ``SandboxPlacementError`` when exhausted). Other snapshot errors fall back
+        to the default image, preserving existing behavior.
+
+        Args:
+            config: Provider-neutral create inputs. ``template`` maps to a snapshot name.
+
+        Returns:
+            The created sandbox plus whether the requested snapshot was used.
+        """
+        create_kwargs = _build_create_kwargs(config)
+        snapshot_name = config.template
+
+        if snapshot_name is None:
+            sandbox = await _create_with_retry(config, create_kwargs, snapshot_name=None)
+            logger.info("OpenSandbox created (default image): %s", sandbox.sandbox_id)
+            return SandboxCreateResult(sandbox=sandbox, created_with_template=False)
+
+        try:
+            sandbox = await _create_with_retry(config, create_kwargs, snapshot_name=snapshot_name)
+            logger.info("OpenSandbox created (snapshot=%s): %s", snapshot_name, sandbox.sandbox_id)
+            return SandboxCreateResult(sandbox=sandbox, created_with_template=True)
+        except SandboxPlacementError:
+            raise
+        except Exception as e:
+            logger.warning(
+                "OpenSandbox snapshot %r creation failed (%s); falling back to default image", snapshot_name, e
+            )
+            sandbox = await _create_with_retry(config, create_kwargs, snapshot_name=None)
+            logger.info("OpenSandbox created (default image): %s", sandbox.sandbox_id)
+            return SandboxCreateResult(sandbox=sandbox, created_with_template=False)
+
+
+async def create(config: SandboxConfig) -> SandboxCreateResult:
+    """Compatibility wrapper for the old module-level provider factory."""
+    return await OpenSandboxProvider().create(config)