fleet-python 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

examples/openai_example.py

@@ -1,241 +1,60 @@
-import time
-import base64
-from typing import List, Dict, Callable
-from playwright.sync_api import sync_playwright, Browser, Page
-
-# Optional: key mapping if your model uses "CUA" style keys
-CUA_KEY_TO_PLAYWRIGHT_KEY = {
-    "/": "Divide",
-    "\\": "Backslash",
-    "alt": "Alt",
-    "arrowdown": "ArrowDown",
-    "arrowleft": "ArrowLeft",
-    "arrowright": "ArrowRight",
-    "arrowup": "ArrowUp",
-    "backspace": "Backspace",
-    "capslock": "CapsLock",
-    "cmd": "Meta",
-    "ctrl": "Control",
-    "delete": "Delete",
-    "end": "End",
-    "enter": "Enter",
-    "esc": "Escape",
-    "home": "Home",
-    "insert": "Insert",
-    "option": "Alt",
-    "pagedown": "PageDown",
-    "pageup": "PageUp",
-    "shift": "Shift",
-    "space": " ",
-    "super": "Meta",
-    "tab": "Tab",
-    "win": "Meta",
-}
-
-
-class BasePlaywrightComputer:
-    """
-    Abstract base for Playwright-based computers:
-
-      - Subclasses override `_get_browser_and_page()` to do local or remote connection,
-        returning (Browser, Page).
-      - This base class handles context creation (`__enter__`/`__exit__`),
-        plus standard "Computer" actions like click, scroll, etc.
-      - We also have extra browser actions: `goto(url)` and `back()`.
-    """
-
-    def get_environment(self):
-        return "browser"
-
-    def get_dimensions(self):
-        return (1024, 768)
-
-    def __init__(self):
-        self._playwright = None
-        self._browser: Browser | None = None
-        self._page: Page | None = None
-
-    def __enter__(self):
-        # Start Playwright and call the subclass hook for getting browser/page
-        self._playwright = sync_playwright().start()
-        self._browser, self._page = self._get_browser_and_page()
-
-        # Set up network interception to flag URLs matching domains in BLOCKED_DOMAINS
-        def handle_route(route, request):
-            route.continue_()
-
-        self._page.route("**/*", handle_route)
-
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if self._browser:
-            self._browser.close()
-        if self._playwright:
-            self._playwright.stop()
-
-    def get_current_url(self) -> str:
-        return self._page.url
-
-    # --- Common "Computer" actions ---
-    def screenshot(self) -> str:
-        """Capture only the viewport (not full_page)."""
-        png_bytes = self._page.screenshot(full_page=False)
-        return base64.b64encode(png_bytes).decode("utf-8")
-
-    def click(self, x: int, y: int, button: str = "left") -> None:
-        if button == "back":
-            self.back()
-        elif button == "forward":
-            self.forward()
-        elif button == "wheel":
-            self._page.mouse.wheel(x, y)
-        else:
-            button_mapping = {"left": "left", "right": "right"}
-            button_type = button_mapping.get(button, "left")
-            self._page.mouse.click(x, y, button=button_type)
-
-    def double_click(self, x: int, y: int) -> None:
-        self._page.mouse.dblclick(x, y)
-
-    def scroll(self, x: int, y: int, scroll_x: int, scroll_y: int) -> None:
-        self._page.mouse.move(x, y)
-        self._page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
-
-    def type(self, text: str) -> None:
-        self._page.keyboard.type(text)
-
-    def wait(self, ms: int = 1000) -> None:
-        time.sleep(ms / 1000)
-
-    def move(self, x: int, y: int) -> None:
-        self._page.mouse.move(x, y)
-
-    def keypress(self, keys: List[str]) -> None:
-        mapped_keys = [CUA_KEY_TO_PLAYWRIGHT_KEY.get(key.lower(), key) for key in keys]
-        for key in mapped_keys:
-            self._page.keyboard.down(key)
-        for key in reversed(mapped_keys):
-            self._page.keyboard.up(key)
-
-    def drag(self, path: List[Dict[str, int]]) -> None:
-        if not path:
-            return
-        self._page.mouse.move(path[0]["x"], path[0]["y"])
-        self._page.mouse.down()
-        for point in path[1:]:
-            self._page.mouse.move(point["x"], point["y"])
-        self._page.mouse.up()
-
-    # --- Extra browser-oriented actions ---
-    def goto(self, url: str) -> None:
-        try:
-            return self._page.goto(url)
-        except Exception as e:
-            print(f"Error navigating to {url}: {e}")
-
-    def back(self) -> None:
-        return self._page.go_back()
-
-    def forward(self) -> None:
-        return self._page.go_forward()
-
-    # --- Subclass hook ---
-    def _get_browser_and_page(self) -> tuple[Browser, Page]:
-        """Subclasses must implement, returning (Browser, Page)."""
-        raise NotImplementedError
-
-
-class LocalPlaywrightBrowser(BasePlaywrightComputer):
-    """Launches a local Chromium instance using Playwright."""
-
-    def __init__(self, headless: bool = False):
-        super().__init__()
-        self.headless = headless
-
-    def _get_browser_and_page(self) -> tuple[Browser, Page]:
-        width, height = self.get_dimensions()
-        launch_args = [
-            f"--window-size={width},{height}",
-            "--disable-extensions",
-            "--disable-file-system",
-        ]
-        browser = self._playwright.chromium.launch(
-            chromium_sandbox=True,
-            headless=self.headless,
-            args=launch_args,
-            env={"DISPLAY": ":0"},
-        )
-
-        context = browser.new_context()
-
-        # Add event listeners for page creation and closure
-        context.on("page", self._handle_new_page)
+import asyncio
+from openai import AsyncOpenAI
+import fleet as flt
+import json
+from typing import Callable
 
-        page = context.new_page()
-        page.set_viewport_size({"width": width, "height": height})
-        page.on("close", self._handle_page_close)
 
-        page.goto("https://bing.com")
+client = AsyncOpenAI()
 
-        return browser, page
 
-    def _handle_new_page(self, page: Page):
-        """Handle the creation of a new page."""
-        print("New page created")
-        self._page = page
-        page.on("close", self._handle_page_close)
-
-    def _handle_page_close(self, page: Page):
-        """Handle the closure of a page."""
-        print("Page closed")
-        if self._page == page:
-            if self._browser.contexts[0].pages:
-                self._page = self._browser.contexts[0].pages[-1]
-            else:
-                print("Warning: All pages have been closed.")
-                self._page = None
+def sanitize_message(msg: dict) -> dict:
+    """Return a copy of the message with image_url omitted for computer_call_output messages."""
+    if msg.get("type") == "computer_call_output":
+        output = msg.get("output", {})
+        if isinstance(output, dict):
+            sanitized = msg.copy()
+            sanitized["output"] = {**output, "image_url": "[omitted]"}
+            return sanitized
+    return msg
 
 
 class Agent:
-    """
-    A sample agent class that can be used to interact with a computer.
-
-    (See simple_cua_loop.py for a simple example without an agent.)
-    """
-
     def __init__(
         self,
+        browser,
         model="computer-use-preview",
-        computer: Computer = None,
         tools: list[dict] = [],
         acknowledge_safety_check_callback: Callable = lambda: False,
     ):
         self.model = model
-        self.computer = computer
+        self.computer = browser
         self.tools = tools
         self.print_steps = True
         self.debug = False
         self.show_images = False
         self.acknowledge_safety_check_callback = acknowledge_safety_check_callback
 
-        if computer:
-            dimensions = computer.get_dimensions()
+        if browser:
+            dimensions = browser.get_dimensions()
             self.tools += [
                 {
                     "type": "computer-preview",
                     "display_width": dimensions[0],
                     "display_height": dimensions[1],
-                    "environment": computer.get_environment(),
+                    "environment": browser.get_environment(),
                 },
             ]
 
     def debug_print(self, *args):
         if self.debug:
-            pp(*args)
+            print(*args)
 
-    def handle_item(self, item):
+    async def handle_item(self, item):
         """Handle each item; may cause a computer action + screenshot."""
+        if self.debug:
+            print(f"Handling item of type: {item.get('type')}")
+
         if item["type"] == "message":
             if self.print_steps:
                 print(item["content"][0]["text"])
@@ -247,7 +66,7 @@ class Agent:
 
             if hasattr(self.computer, name):  # if function exists on computer, call it
                 method = getattr(self.computer, name)
-                method(**args)
+                await method(**args)
             return [
                 {
                     "type": "function_call_output",
@@ -264,11 +83,9 @@ class Agent:
                 print(f"{action_type}({action_args})")
 
             method = getattr(self.computer, action_type)
-            method(**action_args)
+            await method(**action_args)
 
-            screenshot_base64 = self.computer.screenshot()
-            if self.show_images:
-                show_image(screenshot_base64)
+            screenshot_base64 = await self.computer.screenshot()
 
             # if user doesn't ack all safety checks exit with error
             pending_checks = item.get("pending_safety_checks", [])
@@ -292,13 +109,12 @@ class Agent:
             # additional URL safety checks for browser environments
             if self.computer.get_environment() == "browser":
                 current_url = self.computer.get_current_url()
-                check_blocklisted_url(current_url)
                 call_output["output"]["current_url"] = current_url
 
             return [call_output]
         return []
 
-    def run_full_turn(
+    async def run_full_turn(
         self, input_items, print_steps=True, debug=False, show_images=False
     ):
         self.print_steps = print_steps
@@ -310,20 +126,108 @@ class Agent:
         while new_items[-1].get("role") != "assistant" if new_items else True:
             self.debug_print([sanitize_message(msg) for msg in input_items + new_items])
 
-            response = create_response(
+            # The Responses API rejects unknown keys (e.g. `status`, `encrypted_content`).
+            # Strip them from every item before sending.
+            def _clean_item(msg: dict) -> dict:
+                unwanted_keys = {"status", "encrypted_content"}
+                return {k: v for k, v in msg.items() if k not in unwanted_keys}
+
+            clean_input = [_clean_item(m) for m in (input_items + new_items)]
+
+            response = await client.responses.create(
                 model=self.model,
-                input=input_items + new_items,
+                input=clean_input,
                 tools=self.tools,
                 truncation="auto",
             )
-            self.debug_print(response)
 
-            if "output" not in response and self.debug:
-                print(response)
-                raise ValueError("No output from model")
-            else:
-                new_items += response["output"]
-                for item in response["output"]:
-                    new_items += self.handle_item(item)
+            # The OpenAI SDK returns a Pydantic model object, not a plain dict.
+            # Convert it to a standard Python dict so the rest of the code can
+            # remain unchanged from the previous implementation.
+            response_dict = (
+                response.model_dump()  # pydantic v2
+                if hasattr(response, "model_dump")
+                else (
+                    response.to_dict_recursive()
+                    if hasattr(response, "to_dict_recursive")
+                    else dict(response)
+                )
+            )
+            self.debug_print(response_dict)
+
+            # Guard against missing/empty output in the response
+            if not response_dict.get("output"):
+                if self.debug:
+                    print("Full response:", response_dict)
+                if response_dict.get("error") is not None:
+                    error_msg = response_dict["error"].get("message", "Unknown error")
+                    raise ValueError(f"API Error: {error_msg}")
+                else:
+                    raise ValueError("No output from model")
+
+            # Append each item from the model output to conversation history
+            # in the exact order we received them, **without filtering** so that
+            # required pairs such as reasoning → computer_call are preserved.
+            for item in response_dict["output"]:
+                # First, record the original item itself.
+                new_items.append(item)
+
+                # Next, perform any local side-effects (browser actions, etc.).
+                handled_items = await self.handle_item(item)
+
+                # If the handler generated additional items (e.g. computer_call_output)
+                # we append those *immediately* so the order remains:
+                #   reasoning → computer_call → computer_call_output
+                if handled_items:
+                    new_items += handled_items
 
         return new_items
+
+
+tools = []
+
+
+async def ainput(prompt: str = "") -> str:
+    """Async version of input()"""
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, input, prompt)
+
+
+async def main():
+    # Create a Fleet environment instance
+    instance = await flt.env.make("hubspot")
+
+    # Create the Playwright wrapper
+    browser = flt.FleetPlaywrightWrapper(instance)
+    await browser.start()
+
+    try:
+        agent = Agent(browser, model="computer-use-preview", tools=[])
+        items = [
+            {
+                "role": "developer",
+                "content": "You have access to a clone of Hubspot. You can use the computer to navigate the browser and perform actions.",
+            }
+        ]
+
+        while True:
+            try:
+                user_input = await ainput("> ")
+                items.append({"role": "user", "content": user_input})
+                output_items = await agent.run_full_turn(
+                    items, show_images=False, debug=False
+                )
+                items += output_items
+            except (EOFError, KeyboardInterrupt):
+                print("\nShutting down...")
+                break
+            except Exception as e:
+                print(f"Error during interaction: {e}")
+                # Continue the loop for other errors
+    finally:
+        await browser.close()
+        await instance.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/openai_simple_example.py

@@ -0,0 +1,61 @@
+import asyncio
+from openai import AsyncOpenAI
+import fleet as flt
+
+client = AsyncOpenAI()
+
+
+async def main():
+    instance = await flt.env.make("hubspot")
+
+    browser = flt.FleetPlaywrightWrapper(instance)
+    await browser.start()
+
+    try:
+        width, height = browser.get_dimensions()
+        tools = [
+            {
+                "type": "computer-preview",
+                "display_width": width,
+                "display_height": height,
+                "environment": browser.get_environment(),
+            }
+        ]
+
+        response = await client.responses.create(
+            model="computer-use-preview",
+            input=[
+                {
+                    "role": "developer",
+                    "content": "Create a HubSpot deal",
+                }
+            ],
+            tools=tools,
+            truncation="auto",
+        )
+
+        if len(response.output) != 0:
+            if response.output[0].type == "message":
+                print(response.output[0].content[0].text)
+
+            if response.output[0].type == "computer_call":
+                action = response.output[0].action
+                if action.type == "screenshot":
+                    screenshot_base64 = await browser.screenshot()
+                    result = {
+                        "type": "input_image",
+                        "image_url": f"data:image/png;base64,{screenshot_base64}",
+                        "current_url": browser.get_current_url(),
+                    }
+                else:
+                    result = await browser.execute_computer_action(action)
+
+                print("Computer action result:")
+                print(result)
+    finally:
+        await browser.close()
+        await instance.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/quickstart.py

@@ -35,7 +35,7 @@ async def main():
     # 1. List available environments
     print("\n📋 Available environments:")
     try:
-        environments = await fleet.env.list_envs()
+        environments = await fleet.instance.list_envs()
         for env in environments:
             print(f"  - {env.env_key}: {env.name}")
             print(f"    Description: {env.description}")
@@ -48,7 +48,7 @@ async def main():
     # 2. Create a new environment instance
     print("\n🚀 Creating new environment...")
     try:
-        env = await fleet.env.make("fira:v1.2.5", region="us-west-1")
+        env = await fleet.instance.make("fira:v1.2.5", region="us-west-1")
         print(f"✅ Environment created with instance ID: {env.instance_id}")
         
         # Execute a simple action
@@ -85,7 +85,7 @@ async def main():
     # 3. List running instances
     print("\n🏃 Listing running instances...")
     try:
-        instances = await fleet.env.list_instances(status="running")
+        instances = await fleet.instance.list_instances(status="running")
         if instances:
             print(f"Found {len(instances)} running instances:")
             for instance in instances:
@@ -99,13 +99,13 @@ async def main():
     print("\n🔗 Connecting to existing instance...")
     try:
         # Only get running instances
-        running_instances = await fleet.env.list_instances(status="running")
+        running_instances = await fleet.instance.list_instances(status="running")
         if running_instances:
             # Find a running instance that's not the one we just created/deleted
             target_instance = running_instances[0]
             print(f"Connecting to running instance: {target_instance.instance_id}")
             
-            env = await fleet.env.get(target_instance.instance_id)
+            env = await fleet.instance.get(target_instance.instance_id)
             print(f"✅ Connected to instance: {env.instance_id}")
             
             # Execute an action on the existing instance

fleet/__init__.py

@@ -21,7 +21,8 @@ from .exceptions import (
     FleetConfigurationError,
 )
 from .client import Fleet, AsyncFleet, InstanceRequest
-from .env import (
+from .instance import (
+    AsyncInstanceClient,
     ResetRequest,
     ResetResponse,
     CDPDescribeResponse,
@@ -29,6 +30,16 @@ from .env import (
     ChromeStartResponse,
     ChromeStatusResponse,
 )
+from .verifiers import *
+from . import env
+
+# Optional playwright integration
+try:
+    from .playwright import FleetPlaywrightWrapper
+    _PLAYWRIGHT_AVAILABLE = True
+except ImportError:
+    FleetPlaywrightWrapper = None
+    _PLAYWRIGHT_AVAILABLE = False
 
 __version__ = "0.1.1"
 __all__ = [
@@ -39,6 +50,7 @@ __all__ = [
     "FleetConfigurationError",
     "Fleet",
     "AsyncFleet",
+    "AsyncInstanceClient",
     "InstanceRequest",
     "ResetRequest",
     "ResetResponse",
@@ -47,3 +59,7 @@ __all__ = [
     "ChromeStartResponse",
     "ChromeStatusResponse",
 ]
+
+# Add playwright wrapper to exports if available
+if _PLAYWRIGHT_AVAILABLE:
+    __all__.append("FleetPlaywrightWrapper")

fleet/base.py

@@ -4,7 +4,7 @@ from typing import Dict, Any, Optional
 from .models import InstanceResponse
 
 
-class InstanceBase(InstanceResponse):
+class EnvironmentBase(InstanceResponse):
     @property
     def manager_url(self) -> str:
         return f"{self.urls.manager.api}"