meshagent-computers 0.0.37__tar.gz → 0.0.39__tar.gz

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.0.39]
+- Stability
+
+## [0.0.38]
+- Stability
+
 ## [0.0.37]
 - Stability
 

meshagent_computers-0.0.39/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: meshagent-computers
+Version: 0.0.39
+Summary: Computer Building Blocks for Meshagent
+License-Expression: Apache-2.0
+Project-URL: Documentation, https://docs.meshagent.com
+Project-URL: Website, https://www.meshagent.com
+Project-URL: Source, https://www.meshagent.com
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest~=8.4
+Requires-Dist: pytest-asyncio~=0.26
+Requires-Dist: openai~=1.86
+Requires-Dist: meshagent-api~=0.0.39
+Requires-Dist: meshagent-agents~=0.0.39
+Requires-Dist: meshagent-tools~=0.0.39
+Requires-Dist: playwright~=1.51
+Requires-Dist: browserbase~=1.2
+Requires-Dist: scrapybara~=2.4
+Dynamic: license-file
+
+## MeshAgent Computers
+
+The ``meshagent.computers`` package defines abstractions for controlling browsers and operating systems and providing these abilities to agents. 
+
+### ComputerAgent
+The ComputerAgent in `meshagent-computers` extends the ``ChatBot`` with support for using browsers and computers. The computer agent will periodically send screenshots to participants on the thread using the MeshAgent messaging protocol, by sending a message of the type "computer_screen" and an attachment that contains a binary screenshot. 
+
+```Python Python
+from meshagent.api import RequiredToolkit
+from meshagent.openai import OpenAIResponsesAdapter
+from meshagent.computers import ComputerAgent, BrowserbaseBrowser, Operator
+from meshagent.api.services import ServiceHost
+
+service = ServiceHost()
+
+@service.path("/computeragent")
+class BrowserbaseAgent(ComputerAgent):
+    def __init__(self):
+        super().__init__(
+            name="meshagent.browser",
+            title="browser agent",
+            description="a task runner that can use a browser",
+            requires=[RequiredToolkit(name="ui", tools=[])],
+            llm_adapter=OpenAIResponsesAdapter(
+                model="computer-use-preview",
+                response_options={"reasoning": {"generate_summary": "concise"}, "truncation": "auto"},
+            ),
+            labels=["tasks", "computers"],
+            computer_cls=BrowserbaseBrowser,
+            operator_cls=Operator
+        )
+
+asyncio.run(service.run())
+```
+
+---
+### Learn more about MeshAgent on our website or check out the docs for additional examples!
+
+**Website**: [www.meshagent.com](https://www.meshagent.com/)
+
+**Documentation**: [docs.meshagent.com](https://docs.meshagent.com/)
+
+---

meshagent_computers-0.0.39/README.md

@@ -0,0 +1,43 @@
+## MeshAgent Computers
+
+The ``meshagent.computers`` package defines abstractions for controlling browsers and operating systems and providing these abilities to agents. 
+
+### ComputerAgent
+The ComputerAgent in `meshagent-computers` extends the ``ChatBot`` with support for using browsers and computers. The computer agent will periodically send screenshots to participants on the thread using the MeshAgent messaging protocol, by sending a message of the type "computer_screen" and an attachment that contains a binary screenshot. 
+
+```Python Python
+from meshagent.api import RequiredToolkit
+from meshagent.openai import OpenAIResponsesAdapter
+from meshagent.computers import ComputerAgent, BrowserbaseBrowser, Operator
+from meshagent.api.services import ServiceHost
+
+service = ServiceHost()
+
+@service.path("/computeragent")
+class BrowserbaseAgent(ComputerAgent):
+    def __init__(self):
+        super().__init__(
+            name="meshagent.browser",
+            title="browser agent",
+            description="a task runner that can use a browser",
+            requires=[RequiredToolkit(name="ui", tools=[])],
+            llm_adapter=OpenAIResponsesAdapter(
+                model="computer-use-preview",
+                response_options={"reasoning": {"generate_summary": "concise"}, "truncation": "auto"},
+            ),
+            labels=["tasks", "computers"],
+            computer_cls=BrowserbaseBrowser,
+            operator_cls=Operator
+        )
+
+asyncio.run(service.run())
+```
+
+---
+### Learn more about MeshAgent on our website or check out the docs for additional examples!
+
+**Website**: [www.meshagent.com](https://www.meshagent.com/)
+
+**Documentation**: [docs.meshagent.com](https://docs.meshagent.com/)
+
+---

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/meshagent/computers/__init__.py

@@ -6,3 +6,16 @@ from .scrapybara import ScrapybaraBrowser, ScrapybaraUbuntu
 from .operator import Operator
 from .agent import ComputerAgent
 from .version import __version__
+
+
+__all__ = [
+    Computer,
+    BrowserbaseBrowser,
+    LocalPlaywrightComputer,
+    DockerComputer,
+    ScrapybaraBrowser,
+    ScrapybaraUbuntu,
+    Operator,
+    ComputerAgent,
+    __version__,
+]

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/meshagent/computers/agent.py

@@ -3,7 +3,6 @@ from meshagent.tools import Tool, Toolkit, ToolContext
 from meshagent.computers import Computer, Operator, BrowserbaseBrowser
 from meshagent.agents.chat import ChatBot, ChatThreadContext
 from meshagent.api import RequiredToolkit, RemoteParticipant
-from meshagent.api.messaging import RawOutputs
 from meshagent.tools.toolkit import register_toolkit_factory
 from meshagent.openai.tools.responses_adapter import OpenAIResponsesTool
 
@@ -14,8 +13,11 @@ import logging
 logger = logging.getLogger("computer")
 logger.setLevel(logging.WARN)
 
+
 class ComputerToolkit(Toolkit):
-    def __init__(self, name: str, computer:Computer, operator: Operator, tools: list[Tool]):
+    def __init__(
+        self, name: str, computer: Computer, operator: Operator, tools: list[Tool]
+    ):
         super().__init__(name=name, tools=tools)
         self.computer = computer
         self.operator = operator
@@ -23,74 +25,80 @@ class ComputerToolkit(Toolkit):
         self._starting = None
 
     async def ensure_started(self):
-
         self.started = False
 
-        if self.started == False:
-            
+        if not self.started:
             self.started = True
             await self.computer.__aenter__()
-            
 
 
-def make_computer_toolkit(*, operator_cls: Type[Operator], computer_cls: Type[Computer], render_screen: Callable[[bytes],None]):
-
+def make_computer_toolkit(
+    *,
+    operator_cls: Type[Operator],
+    computer_cls: Type[Computer],
+    render_screen: Callable[[bytes], None],
+):
     operator = operator_cls()
     computer = computer_cls()
-    
 
     class ComputerTool(OpenAIResponsesTool):
-        def __init__(self, *, operator: Operator, computer: Computer, title = "computer_call", description = "handle computer calls from computer use preview", rules = [], thumbnail_url = None):
+        def __init__(
+            self,
+            *,
+            operator: Operator,
+            computer: Computer,
+            title="computer_call",
+            description="handle computer calls from computer use preview",
+            rules=[],
+            thumbnail_url=None,
+        ):
             super().__init__(
                 name="computer_call",
                 # TODO: give a correct schema
                 title=title,
                 description=description,
                 rules=rules,
-                thumbnail_url=thumbnail_url,                
+                thumbnail_url=thumbnail_url,
             )
             self.computer = computer
 
         def get_open_ai_tool_definitions(self) -> list[dict]:
-            return [ 
+            return [
                 {
                     "type": "computer_use_preview",
                     "display_width": self.computer.dimensions[0],
                     "display_height": self.computer.dimensions[1],
                     "environment": self.computer.environment,
-                } 
-        ]
-                       
+                }
+            ]
+
         def get_open_ai_output_handlers(self):
-            return {
-                "computer_call" : self.handle_computer_call
-            }
+            return {"computer_call": self.handle_computer_call}
 
         async def handle_computer_call(self, context: ToolContext, **arguments):
-            
             outputs = await operator.play(computer=self.computer, item=arguments)
             for output in outputs:
                 if output["type"] == "computer_call_output":
-                    if output["output"] != None:
+                    if output["output"] is not None:
                         if output["output"]["type"] == "input_image":
-                        
-                            b64 : str = output["output"]["image_url"]
+                            b64: str = output["output"]["image_url"]
                             image_data_b64 = b64.split(",", 1)
-                            
+
                             image_bytes = base64.b64decode(image_data_b64[1])
                             render_screen(image_bytes)
-                        
-                        
+
             nonlocal computer_toolkit
             if len(computer_toolkit.tools) == 1:
                 # HACK: after looking at the page, add the other tools,
                 # if we add these first then the computer-use-preview mode fails if it calls them before using the computer
-                computer_toolkit.tools.extend([
-                    ScreenshotTool(computer=computer),
-                    GotoURL(computer=computer),
-                ])
+                computer_toolkit.tools.extend(
+                    [
+                        ScreenshotTool(computer=computer),
+                        GotoURL(computer=computer),
+                    ]
+                )
             return outputs[0]
-        
+
     class ScreenshotTool(Tool):
         def __init__(self, computer: Computer):
             self.computer = computer
@@ -99,23 +107,20 @@ def make_computer_toolkit(*, operator_cls: Type[Operator], computer_cls: Type[Co
                 name="screenshot",
                 # TODO: give a correct schema
                 input_schema={
-                    "additionalProperties" : False,
-                    "type" : "object",
-                    "required" : ["full_page","save_path"],
-                    "properties" : {
-                        "full_page" : {
-                            "type" : "boolean"
+                    "additionalProperties": False,
+                    "type": "object",
+                    "required": ["full_page", "save_path"],
+                    "properties": {
+                        "full_page": {"type": "boolean"},
+                        "save_path": {
+                            "type": "string",
+                            "description": "a file path to save the screenshot to (should end with .png)",
                         },
-                        "save_path" : {
-                            "type" : "string",
-                            "description" : "a file path to save the screenshot to (should end with .png)"
-                        }
-                    }
+                    },
                 },
-                description="take a screenshot of the current page",               
+                description="take a screenshot of the current page",
             )
 
-        
         async def execute(self, context: ToolContext, save_path: str, full_page: bool):
             screenshot_bytes = await self.computer.screenshot_bytes(full_page=full_page)
             handle = await context.room.storage.open(path=save_path, overwrite=True)
@@ -123,7 +128,7 @@ def make_computer_toolkit(*, operator_cls: Type[Operator], computer_cls: Type[Co
             await context.room.storage.close(handle=handle)
 
             return f"saved screenshot to {save_path}"
-        
+
     class GotoURL(Tool):
         def __init__(self, computer: Computer):
             self.computer = computer
@@ -133,61 +138,66 @@ def make_computer_toolkit(*, operator_cls: Type[Operator], computer_cls: Type[Co
                 description="goes to a specific URL. Make sure it starts with http:// or https://",
                 # TODO: give a correct schema
                 input_schema={
-                    "additionalProperties" : False,
-                    "type" : "object",
-                    "required" : ["url"],
-                    "properties" : {
-                        "url" : {
-                            "type" : "string",
+                    "additionalProperties": False,
+                    "type": "object",
+                    "required": ["url"],
+                    "properties": {
+                        "url": {
+                            "type": "string",
                             "description": "Fully qualified URL to navigate to.",
                         }
-                    }
+                    },
                 },
             )
 
-        
         async def execute(self, context: ToolContext, url: str):
-           
-
-            if url.startswith("https://") == False and url.startswith("http://") == False:
-                url = "https://"+url
+            if not url.startswith("https://") and not url.startswith("http://"):
+                url = "https://" + url
 
             await self.computer.goto(url)
 
             render_screen(await self.computer.screenshot_bytes(full_page=False))
 
-
     computer_tool = ComputerTool(computer=computer, operator=operator)
 
-    computer_toolkit = ComputerToolkit(name="meshagent.openai.computer", computer=computer, operator=operator, tools=[
-        computer_tool
-    ])
+    computer_toolkit = ComputerToolkit(
+        name="meshagent.openai.computer",
+        computer=computer,
+        operator=operator,
+        tools=[computer_tool],
+    )
 
     return computer_toolkit
 
+
 async def make_browserbase_toolkit(context: ToolContext, requirement: RequiredToolkit):
-    return make_computer_toolkit(operator_cls=Operator(), computer_cls=BrowserbaseBrowser())
+    return make_computer_toolkit(
+        operator_cls=Operator(), computer_cls=BrowserbaseBrowser()
+    )
+
 
 register_toolkit_factory("browserbase", make_browserbase_toolkit)
 
 
 class ComputerAgent(ChatBot):
-    def __init__(self, *, name, 
-            title=None,
-            description=None,
-            requires=None,
-            labels = None,
-            computer_cls: Type[Computer] = BrowserbaseBrowser,
-            operator_cls: Type[Operator] = Operator,
-            rules: Optional[list[str]] = None,
-            llm_adapter: Optional[LLMAdapter] = None,
-            toolkits: list[Toolkit] = None
-        ):
-
-        if rules == None:
-            rules=[
+    def __init__(
+        self,
+        *,
+        name,
+        title=None,
+        description=None,
+        requires=None,
+        labels=None,
+        computer_cls: Type[Computer] = BrowserbaseBrowser,
+        operator_cls: Type[Operator] = Operator,
+        rules: Optional[list[str]] = None,
+        llm_adapter: Optional[LLMAdapter] = None,
+        toolkits: list[Toolkit] = None,
+    ):
+        if rules is None:
+            rules = [
                 "if asked to go to a URL, you MUST use the goto function to go to the url if it is available",
-                "after going directly to a URL, the screen will change so you should take a look at it to know what to do next"
+                "after going directly to a URL, the screen will change so you should take a look at it to know what to do next",
             ]
         super().__init__(
             name=name,
@@ -197,36 +207,33 @@ class ComputerAgent(ChatBot):
             labels=labels,
             llm_adapter=llm_adapter,
             toolkits=toolkits,
-            rules=rules
+            rules=rules,
         )
         self.computer_cls = computer_cls
         self.operator_cls = operator_cls
 
-    async def get_thread_toolkits(self, *, thread_context: ChatThreadContext, participant: RemoteParticipant):
-        
-        toolkits = await super().get_thread_toolkits(thread_context=thread_context, participant=participant)
+    async def get_thread_toolkits(
+        self, *, thread_context: ChatThreadContext, participant: RemoteParticipant
+    ):
+        toolkits = await super().get_thread_toolkits(
+            thread_context=thread_context, participant=participant
+        )
 
         def render_screen(image_bytes: bytes):
             for participant in thread_context.participants:
                 self.room.messaging.send_message_nowait(
                     to=participant,
                     type="computer_screen",
-                    message={
-                    },
-                    attachment=image_bytes
+                    message={},
+                    attachment=image_bytes,
                 )
-            
+
         computer_toolkit = make_computer_toolkit(
             operator_cls=self.operator_cls,
             computer_cls=self.computer_cls,
-            render_screen=render_screen
+            render_screen=render_screen,
         )
 
         await computer_toolkit.ensure_started()
 
-        return [
-            computer_toolkit,
-            *toolkits
-        ]
-
-
+        return [computer_toolkit, *toolkits]

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/meshagent/computers/base_playwright.py

@@ -61,7 +61,6 @@ class BasePlaywrightComputer:
 
         # Set up network interception to flag URLs matching domains in BLOCKED_DOMAINS
         async def handle_route(route: Route, request: Request):
-
             url = request.url
             if check_blocklisted_url(url):
                 print(f"Flagging blocked domain: {url}")
@@ -79,18 +78,13 @@ class BasePlaywrightComputer:
         if self._playwright:
             await self._context.__aexit__(exc_type, exc_val, exc_tb)
 
-    def get_current_url(self) -> str:
-        if self._page == None:
-            return "about:blank"
-        
     async def ensure_page(self):
         # After a timeout, we might loose our browser
-        if self._page == None or self._browser.is_connected == False:
+        if self._page is None or not self._browser.is_connected:
             self._browser, self._page = await self._get_browser_and_page()
 
     # --- Common "Computer" actions ---
 
-    
     async def screenshot_bytes(self, full_page: bool = False) -> bytes:
         await self.ensure_page()
         png_bytes = await self._page.screenshot(full_page=full_page)
@@ -146,7 +140,7 @@ class BasePlaywrightComputer:
         await self.ensure_page()
         if not path:
             return
-        
+
         await self._page.mouse.move(path[0]["x"], path[0]["y"])
         await self._page.mouse.down()
         for point in path[1:]:

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/meshagent/computers/browserbase.py

@@ -1,10 +1,9 @@
 import os
-from typing import Tuple, Dict, List, Union, Optional
-from playwright.async_api import Browser, Page, BrowserContext, Error as PlaywrightError
+from typing import Tuple
+from playwright.async_api import Browser, Page, Error as PlaywrightError
 from .base_playwright import BasePlaywrightComputer
 from browserbase import AsyncBrowserbase
 from dotenv import load_dotenv
-import base64
 
 load_dotenv()
 
@@ -75,8 +74,7 @@ class BrowserbaseBrowser(BasePlaywrightComputer):
 
         # Connect to the remote session
         browser = await self._playwright.chromium.connect_over_cdp(
-            self.session.connect_url,
-            timeout=60000
+            self.session.connect_url, timeout=60000
         )
         context = browser.contexts[0]
 
@@ -186,12 +184,13 @@ class BrowserbaseBrowser(BasePlaywrightComputer):
             cdp_session = await self._page.context.new_cdp_session(self._page)
 
             # Capture screenshot using CDP
-            result = await cdp_session.send("Page.captureScreenshot", {
-                "format": "png",
-                "fromSurface": True
-            })
+            result = await cdp_session.send(
+                "Page.captureScreenshot", {"format": "png", "fromSurface": True}
+            )
 
-            return result['data']
+            return result["data"]
         except PlaywrightError as error:
-            print(f"CDP screenshot failed, falling back to standard screenshot: {error}")
+            print(
+                f"CDP screenshot failed, falling back to standard screenshot: {error}"
+            )
             return await super().screenshot()

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/meshagent/computers/computer.py

@@ -1,5 +1,5 @@
 from typing import Protocol, List, Literal, Dict
- 
+
 
 class Computer(Protocol):
     """Defines the 'shape' (methods/properties) our loop expects."""
@@ -28,9 +28,9 @@ class Computer(Protocol):
     async def drag(self, path: List[Dict[str, int]]) -> None: ...
 
     async def get_current_url() -> str: ...
-    
-    async def __aenter__(self) -> 'Computer':
+
+    async def __aenter__(self) -> "Computer":
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> 'Computer':
-        return self
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> "Computer":
+        return self

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/meshagent/computers/docker.py

@@ -1,21 +1,20 @@
 import subprocess
 import time
-import shlex
 import asyncio
 
 
 async def _async_check_output(*args, **kwargs):
     proc = await asyncio.create_subprocess_exec(
-        *args,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-        **kwargs
+        *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE, **kwargs
     )
     stdout, stderr = await proc.communicate()
     if proc.returncode != 0:
-        raise subprocess.CalledProcessError(proc.returncode, args, output=stdout, stderr=stderr)
+        raise subprocess.CalledProcessError(
+            proc.returncode, args, output=stdout, stderr=stderr
+        )
     return stdout
 
+
 class DockerComputer:
     environment = "linux"
     dimensions = (1280, 720)  # Default fallback; will be updated in __enter__.
@@ -108,8 +107,7 @@ class DockerComputer:
         #     "base64 /tmp/screenshot.png"
         # )
         cmd = (
-            f"export DISPLAY={self.display} && "
-            "import -window root png:- | base64 -w 0"
+            f"export DISPLAY={self.display} && import -window root png:- | base64 -w 0"
         )
 
         return await self._exec(cmd)
@@ -175,5 +173,7 @@ class DockerComputer:
             f"DISPLAY={self.display} xdotool mousemove {start_x} {start_y} mousedown 1"
         )
         for point in path[1:]:
-            await self._exec(f"DISPLAY={self.display} xdotool mousemove {point['x']} {point['y']}")
+            await self._exec(
+                f"DISPLAY={self.display} xdotool mousemove {point['x']} {point['y']}"
+            )
         await self._exec(f"DISPLAY={self.display} xdotool mouseup 1")

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/meshagent/computers/local_playwright.py

@@ -11,12 +11,13 @@ class LocalPlaywrightComputer(BasePlaywrightComputer):
 
     async def _get_browser_and_page(self) -> tuple[Browser, Page]:
         width, height = self.dimensions
-        launch_args = [f"--window-size={width},{height}", "--disable-extensions", "--disable-file-system"]
+        launch_args = [
+            f"--window-size={width},{height}",
+            "--disable-extensions",
+            "--disable-file-system",
+        ]
         browser = await self._playwright.chromium.launch(
-            chromium_sandbox=True,
-            headless=self.headless,
-            args=launch_args,
-            env={}
+            chromium_sandbox=True, headless=self.headless, args=launch_args, env={}
         )
         page = await browser.new_page()
         await page.set_viewport_size({"width": width, "height": height})

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/meshagent/computers/operator.py

@@ -2,12 +2,13 @@ from .computer import Computer
 from .utils import check_blocklisted_url
 import json
 
+
 class Operator:
     def __init__(self):
         self.print_steps = False
         self.show_images = False
 
-    async def acknowledge_safety_check_callback(self, data: dict): 
+    async def acknowledge_safety_check_callback(self, data: dict):
         return True
 
     async def show_image(self, base_64: str):
@@ -75,4 +76,4 @@ class Operator:
                 call_output["output"]["current_url"] = current_url
 
             return [call_output]
-        return []
+        return []

meshagent_computers-0.0.39/meshagent/computers/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.39"

meshagent_computers-0.0.39/meshagent_computers.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: meshagent-computers
+Version: 0.0.39
+Summary: Computer Building Blocks for Meshagent
+License-Expression: Apache-2.0
+Project-URL: Documentation, https://docs.meshagent.com
+Project-URL: Website, https://www.meshagent.com
+Project-URL: Source, https://www.meshagent.com
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest~=8.4
+Requires-Dist: pytest-asyncio~=0.26
+Requires-Dist: openai~=1.86
+Requires-Dist: meshagent-api~=0.0.39
+Requires-Dist: meshagent-agents~=0.0.39
+Requires-Dist: meshagent-tools~=0.0.39
+Requires-Dist: playwright~=1.51
+Requires-Dist: browserbase~=1.2
+Requires-Dist: scrapybara~=2.4
+Dynamic: license-file
+
+## MeshAgent Computers
+
+The ``meshagent.computers`` package defines abstractions for controlling browsers and operating systems and providing these abilities to agents. 
+
+### ComputerAgent
+The ComputerAgent in `meshagent-computers` extends the ``ChatBot`` with support for using browsers and computers. The computer agent will periodically send screenshots to participants on the thread using the MeshAgent messaging protocol, by sending a message of the type "computer_screen" and an attachment that contains a binary screenshot. 
+
+```Python Python
+from meshagent.api import RequiredToolkit
+from meshagent.openai import OpenAIResponsesAdapter
+from meshagent.computers import ComputerAgent, BrowserbaseBrowser, Operator
+from meshagent.api.services import ServiceHost
+
+service = ServiceHost()
+
+@service.path("/computeragent")
+class BrowserbaseAgent(ComputerAgent):
+    def __init__(self):
+        super().__init__(
+            name="meshagent.browser",
+            title="browser agent",
+            description="a task runner that can use a browser",
+            requires=[RequiredToolkit(name="ui", tools=[])],
+            llm_adapter=OpenAIResponsesAdapter(
+                model="computer-use-preview",
+                response_options={"reasoning": {"generate_summary": "concise"}, "truncation": "auto"},
+            ),
+            labels=["tasks", "computers"],
+            computer_cls=BrowserbaseBrowser,
+            operator_cls=Operator
+        )
+
+asyncio.run(service.run())
+```
+
+---
+### Learn more about MeshAgent on our website or check out the docs for additional examples!
+
+**Website**: [www.meshagent.com](https://www.meshagent.com/)
+
+**Documentation**: [docs.meshagent.com](https://docs.meshagent.com/)
+
+---

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/meshagent_computers.egg-info/requires.txt

@@ -1,9 +1,9 @@
-pytest~=8.3
+pytest~=8.4
 pytest-asyncio~=0.26
 openai~=1.86
-meshagent-api~=0.0.37
-meshagent-agents~=0.0.37
-meshagent-tools~=0.0.37
+meshagent-api~=0.0.39
+meshagent-agents~=0.0.39
+meshagent-tools~=0.0.39
 playwright~=1.51
 browserbase~=1.2
 scrapybara~=2.4

{meshagent_computers-0.0.37 → meshagent_computers-0.0.39}/pyproject.toml

@@ -12,12 +12,12 @@ description = "Computer Building Blocks for Meshagent"
 requires-python = ">=3.12"
 license = "Apache-2.0"
 dependencies = [
-  "pytest~=8.3",
+  "pytest~=8.4",
   "pytest-asyncio~=0.26",
   "openai~=1.86",
-  "meshagent-api~=0.0.37",
-  "meshagent-agents~=0.0.37",
-  "meshagent-tools~=0.0.37",
+  "meshagent-api~=0.0.39",
+  "meshagent-agents~=0.0.39",
+  "meshagent-tools~=0.0.39",
   "playwright~=1.51",
   "browserbase~=1.2",
   "scrapybara~=2.4"

meshagent_computers-0.0.37/PKG-INFO

@@ -1,23 +0,0 @@
-Metadata-Version: 2.4
-Name: meshagent-computers
-Version: 0.0.37
-Summary: Computer Building Blocks for Meshagent
-License-Expression: Apache-2.0
-Project-URL: Documentation, https://docs.meshagent.com
-Project-URL: Website, https://www.meshagent.com
-Project-URL: Source, https://www.meshagent.com
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pytest~=8.3
-Requires-Dist: pytest-asyncio~=0.26
-Requires-Dist: openai~=1.86
-Requires-Dist: meshagent-api~=0.0.37
-Requires-Dist: meshagent-agents~=0.0.37
-Requires-Dist: meshagent-tools~=0.0.37
-Requires-Dist: playwright~=1.51
-Requires-Dist: browserbase~=1.2
-Requires-Dist: scrapybara~=2.4
-Dynamic: license-file
-
-### Meshagent Computers

meshagent_computers-0.0.37/README.md

@@ -1 +0,0 @@
-### Meshagent Computers

meshagent_computers-0.0.37/meshagent/computers/version.py

@@ -1 +0,0 @@
-__version__ = "0.0.37"

meshagent_computers-0.0.37/meshagent_computers.egg-info/PKG-INFO

@@ -1,23 +0,0 @@
-Metadata-Version: 2.4
-Name: meshagent-computers
-Version: 0.0.37
-Summary: Computer Building Blocks for Meshagent
-License-Expression: Apache-2.0
-Project-URL: Documentation, https://docs.meshagent.com
-Project-URL: Website, https://www.meshagent.com
-Project-URL: Source, https://www.meshagent.com
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pytest~=8.3
-Requires-Dist: pytest-asyncio~=0.26
-Requires-Dist: openai~=1.86
-Requires-Dist: meshagent-api~=0.0.37
-Requires-Dist: meshagent-agents~=0.0.37
-Requires-Dist: meshagent-tools~=0.0.37
-Requires-Dist: playwright~=1.51
-Requires-Dist: browserbase~=1.2
-Requires-Dist: scrapybara~=2.4
-Dynamic: license-file
-
-### Meshagent Computers