aip-agents-binary 0.5.20__py3-none-any.whl → 0.5.22__py3-none-any.whl

aip_agents/tools/browser_use/llm_config.pyi

@@ -0,0 +1,52 @@
+from browser_use.llm import ChatOpenAI
+from typing import Any
+
+__all__ = ['build_browser_use_llm', 'configure_browser_use_environment', 'model_disallows_tunable_params', 'supports_frequency_penalty', 'supports_temperature_override']
+
+def model_disallows_tunable_params(model: Any) -> bool:
+    """Return True if the provider forbids temperature/frequency overrides for the model.
+
+    Args:
+        model: The model name or identifier to check.
+
+    Returns:
+        bool: True if the model disallows tunable parameters, False otherwise.
+    """
+def supports_temperature_override(model: Any) -> bool:
+    """Return True when the given model supports setting a custom temperature.
+
+    Args:
+        model: The model name or identifier to check.
+
+    Returns:
+        bool: True if the model supports temperature override, False otherwise.
+    """
+def supports_frequency_penalty(model: Any) -> bool:
+    """Return True when the given model supports custom frequency penalties.
+
+    Args:
+        model: The model name or identifier to check.
+
+    Returns:
+        bool: True if the model supports frequency penalty override, False otherwise.
+    """
+def build_browser_use_llm(*, model: Any, reasoning_effort: Any, temperature: float | None, api_key: str, base_url: str | None = None) -> ChatOpenAI:
+    """Construct a ChatOpenAI instance with browser-use specific safeguards.
+
+    Args:
+        model: The model name or identifier to use.
+        reasoning_effort: The reasoning effort level for the model.
+        temperature: Optional temperature setting for the model. Can be None.
+        api_key: The API key for authentication.
+        base_url: The base URL for the model.
+
+    Returns:
+        ChatOpenAI: The configured ChatOpenAI instance.
+    """
+def configure_browser_use_environment(enable_cloud_sync: bool, logging_level: str) -> None:
+    """Ensure Browser Use environment flags are aligned with tool configuration.
+
+    Args:
+        enable_cloud_sync: Whether to enable cloud synchronization for browser sessions.
+        logging_level: The desired logging level for browser use operations.
+    """

aip_agents/tools/browser_use/minio_storage.pyi

@@ -0,0 +1,109 @@
+from _typeshed import Incomplete
+
+OBJECT_NAME_PREFIX: str
+
+class MinIOStorage:
+    """Handles MinIO cloud storage operations for video files.
+
+    This class provides a complete interface for MinIO operations including:
+    - Connection management with authentication
+    - Bucket existence validation and creation
+    - File upload with proper metadata
+    - Presigned URL generation for secure access
+
+    Attributes:
+        endpoint: MinIO server endpoint URL.
+        access_key: MinIO access key for authentication.
+        secret_key: MinIO secret key for authentication.
+        secure: Whether to use HTTPS/TLS for connections.
+        bucket_name: Target bucket for file storage.
+        directory_prefix: Optional directory prefix for organized storage.
+        client: MinIO client instance for API operations.
+    """
+    endpoint: Incomplete
+    access_key: Incomplete
+    secret_key: Incomplete
+    secure: Incomplete
+    bucket_name: Incomplete
+    directory_prefix: Incomplete
+    client: Incomplete
+    def __init__(self) -> None:
+        """Initialize MinIO storage with configuration from environment variables.
+
+        Reads configuration from the following environment variables:
+        - OBJECT_STORAGE_URL: MinIO server endpoint
+        - OBJECT_STORAGE_USER: MinIO access key
+        - OBJECT_STORAGE_PASSWORD: MinIO secret key
+        - OBJECT_STORAGE_SECURE: Whether to use HTTPS (default: False)
+        - OBJECT_STORAGE_BUCKET: Target bucket name
+        - OBJECT_STORAGE_DIRECTORY_PREFIX: Optional directory prefix
+
+        Raises:
+            ValueError: If required environment variables are missing.
+            Exception: If bucket creation or validation fails.
+
+        Note:
+            The method automatically ensures the target bucket exists,
+            creating it if necessary.
+        """
+    def get_object_name(self, object_name: str) -> str:
+        '''Get the object name with the directory prefix.
+
+        This method constructs the full object path by combining the directory
+        prefix with the base object name. It ensures consistent path structure
+        for all stored files.
+
+        Args:
+            object_name: Name of the object in MinIO.
+
+        Returns:
+            str: Object name with the directory prefix and steel-recordings subdirectory.
+                Format: {prefix}/steel-recordings/{object_name} or steel-recordings/{object_name}
+
+        Note:
+            The method automatically adds a "steel-recordings" subdirectory to
+            organize video files separately from other content.
+        '''
+    def upload_file(self, file_path: str, object_name: str) -> None:
+        '''Upload a file to MinIO bucket.
+
+        This method handles the complete file upload process including:
+        - File existence validation
+        - Proper content type setting for video files
+        - Error handling and logging
+        - Structured object naming with prefixes
+
+        Args:
+            file_path: Local path to the file to upload.
+            object_name: Name to use for the object in MinIO.
+
+        Raises:
+            Exception: If the file doesn\'t exist or upload fails.
+                Specific S3Error details are included in the exception message.
+
+        Note:
+            The method automatically sets the content type to "video/webm"
+            for proper video file handling in browsers and applications.
+        '''
+    def get_file_url(self, object_name: str) -> str:
+        """Generate a presigned URL for accessing the uploaded file.
+
+        This method creates a temporary, secure URL that allows access to the
+        uploaded file without requiring MinIO credentials. The URL is valid
+        for a limited time and provides secure, direct access to the file.
+
+        Args:
+            object_name: Name of the object in MinIO.
+
+        Returns:
+            str: Presigned URL for secure file access.
+                The URL includes authentication tokens and is valid for a limited time.
+
+        Raises:
+            Exception: If presigned URL generation fails.
+                S3Error details are included in the exception message.
+
+        Note:
+            Presigned URLs are useful for sharing files temporarily without
+            exposing MinIO credentials or requiring users to have storage access.
+        """

aip_agents/tools/browser_use/schemas.pyi

@@ -0,0 +1,32 @@
+from openai.types.shared.chat_model import ChatModel
+from pydantic import BaseModel
+from typing import Literal
+
+class BrowserUseToolInput(BaseModel):
+    """Input schema for Browser Use tool."""
+    task: str
+
+class BrowserUseToolConfig(BaseModel):
+    """Tool configuration schema for Browser Use tool."""
+    steel_api_key: str
+    steel_base_url: str
+    steel_ws_url: str
+    steel_timeout_in_ms: int
+    browser_use_llm_openai_api_key: str
+    browser_use_llm_openai_model: ChatModel | str
+    browser_use_llm_openai_temperature: float | None
+    browser_use_llm_openai_reasoning_effort: Literal['minimal', 'low', 'medium', 'high']
+    browser_use_llm_openai_base_url: str | None
+    browser_use_page_extraction_llm_openai_api_key: str
+    browser_use_page_extraction_llm_openai_model: ChatModel | str
+    browser_use_page_extraction_llm_openai_temperature: float | None
+    browser_use_page_extraction_llm_openai_reasoning_effort: Literal['minimal', 'low', 'medium', 'high']
+    browser_use_page_extraction_llm_openai_base_url: str | None
+    browser_use_extend_system_message: str | None
+    browser_use_vision_detail_level: Literal['auto', 'low', 'high']
+    browser_use_enable_cloud_sync: bool
+    browser_use_logging_level: Literal['debug', 'info', 'warning', 'error', 'result']
+    browser_use_llm_timeout_in_s: int
+    browser_use_step_timeout_in_s: int
+    browser_use_max_session_retries: int
+    browser_use_session_retry_delay_in_s: float

aip_agents/tools/browser_use/session.pyi

@@ -0,0 +1,4 @@
+from browser_use.browser.session import BrowserSession as BrowserUseSession
+
+class BrowserSession(BrowserUseSession):
+    """Represents an active browser session with a running browser process somewhere."""

aip_agents/tools/browser_use/session_errors.pyi

@@ -0,0 +1,53 @@
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+__all__ = ['SessionErrorCategory', 'categorize_fatal_message', 'categorize_warning_message', 'find_fatal_message', 'is_recoverable_message']
+
+@dataclass(frozen=True)
+class SessionErrorCategory:
+    """Represents a fatal Steel/browser disconnect classification."""
+    name: str
+    markers: tuple[str, ...]
+    fatal: bool
+    retryable: bool
+
+def categorize_fatal_message(message: str) -> SessionErrorCategory | None:
+    """Return the fatal session category associated with the given message, if any.
+
+    Args:
+        message: The error message to categorize.
+
+    Returns:
+        The SessionErrorCategory if the message matches a fatal error pattern,
+        None otherwise.
+    """
+def categorize_warning_message(message: str) -> str | None:
+    """Return the name of a known non-fatal warning when present in the message.
+
+    Args:
+        message: The error message to check for warning patterns.
+
+    Returns:
+        The warning name if the message matches a known warning pattern,
+        None otherwise.
+    """
+def find_fatal_message(messages: Iterable[str]) -> tuple[str, SessionErrorCategory] | None:
+    """Return the first fatal message detected in the iterable.
+
+    Args:
+        messages: An iterable of error messages to search through.
+
+    Returns:
+        A tuple of (message, category) for the first fatal message found,
+        None if no fatal messages are detected.
+    """
+def is_recoverable_message(message: str) -> bool:
+    """Return True when the message maps to a retryable session disconnect.
+
+    Args:
+        message: The error message to check for recoverability.
+
+    Returns:
+        True if the message corresponds to a retryable fatal error,
+        False otherwise.
+    """

aip_agents/tools/browser_use/steel_session_recording.pyi

@@ -0,0 +1,63 @@
+from _typeshed import Incomplete
+from aip_agents.tools.browser_use.minio_storage import MinIOStorage as MinIOStorage
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+VIDEO_FILE_NAME_PREFIX: str
+MANIFEST_TEMP_SUFFIX: str
+
+class SteelSessionRecorder:
+    """High-level helper to export Steel sessions via their HLS manifests.
+
+    This class provides a high-level interface for exporting Steel sessions via their HLS manifests.
+    It provides methods for sanitizing session IDs, building safe filenames, and generating video filenames.
+    It also provides methods for downloading and merging HLS manifests, and uploading videos to MinIO.
+    """
+    @staticmethod
+    def safe_session_id(session_id: str) -> str:
+        """Sanitize a session ID for filename usage.
+
+        Args:
+            session_id: The session ID to sanitize.
+
+        Returns:
+            str: The sanitized session ID.
+        """
+    @staticmethod
+    def safe_session_filename(session_id: str, extension: str) -> str:
+        """Build a safe filename for a session recording.
+
+        Args:
+            session_id: The session ID to build a filename for.
+            extension: The extension of the filename.
+
+        Returns:
+            str: The safe filename.
+        """
+    @staticmethod
+    def generate_video_filename(session_id: str, extension: str = '.mp4') -> str:
+        """Generate a filename for a session recording.
+
+        Args:
+            session_id: The session ID to generate a filename for.
+            extension: The extension of the filename.
+
+        Returns:
+            str: The generated filename.
+        """
+    base_url: Incomplete
+    api_key: Incomplete
+    minio_storage: Incomplete
+    def __init__(self, base_url: str, api_key: str) -> None:
+        """Initialize the recorder.
+
+        Args:
+            base_url: Steel API base URL.
+            api_key: Steel API key for authentication.
+        """
+    async def record_session_to_video(self, session_id: str) -> None:
+        """Download the HLS manifest and upload the merged video to MinIO.
+
+        Args:
+            session_id: The session ID to record.
+        """

aip_agents/tools/browser_use/streaming.pyi

@@ -0,0 +1,81 @@
+from aip_agents.tools.browser_use.types import StreamingResponse, ToolCallInfo
+from browser_use import Agent
+from typing import Any, Literal
+
+__all__ = ['PROCESSING_MESSAGE', 'TASK_COMPLETED_MESSAGE', 'create_error_response', 'create_step_response', 'generate_step_content', 'generate_thinking_message', 'yield_iframe_activity', 'yield_status_message', 'yield_thinking_marker']
+
+TASK_COMPLETED_MESSAGE: str
+PROCESSING_MESSAGE: str
+
+def create_step_response(agent: Agent, tool_calls: list[ToolCallInfo], is_done: bool, content: str, thinking_message: str | None) -> StreamingResponse:
+    """Compose the per-step payload emitted during browser-use streaming.
+
+    Args:
+        agent: Browser-use agent producing the step output.
+        tool_calls: Tool call descriptors extracted from the step.
+        is_done: Flag indicating whether this is the final step in the run.
+        content: High-level status text describing the step progress.
+        thinking_message: Optional preformatted thinking summary to attach.
+
+    Returns:
+        StreamingResponse: Serialized payload for the current streaming step.
+    """
+async def generate_thinking_message(content: str, tool_calls: list[dict[str, Any]], *, is_final: bool) -> str | None:
+    """Generate a user-facing thinking summary using the formatter LLM when available.
+
+    Args:
+        content: High-level status text describing the step progress.
+        tool_calls: Serialized tool call dictionaries with outputs.
+        is_final: Whether the task has completed.
+
+    Returns:
+        Markdown-formatted summary string, or ``None`` when not applicable.
+    """
+def create_error_response(error_message: str, recording_url: str = '') -> dict:
+    """Create a standardized error response.
+
+    Args:
+        error_message: The error message to include.
+        recording_url: The recording URL if available.
+
+    Returns:
+        dict: Standardized error response.
+    """
+def generate_step_content(tool_calls: list[ToolCallInfo], is_done: bool) -> str:
+    """Return user-friendly status text derived from tool call outputs.
+
+    Args:
+        tool_calls: Tool call descriptors extracted from the step.
+        is_done: Flag indicating whether this is the final step in the run.
+
+    Returns:
+        User-friendly status text string.
+    """
+def yield_iframe_activity(url: str, content: str) -> dict:
+    """Create and return an iframe activity streaming response.
+
+    Args:
+        url: The URL to display in the iframe.
+        content: The content message for the response.
+
+    Returns:
+        dict: Streaming response dictionary.
+    """
+def yield_status_message(content: str) -> dict:
+    """Create a status update event notifying clients about recovery attempts.
+
+    Args:
+        content: The status message content to include in the event.
+
+    Returns:
+        dict: Streaming response dictionary for the status update event.
+    """
+def yield_thinking_marker(marker_type: Literal['start', 'end']) -> dict:
+    """Create and return a thinking marker streaming response.
+
+    Args:
+        marker_type: Either 'start' or 'end' to indicate thinking phase.
+
+    Returns:
+        dict: Streaming response dictionary.
+    """

aip_agents/tools/browser_use/structured_data_parser.pyi

@@ -0,0 +1,86 @@
+from aip_agents.tools.browser_use.types import ToolCallInfo
+from collections.abc import Callable, Sequence
+from typing import Any
+
+__all__ = ['attempt_json_recovery', 'detect_structured_data_failure', 'extract_content_after_marker', 'extract_json_blob', 'parse_structured_data', 'payload_reports_empty', 'payload_reports_error', 'structured_data_failure_for_call']
+
+def detect_structured_data_failure(tool_calls: Sequence[ToolCallInfo], summarize_error: Callable[[str], str]) -> str | None:
+    """Return a descriptive error when structured data extraction yields no results.
+
+    Args:
+        tool_calls: Tool call descriptors extracted from the latest agent step.
+        summarize_error: Function to summarize error messages.
+
+    Returns:
+        str | None: Failure reason when extraction yielded nothing, otherwise None.
+    """
+def structured_data_failure_for_call(call: ToolCallInfo, summarize_error: Callable[[str], str]) -> str | None:
+    """Evaluate a single tool call for extractor failures.
+
+    Args:
+        call: Tool call descriptor encapsulating name/args/output.
+        summarize_error: Function to summarize error messages.
+
+    Returns:
+        str | None: Failure message when the call represents a bad extraction.
+    """
+def payload_reports_error(payload: dict[str, Any], raw_output: str, summarize_error: Callable[[str], str]) -> str | None:
+    """Return a formatted error message when extractor status indicates failure.
+
+    Args:
+        payload: Parsed JSON payload emitted by the extractor.
+        raw_output: Original extractor output (used for fallback summaries).
+        summarize_error: Function to summarize error messages.
+
+    Returns:
+        str | None: Human-readable failure string when extraction failed.
+    """
+def payload_reports_empty(payload: dict[str, Any], raw_output: str, summarize_error: Callable[[str], str]) -> str | None:
+    """Return a formatted message when the extractor returned no usable data.
+
+    Args:
+        payload: Parsed JSON payload emitted by the extractor.
+        raw_output: Original extractor output string.
+        summarize_error: Function to summarize error messages.
+
+    Returns:
+        str | None: Human-readable failure message when no content was extracted.
+    """
+def parse_structured_data(output: str, summarize_error: Callable[[str], str]) -> tuple[dict[str, Any] | list[Any] | None, str | None]:
+    """Extract the JSON blob emitted by extract_structured_data if present.
+
+    Args:
+        output: Raw string payload returned by extract_structured_data.
+        summarize_error: Function to summarize error messages.
+
+    Returns:
+        tuple[dict[str, Any] | list[Any] | None, str | None]: Parsed JSON payload when extraction succeeds,
+            otherwise a tuple containing None and a diagnostic string on failure.
+    """
+def extract_content_after_marker(output: str) -> str | None:
+    """Extract content after the 'Extracted Content:' marker and clean trailing metadata.
+
+    Args:
+        output: Raw string payload returned by extract_structured_data.
+
+    Returns:
+        str | None: Cleaned content after the marker, or None if marker not found.
+    """
+def extract_json_blob(content: str) -> str | None:
+    """Extract the JSON blob from content by finding delimiters and trimming trailing content.
+
+    Args:
+        content: Content string potentially containing JSON.
+
+    Returns:
+        str | None: Extracted JSON blob, or None if no valid JSON delimiters found.
+    """
+def attempt_json_recovery(json_blob: str) -> dict[str, Any] | list[Any] | None:
+    """Attempt to parse JSON blob, with recovery strategies for common issues.
+
+    Args:
+        json_blob: JSON string to attempt parsing.
+
+    Returns:
+        dict[str, Any] | list[Any] | None: Parsed JSON data if successful, None if all recovery attempts fail.
+    """

aip_agents/tools/browser_use/structured_data_recovery.pyi

@@ -0,0 +1,43 @@
+from _typeshed import Incomplete
+from aip_agents.utils.logger import get_logger as get_logger
+from typing import Any
+
+logger: Incomplete
+
+def recover_concatenated_json_objects(json_blob: str) -> dict[str, Any] | None:
+    """Normalize concatenated JSON object strings into a structured payload.
+
+    Args:
+        json_blob: Raw JSON-like string returned by the structured data extractor.
+
+    Returns:
+        dict[str, Any] | None: Standardized payload when multiple objects are recovered,
+        otherwise None.
+    """
+def repair_json_blob(json_blob: str) -> str | None:
+    """Apply json_repair to malformed JSON strings and return the mutated payload.
+
+    Args:
+        json_blob: Raw JSON string that may contain syntax mistakes.
+
+    Returns:
+        str | None: Repaired JSON string when modifications were applied, otherwise None.
+    """
+
+class _JsonObjectSplitter:
+    """Helper class to split JSON objects with reduced cognitive complexity."""
+    json_blob: Incomplete
+    segments: list[str]
+    depth: int
+    start: int | None
+    last_end: int
+    in_string: bool
+    escaping: bool
+    def __init__(self, json_blob: str) -> None:
+        """Initialize the splitter with the raw JSON string.
+
+        Args:
+            json_blob: Raw string potentially containing concatenated JSON objects.
+        """
+    def split_objects(self) -> list[str]:
+        """Main method to split JSON objects."""

aip_agents/tools/browser_use/types.pyi

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from typing import Any
+
+__all__ = ['BrowserUseFatalError', 'RetryDecision', 'StreamingResponse', 'StreamingState', 'ToolCallInfo']
+
+class BrowserUseFatalError(RuntimeError):
+    """Raised when the Browser Use session must terminate immediately."""
+
+@dataclass
+class ToolCallInfo:
+    """Structured information for a single tool call."""
+    name: str
+    args: dict[str, Any]
+    output: str
+
+@dataclass
+class StreamingResponse:
+    """Standardized streaming response structure."""
+    event_type: str
+    content: str
+    thinking_and_activity_info: dict
+    is_final: bool
+    tool_info: dict[str, Any] | None = ...
+    metadata: dict[str, Any] | None = ...
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary format for yielding."""
+
+@dataclass
+class StreamingState:
+    """State management for streaming operations."""
+    debug_url: str
+    recording_url: str
+    step_count: int = ...
+    is_complete: bool = ...
+    session_id: str | None = ...
+    terminal_error: str | None = ...
+    recording_started: bool = ...
+
+@dataclass
+class RetryDecision:
+    """Encapsulate retry metadata when Steel sessions need to be restarted."""
+    retries_remaining: int
+    attempted_retries: int
+    message: str
+    delay: float

aip_agents/tools/code_sandbox/__init__.pyi

@@ -0,0 +1,3 @@
+from aip_agents.tools.code_sandbox.e2b_sandbox_tool import E2BCodeSandboxTool as E2BCodeSandboxTool
+
+__all__ = ['E2BCodeSandboxTool']

aip_agents/tools/code_sandbox/constant.pyi

@@ -0,0 +1,4 @@
+from _typeshed import Incomplete
+
+DATA_FILE_NAME: str
+DATA_FILE_PATH: Incomplete

aip_agents/tools/code_sandbox/e2b_cloud_sandbox_extended.pyi

@@ -0,0 +1,86 @@
+from _typeshed import Incomplete
+from aip_agents.tools.code_sandbox.constant import DATA_FILE_PATH as DATA_FILE_PATH
+from aip_agents.utils.logger import get_logger as get_logger
+from gllm_inference.schema import Attachment as Attachment
+from gllm_tools.code_interpreter.code_sandbox.e2b_cloud_sandbox import E2BCloudSandbox
+from gllm_tools.code_interpreter.code_sandbox.models import ExecutionResult
+from typing import Any
+
+logger: Incomplete
+
+class SandboxFileWatcher:
+    """File watcher for monitoring file creation in sandbox environments."""
+    sandbox: Incomplete
+    def __init__(self, sandbox: Any) -> None:
+        """Initialize the file watcher with a sandbox instance.
+
+        Args:
+            sandbox (Any): The sandbox instance to monitor.
+        """
+    def setup_monitoring(self) -> None:
+        """Set up filesystem watchers for monitoring file creation.
+
+        Note: /tmp/output is a sandbox-isolated directory, not a shared system /tmp.
+        This directory is scoped to the E2B sandbox instance and is safe for use.
+        """
+    async def process_events(self) -> None:
+        """Process filesystem events from watchers and update created files list."""
+    def reset_created_files(self) -> None:
+        """Reset the list of created files."""
+    def get_created_files(self) -> list[str]:
+        """Get the list of files created during monitoring.
+
+        Returns:
+            list[str]: List of file paths that were created.
+        """
+
+class MyE2BCloudSandbox(E2BCloudSandbox):
+    """Extended E2B Cloud Sandbox with filesystem monitoring capabilities."""
+    file_watcher: SandboxFileWatcher | None
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize the sandbox with monitoring capabilities.
+
+        Args:
+            *args: Positional arguments forwarded to ``E2BCloudSandbox``.
+            **kwargs: Keyword arguments forwarded to ``E2BCloudSandbox``.
+        """
+    async def execute_code(self, code: str, timeout: int = 30, files: list[Attachment] | None = None, **kwargs: Any) -> ExecutionResult:
+        """Execute code in the E2B Cloud sandbox with filesystem monitoring.
+
+        This override fixes the Pydantic validation error by ensuring execution.error
+        is converted to string. Always enables filesystem monitoring to track
+        created files.
+
+        Args:
+            code (str): The code to execute.
+            timeout (int, optional): Maximum execution time in seconds. Defaults to 30.
+            files (list[Attachment] | None, optional): List of Attachment objects with file details. Defaults to None.
+            **kwargs (Any): Additional execution parameters.
+
+        Returns:
+            ExecutionResult: Structured result of the execution.
+
+        Raises:
+            RuntimeError: If sandbox is not initialized.
+        """
+    def get_created_files(self) -> list[str]:
+        """Get the list of files created during the last monitored execution.
+
+        Returns:
+            list[str]: List of file paths that were created.
+        """
+    def download_file(self, file_path: str) -> bytes | None:
+        """Download file content from the sandbox.
+
+        Uses download_url method to get a direct URL and downloads via HTTP,
+        which avoids the binary corruption issue with files.read().
+
+        Args:
+            file_path (str): Path to the file in the sandbox.
+
+        Returns:
+            bytes | None: File content as bytes, or None if download fails.
+
+        Raises:
+            RuntimeError: If sandbox is not initialized.
+        """