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

examples/dsl_example.py

@@ -0,0 +1,112 @@
+from fleet.verifiers import DatabaseSnapshot, IgnoreConfig
+
+async def validate_give_me_more_tasks(
+    before: DatabaseSnapshot,
+    after: DatabaseSnapshot,
+    transcript: str | None = None,
+) -> int:
+    """Validate that bugs are moved to sprint 3 and assigned correctly."""
+
+    # Get user IDs
+    raj_user = after.table("users").eq("name", "Raj Patel").first()
+    sarah_kim_user = after.table("users").eq("name", "Sarah Kim").first()
+
+    if not raj_user:
+        raise AssertionError("User 'Raj Patel' not found")
+    if not sarah_kim_user:
+        raise AssertionError("User 'Sarah Kim' not found")
+
+    raj_id = raj_user["id"]
+    sarah_kim_id = sarah_kim_user["id"]
+
+    # Verify SCRUM-555 (data pipeline bug) is assigned to Sarah Kim
+    after.table("issues").eq("id", "SCRUM-555").assert_eq("owner", sarah_kim_id)
+
+    # Verify other bugs are assigned to Raj Patel
+    other_bugs = [
+        "SCRUM-780",
+        "SCRUM-781",
+        "SCRUM-790",
+        "SCRUM-822",
+        "SCRUM-882",
+        "SCRUM-897",
+        "SCRUM-956",
+        "SCRUM-1331",
+        "SCRUM-1312",
+        "SCRUM-1210",
+        "SCRUM-1230",
+        "SCRUM-1282",
+    ]
+    for bug_id in other_bugs:
+        after.table("issues").eq("id", bug_id).assert_eq("owner", raj_id)
+
+    # Verify all bugs are in sprint_3
+    all_bugs = ["SCRUM-555"] + other_bugs
+    for bug_id in all_bugs:
+        after.table("sprint_issues").eq("issue_id", bug_id).assert_eq(
+            "sprint_id", "sprint_3"
+        )
+
+    # Configure ignore settings
+    ignore_config = IgnoreConfig(
+        tables={"activities", "pageviews", "sprint_issues"},
+        table_fields={
+            "issues": {"updated_at", "created_at", "rowid"},
+            "users": {"updated_at", "created_at", "rowid"},
+            "sprint_issues": {"updated_at", "created_at", "rowid"},
+        },
+    )
+
+    # Build expected changes
+    expected_changes: list[dict] = []
+
+    # Assignment changes
+    expected_changes.append(
+        {
+            "table": "issues",
+            "pk": "SCRUM-555",
+            "field": "owner",
+            "after": sarah_kim_id,
+        }
+    )
+    for bug_id in other_bugs:
+        expected_changes.append(
+            {
+                "table": "issues",
+                "pk": bug_id,
+                "field": "owner",
+                "after": raj_id,
+            }
+        )
+
+    # Sprint changes
+    for bug_id in all_bugs:
+        # Remove from previous sprint if present
+        before_assignment = (
+            before.table("sprint_issues").eq("issue_id", bug_id).first()
+        )
+        if before_assignment:
+            old_sprint = before_assignment.get("sprint_id")
+            expected_changes.append(
+                {
+                    "table": "sprint_issues",
+                    "pk": (old_sprint, bug_id),
+                    "field": None,
+                    "after": "__removed__",
+                }
+            )
+
+        # Add to sprint_3
+        expected_changes.append(
+            {
+                "table": "sprint_issues",
+                "pk": ("sprint_3", bug_id),
+                "field": None,
+                "after": "__added__",
+            }
+        )
+
+    # Enforce invariant
+    before.diff(after, ignore_config).expect_only(expected_changes)
+
+    return TASK_SUCCESSFUL_SCORE

examples/example.py

@@ -6,45 +6,32 @@ import fleet as flt
 
 
 async def main():
-    fleet = flt.AsyncFleet()
-
-    environments = await fleet.list_envs()
+    environments = await flt.env.list_envs()
     print("Environments:", len(environments))
 
     # Create a new instance
-    instance = await fleet.make(
-        flt.InstanceRequest(env_key="hubspot", version="v1.2.7")
-    )
-    print("New Instance:", instance.instance_id)
-
-    environment = await fleet.environment(instance.env_key)
-    print("Environment Default Version:", environment.default_version)
+    env = await flt.env.make("hubspot:v1.2.7")
+    print("New Instance:", env.instance_id)
 
-    response = await instance.env.reset(flt.ResetRequest(seed=42))
+    response = await env.reset(seed=42)
     print("Reset response:", response)
 
-    print(await instance.env.resources())
+    print(await env.resources())
 
-    sqlite = instance.env.db("current")
+    sqlite = env.db()
     print("SQLite:", await sqlite.describe())
 
     print("Query:", await sqlite.query("SELECT * FROM users"))
 
-    sqlite = await instance.env.state("sqlite://current").describe()
+    sqlite = await env.state("sqlite://current").describe()
     print("SQLite:", sqlite)
 
-    await instance.env.browser("cdp").start(
-        flt.ChromeStartRequest(resolution="1920,1080")
-    )
-
-    browser = await instance.env.browser("cdp").describe()
-    print("CDP Page URL:", browser.cdp_page_url)
-    print("CDP Browser URL:", browser.cdp_browser_url)
-    print("CDP Devtools URL:", browser.cdp_devtools_url)
+    browser = env.browser()
+    print("CDP URL:", await browser.cdp_url())
+    print("Devtools URL:", await browser.devtools_url())
 
     # Delete the instance
-    instance = await fleet.delete(instance.instance_id)
-    print("Instance deleted:", instance.terminated_at)
+    await env.close()
 
 
 if __name__ == "__main__":

examples/openai_example.py

@@ -1,7 +1,65 @@
-import time
 import base64
-from typing import List, Dict, Callable
-from playwright.sync_api import sync_playwright, Browser, Page
+from typing import List, Dict, Callable, Optional
+from playwright.async_api import async_playwright, Browser, Page
+import httpx
+import json
+import io
+from io import BytesIO
+from PIL import Image
+import os
+import asyncio
+import fleet as flt
+
+
+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
+
+
+async def create_response(**kwargs):
+    url = "https://api.openai.com/v1/responses"
+    headers = {
+        "Authorization": f"Bearer {os.getenv('OPENAI_API_KEY')}",
+        "Content-Type": "application/json",
+    }
+
+    openai_org = os.getenv("OPENAI_ORG")
+    if openai_org:
+        headers["Openai-Organization"] = openai_org
+
+    # Configure timeout: 30 seconds for connect, 60 seconds for read
+    timeout = httpx.Timeout(connect=60.0, read=60.0, write=60.0, pool=60.0)
+
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        response = await client.post(url, headers=headers, json=kwargs)
+
+        if response.status_code != 200:
+            print(f"Error: {response.status_code} {response.text}")
+
+        return response.json()
+
+
+def pp(obj):
+    print(json.dumps(obj, indent=4))
+
+
+def show_image(base_64_image):
+    image_data = base64.b64decode(base_64_image)
+    image = Image.open(BytesIO(image_data))
+    image.show()
+
+
+def calculate_image_dimensions(base_64_image):
+    image_data = base64.b64decode(base_64_image)
+    image = Image.open(io.BytesIO(image_data))
+    return image.size
+
 
 # Optional: key mapping if your model uses "CUA" style keys
 CUA_KEY_TO_PLAYWRIGHT_KEY = {
@@ -48,136 +106,147 @@ class BasePlaywrightComputer:
         return "browser"
 
     def get_dimensions(self):
-        return (1024, 768)
+        return (1920, 1080)
 
     def __init__(self):
         self._playwright = None
         self._browser: Browser | None = None
         self._page: Page | None = None
 
-    def __enter__(self):
+    async def __aenter__(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()
+        self._playwright = await async_playwright().start()
+        self._browser, self._page = await self._get_browser_and_page()
 
         # Set up network interception to flag URLs matching domains in BLOCKED_DOMAINS
-        def handle_route(route, request):
-            route.continue_()
+        async def handle_route(route, request):
+            await route.continue_()
 
-        self._page.route("**/*", handle_route)
+        await self._page.route("**/*", handle_route)
 
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if self._browser:
-            self._browser.close()
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        # if self._browser:
+        #     await self._browser.close()
         if self._playwright:
-            self._playwright.stop()
+            await self._playwright.stop()
 
     def get_current_url(self) -> str:
         return self._page.url
 
     # --- Common "Computer" actions ---
-    def screenshot(self) -> str:
+    async def screenshot(self) -> str:
         """Capture only the viewport (not full_page)."""
-        png_bytes = self._page.screenshot(full_page=False)
+        png_bytes = await 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:
+    async def click(self, x: int, y: int, button: str = "left") -> None:
         if button == "back":
-            self.back()
+            await self.back()
         elif button == "forward":
-            self.forward()
+            await self.forward()
         elif button == "wheel":
-            self._page.mouse.wheel(x, y)
+            await 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)
+            await self._page.mouse.click(x, y, button=button_type)
 
-    def double_click(self, x: int, y: int) -> None:
-        self._page.mouse.dblclick(x, y)
+    async def double_click(self, x: int, y: int) -> None:
+        await 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})")
+    async def scroll(self, x: int, y: int, scroll_x: int, scroll_y: int) -> None:
+        await self._page.mouse.move(x, y)
+        await self._page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
 
-    def type(self, text: str) -> None:
-        self._page.keyboard.type(text)
+    async def type(self, text: str) -> None:
+        await self._page.keyboard.type(text)
 
-    def wait(self, ms: int = 1000) -> None:
-        time.sleep(ms / 1000)
+    async def wait(self, ms: int = 1000) -> None:
+        await asyncio.sleep(ms / 1000)
 
-    def move(self, x: int, y: int) -> None:
-        self._page.mouse.move(x, y)
+    async def move(self, x: int, y: int) -> None:
+        await self._page.mouse.move(x, y)
 
-    def keypress(self, keys: List[str]) -> None:
+    async 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)
+            await self._page.keyboard.down(key)
         for key in reversed(mapped_keys):
-            self._page.keyboard.up(key)
+            await self._page.keyboard.up(key)
 
-    def drag(self, path: List[Dict[str, int]]) -> None:
+    async 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()
+        await self._page.mouse.move(path[0]["x"], path[0]["y"])
+        await self._page.mouse.down()
         for point in path[1:]:
-            self._page.mouse.move(point["x"], point["y"])
-        self._page.mouse.up()
+            await self._page.mouse.move(point["x"], point["y"])
+        await self._page.mouse.up()
 
     # --- Extra browser-oriented actions ---
-    def goto(self, url: str) -> None:
+    async def goto(self, url: str) -> None:
         try:
-            return self._page.goto(url)
+            return await self._page.goto(url)
         except Exception as e:
             print(f"Error navigating to {url}: {e}")
 
-    def back(self) -> None:
-        return self._page.go_back()
+    async def back(self) -> None:
+        return await self._page.go_back()
 
-    def forward(self) -> None:
-        return self._page.go_forward()
+    async def forward(self) -> None:
+        return await self._page.go_forward()
 
     # --- Subclass hook ---
-    def _get_browser_and_page(self) -> tuple[Browser, Page]:
+    async def _get_browser_and_page(self) -> tuple[Browser, Page]:
         """Subclasses must implement, returning (Browser, Page)."""
         raise NotImplementedError
 
 
-class LocalPlaywrightBrowser(BasePlaywrightComputer):
+class FleetPlaywrightBrowser(BasePlaywrightComputer):
     """Launches a local Chromium instance using Playwright."""
 
-    def __init__(self, headless: bool = False):
+    def __init__(
+        self,
+        fleet: flt.AsyncFleet,
+        env_key: str,
+        version: Optional[str] = None,
+        headless: bool = False,
+    ):
         super().__init__()
+        self.fleet = fleet
+        self.env_key = env_key
+        self.version = version
         self.headless = headless
 
-    def _get_browser_and_page(self) -> tuple[Browser, Page]:
+    async 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"},
+
+        # Create an instance of the environment
+        print(f"Creating instance of {self.env_key} {self.version}...")
+        self.instance = await self.fleet.make(
+            flt.InstanceRequest(env_key=self.env_key, version=self.version)
         )
 
-        context = browser.new_context()
+        # Start the browser
+        print("Starting browser...")
+        await self.instance.env.browser("cdp").start()
+        print("Getting CDP URL...")
+        cdp = await self.instance.env.browser("cdp").describe()
+        print("DevTools URL:", cdp.cdp_devtools_url)
+
+        # Connect to the browser
+        browser = await self._playwright.chromium.connect_over_cdp(cdp.cdp_browser_url)
 
         # Add event listeners for page creation and closure
+        context = browser.contexts[0]
         context.on("page", self._handle_new_page)
 
-        page = context.new_page()
-        page.set_viewport_size({"width": width, "height": height})
+        page = context.pages[0]
+        await page.set_viewport_size({"width": width, "height": height})
         page.on("close", self._handle_page_close)
 
-        page.goto("https://bing.com")
-
         return browser, page
 
     def _handle_new_page(self, page: Page):
@@ -207,7 +276,7 @@ class Agent:
     def __init__(
         self,
         model="computer-use-preview",
-        computer: Computer = None,
+        computer: FleetPlaywrightBrowser = None,
         tools: list[dict] = [],
         acknowledge_safety_check_callback: Callable = lambda: False,
     ):
@@ -234,8 +303,11 @@ class Agent:
         if self.debug:
             pp(*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 +319,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,9 +336,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()
+            screenshot_base64 = await self.computer.screenshot()
             if self.show_images:
                 show_image(screenshot_base64)
 
@@ -292,13 +364,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,7 +381,7 @@ 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(
+            response = await create_response(
                 model=self.model,
                 input=input_items + new_items,
                 tools=self.tools,
@@ -318,12 +389,60 @@ class Agent:
             )
             self.debug_print(response)
 
-            if "output" not in response and self.debug:
-                print(response)
-                raise ValueError("No output from model")
+            if "output" not in response:
+                if self.debug:
+                    print("Full response:", response)
+                if "error" in response:
+                    error_msg = response["error"].get("message", "Unknown error")
+                    raise ValueError(f"API Error: {error_msg}")
+                else:
+                    raise ValueError("No output from model")
             else:
-                new_items += response["output"]
+                # 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["output"]:
-                    new_items += self.handle_item(item)
+                    # 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():
+    fleet = flt.AsyncFleet()
+
+    async with FleetPlaywrightBrowser(fleet, "hubspot", "v1.2.7") as computer:
+        agent = Agent(computer=computer, tools=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:
+            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
+
+
+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.manager.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.manager.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.manager.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.manager.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.manager.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,7 @@ from .exceptions import (
     FleetConfigurationError,
 )
 from .client import Fleet, AsyncFleet, InstanceRequest
-from .env import (
+from .manager import (
     ResetRequest,
     ResetResponse,
     CDPDescribeResponse,
@@ -29,6 +29,8 @@ from .env import (
     ChromeStartResponse,
     ChromeStatusResponse,
 )
+from .verifiers import *
+from . import env
 
 __version__ = "0.1.1"
 __all__ = [

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}"