Skip to content
View as Markdown

ComputerUseService

Section titled “ComputerUseService”
class ComputerUseService()

Synchronous ComputerUseService.

ComputerUseService.__init__

Section titled “ComputerUseService.__init__”
def __init__(impl: AsyncComputerUseService, bridge: SyncBridge) -> None

ComputerUseService.service

Section titled “ComputerUseService.service”
@property
def service() -> AddonProcessesService

ComputerUseService.mouse

Section titled “ComputerUseService.mouse”
@property
def mouse() -> MouseService

ComputerUseService.keyboard

Section titled “ComputerUseService.keyboard”
@property
def keyboard() -> KeyboardService

ComputerUseService.screen

Section titled “ComputerUseService.screen”
@property
def screen() -> ScreenService

ComputerUseService.display

Section titled “ComputerUseService.display”
@property
def display() -> DisplayService

ComputerUseService.a11y

Section titled “ComputerUseService.a11y”
@property
def a11y() -> A11yService

ComputerUseService.recording

Section titled “ComputerUseService.recording”
@property
def recording() -> RecordingService

ComputerUseService.restart

Section titled “ComputerUseService.restart”
def restart() -> ComputerUseRestartResponse

ComputerUseService.start

Section titled “ComputerUseService.start”
def start() -> ComputerUseLifecycleResult

ComputerUseService.status

Section titled “ComputerUseService.status”
def status() -> ComputerUseStatusResponse

ComputerUseService.stop

Section titled “ComputerUseService.stop”
def stop() -> ComputerUseLifecycleResult

AsyncComputerUseService

Section titled “AsyncComputerUseService”
class AsyncComputerUseService()

AsyncComputerUseService.__init__

Section titled “AsyncComputerUseService.__init__”
def __init__(transport: AsyncTransport) -> None

AsyncComputerUseService.status

Section titled “AsyncComputerUseService.status”
async def status() -> ComputerUseStatusResponse

AsyncComputerUseService.start

Section titled “AsyncComputerUseService.start”
async def start() -> ComputerUseLifecycleResult

AsyncComputerUseService.stop

Section titled “AsyncComputerUseService.stop”
async def stop() -> ComputerUseLifecycleResult

AsyncComputerUseService.restart

Section titled “AsyncComputerUseService.restart”
async def restart() -> ComputerUseRestartResponse

A11yService

Section titled “A11yService”
class A11yService()

Synchronous A11yService.

A11yService.__init__

Section titled “A11yService.__init__”
def __init__(impl: AsyncA11yService, bridge: SyncBridge) -> None

A11yService.find

Section titled “A11yService.find”
def find(*,
         scope: ComputerUseA11yScope,
         pid: int | None = None,
         role: str | None = None,
         name: str | None = None,
         name_match: ComputerUseA11yNameMatch | None = None,
         states: Sequence[str] | None = None,
         limit: int | None = None) -> ComputerUseA11yFindResult

A11yService.focus

Section titled “A11yService.focus”
def focus(*, id: str) -> None

A11yService.invoke

Section titled “A11yService.invoke”
def invoke(*, id: str, action: str | None = None) -> None

A11yService.set_value

Section titled “A11yService.set_value”
def set_value(*, id: str, value: str) -> None

A11yService.tree

Section titled “A11yService.tree”
def tree(*,
         scope: ComputerUseA11yScope,
         pid: int | None = None,
         max_depth: int | None = None) -> ComputerUseA11yTree

AsyncA11yService

Section titled “AsyncA11yService”
class AsyncA11yService()

AsyncA11yService.__init__

Section titled “AsyncA11yService.__init__”
def __init__(transport: AsyncTransport) -> None

AsyncA11yService.tree

Section titled “AsyncA11yService.tree”
async def tree(*,
               scope: ComputerUseA11yScope,
               pid: int | None = None,
               max_depth: int | None = None) -> ComputerUseA11yTree

AsyncA11yService.find

Section titled “AsyncA11yService.find”
async def find(*,
               scope: ComputerUseA11yScope,
               pid: int | None = None,
               role: str | None = None,
               name: str | None = None,
               name_match: ComputerUseA11yNameMatch | None = None,
               states: Sequence[str] | None = None,
               limit: int | None = None) -> ComputerUseA11yFindResult

AsyncA11yService.focus

Section titled “AsyncA11yService.focus”
async def focus(*, id: str) -> None

AsyncA11yService.invoke

Section titled “AsyncA11yService.invoke”
async def invoke(*, id: str, action: str | None = None) -> None

AsyncA11yService.set_value

Section titled “AsyncA11yService.set_value”
async def set_value(*, id: str, value: str) -> None

AddonProcessesService

Section titled “AddonProcessesService”
class AddonProcessesService()

Synchronous AddonProcessesService.

AddonProcessesService.__init__

Section titled “AddonProcessesService.__init__”
def __init__(impl: AsyncAddonProcessesService, bridge: SyncBridge) -> None

AddonProcessesService.errors

Section titled “AddonProcessesService.errors”
def errors(name: str) -> ComputerUseProcessErrors

AddonProcessesService.logs

Section titled “AddonProcessesService.logs”
def logs(name: str) -> ComputerUseProcessLogs

AddonProcessesService.restart

Section titled “AddonProcessesService.restart”
def restart(name: str) -> ComputerUseProcessRestartResult

AddonProcessesService.status

Section titled “AddonProcessesService.status”
@overload
def status() -> dict[str, ComputerUseProcessStatus]

AddonProcessesService.status

Section titled “AddonProcessesService.status”
@overload
def status(name: str) -> ComputerUseProcessRunningStatus

AsyncAddonProcessesService

Section titled “AsyncAddonProcessesService”
class AsyncAddonProcessesService()

AsyncAddonProcessesService.__init__

Section titled “AsyncAddonProcessesService.__init__”
def __init__(transport: AsyncTransport) -> None

AsyncAddonProcessesService.status

Section titled “AsyncAddonProcessesService.status”
@overload
async def status() -> dict[str, ComputerUseProcessStatus]

AsyncAddonProcessesService.status

Section titled “AsyncAddonProcessesService.status”
@overload
async def status(name: str) -> ComputerUseProcessRunningStatus

AsyncAddonProcessesService.restart

Section titled “AsyncAddonProcessesService.restart”
async def restart(name: str) -> ComputerUseProcessRestartResult

AsyncAddonProcessesService.logs

Section titled “AsyncAddonProcessesService.logs”
async def logs(name: str) -> ComputerUseProcessLogs

AsyncAddonProcessesService.errors

Section titled “AsyncAddonProcessesService.errors”
async def errors(name: str) -> ComputerUseProcessErrors

DisplayService

Section titled “DisplayService”
class DisplayService()

Synchronous DisplayService.

DisplayService.__init__

Section titled “DisplayService.__init__”
def __init__(impl: AsyncDisplayService, bridge: SyncBridge) -> None

DisplayService.info

Section titled “DisplayService.info”
def info() -> ComputerUseDisplayInfo

DisplayService.windows

Section titled “DisplayService.windows”
def windows() -> ComputerUseDisplayWindows

AsyncDisplayService

Section titled “AsyncDisplayService”
class AsyncDisplayService()

AsyncDisplayService.__init__

Section titled “AsyncDisplayService.__init__”
def __init__(transport: AsyncTransport) -> None

AsyncDisplayService.info

Section titled “AsyncDisplayService.info”
async def info() -> ComputerUseDisplayInfo

AsyncDisplayService.windows

Section titled “AsyncDisplayService.windows”
async def windows() -> ComputerUseDisplayWindows

KeyboardService

Section titled “KeyboardService”
class KeyboardService()

Synchronous KeyboardService.

KeyboardService.__init__

Section titled “KeyboardService.__init__”
def __init__(impl: AsyncKeyboardService, bridge: SyncBridge) -> None

KeyboardService.hotkey

Section titled “KeyboardService.hotkey”
def hotkey(*, keys: str) -> None

KeyboardService.key

Section titled “KeyboardService.key”
def key(*,
        key: str,
        modifiers: Sequence[ComputerUseKeyboardModifier] | None = None) -> None

KeyboardService.type

Section titled “KeyboardService.type”
def type(*, text: str, delay: int | None = None) -> None

AsyncKeyboardService

Section titled “AsyncKeyboardService”
class AsyncKeyboardService()

AsyncKeyboardService.__init__

Section titled “AsyncKeyboardService.__init__”
def __init__(transport: AsyncTransport) -> None

AsyncKeyboardService.type

Section titled “AsyncKeyboardService.type”
async def type(*, text: str, delay: int | None = None) -> None

AsyncKeyboardService.key

Section titled “AsyncKeyboardService.key”
async def key(*,
              key: str,
              modifiers: Sequence[ComputerUseKeyboardModifier] | None = None) -> None

AsyncKeyboardService.hotkey

Section titled “AsyncKeyboardService.hotkey”
async def hotkey(*, keys: str) -> None

MouseService

Section titled “MouseService”
class MouseService()

Synchronous MouseService.

MouseService.__init__

Section titled “MouseService.__init__”
def __init__(impl: AsyncMouseService, bridge: SyncBridge) -> None

MouseService.click

Section titled “MouseService.click”
def click(*,
          x: int,
          y: int,
          button: ComputerUseMouseButton | None = None,
          double: bool | None = None) -> ComputerUsePoint

MouseService.drag

Section titled “MouseService.drag”
def drag(*,
         start_x: int,
         start_y: int,
         end_x: int,
         end_y: int,
         button: ComputerUseMouseButton | None = None) -> ComputerUsePoint

MouseService.move

Section titled “MouseService.move”
def move(*, x: int, y: int) -> ComputerUsePoint

MouseService.position

Section titled “MouseService.position”
def position() -> ComputerUsePoint

MouseService.scroll

Section titled “MouseService.scroll”
def scroll(*,
           x: int,
           y: int,
           direction: ComputerUseScrollDirection,
           amount: int | None = None) -> ComputerUseScrollResult

AsyncMouseService

Section titled “AsyncMouseService”
class AsyncMouseService()

AsyncMouseService.__init__

Section titled “AsyncMouseService.__init__”
def __init__(transport: AsyncTransport) -> None

AsyncMouseService.position

Section titled “AsyncMouseService.position”
async def position() -> ComputerUsePoint

AsyncMouseService.move

Section titled “AsyncMouseService.move”
async def move(*, x: int, y: int) -> ComputerUsePoint

AsyncMouseService.click

Section titled “AsyncMouseService.click”
async def click(*,
                x: int,
                y: int,
                button: ComputerUseMouseButton | None = None,
                double: bool | None = None) -> ComputerUsePoint

AsyncMouseService.drag

Section titled “AsyncMouseService.drag”
async def drag(*,
               start_x: int,
               start_y: int,
               end_x: int,
               end_y: int,
               button: ComputerUseMouseButton | None = None) -> ComputerUsePoint

AsyncMouseService.scroll

Section titled “AsyncMouseService.scroll”
async def scroll(*,
                 x: int,
                 y: int,
                 direction: ComputerUseScrollDirection,
                 amount: int | None = None) -> ComputerUseScrollResult

RecordingService

Section titled “RecordingService”
class RecordingService()

Synchronous RecordingService.

RecordingService.__init__

Section titled “RecordingService.__init__”
def __init__(impl: AsyncRecordingService, bridge: SyncBridge) -> None

RecordingService.delete

Section titled “RecordingService.delete”
def delete(id: str) -> None

RecordingService.download

Section titled “RecordingService.download”
def download(id: str) -> bytes

RecordingService.get

Section titled “RecordingService.get”
def get(id: str) -> ComputerUseRecording

RecordingService.list

Section titled “RecordingService.list”
def list() -> ComputerUseRecordingList

RecordingService.start

Section titled “RecordingService.start”
def start(*, label: str | None = None) -> ComputerUseRecording

RecordingService.stop

Section titled “RecordingService.stop”
def stop(*, id: str) -> ComputerUseRecording

AsyncRecordingService

Section titled “AsyncRecordingService”
class AsyncRecordingService()

AsyncRecordingService.__init__

Section titled “AsyncRecordingService.__init__”
def __init__(transport: AsyncTransport) -> None

AsyncRecordingService.start

Section titled “AsyncRecordingService.start”
async def start(*, label: str | None = None) -> ComputerUseRecording

AsyncRecordingService.stop

Section titled “AsyncRecordingService.stop”
async def stop(*, id: str) -> ComputerUseRecording

AsyncRecordingService.list

Section titled “AsyncRecordingService.list”
async def list() -> ComputerUseRecordingList

AsyncRecordingService.get

Section titled “AsyncRecordingService.get”
async def get(id: str) -> ComputerUseRecording

AsyncRecordingService.download

Section titled “AsyncRecordingService.download”
async def download(id: str) -> bytes

AsyncRecordingService.delete

Section titled “AsyncRecordingService.delete”
async def delete(id: str) -> None

ScreenService

Section titled “ScreenService”
class ScreenService()

Synchronous ScreenService.

ScreenService.__init__

Section titled “ScreenService.__init__”
def __init__(impl: AsyncScreenService, bridge: SyncBridge) -> None

ScreenService.capture

Section titled “ScreenService.capture”
def capture(*, show_cursor: bool | None = None) -> ComputerUseScreenshot

ScreenService.capture_compressed

Section titled “ScreenService.capture_compressed”
def capture_compressed(*,
                       format: ComputerUseScreenshotFormat | None = None,
                       quality: int | None = None,
                       scale: float | None = None,
                       show_cursor: bool | None = None) -> ComputerUseScreenshot

ScreenService.region

Section titled “ScreenService.region”
def region(*,
           x: int,
           y: int,
           width: int,
           height: int,
           show_cursor: bool | None = None) -> ComputerUseScreenshot

ScreenService.region_compressed

Section titled “ScreenService.region_compressed”
def region_compressed(*,
                      x: int,
                      y: int,
                      width: int,
                      height: int,
                      format: ComputerUseScreenshotFormat | None = None,
                      quality: int | None = None,
                      scale: float | None = None,
                      show_cursor: bool | None = None) -> ComputerUseScreenshot

AsyncScreenService

Section titled “AsyncScreenService”
class AsyncScreenService()

AsyncScreenService.__init__

Section titled “AsyncScreenService.__init__”
def __init__(transport: AsyncTransport) -> None

AsyncScreenService.capture

Section titled “AsyncScreenService.capture”
async def capture(*, show_cursor: bool | None = None) -> ComputerUseScreenshot

AsyncScreenService.region

Section titled “AsyncScreenService.region”
async def region(*,
                 x: int,
                 y: int,
                 width: int,
                 height: int,
                 show_cursor: bool | None = None) -> ComputerUseScreenshot

AsyncScreenService.capture_compressed

Section titled “AsyncScreenService.capture_compressed”
async def capture_compressed(*,
                             format: ComputerUseScreenshotFormat | None = None,
                             quality: int | None = None,
                             scale: float | None = None,
                             show_cursor: bool | None = None) -> ComputerUseScreenshot

AsyncScreenService.region_compressed

Section titled “AsyncScreenService.region_compressed”
async def region_compressed(*,
                            x: int,
                            y: int,
                            width: int,
                            height: int,
                            format: ComputerUseScreenshotFormat | None = None,
                            quality: int | None = None,
                            scale: float | None = None,
                            show_cursor: bool | None = None) -> ComputerUseScreenshot

ComputerUseDesktopFailure

Section titled “ComputerUseDesktopFailure”
@dataclass(frozen=True, slots=True)
class ComputerUseDesktopFailure()

Attributes:

  • code ComputerUseDesktopFailureCode
  • message str
  • extra_fields Optional[Dict[str, JsonValue]] = None
  • raw_code Optional[str] = None

ComputerUseNotStartedStatus

Section titled “ComputerUseNotStartedStatus”
@dataclass(frozen=True, slots=True)
class ComputerUseNotStartedStatus()

Attributes:

  • status Literal[‘inactive’] = ‘inactive’
  • desktop Literal[‘not_started’] = ‘not_started’
  • cause None = None
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseStartingStatus

Section titled “ComputerUseStartingStatus”
@dataclass(frozen=True, slots=True)
class ComputerUseStartingStatus()

Attributes:

  • status Literal[‘inactive’] = ‘inactive’
  • desktop Literal[‘starting’] = ‘starting’
  • cause None = None
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseReadyStatus

Section titled “ComputerUseReadyStatus”
@dataclass(frozen=True, slots=True)
class ComputerUseReadyStatus()

Attributes:

  • status Literal[‘active’] = ‘active’
  • desktop Literal[‘ready’] = ‘ready’
  • cause None = None
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseFailedStatus

Section titled “ComputerUseFailedStatus”
@dataclass(frozen=True, slots=True)
class ComputerUseFailedStatus()

Attributes:

  • cause ComputerUseDesktopFailure
  • status Literal[‘inactive’] = ‘inactive’
  • desktop Literal[‘failed’] = ‘failed’
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseUnknownStatus

Section titled “ComputerUseUnknownStatus”
@dataclass(frozen=True, slots=True)
class ComputerUseUnknownStatus()

A (status, desktop) pair this SDK release does not recognize, because a newer daemon added a value or a combination. raw_status / raw_desktop carry what the daemon sent; the recognized variants need no raw sibling, since their typed values are the wire values. cause is the failure the daemon attached to the unrecognized state, when it sent one.

Attributes:

  • raw_status str
  • raw_desktop str
  • status Literal[‘unknown’] = ‘unknown’
  • desktop Literal[‘unknown’] = ‘unknown’
  • cause Optional[ComputerUseDesktopFailure] = None
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseRestartResponse

Section titled “ComputerUseRestartResponse”
@dataclass(frozen=True, slots=True)
class ComputerUseRestartResponse()

Attributes:

  • message str
  • status Literal[‘active’] = ‘active’
  • desktop Literal[‘ready’] = ‘ready’
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseProcessStatus

Section titled “ComputerUseProcessStatus”
@dataclass(frozen=True, slots=True)
class ComputerUseProcessStatus()

Attributes:

  • running Optional[bool] = None
  • priority Optional[int] = None
  • auto_restart Optional[bool] = None
  • pid Optional[int] = None
  • failed Optional[bool] = None
  • restart_attempts Optional[int] = None
  • restart_backoff_ms Optional[int] = None
  • status Optional[str] = None
  • extra_fields Optional[Dict[str, JsonValue]] = None

ComputerUseProcessRunningStatus

Section titled “ComputerUseProcessRunningStatus”
@dataclass(frozen=True, slots=True)
class ComputerUseProcessRunningStatus()

Attributes:

  • process_name str
  • running bool

ComputerUsePoint

Section titled “ComputerUsePoint”
@dataclass(frozen=True, slots=True)
class ComputerUsePoint()

Attributes:

  • x int
  • y int

ComputerUseDisplay

Section titled “ComputerUseDisplay”
@dataclass(frozen=True, slots=True)
class ComputerUseDisplay()

Attributes:

  • id int
  • x int
  • y int
  • width int
  • height int
  • is_active bool

ComputerUseWindow

Section titled “ComputerUseWindow”
@dataclass(frozen=True, slots=True)
class ComputerUseWindow()

Attributes:

  • id int
  • title str
  • x int
  • y int
  • width int
  • height int
  • is_active bool

ComputerUseAccessibilityBounds

Section titled “ComputerUseAccessibilityBounds”
@dataclass(frozen=True, slots=True)
class ComputerUseAccessibilityBounds()

Attributes:

  • x int
  • y int
  • width int
  • height int

ComputerUseAccessibilityNode

Section titled “ComputerUseAccessibilityNode”
@dataclass(frozen=True, slots=True)
class ComputerUseAccessibilityNode()

Attributes:

  • id str
  • role str
  • name str
  • bounds ComputerUseAccessibilityBounds
  • states List[str]
  • description Optional[str] = None
  • actions Optional[List[str]] = None
  • children Optional[List[ComputerUseAccessibilityNode]] = None
  • value Optional[str] = None
  • value_truncated bool = False

ComputerUseRecording

Section titled “ComputerUseRecording”
@dataclass(frozen=True, slots=True)
class ComputerUseRecording()

Attributes:

  • id str
  • file_name str
  • file_path str
  • start_time str
  • status str
  • end_time Optional[str] = None
  • duration_seconds Optional[float] = None
  • size_bytes Optional[int] = None

ComputerUseMouseButton

Section titled “ComputerUseMouseButton”
ComputerUseMouseButton = Literal['left', 'right', 'middle']

ComputerUseScrollDirection

Section titled “ComputerUseScrollDirection”
ComputerUseScrollDirection = Literal['up', 'down']

ComputerUseScreenshotFormat

Section titled “ComputerUseScreenshotFormat”
ComputerUseScreenshotFormat = Literal['png', 'jpeg']

ComputerUseKeyboardModifier

Section titled “ComputerUseKeyboardModifier”
ComputerUseKeyboardModifier = Literal['ctrl', 'alt', 'shift', 'cmd']

ComputerUseA11yScope

Section titled “ComputerUseA11yScope”
ComputerUseA11yScope = Literal['focused', 'pid', 'all']

ComputerUseA11yNameMatch

Section titled “ComputerUseA11yNameMatch”
ComputerUseA11yNameMatch = Literal['exact', 'substring', 'regex']

ComputerUseActivityStatus

Section titled “ComputerUseActivityStatus”
ComputerUseActivityStatus = Literal['active', 'inactive', 'unknown']

ComputerUseDesktopState

Section titled “ComputerUseDesktopState”
ComputerUseDesktopState = Literal['not_started', 'starting', 'ready', 'failed', 'unknown']

ComputerUseDesktopFailureCode

Section titled “ComputerUseDesktopFailureCode”
ComputerUseDesktopFailureCode = Literal['desktop_exited', 'addon_crashed', 'start_failed', 'start_interrupted', 'session_ended', 'session_replaced', 'state_corrupt', 'state_persistence_failed', 'unknown']

ComputerUseStatusResponse

Section titled “ComputerUseStatusResponse”
ComputerUseStatusResponse = Union[ComputerUseNotStartedStatus, ComputerUseStartingStatus, ComputerUseReadyStatus, ComputerUseFailedStatus, ComputerUseUnknownStatus]

ComputerUseLifecycleResponse

Section titled “ComputerUseLifecycleResponse”
ComputerUseLifecycleResponse = ComputerUseLifecycleResult

ComputerUseProcessRestartResponse

Section titled “ComputerUseProcessRestartResponse”
ComputerUseProcessRestartResponse = ComputerUseProcessRestartResult

ComputerUseProcessLogsResponse

Section titled “ComputerUseProcessLogsResponse”
ComputerUseProcessLogsResponse = ComputerUseProcessLogs

ComputerUseProcessErrorsResponse

Section titled “ComputerUseProcessErrorsResponse”
ComputerUseProcessErrorsResponse = ComputerUseProcessErrors

ComputerUseScreenshotResponse

Section titled “ComputerUseScreenshotResponse”
ComputerUseScreenshotResponse = ComputerUseScreenshot

ComputerUseScrollResponse

Section titled “ComputerUseScrollResponse”
ComputerUseScrollResponse = ComputerUseScrollResult

ComputerUseDisplayInfoResponse

Section titled “ComputerUseDisplayInfoResponse”
ComputerUseDisplayInfoResponse = ComputerUseDisplayInfo

ComputerUseDisplayWindowsResponse

Section titled “ComputerUseDisplayWindowsResponse”
ComputerUseDisplayWindowsResponse = ComputerUseDisplayWindows

ComputerUseA11yTreeResponse

Section titled “ComputerUseA11yTreeResponse”
ComputerUseA11yTreeResponse = ComputerUseA11yTree

ComputerUseA11yFindResponse

Section titled “ComputerUseA11yFindResponse”
ComputerUseA11yFindResponse = ComputerUseA11yFindResult

ComputerUseRecordingsResponse

Section titled “ComputerUseRecordingsResponse”
ComputerUseRecordingsResponse = ComputerUseRecordingList