gl-browser-use-binary 0.0.0b9__cp313-cp313-win_amd64.whl

gl_browser_use/__init__.pyi

@@ -0,0 +1,12 @@
+from gl_browser_use.client import BrowserUseClient as BrowserUseClient
+from gl_browser_use.config import BrowserUseClientConfig as BrowserUseClientConfig
+from gl_browser_use.errors import BrowserUseConfigurationError as BrowserUseConfigurationError, BrowserUseDependencyError as BrowserUseDependencyError, BrowserUseExecutionError as BrowserUseExecutionError, BrowserUseMissingDependencyError as BrowserUseMissingDependencyError, BrowserUseRetryExhaustedError as BrowserUseRetryExhaustedError, BrowserUseSDKError as BrowserUseSDKError
+from gl_browser_use.infrastructure.base import BrowserInfrastructure as BrowserInfrastructure, BrowserInfrastructureContext as BrowserInfrastructureContext
+from gl_browser_use.models import BrowserUseRunResult as BrowserUseRunResult, BrowserUseStreamEvent as BrowserUseStreamEvent
+from gl_browser_use.storage.base import ObjectStorage as ObjectStorage
+
+__all__ = ['BrowserUseClient', 'BrowserUseClientConfig', 'BrowserUseConfigurationError', 'BrowserUseDependencyError', 'BrowserUseExecutionError', 'BrowserUseMissingDependencyError', 'BrowserUseRetryExhaustedError', 'BrowserUseSDKError', 'BrowserUseRunResult', 'BrowserUseStreamEvent', 'BrowserInfrastructure', 'BrowserInfrastructureContext', 'SteelBrowserInfrastructure', 'ObjectStorage', 'MinIOS3CompatibleStorage']
+
+# Names in __all__ with no definition:
+#   MinIOS3CompatibleStorage
+#   SteelBrowserInfrastructure

gl_browser_use/client.pyi

@@ -0,0 +1,57 @@
+from _typeshed import Incomplete
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from gl_browser_use.config import BrowserUseClientConfig as BrowserUseClientConfig
+from gl_browser_use.errors import BrowserUseExecutionError as BrowserUseExecutionError, BrowserUseRetryExhaustedError as BrowserUseRetryExhaustedError
+from gl_browser_use.events import RECORDING_MESSAGE as RECORDING_MESSAGE, STREAMING_MESSAGE as STREAMING_MESSAGE, TASK_COMPLETED_MESSAGE as TASK_COMPLETED_MESSAGE, build_activity_event as build_activity_event, build_error_event as build_error_event, build_retry_event as build_retry_event, build_step_content as build_step_content, build_step_event as build_step_event, build_thinking_event as build_thinking_event
+from gl_browser_use.infrastructure.base import BrowserInfrastructure as BrowserInfrastructure, BrowserInfrastructureContext as BrowserInfrastructureContext
+from gl_browser_use.models import BrowserUseRunResult as BrowserUseRunResult, BrowserUseRunStatus as BrowserUseRunStatus, BrowserUseStreamEvent as BrowserUseStreamEvent
+from gl_browser_use.parsing import coerce_string as coerce_string, extract_final_output as extract_final_output, extract_tool_calls as extract_tool_calls, summarize_terminal_error as summarize_terminal_error, validate_structured_data_output as validate_structured_data_output
+from gl_browser_use.session_errors import is_recoverable_session_error as is_recoverable_session_error
+from gl_browser_use.storage.base import ObjectStorage as ObjectStorage
+from typing import Any
+
+logger: Incomplete
+EmitCallable = Callable[[BrowserUseStreamEvent | None], Awaitable[None] | None]
+
+def recording_metadata(*, infrastructure: BrowserInfrastructure | None, storage: ObjectStorage | None, browser_context: BrowserInfrastructureContext | None) -> dict[str, Any]:
+    """Return recording status metadata aligned with implementation behavior."""
+
+class BrowserUseClient:
+    """Facade for running browser automation tasks.
+
+    Note: ``infrastructure`` and ``storage`` attributes are read by ``run``/
+    ``run_once``/``run_sync`` on each call. Swapping them while a run is in
+    flight is undefined behavior.
+    """
+    config: Incomplete
+    infrastructure: Incomplete
+    storage: Incomplete
+    def __init__(self, *, config: BrowserUseClientConfig, infrastructure: BrowserInfrastructure | None = None, storage: ObjectStorage | None = None) -> None:
+        """Initialize the client."""
+    async def run(self, task: str) -> AsyncGenerator[BrowserUseStreamEvent, None]:
+        """Run the client."""
+    async def run_once(self, task: str) -> BrowserUseRunResult:
+        """Run the client once and return a single aggregated result.
+
+        Raises:
+        ------
+        BrowserUseExecutionError
+            When the task input is invalid.
+        BrowserUseConfigurationError
+            When required configuration is missing.
+        BrowserUseRetryExhaustedError
+            When all recoverable session retries are exhausted.
+        """
+    def run_sync(self, task: str) -> BrowserUseRunResult:
+        """Run the client synchronously.
+
+        Raises:
+        ------
+        BrowserUseExecutionError
+            When invoked from a thread that already has a running event loop,
+            or when task validation fails.
+        BrowserUseConfigurationError
+            When required configuration is missing.
+        BrowserUseRetryExhaustedError
+            When all recoverable session retries are exhausted.
+        """

gl_browser_use/config.pyi

@@ -0,0 +1,43 @@
+from _typeshed import Incomplete
+from gl_browser_use.errors import BrowserUseConfigurationError as BrowserUseConfigurationError
+from openai.types.shared_params.chat_model import ChatModel
+from openai.types.shared_params.reasoning_effort import ReasoningEffort
+from pydantic import BaseModel
+from typing import Any, Literal
+
+class BrowserUseClientConfig(BaseModel):
+    """Typed runtime configuration for :class:`BrowserUseClient`."""
+    model_config: Incomplete
+    llm_openai_api_key: str | None
+    llm_openai_model: ChatModel | str
+    llm_openai_temperature: float | None
+    llm_openai_reasoning_effort: ReasoningEffort
+    llm_openai_base_url: str | None
+    page_extraction_llm_openai_api_key: str | None
+    page_extraction_llm_openai_model: ChatModel | str
+    page_extraction_llm_openai_temperature: float | None
+    page_extraction_llm_openai_reasoning_effort: ReasoningEffort
+    page_extraction_llm_openai_base_url: str | None
+    sensitive_data: dict[str, str | dict[str, str]] | None
+    extend_system_message: str | None
+    vision_detail_level: Literal['auto', 'low', 'high']
+    llm_timeout_in_s: int | None
+    step_timeout_in_s: int
+    agent_kwargs: dict[str, Any]
+    enable_cloud_sync: bool
+    logging_level: Literal['debug', 'info', 'warning', 'error', 'result']
+    max_steps: int
+    max_session_retries: int
+    session_retry_delay_in_s: float
+    def validate(self, *, strict: bool = False) -> list[str]:
+        """Validate required runtime values.
+
+        Returns a list of field-level validation issues. If ``strict`` is
+        ``True``, raise :class:`BrowserUseConfigurationError` on any issues.
+        """
+    def redacted_dict(self, *, include_secrets: bool = False) -> dict[str, Any]:
+        '''Return a config dictionary safe to log.
+
+        Fields marked with ``json_schema_extra={"secret": True}`` are replaced
+        with ``"***"`` unless ``include_secrets`` is ``True``.
+        '''

gl_browser_use/errors.pyi

@@ -0,0 +1,41 @@
+from _typeshed import Incomplete
+from typing import Any, Final
+
+__all__ = ['MINIO_EXTRA', 'OPENSANDBOX_EXTRA', 'PACKAGE_NAME', 'STEEL_EXTRA', 'BrowserUseConfigurationError', 'BrowserUseDependencyError', 'BrowserUseExecutionError', 'BrowserUseMissingDependencyError', 'BrowserUseRetryExhaustedError', 'BrowserUseSDKError', 'install_hint']
+
+PACKAGE_NAME: Final[str]
+STEEL_EXTRA: Final[str]
+OPENSANDBOX_EXTRA: Final[str]
+MINIO_EXTRA: Final[str]
+
+def install_hint(extra: str) -> str:
+    """Return a ``pip install`` hint for the given optional extra."""
+
+class BrowserUseSDKError(RuntimeError):
+    """Base exception for all SDK errors."""
+    message: Incomplete
+    details: Incomplete
+    origin: Incomplete
+    def __init__(self, message: str, *, details: dict[str, Any] | None = None, origin: BaseException | None = None) -> None:
+        """Initialize the error."""
+
+class BrowserUseDependencyError(BrowserUseSDKError):
+    """Raised when required optional dependencies are unavailable."""
+    missing_dependency: Incomplete
+    package_hint: Incomplete
+    def __init__(self, message: str, *, missing_dependency: str | None = None, package_hint: str | None = None, details: dict[str, Any] | None = None, origin: BaseException | None = None) -> None:
+        """Initialize the error."""
+
+class BrowserUseMissingDependencyError(BrowserUseDependencyError):
+    """Raised when an optional extra dependency is not installed."""
+class BrowserUseConfigurationError(BrowserUseSDKError):
+    """Raised when required configuration values are missing or invalid."""
+class BrowserUseExecutionError(BrowserUseSDKError):
+    """Raised when execution of a run fails."""
+
+class BrowserUseRetryExhaustedError(BrowserUseExecutionError):
+    """Raised when session retries are exhausted after recoverable errors."""
+    attempt: Incomplete
+    max_attempts: Incomplete
+    def __init__(self, message: str, *, attempt: int, max_attempts: int, details: dict[str, Any] | None = None, origin: BaseException | None = None) -> None:
+        """Initialize the error."""

gl_browser_use/events.pyi

@@ -0,0 +1,29 @@
+from gl_browser_use.models import BrowserUseStreamEvent
+from typing import Any
+
+__all__ = ['EVENT_ID', 'PROCESSING_MESSAGE', 'RECORDING_MESSAGE', 'STREAMING_MESSAGE', 'TASK_COMPLETED_MESSAGE', 'build_activity_event', 'build_error_event', 'build_fallback_thinking_message', 'build_retry_event', 'build_step_content', 'build_step_event', 'build_thinking_event']
+
+EVENT_ID: str
+TASK_COMPLETED_MESSAGE: str
+PROCESSING_MESSAGE: str
+STREAMING_MESSAGE: str
+RECORDING_MESSAGE: str
+
+def build_activity_event(url: str, content: str) -> BrowserUseStreamEvent:
+    """Return an activity event carrying ``url`` in the standard iframe payload."""
+def build_thinking_event(marker: str, *, content: str, final: bool = False) -> BrowserUseStreamEvent:
+    """Return a thinking-marker event for ``thinking_start``/``thinking_end``/``thinking``."""
+def build_step_event(tool_calls: list[Any], content: str, *, is_final: bool) -> BrowserUseStreamEvent:
+    """Return a step event summarizing ``tool_calls`` with a fallback thinking narration."""
+def build_error_event(error_message: str, *, recording_url: str = '') -> BrowserUseStreamEvent:
+    """Return a terminal tool-result error event with optional ``recording_url``.
+
+    ``error_message`` is expected to be already summarized by the caller via
+    :func:`gl_browser_use.parsing.summarize_terminal_error`.
+    """
+def build_retry_event(attempt: int, max_attempts: int, reason: str) -> BrowserUseStreamEvent:
+    """Return a retry status event carrying attempt counters and the recoverable reason."""
+def build_fallback_thinking_message(content: str, tool_calls: list[Any]) -> str:
+    """Build a fallback thinking narration that lists recent tool-call outputs."""
+def build_step_content(tool_calls: list[Any], is_done: bool) -> str:
+    """Return a user-visible content string for a step event based on ``tool_calls``."""

gl_browser_use/infrastructure/__init__.pyi

@@ -0,0 +1,7 @@
+from gl_browser_use.infrastructure.base import BrowserInfrastructure as BrowserInfrastructure, BrowserInfrastructureContext as BrowserInfrastructureContext
+
+__all__ = ['BrowserInfrastructure', 'BrowserInfrastructureContext', 'OpenSandboxBrowserInfrastructure', 'SteelBrowserInfrastructure']
+
+# Names in __all__ with no definition:
+#   OpenSandboxBrowserInfrastructure
+#   SteelBrowserInfrastructure

gl_browser_use/infrastructure/base.pyi

@@ -0,0 +1,55 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from gl_browser_use.storage.base import ObjectStorage
+from typing import Any, Generic, TypeVar
+
+__all__ = ['BrowserInfrastructure', 'BrowserInfrastructureContext']
+
+ClientType = TypeVar('ClientType')
+SessionType = TypeVar('SessionType')
+
+@dataclass
+class BrowserInfrastructureContext(Generic[ClientType, SessionType]):
+    """Runtime context for an active browser infrastructure session."""
+    client: ClientType
+    session: SessionType
+    session_id: str
+    streaming_url: str
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+class BrowserInfrastructure(ABC, Generic[ClientType, SessionType]):
+    """Abstract contract for browser infrastructure providers.
+
+    Provider-specific configuration (API keys, endpoints, timeouts) belongs to
+    the concrete subclass; this base only defines the behavioral surface.
+    """
+    @property
+    @abstractmethod
+    def provider(self) -> str:
+        """Return the human-readable infrastructure provider name."""
+    @property
+    def supports_recording(self) -> bool:
+        """Whether this infrastructure can produce session recordings."""
+    @abstractmethod
+    async def create_session(self) -> BrowserInfrastructureContext[ClientType, SessionType]:
+        """Create a new browser infrastructure session and return the active context."""
+    @abstractmethod
+    async def release_session(self, context: BrowserInfrastructureContext[ClientType, SessionType]) -> None:
+        """Release or dispose browser infrastructure session resources."""
+    @abstractmethod
+    def cdp_url(self, session_id: str) -> str:
+        """Build a CDP endpoint URL for the provided browser infrastructure session ID."""
+    def recording_filename(self, session_id: str) -> str:
+        """Return the preferred recording object name for the provided browser infrastructure session ID."""
+    def resolve_recording_url(self, session_id: str, storage: ObjectStorage | None) -> str | None:
+        """Resolve a recording URL from storage without scheduling any new work."""
+    def can_record(self, context: BrowserInfrastructureContext[ClientType, SessionType] | None, storage: ObjectStorage | None) -> bool:
+        '''Return True when an active recording can be produced for ``context``.
+
+        This encapsulates the "recording is supported, a live context exists,
+        and storage is available" check that clients use before scheduling a
+        recording or resolving a recording URL.
+        '''
+    @abstractmethod
+    def schedule_recording(self, context: BrowserInfrastructureContext[ClientType, SessionType], storage: ObjectStorage | None) -> None:
+        """Optionally schedule background recording for the provided context."""

gl_browser_use/infrastructure/opensandbox.pyi

@@ -0,0 +1,55 @@
+from _typeshed import Incomplete
+from datetime import timedelta
+from gl_browser_use.infrastructure.base import BrowserInfrastructure, BrowserInfrastructureContext
+from gl_browser_use.storage.base import ObjectStorage
+from opensandbox.sandbox import Sandbox
+
+__all__ = ['DEFAULT_OPENSANDBOX_DOMAIN', 'DEFAULT_OPENSANDBOX_IMAGE', 'OpenSandboxBrowserInfrastructure', '_build_novnc_url', '_extract_browser_id', '_fetch_web_socket_debugger_url', '_parse_domain', '_rewrite_cdp_url']
+
+DEFAULT_OPENSANDBOX_DOMAIN: str
+DEFAULT_OPENSANDBOX_IMAGE: str
+
+def _parse_domain(raw: str | None) -> tuple[str, str]:
+    """Return ``(protocol, domain)`` from a domain string or URL."""
+def _fetch_web_socket_debugger_url(devtools_endpoint: str, *, protocol: str, poll_timeout_s: float = ..., poll_interval_s: float = ...) -> str:
+    """Poll DevTools ``/json/version`` until ``webSocketDebuggerUrl`` is available."""
+def _extract_browser_id(web_socket_debugger_url: str) -> str: ...
+def _rewrite_cdp_url(devtools_endpoint: str, browser_id: str, ws_protocol: str) -> str: ...
+def _build_novnc_url(novnc_endpoint: str, http_protocol: str) -> str:
+    """Build a noVNC URL that auto-connects to the sandbox VNC stream."""
+
+class OpenSandboxBrowserInfrastructure(BrowserInfrastructure[Sandbox, Sandbox]):
+    """Concrete OpenSandbox implementation for browser infrastructure sessions."""
+    domain: Incomplete
+    protocol: Incomplete
+    api_key: Incomplete
+    use_server_proxy: Incomplete
+    image: Incomplete
+    entrypoint: Incomplete
+    timeout: Incomplete
+    devtools_poll_timeout_s: Incomplete
+    def __init__(self, *, domain: str | None = None, api_key: str | None = None, protocol: str | None = None, use_server_proxy: bool | None = None, image: str = ..., entrypoint: list[str] | None = None, timeout: timedelta = ..., devtools_poll_timeout_s: float = ...) -> None:
+        """Initialize OpenSandbox browser infrastructure.
+
+        ``domain`` defaults to ``OPENSANDBOX_DOMAIN`` or ``localhost:8080``.
+        ``api_key`` defaults to ``OPENSANDBOX_API_KEY``.
+        """
+    @property
+    def provider(self) -> str:
+        """Return the human-readable infrastructure provider name."""
+    @property
+    def supports_recording(self) -> bool:
+        """Whether Playwright-based noVNC recording is available."""
+    async def create_session(self) -> BrowserInfrastructureContext[Sandbox, Sandbox]:
+        """Create a new OpenSandbox session and return the active context."""
+    async def release_session(self, context: BrowserInfrastructureContext[Sandbox, Sandbox]) -> None:
+        """Release OpenSandbox resources.
+
+        Stops an orphaned recorder when recording was started but never scheduled.
+        """
+    def cdp_url(self, session_id: str) -> str:
+        """Build a CDP endpoint URL for the provided session ID."""
+    def recording_filename(self, session_id: str) -> str:
+        """Return the preferred recording object name for the provided session ID."""
+    def schedule_recording(self, context: BrowserInfrastructureContext[Sandbox, Sandbox], storage: ObjectStorage | None) -> None:
+        """Stop the recorder and schedule background upload to object storage."""

gl_browser_use/infrastructure/playwright_recorder.pyi

@@ -0,0 +1,22 @@
+import threading
+from gl_browser_use.storage.base import ObjectStorage
+
+__all__ = ['PlaywrightRecorder', 'is_playwright_available']
+
+def is_playwright_available() -> bool:
+    """Return True when Playwright is installed."""
+
+class PlaywrightRecorder:
+    """Record a noVNC page in headless Chromium and upload to object storage."""
+    def __init__(self) -> None: ...
+    async def start(self, novnc_url: str, width: int = 1280, height: int = 1024) -> None:
+        """Open the noVNC URL and start recording."""
+    async def stop(self) -> tuple[bytes, str] | None:
+        """Stop recording and return WebM bytes."""
+    async def stop_and_upload(self, storage: ObjectStorage, object_name: str) -> str | None:
+        """Stop recording, upload WebM via object storage, and return the remote name."""
+    async def stop_best_effort(self) -> tuple[bytes, str] | None:
+        """Stop recording, suppressing errors."""
+    @classmethod
+    def schedule_stop_and_upload_in_background(cls, recorder: PlaywrightRecorder, storage: ObjectStorage | None, object_name: str, *, session_id: str = '') -> threading.Thread | None:
+        """Finalize Playwright on the event loop and upload in a background thread."""

gl_browser_use/infrastructure/recording_utils.pyi

@@ -0,0 +1,12 @@
+from os import PathLike
+
+__all__ = ['cleanup_temp_directory', 'recording_filename', 'safe_session_id', 'RECORDING_FILENAME_PREFIX']
+
+RECORDING_FILENAME_PREFIX: str
+
+def safe_session_id(session_id: str) -> str:
+    """Return a storage-safe session identifier."""
+def recording_filename(session_id: str, extension: str = '.mp4') -> str:
+    """Return the preferred recording file name for a session ID."""
+def cleanup_temp_directory(path: str | bytes | PathLike[str] | PathLike[bytes]) -> None:
+    """Remove a temporary recording directory, ignoring missing paths."""

gl_browser_use/infrastructure/steel.pyi

@@ -0,0 +1,52 @@
+import threading
+from _typeshed import Incomplete
+from gl_browser_use.infrastructure.base import BrowserInfrastructure, BrowserInfrastructureContext
+from gl_browser_use.storage.base import ObjectStorage
+from steel import Steel
+from steel.types.session import Session
+
+__all__ = ['SteelBrowserInfrastructure']
+
+class _SteelSessionRecorder:
+    """Capture Steel HLS sessions and upload recordings to object storage."""
+    base_url: Incomplete
+    api_key: Incomplete
+    storage: Incomplete
+    def __init__(self, base_url: str, api_key: str, *, storage: ObjectStorage | None = None) -> None: ...
+    async def record_session_to_video(self, session_id: str) -> bool: ...
+    @classmethod
+    def schedule_recording_in_background(cls, session_id: str, base_url: str, api_key: str, storage: ObjectStorage | None) -> threading.Thread | None: ...
+
+class SteelBrowserInfrastructure(BrowserInfrastructure[Steel, Session]):
+    """Concrete Steel implementation for browser infrastructure sessions."""
+    api_key: Incomplete
+    base_url: Incomplete
+    ws_url: Incomplete
+    timeout_in_ms: Incomplete
+    def __init__(self, api_key: str | None = None, base_url: str = ..., ws_url: str = ..., timeout_in_ms: int = ...) -> None:
+        """Initialize the Steel browser infrastructure.
+
+        ``api_key`` defaults to the ``STEEL_API_KEY`` environment variable
+        resolved at construction time (not import time) when not provided.
+        """
+    @property
+    def provider(self) -> str:
+        """Return the human-readable infrastructure provider name."""
+    @property
+    def supports_recording(self) -> bool:
+        """Whether this infrastructure can produce session recordings.
+
+        ``True`` indicates Steel supports recording. Recording is only
+        actually started when an available :class:`ObjectStorage` is also
+        provided to the :class:`BrowserUseClient`.
+        """
+    async def create_session(self) -> BrowserInfrastructureContext[Steel, Session]:
+        """Create a new Steel session and return the active context."""
+    async def release_session(self, context: BrowserInfrastructureContext[Steel, Session]) -> None:
+        """Release or dispose Steel session resources."""
+    def cdp_url(self, session_id: str) -> str:
+        """Build a CDP endpoint URL for the provided Steel session ID."""
+    def recording_filename(self, session_id: str) -> str:
+        """Return the preferred recording object name for the provided Steel session ID."""
+    def schedule_recording(self, context: BrowserInfrastructureContext[Steel, Session], storage: ObjectStorage | None) -> None:
+        """Schedule background recording for the provided context."""

gl_browser_use/models.pyi

@@ -0,0 +1,32 @@
+from _typeshed import Incomplete
+from dataclasses import dataclass, field
+from typing import Any
+
+BrowserUseRunStatus: Incomplete
+
+@dataclass(frozen=True)
+class BrowserUseStreamEvent:
+    """Structured stream event emitted during ``BrowserUseClient`` execution."""
+    event_type: str
+    content: str
+    thinking_and_activity_info: dict[str, Any] = field(default_factory=dict)
+    is_final: bool = ...
+    tool_info: dict[str, Any] | None = ...
+    metadata: dict[str, Any] | None = ...
+
+@dataclass(frozen=True)
+class BrowserUseRunResult:
+    """Final result returned for a completed run."""
+    status: BrowserUseRunStatus
+    task: str
+    final_output: str
+    session_id: str | None = ...
+    streaming_url: str | None = ...
+    recording_url: str | None = ...
+    steps: int = ...
+    error: str | None = ...
+    events: list[BrowserUseStreamEvent] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+    @property
+    def is_success(self) -> bool:
+        """Return True if the run was successful."""

gl_browser_use/parsing.pyi

@@ -0,0 +1,41 @@
+from browser_use import Agent
+from dataclasses import dataclass
+from typing import Any
+
+__all__ = ['ToolCall', 'coerce_string', 'extract_final_output', 'extract_outputs', 'extract_tool_calls', 'parse_structured_data', 'read_tool_call', 'summarize_terminal_error', 'validate_structured_data_output']
+
+def coerce_string(value: Any) -> str:
+    '''Return a stable ``str`` representation of ``value`` (``None`` becomes ``""``).'''
+def summarize_terminal_error(error_message: str, *, max_length: int = 200) -> str:
+    """Collapse whitespace in ``error_message`` and truncate to ``max_length`` characters."""
+
+@dataclass
+class ToolCall:
+    """Normalized tool-call snapshot extracted from the underlying agent state."""
+    name: str
+    args: dict[str, Any]
+    output: str = ...
+
+def read_tool_call(call: Any) -> tuple[str, dict[str, Any], str]:
+    """Return a ``(name, args, output)`` triple for a tool call of any supported shape.
+
+    ``name`` may be an empty string when the underlying payload is missing
+    a name; callers requiring a fallback label should apply one explicitly.
+    """
+def extract_outputs(last_result: list[Any]) -> list[str]:
+    """Return one display string per entry in ``last_result``."""
+def extract_tool_calls(agent: Agent) -> list[ToolCall]:
+    """Extract serialized tool-call snapshots from the agent's last model output."""
+def extract_final_output(agent: Agent) -> str:
+    """Return the final textual output from the agent, or an empty string if absent."""
+def parse_structured_data(output: str) -> tuple[dict[str, Any] | list[Any] | None, str | None]:
+    """Parse the ``Extracted Content:`` block in ``output`` with fallback recovery.
+
+    The parser (1) trims trailers and slices from the first ``{``/``[``;
+    (2) attempts a direct ``json.loads``; (3) attempts to recover
+    concatenated top-level JSON objects; (4) extracts a balanced-prefix
+    JSON value with a depth-aware scanner that respects string literals
+    and parses it; and finally (5) falls back to ``json_repair.repair_json``.
+    """
+def validate_structured_data_output(tool_calls: list[ToolCall]) -> str | None:
+    """Return a user-facing error when structured data extraction failed or yielded no usable entries."""

gl_browser_use/parsing_recovery.pyi

@@ -0,0 +1,35 @@
+from _typeshed import Incomplete
+from typing import Any
+
+__all__ = ['extract_balanced_json_value', 'recover_concatenated_json_objects', 'repair_json_blob']
+
+def extract_balanced_json_value(text: str) -> str | None:
+    """Return the first balanced JSON value found in ``text`` (respecting string literals).
+
+    Returns ``None`` when no ``{``/``[`` is found or when the scan never
+    closes cleanly (unbalanced, truncated, or ends inside a string).
+    """
+def recover_concatenated_json_objects(json_blob: str) -> dict[str, Any] | None:
+    """Normalize concatenated JSON object strings into a single structured payload.
+
+    Returns ``None`` if ``json_blob`` does not contain multiple top-level JSON
+    objects or they cannot be parsed individually.
+    """
+def repair_json_blob(json_blob: str) -> str | None:
+    """Apply ``json_repair.repair_json`` to ``json_blob`` and return the mutated payload.
+
+    Returns ``None`` when ``json_repair`` could not repair the input or when
+    the repair produced no changes.
+    """
+
+class _JsonObjectSplitter:
+    """Split concatenated top-level JSON objects while respecting string literals."""
+    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: ...
+    def split_objects(self) -> list[str]: ...

gl_browser_use/session_errors.pyi

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+__all__ = ['SessionErrorCategory', 'categorize_fatal_session_message', 'is_recoverable_session_error']
+
+@dataclass(frozen=True)
+class SessionErrorCategory:
+    """Session error classification for retry decisions."""
+    name: str
+    markers: tuple[str, ...]
+    fatal: bool
+    retryable: bool
+
+def categorize_fatal_session_message(message: str) -> SessionErrorCategory | None:
+    """Return the matching :class:`SessionErrorCategory` for ``message`` or ``None``."""
+def is_recoverable_session_error(message: str) -> bool:
+    """Return True when ``message`` matches a recoverable session-failure category."""

gl_browser_use/storage/__init__.pyi

@@ -0,0 +1,6 @@
+from gl_browser_use.storage.base import OBJECT_NAME_PREFIX as OBJECT_NAME_PREFIX, ObjectStorage as ObjectStorage
+
+__all__ = ['OBJECT_NAME_PREFIX', 'ObjectStorage', 'MinIOS3CompatibleStorage']
+
+# Names in __all__ with no definition:
+#   MinIOS3CompatibleStorage

gl_browser_use/storage/base.pyi

@@ -0,0 +1,46 @@
+from _typeshed import Incomplete
+from abc import ABC, abstractmethod
+
+__all__ = ['ObjectStorage', 'OBJECT_NAME_PREFIX']
+
+OBJECT_NAME_PREFIX: str
+
+class ObjectStorage(ABC):
+    """Abstract contract for object storage providers."""
+    endpoint: Incomplete
+    access_key: Incomplete
+    secret_key: Incomplete
+    bucket_name: Incomplete
+    directory_prefix: Incomplete
+    secure: Incomplete
+    def __init__(self, *, endpoint: str | None = None, access_key: str | None = None, secret_key: str | None = None, bucket_name: str | None = None, directory_prefix: str | None = None, secure: bool | None = None) -> None:
+        """Initialize the object storage.
+
+        Raises:
+        ------
+        BrowserUseConfigurationError
+            When any of ``endpoint``, ``access_key``, ``secret_key`` or
+            ``bucket_name`` is missing from both the arguments and the
+            corresponding ``OBJECT_STORAGE_*`` environment variable.
+        """
+    @property
+    @abstractmethod
+    def provider(self) -> str:
+        """Return the human-readable storage provider name."""
+    @property
+    def is_available(self) -> bool:
+        """Whether this storage provider is currently available."""
+    @property
+    def last_error(self) -> str | None:
+        """Return the last error encountered during client initialization or operation."""
+    @classmethod
+    def from_environment(cls) -> ObjectStorage:
+        """Create a storage instance from environment variables."""
+    def resolve_object_name(self, object_name: str) -> str:
+        """Return the effective remote object name."""
+    @abstractmethod
+    def upload_file(self, file_path: str, object_name: str) -> str | None:
+        """Upload a file and optionally return the stored object name."""
+    @abstractmethod
+    def get_file_url(self, object_name: str) -> str | None:
+        """Return an object URL when available."""

gl_browser_use/storage/minio_compatible.pyi

@@ -0,0 +1,15 @@
+from gl_browser_use.storage.base import ObjectStorage
+
+__all__ = ['MinIOS3CompatibleStorage']
+
+class MinIOS3CompatibleStorage(ObjectStorage):
+    """Concrete S3-compatible storage implemented with MinIO."""
+    def __init__(self, *, endpoint: str | None = None, access_key: str | None = None, secret_key: str | None = None, bucket_name: str | None = None, directory_prefix: str | None = None, secure: bool | None = None) -> None:
+        """Initialize the MinIO/S3-compatible storage."""
+    @property
+    def provider(self) -> str:
+        """Return the human-readable storage provider name."""
+    def upload_file(self, file_path: str, object_name: str) -> str | None:
+        """Upload a file and optionally return the stored object name."""
+    def get_file_url(self, object_name: str) -> str | None:
+        """Return an object URL when available."""

gl_browser_use.pyi

@@ -0,0 +1,83 @@
+# This file was generated by Nuitka
+
+# Stubs included by default
+from __future__ import annotations
+from __future__ import annotations
+from gl_browser_use.client import BrowserUseClient
+from gl_browser_use.config import BrowserUseClientConfig
+from gl_browser_use.errors import BrowserUseConfigurationError, BrowserUseDependencyError, BrowserUseExecutionError, BrowserUseMissingDependencyError, BrowserUseRetryExhaustedError, BrowserUseSDKError
+from gl_browser_use.infrastructure import __getattr__
+from gl_browser_use.infrastructure.base import BrowserInfrastructure, BrowserInfrastructureContext
+from gl_browser_use.models import BrowserUseRunResult, BrowserUseStreamEvent
+from gl_browser_use.storage import __getattr__
+from gl_browser_use.storage.base import ObjectStorage
+from typing import Any
+
+__all__ = ['BrowserUseClient', 'BrowserUseClientConfig', 'BrowserUseConfigurationError', 'BrowserUseDependencyError', 'BrowserUseExecutionError', 'BrowserUseMissingDependencyError', 'BrowserUseRetryExhaustedError', 'BrowserUseSDKError', 'BrowserUseRunResult', 'BrowserUseStreamEvent', 'BrowserInfrastructure', 'BrowserInfrastructureContext', 'SteelBrowserInfrastructure', 'ObjectStorage', 'MinIOS3CompatibleStorage']
+def __getattr__(name: str) -> Any:
+    ...
+
+def __dir__() -> list[str]:
+    ...
+
+__version__ = '0.1.0'
+
+__name__ = ...
+
+
+
+# Modules used internally, to allow implicit dependencies to be seen:
+import os
+import __future__
+import gl_browser_use.infrastructure.__getattr__
+import gl_browser_use.storage.__getattr__
+import asyncio
+import contextlib
+import copy
+import dataclasses
+import inspect
+import logging
+import time
+import collections
+import collections.abc
+import typing
+import browser_use
+import browser_use.agent
+import browser_use.agent.cloud_events
+import browser_use.agent.views
+import browser_use.browser
+import browser_use.llm
+import browser_use.logging_config
+import bubus
+import openai
+import openai.types
+import openai.types.shared_params
+import openai.types.shared_params.chat_model
+import openai.types.shared_params.reasoning_effort
+import urllib
+import urllib.parse
+import pydantic
+import json
+import textwrap
+import abc
+import re
+import datetime
+import requests
+import opensandbox
+import opensandbox.config
+import opensandbox.sandbox
+import tempfile
+import threading
+import pathlib
+import pathlib.Path
+import importlib
+import playwright
+import playwright.async_api
+import shutil
+import io
+import steel
+import steel.types
+import steel.types.session
+import json_repair
+import mimetypes
+import minio

gl_browser_use_binary-0.0.0b9.dist-info/METADATA

@@ -0,0 +1,287 @@
+Metadata-Version: 2.2
+Name: gl-browser-use-binary
+Version: 0.0.0b9
+Summary: A typed Python SDK for running browser automation tasks through `browser-use`
+Author-email: Reinhart Linanda <reinhart.linanda@gdplabs.id>
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: browser-use<0.12.0,>=0.11.13
+Requires-Dist: json-repair<0.61.0,>=0.60.1
+Requires-Dist: pydantic<3.0.0,>=2.11.7
+Requires-Dist: requests<3.0.0,>=2.32.4
+Requires-Dist: pydantic-settings<3.0.0,>=2.5.2
+Provides-Extra: steel
+Requires-Dist: steel-sdk<0.17.0,>=0.16.0; extra == "steel"
+Provides-Extra: opensandbox
+Requires-Dist: opensandbox<0.2.0,>=0.1.9; extra == "opensandbox"
+Requires-Dist: playwright<2.0.0,>=1.40.0; extra == "opensandbox"
+Provides-Extra: infrastructure
+Requires-Dist: gl-browser-use-binary[opensandbox,steel]; extra == "infrastructure"
+Provides-Extra: minio
+Requires-Dist: minio<8.0.0,>=7.2.20; extra == "minio"
+Provides-Extra: storage
+Requires-Dist: gl-browser-use-binary[minio]; extra == "storage"
+Provides-Extra: full
+Requires-Dist: gl-browser-use-binary[infrastructure,storage]; extra == "full"
+
+# GL Browser Use
+
+GL Browser Use is a typed Python SDK for running browser automation tasks through `browser-use`. It provides a stable client facade, structured stream events, explicit result objects, optional Steel or OpenSandbox browser infrastructure, optional MinIO/S3-compatible recording storage, and bounded retries for recoverable browser-session failures.
+
+## Installation
+
+Install the core SDK:
+
+```bash
+pip install gl-browser-use
+```
+
+Install optional providers only when you need them:
+
+```bash
+pip install "gl-browser-use[steel]"           # Steel browser infrastructure
+pip install "gl-browser-use[opensandbox]"     # OpenSandbox browser infrastructure
+pip install "gl-browser-use[infrastructure]"  # All browser infrastructure providers
+pip install "gl-browser-use[minio]"           # MinIO/S3-compatible object storage
+pip install "gl-browser-use[storage]"         # All object storage providers
+pip install "gl-browser-use[full]"            # Infrastructure + storage providers
+```
+
+Use the concrete extras (`steel`, `opensandbox`, `minio`) in application dependency files when you want to pin exactly which provider you depend on. The slot extras (`infrastructure`, `storage`, `full`) are convenience aliases and may include more providers later.
+
+## Quick Start
+
+`BrowserUseClient` supports streaming and non-streaming execution. API keys can be passed directly or read from environment variables.
+
+```python
+import asyncio
+
+from gl_browser_use import BrowserUseClient, BrowserUseClientConfig
+from gl_browser_use.infrastructure import SteelBrowserInfrastructure
+from gl_browser_use.storage import MinIOS3CompatibleStorage
+
+
+async def main() -> None:
+    client = BrowserUseClient(
+        config=BrowserUseClientConfig(
+            llm_openai_api_key="...",
+            page_extraction_llm_openai_api_key="...",
+            max_session_retries=2,
+            session_retry_delay_in_s=3.0,
+        ),
+        infrastructure=SteelBrowserInfrastructure(),  # reads STEEL_API_KEY by default
+        storage=MinIOS3CompatibleStorage.from_environment(),
+    )
+
+    async for event in client.run("Open Hacker News and list five article titles"):
+        print(event.content)
+
+
+asyncio.run(main())
+```
+
+For a single aggregated result:
+
+```python
+from gl_browser_use import BrowserUseClient, BrowserUseClientConfig
+from gl_browser_use.infrastructure import SteelBrowserInfrastructure
+
+client = BrowserUseClient(
+    config=BrowserUseClientConfig(
+        llm_openai_api_key="...",
+        page_extraction_llm_openai_api_key="...",
+    ),
+    infrastructure=SteelBrowserInfrastructure(),
+)
+
+result = client.run_sync("Open Hacker News and list five article titles")
+
+print(result.status)
+print(result.final_output)
+print(result.session_id)
+print(result.streaming_url)
+print(result.recording_url)
+print(result.metadata)
+```
+
+## Configuration
+
+`BrowserUseClientConfig` validates required values when the client is created. If `llm_openai_api_key` or `page_extraction_llm_openai_api_key` is not passed, both default to `OPENAI_API_KEY`.
+
+Common client options:
+
+1. `llm_openai_model`: primary browser-control model. Default: `o3`.
+2. `page_extraction_llm_openai_model`: page extraction model. Default: `gpt-5-mini`.
+3. `sensitive_data`: optional browser-use placeholder map. It accepts either a flat
+    placeholder-to-value map or a domain-scoped map. Values are excluded from normal
+    config serialization and redacted from `redacted_dict()` output.
+4. `extend_system_message`: optional system prompt extension.
+5. `vision_detail_level`: `auto`, `low`, or `high`. Default: `auto`.
+6. `llm_timeout_in_s`: optional LLM timeout.
+7. `step_timeout_in_s`: per-step browser timeout. Default: `180`.
+8. `agent_kwargs`: additional `browser_use.Agent` constructor arguments. It cannot
+    override SDK-managed arguments such as the task, LLMs, browser session, `sensitive_data`,
+    or timeouts.
+9. `enable_cloud_sync`: controls `browser-use` cloud sync. Default: `False`.
+10. `logging_level`: `debug`, `info`, `warning`, `error`, or `result`. Default: `info`.
+11. `max_session_retries`: recoverable session retries. Default: `2`.
+12. `session_retry_delay_in_s`: delay between retries. Default: `3.0`.
+
+### Sensitive data and Agent options
+
+```python
+config = BrowserUseClientConfig(
+    llm_openai_api_key="...",
+    page_extraction_llm_openai_api_key="...",
+    sensitive_data={"username": "example-user", "password": "example-password"},
+    agent_kwargs={"use_vision": False, "max_actions_per_step": 2},
+)
+```
+
+Keep one configured client per credential scope. Browser-use also accepts domain-scoped
+`sensitive_data` maps. Never put real values in logs, serialized configuration, or
+`agent_kwargs`.
+
+When supplying sensitive data, restrict browser navigation to the expected domains (for
+example, through the infrastructure session's browser-use `BrowserProfile(allowed_domains=...)`)
+to reduce prompt-injection exfiltration risk. `agent_kwargs` cannot override browser/session
+ownership (`browser`, `browser_profile`, and `browser_session` are reserved); configure those
+controls through the selected infrastructure instead.
+
+Optional provider environment variables:
+
+1. `STEEL_API_KEY`: used by `SteelBrowserInfrastructure()` when `api_key` is not passed.
+2. `OPENSANDBOX_DOMAIN`: OpenSandbox control-plane host. Default: `localhost:8080`.
+3. `OPENSANDBOX_API_KEY`: required for shared OpenSandbox clusters; optional for local insecure servers.
+4. `OBJECT_STORAGE_URL`: MinIO/S3 endpoint, for example `localhost:9001` or `https://storage.example`.
+5. `OBJECT_STORAGE_USERNAME`: object storage access key.
+6. `OBJECT_STORAGE_PASSWORD`: object storage secret key.
+7. `OBJECT_STORAGE_BUCKET_NAME`: target bucket name.
+8. `OBJECT_STORAGE_DIRECTORY_PREFIX`: optional object key prefix.
+9. `OBJECT_STORAGE_SECURE`: `true` for HTTPS when the endpoint has no scheme.
+
+Copy `.env.example` to `.env` for local development, then load it with your application environment manager.
+
+## Runtime API
+
+The client exposes three run methods:
+
+1. `run(task)`: async generator that yields `BrowserUseStreamEvent` values as work progresses.
+2. `run_once(task)`: async method that returns one `BrowserUseRunResult` and includes emitted events in `result.events`.
+3. `run_sync(task)`: blocking wrapper around `run_once()` using `asyncio.run()`.
+
+Do not call `run_sync()` from an already running event loop. Use `await run_once()` or `async for event in run()` in async applications.
+
+Cancelling the stream by breaking from `async for` or calling `await stream.aclose()` cancels the underlying run task. Browser sessions and infrastructure sessions are released in cleanup.
+
+## Result Contract
+
+`BrowserUseRunResult` contains:
+
+1. `status`: `success`, `error`, or `cancelled`.
+2. `task`: normalized task string.
+3. `final_output`: final text extracted from the underlying agent, or `Task completed` when no final text is available.
+4. `session_id`: infrastructure session ID when an external browser session was used.
+5. `streaming_url`: browser debug or streaming URL when available.
+6. `recording_url`: expected recording URL when recording is configured.
+7. `steps`: number of browser-use steps executed.
+8. `error`: terminal error message for error results.
+9. `events`: collected stream events for `run_once()`.
+10. `metadata`: attempt, retry, and recording metadata.
+
+Recording metadata uses these statuses:
+
+1. `disabled`: infrastructure, storage, or browser context is not available.
+2. `unsupported`: the selected infrastructure does not support recording.
+3. `unavailable`: storage is configured but not available.
+4. `scheduled`: a background recording upload has been scheduled.
+5. `unknown`: recording may have started, but the terminal error did not include enough context to determine the final state.
+
+## Streaming Contract
+
+`BrowserUseStreamEvent` contains:
+
+1. `event_type`
+2. `content`
+3. `thinking_and_activity_info`
+4. `is_final`
+5. `tool_info`
+6. `metadata`
+
+Important event content values:
+
+1. `Receive streaming URL`: emitted when a browser debug or streaming URL is available.
+2. `Receive recording URL`: emitted when a recording URL can be resolved.
+3. `Task completed`: emitted for the final successful step.
+
+Activity events encode iframe URLs in `thinking_and_activity_info["data_value"]` as a JSON string:
+
+```json
+{"type": "iframe", "message": "<url>"}
+```
+
+Step events include serialized tool calls in `tool_info["tool_calls"]`.
+
+## Retries And Errors
+
+The client retries only classified recoverable browser-session failures, such as browser closure or websocket disconnect messages. Before each retry, it emits a retry status event. Retries are bounded by `max_session_retries`, so total attempts are `max_session_retries + 1`.
+
+Non-recoverable task failures return `BrowserUseRunResult(status="error")`. Recoverable failures that exhaust all attempts raise `BrowserUseRetryExhaustedError`.
+
+SDK error types:
+
+1. `BrowserUseConfigurationError`: missing or invalid runtime configuration.
+2. `BrowserUseDependencyError`: optional provider dependency problem.
+3. `BrowserUseMissingDependencyError`: optional provider extra is not installed.
+4. `BrowserUseExecutionError`: execution-time failure.
+5. `BrowserUseRetryExhaustedError`: recoverable session retries were exhausted.
+
+## Optional Providers
+
+Optional providers are lazy-loaded. Importing `gl_browser_use` does not require Steel, OpenSandbox, or MinIO to be installed.
+
+```python
+from gl_browser_use.infrastructure import OpenSandboxBrowserInfrastructure, SteelBrowserInfrastructure
+from gl_browser_use.storage import MinIOS3CompatibleStorage
+```
+
+`SteelBrowserInfrastructure` creates Steel browser sessions and provides CDP/streaming URLs.
+
+`OpenSandboxBrowserInfrastructure` provisions the repo-committed Chrome example image (`opensandbox/chrome:latest`, built from `examples/opensandbox/chrome`) through a local or shared OpenSandbox server, exposes noVNC inspection URLs, connects over proxied CDP, and uploads WebM session recordings to object storage with the same deferred `recording_url` semantics as Steel. Pass `storage` to `BrowserUseClient` when recording is enabled.
+
+**DevTools note:** the Chrome image exposes CDP on `0.0.0.0:9222` (`--remote-debugging-address=0.0.0.0` plus a `socat` forward for Chromium M113+). Rebuild from `examples/opensandbox/chrome` after pulling changes; the SDK discovers CDP via `sandbox.get_endpoint(9222)`. See `examples/opensandbox/chrome/README.md`.
+
+OpenSandbox local setup:
+
+```bash
+DOCKER_HOST=unix://${HOME}/.docker/desktop/docker.sock \
+  OPENSANDBOX_INSECURE_SERVER=YES opensandbox-server
+
+cd libs/gl-browser-use/examples/opensandbox/chrome
+docker build -t opensandbox/chrome:latest .
+playwright install chromium
+```
+
+`MinIOS3CompatibleStorage` uploads session recordings to MinIO or an S3-compatible service and returns presigned URLs.
+
+## Development
+
+From `libs/gl-browser-use`:
+
+```bash
+make install-dev
+make test-unit
+make test-integration
+make lint
+make build-check
+```
+
+Useful targets:
+
+1. `make test`: run all tests.
+2. `make test-unit`: run unit tests with coverage.
+3. `make test-integration`: run integration-marked contract tests.
+4. `make lint`: run Ruff checks.
+5. `make format`: run Ruff fixes and formatter.
+6. `make pre-commit`: run pre-commit hooks.
+7. `make build-check`: build the package and validate artifacts with Twine.

gl_browser_use_binary-0.0.0b9.dist-info/RECORD

@@ -0,0 +1,24 @@
+gl_browser_use.cp313-win_amd64.pyd,sha256=s7TpsZ6Ztus48T-JbV4Tg_h1SN7odRx-OHf9rLFn9Qo,959488
+gl_browser_use.pyi,sha256=p6iz4o2Hs4jLimApvxcZRQUcSr8UOu4SdRBJLMU_gLM,2528
+gl_browser_use/__init__.pyi,sha256=1uchB2q9Iq7GBPac_MQf4okzXalqcwNQeBUAVpXDU8E,1417
+gl_browser_use/client.pyi,sha256=_UWgAWXn85NHNVSfUboJOxDRSUvg_F-xrz4-Zn_UBu8,3552
+gl_browser_use/config.pyi,sha256=73-MZI978JcBtUgeyjUftry2pB4ReuBoz4RKuCpfps4,1974
+gl_browser_use/errors.pyi,sha256=LlpVLDHEQCyqekY0Jq88iqjJgQuSzDsM1gGQBkeWUMw,2088
+gl_browser_use/events.pyi,sha256=A7o-FcXn8FHbrxeIZqQ75byYo6OkUVYekaIrU-nVWiY,1888
+gl_browser_use/models.pyi,sha256=KcNLDd6XPQqHa7Ccuf5ezfDsJuLkVFQNqk67SA1A_1A,1078
+gl_browser_use/parsing.pyi,sha256=K14ptm7O5DgGRxtRxi-1SrKsMdm4XqzXhrBXeNE9V3w,2267
+gl_browser_use/parsing_recovery.pyi,sha256=LCaHWb0oCSGgwPxEwG3z1f25UCLpb6y5WZnrXO7unMA,1416
+gl_browser_use/session_errors.pyi,sha256=fQOcS7Gh2FSawL0VaIRICtCsd-3jdgJUAdExszWmwWU,662
+gl_browser_use/infrastructure/__init__.pyi,sha256=AmrO_89UUoEn8Xe_tiDLZ38rFwDd3Xs-rOaM6EHCYZw,406
+gl_browser_use/infrastructure/base.pyi,sha256=kLTlBvVwpQrStuoo5FfdE_VoG1qCfApEThvb8xC48g4,2817
+gl_browser_use/infrastructure/opensandbox.pyi,sha256=Tj9tg7WMbRbne3qkcOsiVZYkfQ3ZrsIV9iBAg14OSDA,3234
+gl_browser_use/infrastructure/playwright_recorder.pyi,sha256=A27qsALvrhmwAwtNqe4VxzGaqzT1DwrY7DWjGPNczzA,1227
+gl_browser_use/infrastructure/recording_utils.pyi,sha256=pcaDHoN_HeKeyg7fSVLNIfgU6MkZNDp6QPJb5zoAXVk,579
+gl_browser_use/infrastructure/steel.pyi,sha256=Rwu-BqKFNu1UR_u_bVIKzaT5tLheeXF_tG6vWePymtI,2726
+gl_browser_use/storage/__init__.pyi,sha256=y1Yp7iB0WWc2sklofSSZe7xbUzbsBsm0K1OA9W_bnAY,267
+gl_browser_use/storage/base.pyi,sha256=_V26BMVpbCqY4jqWLTKrgXhsQ9pQ3NCgXEd4WHrgHGc,1936
+gl_browser_use/storage/minio_compatible.pyi,sha256=MQnQ1IxTnCx74uiBOlEdzs9BHf88YL37UFZZWTzoTag,871
+gl_browser_use_binary-0.0.0b9.dist-info/METADATA,sha256=-MvHMUQdl_8ddPeFnwy6OnN8jUnEWyTdgFVgvIMZ1yg,12766
+gl_browser_use_binary-0.0.0b9.dist-info/WHEEL,sha256=ikXeVivtRq-oqOZfN0jwm7M68yNYx-wxpXplGP7L4Is,97
+gl_browser_use_binary-0.0.0b9.dist-info/top_level.txt,sha256=I3agYm4bLWMzPbZo_gLgMdmn91EFAXX-hziarvf9VWY,15
+gl_browser_use_binary-0.0.0b9.dist-info/RECORD,,

gl_browser_use_binary-0.0.0b9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: Nuitka (2.8.10)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

gl_browser_use_binary-0.0.0b9.dist-info/top_level.txt

@@ -0,0 +1 @@
+gl_browser_use