implement review remarks

Author: mlikasam-askui

src/askui/__init__.py

@@ -45,7 +45,7 @@
 from .models.types.response_schemas import ResponseSchema, ResponseSchemaBase
 from .retry import ConfigurableRetry, Retry
 from .tools import ModifierKey, PcKey
-from .tools.askui import LocalAgentOsServer, RemoteAgentOsServer
+from .tools.askui import LocalAgentOsTargetComputer, RemoteAgentOsTargetComputer
 from .utils.image_utils import ImageSource
 from .utils.source_utils import InputSource
 
@@ -70,8 +70,8 @@
 logging.getLogger(__name__).addHandler(logging.NullHandler())
 
 __all__ = [
-    "RemoteAgentOsServer",
-    "LocalAgentOsServer",
+    "RemoteAgentOsTargetComputer",
+    "LocalAgentOsTargetComputer",
     "Agent",
     "AutomationError",
     "ComputerAgent",

src/askui/computer_agent.py

@@ -17,13 +17,13 @@
     create_computer_agent_prompt,
 )
 from askui.tools.computer import (
-    ComputerGetActiveAgentOsServerTool,
+    ComputerGetCurrentComputerTargetIdTool,
     ComputerGetMousePositionTool,
     ComputerGetSystemInfoTool,
     ComputerKeyboardPressedTool,
     ComputerKeyboardReleaseTool,
     ComputerKeyboardTapTool,
-    ComputerListAgentOsServersTool,
+    ComputerListAgentOsTargetComputersTool,
     ComputerListDisplaysTool,
     ComputerMouseClickTool,
     ComputerMouseHoldDownTool,
@@ -33,15 +33,15 @@
     ComputerRetrieveActiveDisplayTool,
     ComputerScreenshotTool,
     ComputerSetActiveDisplayTool,
-    ComputerSwitchAgentOsServerTool,
+    ComputerSwitchAgentOsTargetComputerTool,
     ComputerTypeTool,
 )
 from askui.tools.exception_tool import ExceptionTool
 
 from .reporting import CompositeReporter, Reporter
 from .retry import Retry
 from .tools import AgentToolbox, ComputerAgentOsFacade, ModifierKey, PcKey
-from .tools.askui import AgentOsServer, AskUiControllerClient
+from .tools.askui import AgentOsTargetComputer, AskUiControllerClient
 
 logger = logging.getLogger(__name__)
 
@@ -54,27 +54,28 @@ class ComputerAgent(Agent):
     It uses computer vision models to locate UI elements and execute actions on them.
 
     A single `ComputerAgent` can drive **one or more machines** through the
-    `agent_os_servers` argument. Each entry is an Agent OS server (local
-    subprocess or remote gRPC endpoint) identified by a stable `computer_id`.
-    At any moment one server is *active* and receives all explicit calls
-    (`click`, `type`, `keyboard`, ...). The active server can be changed at
-    runtime via `agent.tools.os.switch_agent_os_server(computer_id)` or
-    scoped to a block using `agent.tools.os.temporary_select(computer_id)`.
-    The `act()` model is also given list/switch/get-active tools so it can
-    orchestrate work across machines on its own (e.g. read something on one
-    computer and re-enter it on another).
+    `agent_os_target_computers` argument. Each entry is an Agent OS target
+    computer (local subprocess or remote gRPC endpoint) identified by a stable
+    `computer_id`. At any moment one target is *active* and receives all
+    explicit calls (`click`, `type`, `keyboard`, ...). The active target can be
+    changed at runtime via
+    `agent.tools.os.switch_agent_os_target_computer(computer_id)` or scoped to a
+    block using `agent.tools.os.temporary_select(computer_id)`. The `act()`
+    model is also given list/switch/get-current tools so it can orchestrate
+    work across machines on its own (e.g. read something on one computer and
+    re-enter it on another).
 
     Args:
-        display (int, optional): The display number to use for screen interactions on the default local server. Ignored when `agent_os_servers` is provided. Defaults to `1`.
+        display (int, optional): The display number to use for screen interactions on the default local target. Ignored when `agent_os_target_computers` is provided. Defaults to `1`.
         reporters (list[Reporter] | None, optional): List of reporter instances for logging and reporting. If `None`, an empty list is used.
-        agent_os_servers (list[AgentOsServer] | None, optional):
-            Agent OS servers the agent can route actions to. May mix one
-            `LocalAgentOsServer` (managing a controller subprocess on this
-            machine) with any number of `RemoteAgentOsServer`s pointing at
+        agent_os_target_computers (list[AgentOsTargetComputer] | None, optional):
+            Target computers the agent can route actions to. May mix one
+            `LocalAgentOsTargetComputer` (managing a controller subprocess on this
+            machine) with any number of `RemoteAgentOsTargetComputer`s pointing at
             controllers already running on other machines. Constraints: at
-            least one server, at most one local, and remote `address`es plus
+            least one target, at most one local, and remote `address`es plus
             all `computer_id`s must be unique. The first entry becomes the
-            initial active server. Defaults to a single local server bound to
+            initial active target. Defaults to a single local target bound to
             `display`.
         settings (AgentSettings | None, optional): Provider-based model settings. If `None`, uses the default AskUI model stack.
         retry (Retry, optional): The retry instance to use for retrying failed actions. Defaults to `ConfigurableRetry` with exponential backoff. Currently only supported for `locate()` method.
@@ -94,18 +95,18 @@ class ComputerAgent(Agent):
 
     Example:
         Research on one machine and write up the findings on another. The
-        first server in the list is the active one; `temporary_select`
+        first target in the list is the active one; `temporary_select`
         re-routes a block of explicit calls and restores the previous
-        active server on exit.
+        active target on exit.
 
         ```python
         from askui import ComputerAgent
-        from askui.tools.askui import LocalAgentOsServer, RemoteAgentOsServer
+        from askui.tools.askui import LocalAgentOsTargetComputer, RemoteAgentOsTargetComputer
 
         with ComputerAgent(
-            agent_os_servers=[
-                LocalAgentOsServer(computer_id="research-box"),
-                RemoteAgentOsServer(
+            agent_os_target_computers=[
+                LocalAgentOsTargetComputer(computer_id="research-box"),
+                RemoteAgentOsTargetComputer(
                     address="192.168.1.42:26000",
                     description="Writer box with a text editor open",
                     computer_id="writer-box",
@@ -129,7 +130,7 @@ class ComputerAgent(Agent):
         from askui import ComputerAgent
 
         with ComputerAgent() as agent:
-            agent.tools.os.add_remote_agent_os_server(
+            agent.tools.os.add_remote_agent_os_target_computer(
                 address="10.0.0.5:26000",
                 description="Build server",
             )
@@ -144,15 +145,15 @@ class ComputerAgent(Agent):
             "act_tools",
             "callbacks",
             "truncation_strategy",
-            "agent_os_servers",
+            "agent_os_target_computers",
         }
     )
     @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
     def __init__(
         self,
         display: Annotated[int, Field(ge=1)] = 1,
         reporters: list[Reporter] | None = None,
-        agent_os_servers: list[AgentOsServer] | None = None,
+        agent_os_target_computers: list[AgentOsTargetComputer] | None = None,
         settings: AgentSettings | None = None,
         retry: Retry | None = None,
         act_tools: list[Tool] | None = None,
@@ -164,7 +165,7 @@ def __init__(
             agent_os=AskUiControllerClient(
                 display=display,
                 reporter=reporter,
-                agent_os_servers=agent_os_servers,
+                agent_os_target_computers=agent_os_target_computers,
             )
         )
         super().__init__(
@@ -588,9 +589,9 @@ def get_default_tools() -> list[Tool]:
             ComputerListDisplaysTool(),
             ComputerRetrieveActiveDisplayTool(),
             ComputerSetActiveDisplayTool(),
-            ComputerListAgentOsServersTool(),
-            ComputerSwitchAgentOsServerTool(),
-            ComputerGetActiveAgentOsServerTool(),
+            ComputerListAgentOsTargetComputersTool(),
+            ComputerSwitchAgentOsTargetComputerTool(),
+            ComputerGetCurrentComputerTargetIdTool(),
         ]
 
 

src/askui/models/shared/tools.py

@@ -362,10 +362,10 @@ def __init__(
 
     @property
     def agent_os(self) -> AgentOs | AndroidAgentOs:
-        """Get the agent OS.
+        """Get the AgentOS.
 
         Returns:
-            AgentOs | AndroidAgentOs: The agent OS instance.
+            AgentOs | AndroidAgentOs: The AgentOS instance.
         """
         if self._agent_os is None:
             msg = (
@@ -381,7 +381,7 @@ def agent_os(self, agent_os: AgentOs | AndroidAgentOs) -> None:
         self._agent_os = agent_os
 
     def is_agent_os_initialized(self) -> bool:
-        """Check if the agent OS is initialized."""
+        """Check if the AgentOS is initialized."""
         return self._agent_os is not None
 
 
@@ -471,10 +471,10 @@ def __init__(
                 self.add_agent_os(agent_os)
 
     def add_agent_os(self, agent_os: AgentOs | AndroidAgentOs) -> None:
-        """Add an agent OS to the collection.
+        """Add an AgentOS to the collection.
 
         Args:
-            agent_os (AgentOs | AndroidAgentOs): The agent OS instance to add.
+            agent_os (AgentOs | AndroidAgentOs): The AgentOS instance to add.
         """
         self._agent_os_list.append(agent_os)
 
@@ -538,19 +538,19 @@ def get_agent_os_by_tags(
         self, required_tags: list[str]
     ) -> AgentOs | AndroidAgentOs:
         """
-        Find the first registered agent OS whose tags are a superset of
+        Find the first registered AgentOS whose tags are a superset of
         `required_tags`.
 
-        Every tag in `required_tags` must appear in the agent OS's tags; the
-        agent OS may declare additional tags beyond those.
+        Every tag in `required_tags` must appear in the AgentOS's tags; the
+        AgentOS may declare additional tags beyond those.
 
         Raises:
-            ValueError: when no registered agent OS satisfies the required tags.
+            ValueError: when no registered AgentOS satisfies the required tags.
         """
         for agent_os in self._agent_os_list:
             if all(required in agent_os.tags for required in required_tags):
                 return agent_os
-        msg = f"No agent OS satisfies required tags [{', '.join(required_tags)}]"
+        msg = f"No AgentOS satisfies required tags [{', '.join(required_tags)}]"
         raise ValueError(msg)
 
     def _initialize_tools(self) -> None:

src/askui/tools/agent_os.py

@@ -9,9 +9,9 @@
 from askui.models.shared.tool_tags import ToolTags
 
 if TYPE_CHECKING:
-    from askui.tools.askui.agent_os_server import (
-        AgentOsServer,
-        RemoteAgentOsServer,
+    from askui.tools.askui.agent_os_target_computer import (
+        AgentOsTargetComputer,
+        RemoteAgentOsTargetComputer,
     )
     from askui.tools.askui.askui_ui_controller_grpc.generated import (
         Controller_V1_pb2 as controller_v1_pbs,
@@ -683,63 +683,61 @@ def set_window_in_focus(self, process_id: int, window_id: int) -> None:
         """
         raise NotImplementedError
 
-    # --- Agent-OS-server management -----------------------------------------------
-    # These methods only do something meaningful for backends that talk to multiple
-    # Agent OS servers (`AskUiControllerClient`). Other `AgentOs` implementations
-    # (Playwright, Android, ...) inherit the default implementations, which raise
-    # `NotImplementedError`.
-
-    def add_agent_os_server(self, server: "AgentOsServer") -> "AgentOsServer":
-        """Register an additional Agent OS server. Auto-connects if connected."""
+    def add_agent_os_target_computer(
+        self, agent_os_target_computer: "AgentOsTargetComputer"
+    ) -> "AgentOsTargetComputer":
+        """Register an additional target computer. Auto-connects if connected."""
         raise NotImplementedError
 
-    def add_remote_agent_os_server(
+    def add_remote_agent_os_target_computer(
         self,
         address: str,
         description: str,
-    ) -> "RemoteAgentOsServer":
-        """Register an additional remote Agent OS server."""
+    ) -> "RemoteAgentOsTargetComputer":
+        """Register an additional remote target computer."""
         raise NotImplementedError
 
-    def reset_agent_os_servers(
+    def reset_agent_os_target_computers(
         self,
-        agent_os_servers: "list[AgentOsServer] | None" = None,
+        agent_os_target_computers: "list[AgentOsTargetComputer] | None" = None,
     ) -> None:
-        """Disconnect (if connected) and replace the Agent-OS-server list."""
+        """Disconnect (if connected) and replace the target computer list."""
         raise NotImplementedError
 
-    def list_agent_os_servers(self) -> "list[AgentOsServer]":
-        """Return all registered Agent OS servers."""
+    def list_agent_os_target_computers(self) -> "list[AgentOsTargetComputer]":
+        """Return all registered target computers."""
         raise NotImplementedError
 
-    def get_active_agent_os_server(self, report: bool = True) -> "AgentOsServer":
-        """Return the currently active Agent OS server."""
+    def get_current_computer_target_id(self, report: bool = True) -> str:
+        """Return the `computer_id` of the currently active target computer."""
         raise NotImplementedError
 
-    def switch_agent_os_server(self, computer_id: str) -> "AgentOsServer":
-        """Switch the active Agent OS server by its `computer_id`."""
+    def switch_agent_os_target_computer(
+        self, computer_id: str
+    ) -> "AgentOsTargetComputer":
+        """Switch the active target computer by its `computer_id`."""
         raise NotImplementedError
 
     def temporary_select(self, computer_id: str) -> AbstractContextManager[Self]:
         """
-        Temporarily switch the active Agent OS server for the duration of a `with`
-        block, then restore the previously-active server on exit (even if the block
-        raises).
+        Temporarily switch the active target computer for the duration of a `with`
+        block, then restore the previously-active target on exit (even if the
+        block raises).
 
         Args:
-            computer_id (str): Computer id of the server to activate inside the
+            computer_id (str): Computer id of the target to activate inside the
                 block.
 
         Returns:
             AbstractContextManager[Self]: Context manager that yields this
-                `AgentOs` with the selected server active.
+                `AgentOs` with the selected target active.
 
         Example:
             ```python
             with agent_os.temporary_select('Remote-Machine') as remote_machine:
                 img = remote_machine.screenshot()
                 img.save("remote_machine.png")
-            # previous active server restored here
+            # previous active target restored here
             ```
         """
         raise NotImplementedError

src/askui/tools/askui/__init__.py

@@ -1,17 +1,17 @@
-from .agent_os_server import (
-    AgentOsServer,
-    LocalAgentOsServer,
-    RemoteAgentOsServer,
+from .agent_os_target_computer import (
+    AgentOsTargetComputer,
+    LocalAgentOsTargetComputer,
+    RemoteAgentOsTargetComputer,
 )
-from .agent_os_server_manager import (
-    AgentOsServerManager,
+from .agent_os_target_computer_manager import (
+    AgentOsTargetComputerManager,
 )
 from .askui_controller import AskUiControllerClient
 
 __all__ = [
-    "AgentOsServer",
-    "AgentOsServerManager",
+    "AgentOsTargetComputer",
+    "AgentOsTargetComputerManager",
     "AskUiControllerClient",
-    "LocalAgentOsServer",
-    "RemoteAgentOsServer",
+    "LocalAgentOsTargetComputer",
+    "RemoteAgentOsTargetComputer",
 ]