anchorbrowser 0.1.0a1__py3-none-any.whl → 0.1.0a2__py3-none-any.whl

anchorbrowser/_client.py

@@ -21,7 +21,7 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import tools, profiles, extensions
+from .resources import agent, tools, browser, profiles, extensions
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, AnchorbrowserError
 from ._base_client import (
@@ -48,6 +48,8 @@ class Anchorbrowser(SyncAPIClient):
     sessions: sessions.SessionsResource
     tools: tools.ToolsResource
     extensions: extensions.ExtensionsResource
+    browser: browser.BrowserResource
+    agent: agent.AgentResource
     with_raw_response: AnchorbrowserWithRawResponse
     with_streaming_response: AnchorbrowserWithStreamedResponse
 
@@ -109,6 +111,8 @@ class Anchorbrowser(SyncAPIClient):
         self.sessions = sessions.SessionsResource(self)
         self.tools = tools.ToolsResource(self)
         self.extensions = extensions.ExtensionsResource(self)
+        self.browser = browser.BrowserResource(self)
+        self.agent = agent.AgentResource(self)
         self.with_raw_response = AnchorbrowserWithRawResponse(self)
         self.with_streaming_response = AnchorbrowserWithStreamedResponse(self)
 
@@ -222,6 +226,8 @@ class AsyncAnchorbrowser(AsyncAPIClient):
     sessions: sessions.AsyncSessionsResource
     tools: tools.AsyncToolsResource
     extensions: extensions.AsyncExtensionsResource
+    browser: browser.AsyncBrowserResource
+    agent: agent.AsyncAgentResource
     with_raw_response: AsyncAnchorbrowserWithRawResponse
     with_streaming_response: AsyncAnchorbrowserWithStreamedResponse
 
@@ -283,6 +289,8 @@ class AsyncAnchorbrowser(AsyncAPIClient):
         self.sessions = sessions.AsyncSessionsResource(self)
         self.tools = tools.AsyncToolsResource(self)
         self.extensions = extensions.AsyncExtensionsResource(self)
+        self.browser = browser.AsyncBrowserResource(self)
+        self.agent = agent.AsyncAgentResource(self)
         self.with_raw_response = AsyncAnchorbrowserWithRawResponse(self)
         self.with_streaming_response = AsyncAnchorbrowserWithStreamedResponse(self)
 
@@ -397,7 +405,8 @@ class AnchorbrowserWithRawResponse:
         self.sessions = sessions.SessionsResourceWithRawResponse(client.sessions)
         self.tools = tools.ToolsResourceWithRawResponse(client.tools)
         self.extensions = extensions.ExtensionsResourceWithRawResponse(client.extensions)
-
+        self.browser = browser.BrowserResourceWithRawResponse(client.browser)
+        self.agent = agent.AgentResourceWithRawResponse(client.agent)
 
 class AsyncAnchorbrowserWithRawResponse:
     def __init__(self, client: AsyncAnchorbrowser) -> None:
@@ -405,7 +414,8 @@ class AsyncAnchorbrowserWithRawResponse:
         self.sessions = sessions.AsyncSessionsResourceWithRawResponse(client.sessions)
         self.tools = tools.AsyncToolsResourceWithRawResponse(client.tools)
         self.extensions = extensions.AsyncExtensionsResourceWithRawResponse(client.extensions)
-
+        self.browser = browser.AsyncBrowserResourceWithRawResponse(client.browser)
+        self.agent = agent.AsyncAgentResourceWithRawResponse(client.agent)
 
 class AnchorbrowserWithStreamedResponse:
     def __init__(self, client: Anchorbrowser) -> None:
@@ -413,7 +423,8 @@ class AnchorbrowserWithStreamedResponse:
         self.sessions = sessions.SessionsResourceWithStreamingResponse(client.sessions)
         self.tools = tools.ToolsResourceWithStreamingResponse(client.tools)
         self.extensions = extensions.ExtensionsResourceWithStreamingResponse(client.extensions)
-
+        self.browser = browser.BrowserResourceWithStreamingResponse(client.browser)
+        self.agent = agent.AgentResourceWithStreamingResponse(client.agent)
 
 class AsyncAnchorbrowserWithStreamedResponse:
     def __init__(self, client: AsyncAnchorbrowser) -> None:
@@ -421,7 +432,8 @@ class AsyncAnchorbrowserWithStreamedResponse:
         self.sessions = sessions.AsyncSessionsResourceWithStreamingResponse(client.sessions)
         self.tools = tools.AsyncToolsResourceWithStreamingResponse(client.tools)
         self.extensions = extensions.AsyncExtensionsResourceWithStreamingResponse(client.extensions)
-
+        self.browser = browser.AsyncBrowserResourceWithStreamingResponse(client.browser)
+        self.agent = agent.AsyncAgentResourceWithStreamingResponse(client.agent)
 
 Client = Anchorbrowser
 

anchorbrowser/_models.py

@@ -208,14 +208,18 @@ class BaseModel(pydantic.BaseModel):
             else:
                 fields_values[name] = field_get_default(field)
 
+        extra_field_type = _get_extra_fields_type(__cls)
+
         _extra = {}
         for key, value in values.items():
             if key not in model_fields:
+                parsed = construct_type(value=value, type_=extra_field_type) if extra_field_type is not None else value
+
                 if PYDANTIC_V2:
-                    _extra[key] = value
+                    _extra[key] = parsed
                 else:
                     _fields_set.add(key)
-                    fields_values[key] = value
+                    fields_values[key] = parsed
 
         object.__setattr__(m, "__dict__", fields_values)
 
@@ -370,6 +374,23 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object:
     return construct_type(value=value, type_=type_, metadata=getattr(field, "metadata", None))
 
 
+def _get_extra_fields_type(cls: type[pydantic.BaseModel]) -> type | None:
+    if not PYDANTIC_V2:
+        # TODO
+        return None
+
+    schema = cls.__pydantic_core_schema__
+    if schema["type"] == "model":
+        fields = schema["schema"]
+        if fields["type"] == "model-fields":
+            extras = fields.get("extras_schema")
+            if extras and "cls" in extras:
+                # mypy can't narrow the type
+                return extras["cls"]  # type: ignore[no-any-return]
+
+    return None
+
+
 def is_basemodel(type_: type) -> bool:
     """Returns whether or not the given type is either a `BaseModel` or a union of `BaseModel`"""
     if is_union(type_):

anchorbrowser/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "anchorbrowser"
-__version__ = "0.1.0-alpha.1"  # x-release-please-version
+__version__ = "0.1.0-alpha.2"  # x-release-please-version

anchorbrowser/lib/agent.py

@@ -0,0 +1,69 @@
+import json
+import asyncio
+import threading
+from typing import Any, Dict, Callable, Optional, TypedDict
+from asyncio import Future
+
+from ..lib.browser import BrowserSetup, get_agent_ws_url
+
+
+class AgentTaskParams(TypedDict, total=False):
+    url: Optional[str]
+    output_schema: Optional[Dict[str, Any]]
+    on_agent_step: Optional[Callable[[str], None]]
+
+
+def create_task_payload(prompt: str, output_schema: Optional[Dict[str, Any]] = None) -> str:
+    if not prompt or prompt.strip() == "":
+        raise ValueError("Prompt cannot be empty")
+
+    return json.dumps(
+        {
+            "prompt": prompt,
+            "output_schema": output_schema,
+        }
+    )
+
+
+def on_agent_step_sync(on_agent_step: Callable[[str], None], browser_setup: BrowserSetup) -> Future[None]:
+    import websockets
+
+    async def websocket_listener() -> None:
+        ws_url = get_agent_ws_url(browser_setup.base_url, browser_setup.session_id)
+        try:
+            async with websockets.connect(ws_url) as ws:
+                async for ws_msg in ws:
+                    on_agent_step(str(ws_msg))
+        except Exception as e:
+            future.set_exception(e)
+
+    def run_in_thread() -> None:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            loop.run_until_complete(websocket_listener())
+        finally:
+            loop.close()
+
+    # Create a future to track the task
+    future = Future[None]()
+    try:
+        thread = threading.Thread(target=lambda: future.set_result(run_in_thread()))
+        thread.daemon = True
+        thread.start()
+    except Exception:
+        pass
+
+    return future
+
+
+def on_agent_step_async(on_agent_step: Callable[[str], None], browser_setup: BrowserSetup) -> None:
+    import websockets
+
+    async def websocket_listener() -> None:
+        ws_url = get_agent_ws_url(browser_setup.base_url, browser_setup.session_id)
+        async with websockets.connect(ws_url) as ws:
+            async for ws_msg in ws:
+                on_agent_step(str(ws_msg))
+
+    asyncio.create_task(websocket_listener())

anchorbrowser/lib/browser.py

@@ -0,0 +1,186 @@
+from typing import TYPE_CHECKING, Any, Dict, Callable, Optional, TypedDict
+from contextlib import contextmanager, asynccontextmanager, _GeneratorContextManager, _AsyncGeneratorContextManager
+
+from pydantic import BaseModel
+from playwright.sync_api import Page, Worker, Browser, BrowserContext
+from playwright.async_api import (
+    Page as AsyncPage,
+    Worker as AsyncWorker,
+    Browser as AsyncBrowser,
+    BrowserContext as AsyncBrowserContext,
+)
+
+if TYPE_CHECKING:
+    from collections import Generator, AsyncGenerator
+
+
+@contextmanager
+def get_playwright_chromium_from_cdp_url(
+    api_base_url: str, session_id: str, api_key: str
+) -> "Generator[Browser, Any, None]":
+    from playwright.sync_api import sync_playwright
+
+    browser = None
+    playwright = sync_playwright().start()
+    try:
+        browser = playwright.chromium.connect_over_cdp(get_cdp_url(api_base_url, session_id, api_key))
+        yield browser
+    finally:
+        if browser:
+            browser.close()
+        playwright.stop()
+
+
+@asynccontextmanager
+async def get_async_playwright_chromium_from_cdp_url(
+    api_base_url: str, session_id: str, api_key: str
+) -> "AsyncGenerator[AsyncBrowser, None]":
+    from playwright.async_api import async_playwright
+
+    browser = None
+    playwright = await async_playwright().start()
+    try:
+        browser = await playwright.chromium.connect_over_cdp(get_cdp_url(api_base_url, session_id, api_key))
+        yield browser
+    finally:
+        if browser:
+            await browser.close()
+        await playwright.stop()
+
+
+def get_cdp_url(api_base_url: str, session_id: str, api_key: str) -> str:
+    return f"{api_base_url.replace('https://', 'wss://').replace('api.', 'connect.')}?apiKey={api_key}&sessionId={session_id}"
+
+
+def get_agent_ws_url(api_base_url: str, session_id: str) -> str:
+    return f"{api_base_url.replace('https://', 'wss://').replace('api.', 'connect.')}/ws?sessionId={session_id}"
+
+
+def get_ai_service_worker(browser_context: "BrowserContext") -> Optional["Worker"]:
+    return next(
+        (
+            sw
+            for sw in browser_context.service_workers
+            if "chrome-extension://bppehibnhionalpjigdjdilknbljaeai/background.js" in sw.url
+        ),
+        None,
+    )
+
+
+async def get_ai_service_worker_async(browser_context: "AsyncBrowserContext") -> Optional["AsyncWorker"]:
+    return next(
+        (
+            sw
+            for sw in browser_context.service_workers
+            if "chrome-extension://bppehibnhionalpjigdjdilknbljaeai/background.js" in sw.url
+        ),
+        None,
+    )
+
+
+class BrowserSetup(BaseModel):
+    session_id: str
+    base_url: str
+    api_key: str
+    _browser: Optional[Browser] = None
+    _async_browser: Optional[AsyncBrowser] = None
+    _context_manager: Optional[_GeneratorContextManager[Browser]] = None
+    _async_context_manager: Optional[_AsyncGeneratorContextManager[AsyncBrowser]] = None
+
+    async def __aenter__(self) -> "BrowserSetup":
+        self._async_context_manager = get_async_playwright_chromium_from_cdp_url(
+            self.base_url,
+            self.session_id,
+            self.api_key,
+        )
+        self._async_browser = await self._async_context_manager.__aenter__()
+        return self
+
+    def __enter__(self) -> "BrowserSetup":
+        self._context_manager = get_playwright_chromium_from_cdp_url(
+            self.base_url,
+            self.session_id,
+            self.api_key,
+        )
+        self._browser = self._context_manager.__enter__()
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> Optional[bool]:
+        if self._context_manager:
+            return self._context_manager.__exit__(exc_type, exc_val, exc_tb)
+        return None
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> Optional[bool]:
+        if self._async_context_manager:
+            return await self._async_context_manager.__aexit__(exc_type, exc_val, exc_tb)
+        return None
+
+    @property
+    def browser_generator(self) -> _GeneratorContextManager[Browser]:
+        return get_playwright_chromium_from_cdp_url(
+            self.base_url,
+            self.session_id,
+            self.api_key,
+        )
+
+    @property
+    def async_browser_generator(self) -> _AsyncGeneratorContextManager[AsyncBrowser]:
+        return get_async_playwright_chromium_from_cdp_url(
+            self.base_url,
+            self.session_id,
+            self.api_key,
+        )
+
+    @property
+    def browser(self) -> Browser:
+        if self._browser is None:
+            raise RuntimeError("BrowserSetup must be used as a context manager")
+        return self._browser
+
+    @property
+    async def async_browser(self) -> AsyncBrowser:
+        if self._async_browser is None:
+            raise RuntimeError("BrowserSetup must be used as a context manager")
+        return self._async_browser
+
+    @property
+    def context(self) -> BrowserContext:
+        return self.browser.contexts[0]
+
+    @property
+    async def async_context(self) -> AsyncBrowserContext:
+        return (await self.async_browser).contexts[0]
+
+    @property
+    def page(self) -> Page:
+        return self.context.pages[0]
+
+    @property
+    async def async_page(self) -> AsyncPage:
+        return (await self.async_context).pages[0]
+
+    @property
+    def ai(self) -> Worker:
+        ai_service_worker = get_ai_service_worker(self.context)
+        if not ai_service_worker:
+            raise ValueError("AI service worker not found")
+        return ai_service_worker
+
+    @property
+    async def async_ai(self) -> AsyncWorker:
+        ai_service_worker = await get_ai_service_worker_async(await self.async_context)
+        if not ai_service_worker:
+            raise ValueError("AI service worker not found")
+        return ai_service_worker
+
+
+class AgentTaskParams(TypedDict, total=False):
+    url: Optional[str]
+    output_schema: Optional[Dict[str, Any]]
+    on_agent_step: Optional[Callable[[str], None]]
+
+
+class BrowserTaskResponse(TypedDict):
+    session_id: str
+    task_result_task: Any
+    playwright_browser: Any

anchorbrowser/resources/agent.py

@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ..lib.agent import on_agent_step_sync, create_task_payload, on_agent_step_async
+from ..lib.browser import (
+    BrowserSetup,
+    AgentTaskParams,
+    BrowserTaskResponse,
+)
+from ..types.session_create_params import Session
+
+__all__ = ["AgentResource", "AsyncAgentResource"]
+
+
+class AgentResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AgentResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return AgentResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AgentResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return AgentResourceWithStreamingResponse(self)
+
+    def task(
+        self,
+        prompt: str,
+        *,
+        session_options: Optional[Session] = None,
+        task_options: Optional[AgentTaskParams] = None,
+    ) -> str:
+        """Execute an AI agent task within a browser session.
+
+        Creates a new browser session and executes the given prompt as an AI agent task.
+        The agent can optionally navigate to a specific URL and use a structured output schema.
+
+        Args:
+            prompt (str): The task prompt/instruction for the AI agent to execute.
+            session_options (Optional[Session], optional): Configuration options for the
+                browser session. Defaults to None, which creates a session with default settings.
+            task_options (Optional[AgentTaskParams], optional): Additional task configuration
+
+        Returns:
+            str: The result of the AI agent task execution.
+        """
+        session = self._client.sessions.create(session=session_options or {})
+        if not session.data or not session.data.id:
+            raise ValueError("Failed to create session: No session ID returned")
+
+        with BrowserSetup(
+            session_id=session.data.id,
+            base_url=str(self._client.base_url),
+            api_key=self._client.api_key,
+        ) as browser_setup:
+            output_schema = None
+            if task_options:
+                output_schema = task_options.get("output_schema")
+                url = task_options.get("url")
+                if url:
+                    browser_setup.page.goto(url)
+                on_agent_step = task_options.get("on_agent_step")
+                if on_agent_step:
+                    on_agent_step_sync(on_agent_step, browser_setup)
+            task_payload = create_task_payload(prompt, output_schema)
+            task_result = str(browser_setup.ai.evaluate(task_payload))
+            return task_result
+
+    def browser_task(
+        self,
+        prompt: str,
+        *,
+        session_options: Optional[Session] = None,
+        task_options: Optional[AgentTaskParams] = None,
+    ) -> BrowserTaskResponse:
+        """Execute an AI agent task and return a browser task response with session control.
+
+        Creates a new browser session, executes the given prompt as an AI agent task \n
+        returns a object that includes the session ID, task result, and browser instance for continued interaction by the caller. \n
+        This method differs from `task()` by returning control of the browser session to the caller rather than automatically closing it after task completion. \n
+        Args:
+            prompt (str): The task prompt/instruction for the AI agent to execute. \n
+            session_options (Optional[Session], optional): Configuration options for the browser session. Defaults to None, which creates a session with default settings. \n
+            task_options (Optional[AgentTaskParams], optional): Additional task configuration including: \n
+        - output_schema: Schema for structured output formatting
+        - url: URL to navigate to before executing the task
+        - on_agent_step: Callback function for agent step events
+                Defaults to None.
+
+        Returns:
+            Response object containing:
+                - session_id: The ID of the created browser session
+                - task_result_task: The result of the AI agent task execution
+                - playwright_browser: Browser instance for continued interaction
+        """
+        session = self._client.sessions.create(session=session_options or {})
+        if not session.data or not session.data.id:
+            raise ValueError("Failed to create session: No session ID returned")
+
+        with BrowserSetup(
+            session_id=session.data.id,
+            base_url=str(self._client.base_url),
+            api_key=self._client.api_key,
+        ) as browser_setup:
+            output_schema = None
+            if task_options:
+                output_schema = task_options.get("output_schema")
+                url = task_options.get("url")
+                if url:
+                    browser_setup.page.goto(url)
+                on_agent_step = task_options.get("on_agent_step")
+                if on_agent_step:
+                    on_agent_step_sync(on_agent_step, browser_setup)
+            task_payload = create_task_payload(prompt, output_schema)
+            task_result = str(browser_setup.ai.evaluate(task_payload))
+            return BrowserTaskResponse(
+                session_id=session.data.id,
+                task_result_task=task_result,
+                playwright_browser=browser_setup.browser_generator,
+            )
+
+
+class AsyncAgentResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncAgentResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncAgentResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncAgentResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return AsyncAgentResourceWithStreamingResponse(self)
+
+    async def task(
+        self,
+        prompt: str,
+        *,
+        session_options: Optional[Session] = None,
+        task_options: Optional[AgentTaskParams] = None,
+    ) -> str:
+        """Execute an AI agent task within a browser session.
+
+        Creates a new browser session and executes the given prompt as an AI agent task.
+        The agent can optionally navigate to a specific URL and use a structured output schema.
+
+        Args:
+            prompt (str): The task prompt/instruction for the AI agent to execute.
+            session_options (Optional[Session], optional): Configuration options for the
+                browser session. Defaults to None, which creates a session with default settings.
+            task_options (Optional[AgentTaskParams], optional): Additional task configuration
+
+        Returns:
+            str: The result of the AI agent task execution.
+        """
+        session = await self._client.sessions.create(session=session_options or {})
+        if not session.data or not session.data.id:
+            raise ValueError("Failed to create session: No session ID returned")
+
+        browser_setup = BrowserSetup(
+            session_id=session.data.id,
+            base_url=str(self._client.base_url),
+            api_key=self._client.api_key,
+        )
+
+        async with browser_setup:
+            output_schema = None
+            if task_options:
+                output_schema = task_options.get("output_schema")
+                url = task_options.get("url")
+                if url:
+                    await (await browser_setup.async_page).goto(url)
+                on_agent_step = task_options.get("on_agent_step")
+                if on_agent_step:
+                    on_agent_step_async(on_agent_step, browser_setup)
+            task_payload = create_task_payload(prompt, output_schema)
+            task_result = await (await browser_setup.async_ai).evaluate(task_payload)
+            return str(task_result)
+
+    async def browser_task(
+        self,
+        prompt: str,
+        *,
+        session_options: Optional[Session] = None,
+        task_options: Optional[AgentTaskParams] = None,
+    ) -> BrowserTaskResponse:
+        """Execute an AI agent task and return a browser task response with session control.
+
+        Creates a new browser session, executes the given prompt as an AI agent task \n
+        returns a object that includes the session ID, task result, and browser instance for continued interaction by the caller. \n
+        This method differs from `task()` by returning control of the browser session to the caller rather than automatically closing it after task completion. \n
+        Args:
+            prompt (str): The task prompt/instruction for the AI agent to execute. \n
+            session_options (Optional[Session], optional): Configuration options for the browser session. Defaults to None, which creates a session with default settings. \n
+            task_options (Optional[AgentTaskParams], optional): Additional task configuration including: \n
+        - output_schema: Schema for structured output formatting
+        - url: URL to navigate to before executing the task
+        - on_agent_step: Callback function for agent step events
+                Defaults to None.
+
+        Returns:
+            Response object containing:
+                - session_id: The ID of the created browser session
+                - task_result_task: The result of the AI agent task execution
+                - playwright_browser: Browser instance for continued interaction
+        """
+        session = await self._client.sessions.create(session=session_options or {})
+        if not session.data or not session.data.id:
+            raise ValueError("Failed to create session: No session ID returned")
+
+        async with BrowserSetup(
+            session_id=session.data.id,
+            base_url=str(self._client.base_url),
+            api_key=self._client.api_key,
+        ) as browser_setup:
+            output_schema = None
+            if task_options:
+                output_schema = task_options.get("output_schema")
+                url = task_options.get("url")
+                if url:
+                    await (await browser_setup.async_page).goto(url)
+                on_agent_step = task_options.get("on_agent_step")
+                if on_agent_step:
+                    on_agent_step_async(on_agent_step, browser_setup)
+            task_payload = create_task_payload(prompt, output_schema)
+            task_result = await (await browser_setup.async_ai).evaluate(task_payload)
+            return BrowserTaskResponse(
+                session_id=session.data.id,
+                task_result_task=task_result,
+                playwright_browser=browser_setup.async_browser_generator,
+            )
+
+
+class AgentResourceWithRawResponse:
+    def __init__(self, agent: AgentResource) -> None:
+        self._agent = agent
+
+        self.task = to_raw_response_wrapper(
+            agent.task,
+        )
+        self.browser_task = to_raw_response_wrapper(
+            agent.browser_task,
+        )
+
+
+class AsyncAgentResourceWithRawResponse:
+    def __init__(self, agent: AsyncAgentResource) -> None:
+        self._agent = agent
+
+        self.task = async_to_raw_response_wrapper(
+            agent.task,
+        )
+        self.browser_task = async_to_raw_response_wrapper(
+            agent.browser_task,
+        )
+
+
+class AgentResourceWithStreamingResponse:
+    def __init__(self, agent: AgentResource) -> None:
+        self._agent = agent
+
+        self.task = to_streamed_response_wrapper(
+            agent.task,
+        )
+        self.browser_task = to_streamed_response_wrapper(
+            agent.browser_task,
+        )
+
+
+class AsyncAgentResourceWithStreamingResponse:
+    def __init__(self, agent: AsyncAgentResource) -> None:
+        self._agent = agent
+
+        self.task = async_to_streamed_response_wrapper(
+            agent.task,
+        )
+        self.browser_task = async_to_streamed_response_wrapper(
+            agent.browser_task,
+        )

anchorbrowser/resources/browser.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from contextlib import _GeneratorContextManager, _AsyncGeneratorContextManager
+
+from playwright.sync_api import Browser
+from playwright.async_api import Browser as AsyncBrowser
+
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ..lib.browser import (
+    get_playwright_chromium_from_cdp_url,
+    get_async_playwright_chromium_from_cdp_url,
+)
+
+__all__ = ["BrowserResource", "AsyncBrowserResource"]
+
+
+class BrowserResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> BrowserResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return BrowserResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BrowserResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return BrowserResourceWithStreamingResponse(self)
+
+    def connect(self, session_id: str) -> _GeneratorContextManager[Browser]:
+        """Connect to a browser session.
+
+        Args:
+            session_id (str): The ID of the session to connect to.
+
+        Returns:
+            BrowserContext: a context manager that can be used to interact with the browser(playwright)
+        """
+        return get_playwright_chromium_from_cdp_url(str(self._client.base_url), session_id, self._client.api_key)
+
+    def create(self) -> _GeneratorContextManager[Browser]:
+        session = self._client.sessions.create()
+        if not session.data or not session.data.id:
+            raise ValueError("Failed to create session")
+        return get_playwright_chromium_from_cdp_url(str(self._client.base_url), session.data.id, self._client.api_key)
+
+
+class AsyncBrowserResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncBrowserResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncBrowserResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBrowserResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return AsyncBrowserResourceWithStreamingResponse(self)
+
+    async def connect(self, session_id: str) -> _AsyncGeneratorContextManager[AsyncBrowser]:
+        """Connect to a browser session.
+
+        Args:
+            session_id (str): The ID of the session to connect to.
+
+        Returns:
+            BrowserContext: a context manager that can be used to interact with the browser(playwright)
+        """
+        return get_async_playwright_chromium_from_cdp_url(str(self._client.base_url), session_id, self._client.api_key)
+
+    async def create(self) -> _AsyncGeneratorContextManager[AsyncBrowser]:
+        """Create a new browser session.
+
+        Returns:
+            BrowserContext: a context manager that can be used to interact with the browser(playwright)
+        """
+        session = await self._client.sessions.create()
+        if not session.data or not session.data.id:
+            raise ValueError("Failed to create session")
+        return get_async_playwright_chromium_from_cdp_url(
+            str(self._client.base_url), session.data.id, self._client.api_key
+        )
+
+
+class BrowserResourceWithRawResponse:
+    def __init__(self, browser: BrowserResource) -> None:
+        self._browser = browser
+
+        self.connect = to_raw_response_wrapper(
+            browser.connect,
+        )
+        self.create = to_raw_response_wrapper(
+            browser.create,
+        )
+
+
+class AsyncBrowserResourceWithRawResponse:
+    def __init__(self, browser: AsyncBrowserResource) -> None:
+        self._browser = browser
+
+        self.connect = async_to_raw_response_wrapper(
+            browser.connect,
+        )
+        self.create = async_to_raw_response_wrapper(
+            browser.create,
+        )
+
+
+class BrowserResourceWithStreamingResponse:
+    def __init__(self, browser: BrowserResource) -> None:
+        self._browser = browser
+
+        self.connect = to_streamed_response_wrapper(
+            browser.connect,
+        )
+        self.create = to_streamed_response_wrapper(
+            browser.create,
+        )
+
+
+class AsyncBrowserResourceWithStreamingResponse:
+    def __init__(self, browser: AsyncBrowserResource) -> None:
+        self._browser = browser
+
+        self.connect = async_to_streamed_response_wrapper(
+            browser.connect,
+        )
+        self.create = async_to_streamed_response_wrapper(
+            browser.create,
+        )

anchorbrowser/types/extension_manifest.py

@@ -1,6 +1,8 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from pydantic import Field as FieldInfo
 
 from .._models import BaseModel
 
@@ -18,6 +20,7 @@ class ExtensionManifest(BaseModel):
 
     version: Optional[str] = None
 
+    __pydantic_extra__: Dict[str, object] = FieldInfo(init=False)  # pyright: ignore[reportIncompatibleVariableOverride]
     if TYPE_CHECKING:
         # Stub to indicate that arbitrary properties are accepted.
         # To access properties that are not valid identifiers you can use `getattr`, e.g.

{anchorbrowser-0.1.0a1.dist-info → anchorbrowser-0.1.0a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: anchorbrowser
-Version: 0.1.0a1
+Version: 0.1.0a2
 Summary: The official Python library for the anchorbrowser API
 Project-URL: Homepage, https://github.com/anchorbrowser/AnchorBrowser-SDK-Python
 Project-URL: Repository, https://github.com/anchorbrowser/AnchorBrowser-SDK-Python
@@ -26,8 +26,10 @@ Requires-Dist: anyio<5,>=3.5.0
 Requires-Dist: distro<2,>=1.7.0
 Requires-Dist: httpx<1,>=0.23.0
 Requires-Dist: pydantic<3,>=1.9.0
+Requires-Dist: pytest-playwright
 Requires-Dist: sniffio
 Requires-Dist: typing-extensions<5,>=4.10
+Requires-Dist: websockets
 Provides-Extra: aiohttp
 Requires-Dist: aiohttp; extra == 'aiohttp'
 Requires-Dist: httpx-aiohttp>=0.1.8; extra == 'aiohttp'

{anchorbrowser-0.1.0a1.dist-info → anchorbrowser-0.1.0a2.dist-info}/RECORD

@@ -1,17 +1,17 @@
 anchorbrowser/__init__.py,sha256=Y9SS6YKjFHc3NR74t9tzppSPjZ4U-zyYI8uPM5r17QU,2682
 anchorbrowser/_base_client.py,sha256=viDcyxFrFwusLXdK0lE6g9hRoB8fBvZcUOQpfSurARs,66929
-anchorbrowser/_client.py,sha256=S3WVCPjrYKZO7b73kGqNpzKZeDEIfngyVNSf8wMt5ZI,16915
+anchorbrowser/_client.py,sha256=xzMIA4NH4atxKHtepaW607dpH1yftDQLSr42CValZ2M,17919
 anchorbrowser/_compat.py,sha256=VWemUKbj6DDkQ-O4baSpHVLJafotzeXmCQGJugfVTIw,6580
 anchorbrowser/_constants.py,sha256=S14PFzyN9-I31wiV7SmIlL5Ga0MLHxdvegInGdXH7tM,462
 anchorbrowser/_exceptions.py,sha256=Qz7WOsYUFZ3bEoN28V-C9Wk-EvYerqP83-fMUINlZKQ,3234
 anchorbrowser/_files.py,sha256=YiRJFxnIpA4R0pnDmFtr_di9nD5txfnUOipc63hvBDs,3634
-anchorbrowser/_models.py,sha256=aRCuUozbf1yNMK9XbMmxcgxDJYogijGTtQEr3g_wbyA,29316
+anchorbrowser/_models.py,sha256=KvjsMfb88XZlFUKVoOxr8OyDj47MhoH2OKqWNEbBhk4,30010
 anchorbrowser/_qs.py,sha256=AOkSz4rHtK4YI3ZU_kzea-zpwBUgEY8WniGmTPyEimc,4846
 anchorbrowser/_resource.py,sha256=7lE1EgpVj5kwckk-27umtigTOf9nKTyRl97cgNwRbRQ,1142
 anchorbrowser/_response.py,sha256=xsiyWOC8LWW-NvbFtZ-MJD4f7eI9RnivKwtKImZ-8o4,28860
 anchorbrowser/_streaming.py,sha256=9uTovnqQkz3LRbIWe9fSWwzB_aI1cX14LvEuMhkEcDI,10128
 anchorbrowser/_types.py,sha256=-8YuIWJ9gV1xWRzK7aR74ryHGMjFtNl5NGZpbuYtPIU,6204
-anchorbrowser/_version.py,sha256=H7EnW4PUznLvRCsBHOvDJ9nrBion45JYEaLEeyBiJfw,173
+anchorbrowser/_version.py,sha256=bq-FIYtBF2Y62oY8DbKdaBTdzcUeJm989xXQKycdEcY,173
 anchorbrowser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anchorbrowser/_utils/__init__.py,sha256=PNZ_QJuzZEgyYXqkO1HVhGkj5IU9bglVUcw7H-Knjzw,2062
 anchorbrowser/_utils/_logs.py,sha256=VECnOdIr_cYELMwV_E72FPDY8f1qoYxASex-FciwPxc,795
@@ -24,7 +24,11 @@ anchorbrowser/_utils/_transform.py,sha256=n7kskEWz6o__aoNvhFoGVyDoalNe6mJwp-g7BW
 anchorbrowser/_utils/_typing.py,sha256=D0DbbNu8GnYQTSICnTSHDGsYXj8TcAKyhejb0XcnjtY,4602
 anchorbrowser/_utils/_utils.py,sha256=ts4CiiuNpFiGB6YMdkQRh2SZvYvsl7mAF-JWHCcLDf4,12312
 anchorbrowser/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
+anchorbrowser/lib/agent.py,sha256=M9Yg00Ogntfy0DZ9UvxLQp27prAYjo-0SrVLaovLM8g,2078
+anchorbrowser/lib/browser.py,sha256=aLsNgZYY-54YMfLW2jN4QjsUzOTv4PtSUMWDlhLUSZA,6069
 anchorbrowser/resources/__init__.py,sha256=fvjfy3JG7uR4Bz-wYI6euyWxCNVFI08v7m9ARGzTaTs,1993
+anchorbrowser/resources/agent.py,sha256=2xAcNfeu9otN6qk0RY4pr6fjNloqKriEQEJW50nJAC4,13052
+anchorbrowser/resources/browser.py,sha256=BB5hq_ayIDL_ziYHq13oj8US3XkHzkoXiGLBm7h9dH0,5548
 anchorbrowser/resources/extensions.py,sha256=Ri4BuoHYV7_iHdCypGPVQ5AgX4FPkzgHFH_TIMWnsBE,15943
 anchorbrowser/resources/profiles.py,sha256=WxuQnGxx8OAmEfl44aJfV-Bnx_XRBnNvs-Ozcfcnj9U,21347
 anchorbrowser/resources/tools.py,sha256=U6kxpmQkHQC3i4-my54R27NA-CBnMEYsZFrudEnxawM,20946
@@ -40,7 +44,7 @@ anchorbrowser/resources/sessions/recordings/recordings.py,sha256=6OXB_m09wPYZGsb
 anchorbrowser/types/__init__.py,sha256=O5J8M3dkfHUoSYFI6zjxoF3Phmajl_M9vROulwJ4xpI,2520
 anchorbrowser/types/extension_delete_response.py,sha256=3ixtvxjz_Ay-Kp8lamJzbIrqKpvfqWui5l13Sr035To,327
 anchorbrowser/types/extension_list_response.py,sha256=-OysuceCBHQLLT8B-zvwtHQDXqx__Zjkkb-gNT58N3Y,876
-anchorbrowser/types/extension_manifest.py,sha256=rAudf0olz_iq2Jxb6ejZU4FXd9p-NDFNs3pNDFZ8_8A,704
+anchorbrowser/types/extension_manifest.py,sha256=rW6mjLODcQ9XHXWh6XBU1Sr_WZD0w8eod4YLH5dXjwc,872
 anchorbrowser/types/extension_retrieve_response.py,sha256=wBpk7gNgAbVf1etsCSrC4JOrKD6c_9HTv2S2FjNiAiM,807
 anchorbrowser/types/extension_upload_params.py,sha256=bBd8BMRVHu6P18jJovVMLPnIzGXGlV8Geb8TdiuGPbQ,470
 anchorbrowser/types/extension_upload_response.py,sha256=ee8KYWIb-AjURMzrtAMNUTjV3Izhj6AB0LeAvR0npvk,868
@@ -90,7 +94,7 @@ anchorbrowser/types/sessions/recording_resume_response.py,sha256=JXGXVLDwcbodSOC
 anchorbrowser/types/sessions/recordings/__init__.py,sha256=OKfJYcKb4NObdiRObqJV_dOyDQ8feXekDUge2o_4pXQ,122
 anchorbrowser/types/shared/__init__.py,sha256=FQKjY3VDxI8T0feNRazdY5TOqb2KDeEwZaoJjsxuEl4,152
 anchorbrowser/types/shared/success_response.py,sha256=l9OWrucXoSjBdsx5QKdvBPFtxv8d0YdpYY6iL5cWWuc,314
-anchorbrowser-0.1.0a1.dist-info/METADATA,sha256=ufUmrcbnkXX99NqYJKaleOTkeEqu9JCw7JUcbO5BeDc,15083
-anchorbrowser-0.1.0a1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-anchorbrowser-0.1.0a1.dist-info/licenses/LICENSE,sha256=QYTH6OztHxnELDn890vME8F7-euzmsHhWI4XOSYxwOg,11343
-anchorbrowser-0.1.0a1.dist-info/RECORD,,
+anchorbrowser-0.1.0a2.dist-info/METADATA,sha256=sJXgogjt-WLPFUGEKcJBDhu5-Srk8iHvd8nLXbyUA3s,15142
+anchorbrowser-0.1.0a2.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+anchorbrowser-0.1.0a2.dist-info/licenses/LICENSE,sha256=QYTH6OztHxnELDn890vME8F7-euzmsHhWI4XOSYxwOg,11343
+anchorbrowser-0.1.0a2.dist-info/RECORD,,