inspect-ai 0.3.70__py3-none-any.whl → 0.3.72__py3-none-any.whl

inspect_ai/tool/_tools/_web_browser/_resources/cdp/a11y.py

@@ -0,0 +1,279 @@
+"""
+Types and pure functional helpers associated with Chrome DevTools Protocol's 'Accessibility' Domain
+
+https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/
+"""
+
+from typing import Literal, NewType, Optional
+
+from pydantic import BaseModel
+
+from cdp.dom import DOMBackendNodeId
+
+# brand these str's so that we don't confuse them with other str's
+PageFrameId = NewType("PageFrameId", str)
+AXNodeId = NewType("AXNodeId", str)
+
+
+AXPropertyName = Literal[
+    "actions",
+    "busy",
+    "disabled",
+    "editable",
+    "focusable",
+    "focused",
+    "hidden",
+    "hiddenRoot",
+    "invalid",
+    "keyshortcuts",
+    "settable",
+    "roledescription",
+    "live",
+    "atomic",
+    "relevant",
+    "root",
+    "autocomplete",
+    "hasPopup",
+    "level",
+    "multiselectable",
+    "orientation",
+    "multiline",
+    "readonly",
+    "required",
+    "valuemin",
+    "valuemax",
+    "valuetext",
+    "checked",
+    "expanded",
+    "modal",
+    "pressed",
+    "selected",
+    "activedescendant",
+    "controls",
+    "describedby",
+    "details",
+    "errormessage",
+    "flowto",
+    "labelledby",
+    "owns",
+    "url",
+]
+
+
+AXValueType = Literal[
+    "boolean",
+    "tristate",
+    "booleanOrUndefined",
+    "idref",
+    "idrefList",
+    "integer",
+    "node",
+    "nodeList",
+    "number",
+    "string",
+    "computedString",
+    "token",
+    "tokenList",
+    "domRelation",
+    "role",
+    "internalRole",
+    "valueUndefined",
+]
+
+
+class AXRelatedNode(BaseModel, frozen=True):
+    backendDOMNodeId: DOMBackendNodeId
+    """The BackendNodeId of the related DOM node."""
+    idref: str | None = None
+    """The IDRef value provided, if any."""
+    text: str | None = None
+    """The text alternative of this node in the current context."""
+
+
+AXValueSourceType = Literal[
+    "attribute", "implicit", "stylet", "contents", "placeholder", "relatedElement"
+]
+
+AXValueNativeSourceType = Literal[
+    "description",
+    "figcaption",
+    "label",
+    "labelfor",
+    "labelwrapped",
+    "legend",
+    "rubyannotation",
+    "tablecaption",
+    "title",
+    "other",
+]
+
+
+class AXValueSource(BaseModel, frozen=True):
+    """A single source for a computed AX property."""
+
+    type: AXValueSourceType
+    """What type of source this is."""
+    value: Optional["AXValue"] = None
+    """The value of this property source."""
+    attribute: str | None = None
+    """The name of the relevant attribute, if any."""
+    attributeValue: Optional["AXValue"] = None
+    """The value of the relevant attribute, if any."""
+    superseded: bool | None = None
+    """Whether this source is superseded by a higher priority source."""
+    nativeSource: AXValueNativeSourceType | None = None
+    """The native markup source for this value, e.g. a `<label>` element."""
+    nativeSourceValue: Optional["AXValue"] = None
+    """The value, such as a node or node list, of the native source."""
+    invalid: bool | None = None
+    """Whether the value for this property is invalid."""
+    invalidReason: str | None = None
+    """Reason for the value being invalid, if it is."""
+
+
+class AXValue(BaseModel, frozen=True):
+    """A single computed AX property."""
+
+    type: AXValueType
+    """The type of this value."""
+    value: object | None = None
+    """The computed value of this property."""
+    relatedNodes: tuple[AXRelatedNode, ...] | None = None
+    """One or more related nodes, if applicable."""
+    sources: tuple[AXValueSource, ...] | None = None
+    """The sources which contributed to the computation of this property."""
+
+
+class AXProperty(BaseModel, frozen=True):
+    name: AXPropertyName
+    """The name of this property."""
+    value: AXValue
+    """The value of this property."""
+
+
+# AXNode's ignoredReasons is documented to be a list[AXProperty]. However, that seems to
+# be erroneous since the namespace for ignored reason names is completely separate from property names.
+class AXIgnoredReason(BaseModel, frozen=True):
+    # name: Literal[
+    #     "uninteresting",
+    #     "ariaHiddenSubtree",
+    #     "ariaHiddenElement",
+    #     "notRendered",
+    #     "notVisible",
+    #     "emptyAlt",
+    # ]
+    name: str  # since this is all undocumented, it's best to be loose
+    """The name of this ignored reason."""
+    value: AXValue
+    """The value of this ignored reason."""
+
+
+class AXNode(BaseModel, frozen=True):
+    """A node in the accessibility tree."""
+
+    nodeId: AXNodeId
+    """Unique identifier for this node."""
+    ignored: bool
+    """Wether this node is ignore3d for accessibility"""
+    ignoredReasons: tuple[AXIgnoredReason, ...] | None = None
+    """Collection of reasons why this node is hidden."""
+    role: AXValue | None = None
+    """This `Node`'s role, wether explicit or implicit."""
+    chromeRole: AXValue | None = None
+    """This `Node`'s Chrome raw role."""
+    name: AXValue | None = None
+    """The accessible name for this `Node`."""
+    description: AXValue | None = None
+    """The accessible description for this `Node`."""
+    value: AXValue | None = None
+    """The value for this `Node`."""
+    properties: tuple[AXProperty, ...] | None = None
+    """All other properties"""
+    parentId: AXNodeId | None = None
+    """ID for this node's parent."""
+    childIds: tuple[AXNodeId, ...] | None = None
+    """IDs for each of this node's child nodes."""
+    backendDOMNodeId: DOMBackendNodeId | None = None
+    """The backend ID for the associated DOM node, if any."""
+    frameId: PageFrameId | None = None
+    """The frame ID for the frame associated with this nodes document."""
+
+
+class AXTree(BaseModel, frozen=True):
+    nodes: tuple[AXNode, ...]
+
+
+# CDP defines `AXValue.value` as `Any`, so this is a coercion function
+def string_from_ax_value(value: AXValue | None) -> str:
+    """
+    Coerces an AXValue to a string.
+
+    Args:
+      value (AXValue | None): The AXValue to be coerced.
+
+    Returns:
+      str: The string representation of the AXValue, or an empty string if the value is None or not a string.
+    """
+    return value.value if value and isinstance(value.value, str) else ""
+
+
+def node_has_property(node: AXNode, property_name: AXPropertyName) -> bool:
+    """
+    Checks if an AXNode has a specific property.
+
+    Args:
+      node (AXNode): The AXNode to check.
+      property_name (AXPropertyName): The name of the property to look for.
+
+    Returns:
+      bool: True if the node has the property, False otherwise.
+    """
+    return node_property(node, property_name) is not None
+
+
+def node_property(node: AXNode, property_name: AXPropertyName) -> AXProperty | None:
+    """
+    Retrieves a specific property from an AXNode.
+
+    Args:
+      node (AXNode): The AXNode to retrieve the property from.
+      property_name (AXPropertyName): The name of the property to retrieve.
+
+    Returns:
+      AXProperty | None: The property if found, otherwise None.
+    """
+    return next(
+        (prop for prop in node.properties or () if prop.name == property_name), None
+    )
+
+
+def node_bool_property(node: AXNode, property_name: AXPropertyName) -> bool:
+    """
+    Retrieves a boolean property from an AXNode.
+
+    Args:
+      node (AXNode): The AXNode to retrieve the property from.
+      property_name (AXPropertyName): The name of the property to retrieve.
+
+    Returns:
+      bool: The boolean value of the property, or False if the property is not found or not a boolean.
+    """
+    return bool(prop.value) if (prop := node_property(node, property_name)) else False
+
+
+def node_str_property(node: AXNode, property_name: AXPropertyName) -> str | None:
+    """
+    Retrieves a str property from an AXNode.
+
+    Args:
+      node (AXNode): The AXNode to retrieve the property from.
+      property_name (AXPropertyName): The name of the property to retrieve.
+
+    Returns:
+      str: The str value of the property, or None if the property is not found or not a str.
+    """
+    prop = node_property(node, property_name)
+    if prop is None:
+        return None
+    v = prop.value
+    return v.value if isinstance(v.value, str) else None

inspect_ai/tool/_tools/_web_browser/_resources/cdp/dom.py

@@ -0,0 +1,9 @@
+"""
+Types associated with Chrome DevTools Protocol's 'DOM' Domain
+
+https://chromedevtools.github.io/devtools-protocol/tot/DOM/
+"""
+
+from typing import NewType
+
+DOMBackendNodeId = NewType("DOMBackendNodeId", int)

inspect_ai/tool/_tools/_web_browser/_resources/cdp/dom_snapshot.py

@@ -0,0 +1,293 @@
+"""
+Types and pure functional helpers associated with Chrome DevTools Protocol's 'DOMSnapshot' Domain
+
+https://chromedevtools.github.io/devtools-protocol/tot/DOMSnapshot/
+"""
+
+from typing import Literal, NewType, TypedDict
+
+from pydantic import BaseModel
+
+from cdp.dom import DOMBackendNodeId
+
+StringIndex = NewType("StringIndex", int)
+Rectangle = tuple[float, ...]
+ArrayOfStrings = tuple[StringIndex, ...]
+
+
+class RareStringData(BaseModel, frozen=True):
+    """Data that is only present on rare nodes."""
+
+    index: tuple[int, ...]
+    value: tuple[StringIndex, ...]
+
+
+class RareIntegerData(BaseModel, frozen=True):
+    index: tuple[int, ...]
+    value: tuple[int, ...]
+
+
+class RareBooleanData(BaseModel, frozen=True):
+    index: tuple[int, ...]
+
+
+class NodeTreeSnapshot(BaseModel, frozen=True):
+    """Table containing nodes."""
+
+    parentIndex: tuple[int, ...] | None = None
+    """Parent node index."""
+    nodeType: tuple[int, ...] | None = None
+    """`Node`'s nodeType"""
+    shadowRootType: RareStringData | None = None
+    """Type of the shadow root the `Node` is in. String values are equal to the `ShadowRootType` enum."""
+    nodeName: tuple[StringIndex, ...] | None = None
+    """`Node`'s nodeName."""
+    nodeValue: tuple[StringIndex, ...] | None = None
+    """`Node`'s nodeValue."""
+    backendNodeId: tuple[DOMBackendNodeId, ...] | None = None
+    """`Node`'s id, corresponds to DOM.Node.backendNodeId."""
+    attributes: tuple[ArrayOfStrings, ...] | None = None
+    # attributes: list[int] | None = None
+    """Attributes of an `Element` node. Flatten name, value pairs."""
+    textValue: RareStringData | None = None
+    """Only set for textarea elements, contains the text value."""
+    inputValue: RareStringData | None = None
+    """Only set for input elements, contains the input's associated text value."""
+    inputChecked: RareBooleanData | None = None
+    """Only set for radio and checkbox input elements, indicates if the element has been checked"""
+    optionSelected: RareBooleanData | None = None
+    """Only set for option elements, indicates if the element has been selected"""
+    contentDocumentIndex: RareIntegerData | None = None
+    """The index of the document in the list of the snapshot documents."""
+    pseudoType: RareStringData | None = None
+    """Type of a pseudo element node."""
+    pseudoIdentifier: RareStringData | None = None
+    """Pseudo element identifier for this node. Only present if there is a valid pseudoType."""
+    isClickable: RareBooleanData | None = None
+    """Whether this DOM node responds to mouse clicks. This includes nodes that have had click event listeners attached via JavaScript as well as anchor tags that naturally navigate when clicked."""
+    currentSourceURL: RareStringData | None = None
+    """The selected url for nodes with a srcset attribute."""
+    originURL: RareStringData | None = None
+    """The url of the script (if any) that generates this node."""
+
+
+class LayoutTreeSnapshot(BaseModel, frozen=True):
+    """Table of details of an element in the DOM tree with a `LayoutObject`."""
+
+    nodeIndex: tuple[int, ...]
+    """Index of the corresponding node in the `NodeTreeSnapshot` array returned by `captureSnapshot`."""
+    styles: tuple[ArrayOfStrings, ...]
+    """Array of indexes specifying computed style strings, filtered according to the computedStyles parameter passed to captureSnapshot."""
+    bounds: tuple[Rectangle, ...]
+    """The absolute position bounding box."""
+    text: tuple[StringIndex, ...]
+    """Contents of the `LayoutText`, if any."""
+    stackingContexts: RareBooleanData
+    """Stacking context information."""
+    paintOrders: tuple[int, ...] | None = None
+    """Global paint order index, which is determined by the stacking order of the nodes. Nodes that are painted together will have the same index. Only provided if `includePaintOrder` in `captureSnapshot` was true."""
+    offsetRects: tuple[Rectangle, ...] | None = None
+    """The offset rect of nodes. Only available when `includeDOMRects` is set to true"""
+    scrollRects: tuple[Rectangle, ...] | None = None
+    """The scroll rect of nodes. Only available when `includeDOMRects` is set to true"""
+    clientRects: tuple[Rectangle, ...] | None = None
+    """The client rect of nodes. Only available when `includeDOMRects` is set to true"""
+    blendedBackgroundColors: tuple[StringIndex, ...] | None = None
+    """The list of background colors that are blended with colors of overlapping elements. Experimental"""
+    textColorOpacities: tuple[float, ...] | None = None
+    """The list of computed text opacities. Experimental"""
+
+
+class TextBoxSnapshot(BaseModel, frozen=True):
+    """Table of details of the post layout rendered text positions. The exact layout should not be regarded as stable and may change between versions."""
+
+    layoutIndex: tuple[int, ...]
+    """Index of the layout tree node that owns this box collection."""
+    bounds: tuple[Rectangle, ...]
+    """The absolute position bounding box."""
+    start: tuple[int, ...]
+    """The starting index in characters, for this post layout textbox substring. Characters that would be represented as a surrogate pair in UTF-16 have length 2."""
+    length: tuple[int, ...]
+    """The number of characters in this post layout textbox substring. Characters that would be represented as a surrogate pair in UTF-16 have length 2."""
+
+
+class DocumentSnapshot(BaseModel, frozen=True):
+    documentURL: StringIndex
+    """Document URL that `Document` or `FrameOwner` node points to."""
+    title: StringIndex
+    """Document title."""
+    baseURL: StringIndex
+    """Base URL that `Document` or `FrameOwner` node uses for URL completion."""
+    contentLanguage: StringIndex
+    """Contains the document's content language."""
+    encodingName: StringIndex
+    """Contains the document's character set encoding."""
+    publicId: StringIndex
+    """`DocumentType` node's publicId."""
+    systemId: StringIndex
+    """`DocumentType` node's systemId."""
+    frameId: StringIndex
+    """Frame ID for frame owner elements and also for the document node."""
+    nodes: NodeTreeSnapshot
+    """A table with dom nodes."""
+    layout: LayoutTreeSnapshot
+    """The nodes in the layout tree."""
+    textBoxes: TextBoxSnapshot
+    """The post-layout inline text nodes."""
+    scrollOffsetX: float | None = None
+    """Horizontal scroll offset."""
+    scrollOffsetY: float | None = None
+    """Vertical scroll offset."""
+    contentWidth: float | None = None
+    """Document content width."""
+    contentHeight: float | None = None
+    """Document content height."""
+
+
+class DOMSnapshot(BaseModel, frozen=True):
+    documents: tuple[DocumentSnapshot, ...]
+    """The nodes in the DOM tree. The DOMNode at index 0 corresponds to the root document."""
+    strings: tuple[str, ...]
+    """Shared string table that all string properties refer to with indexes."""
+
+
+NodeIndex = NewType("NodeIndex", int)
+LayoutIndex = NewType("LayoutIndex", int)
+
+
+class DOMSnapshotContext(TypedDict):
+    dom_snapshot: DOMSnapshot
+    node_id_to_node_index: dict[DOMBackendNodeId, NodeIndex]
+    # Below are dicts to help with non-1:1 index mappings like layouts and RareStringData's
+    node_index_to_layout_index: dict[NodeIndex, LayoutIndex]
+    node_index_to_current_src_url_index: dict[NodeIndex, StringIndex]
+    node_index_to_text_value_index: dict[NodeIndex, StringIndex]
+
+
+def create_snapshot_context(dom_snapshot: DOMSnapshot) -> DOMSnapshotContext:
+    """
+    Creates a DOMSnapshotContext that can be used to efficiently extract data from a DOMSnapshot.
+
+    Given the fact that a DOMSnapshot uses long flat correlated lists (see below), this context
+    enables efficient lookups that avoid full list scans.
+
+    NOTE: Currently, this context and associated code assumes document[0]
+
+    The DOMSnapshot domain represents the DOM tree as as set of objects each containing
+    parallel flat arrays — NodeTreeSnapshot, LayoutTreeSnapshot, etc.
+
+    Each node in the DOM tree is represented in the NodeTreeSnapshot object by corresponding
+    entries at the same index across multiple arrays (parentIndex, nodeType, backendNodeId, etc.):
+
+    NodeTreeSnapshot:
+                  │   0    │   1    |   2    |   3    |   4
+    ──────────────┼────────┼────────┼────────┼────────┼────────
+    actual tag    │ <html> │ <body> │ <div>  │  <p>   │ <span>
+    parentIndex   │  -1    │   0    │   1    │   2    │   3
+    backendNodeId │  666   │  745   │  103   │  421   │   7
+    attributes    │  ...   │  ...   │  ...   │  ...   │  ...
+    nodeValue     │  ...   │  ...   │  ...   │  ...   │  ...
+    etc           │  ...   │  ...   │  ...   │  ...   │  ...
+
+
+    Because layout is independent of node ordering, entries in the LayoutTreeSnapshot object maintain
+    a reference back to their corresponding node through the nodeIndex field along with layout specific
+    properties (bounds, paintOrders, etc).
+
+    LayoutTreeSnapshot:
+                  │   0    │    1   │   2    │   3    │   4
+    ──────────────┼────────┼────────┼────────┼────────┼────────
+    bounds        │  ...   │  ...   │  ...   │  ...   │  ...
+    etc           │  ...   │  ...   │  ...   │  ...   │  ...
+    nodeIndex     │   3    │   0    │   4    │   2    │   1
+    ──────────────┼────────┼────────┼────────┼────────┼────────
+                  │   ↓    │   ↓    │   ↓    │   ↓    │   ↓
+    backendNodeId │  421   │  666   │   7    │  103   │  745
+    actual tag    │  <p>   │ <html> │ <span> │ <div>  │ <body>
+    """
+    document = dom_snapshot.documents[0]
+    return {
+        "dom_snapshot": dom_snapshot,
+        "node_id_to_node_index": {
+            node_id: index
+            for index, node_id in enumerate(document.nodes.backendNodeId or [])
+        },
+        "node_index_to_layout_index": {
+            node_index: layout_index
+            for layout_index, node_index in enumerate(document.layout.nodeIndex)
+        },
+        "node_index_to_current_src_url_index": _dict_for_rare_string_data(
+            document.nodes.currentSourceURL
+        ),
+        "node_index_to_text_value_index": _dict_for_rare_string_data(
+            document.nodes.textValue
+        ),
+    }
+
+
+def index_for_node_id(
+    node_id: DOMBackendNodeId, context: DOMSnapshotContext
+) -> NodeIndex | None:
+    return context["node_id_to_node_index"].get(node_id, None)
+
+
+def bounds_for_node_index(
+    node_index: NodeIndex, context: DOMSnapshotContext
+) -> Rectangle | None:
+    return (
+        context["dom_snapshot"].documents[0].layout.bounds[layout_index]
+        if (layout_index := _layout_index_for_node_index(node_index, context))
+        is not None
+        else None
+    )
+
+
+def current_url_src_for_node_index(
+    node_index: NodeIndex, context: DOMSnapshotContext
+) -> str | None:
+    return _rare_string_for_node_index(
+        node_index, "node_index_to_current_src_url_index", context
+    )
+
+
+def text_value_for_node_index(
+    node_index: NodeIndex, context: DOMSnapshotContext
+) -> str | None:
+    return _rare_string_for_node_index(
+        node_index, "node_index_to_text_value_index", context
+    )
+
+
+def _layout_index_for_node_index(
+    node_index: NodeIndex, context: DOMSnapshotContext
+) -> LayoutIndex | None:
+    """Returns the index of the layout entry, if any, corresponding to the given node id."""
+    return context["node_index_to_layout_index"].get(node_index, None)
+
+
+def _rare_string_for_node_index(
+    node_index: NodeIndex,
+    dict_name: Literal[
+        "node_index_to_text_value_index", "node_index_to_current_src_url_index"
+    ],
+    context: DOMSnapshotContext,
+) -> str | None:
+    return (
+        _string_for_string_index(text_value_index, context)
+        if (text_value_index := context[dict_name].get(node_index, None))
+        else None
+    )
+
+
+def _string_for_string_index(index: StringIndex, context: DOMSnapshotContext) -> str:
+    return context["dom_snapshot"].strings[index]
+
+
+def _dict_for_rare_string_data(
+    rare_string_data: RareStringData,
+) -> dict[NodeIndex, StringIndex]:
+    """Creates a dictionary from a RareStringData object enabling lookups given a node index."""
+    return {
+        index: value
+        for index, value in zip(rare_string_data.index, rare_string_data.value)
+    }

inspect_ai/tool/_tools/_web_browser/_resources/cdp/page.py

@@ -0,0 +1,94 @@
+"""
+Types associated with Chrome DevTools Protocol's 'Page' Domain
+
+https://chromedevtools.github.io/devtools-protocol/tot/Page/
+"""
+
+from typing import Literal, NewType
+
+from pydantic import BaseModel
+
+FrameId = NewType("FrameId", str)
+
+
+class SecurityOriginDetails(BaseModel, frozen=True):
+    """Additional information about the frame document's security origin."""
+
+    isLocalhost: bool
+    """Indicates whether the frame document's security origin is one of the local hostnames (e.g. "localhost") or IP addresses (IPv4 127.0.0.0/8 or IPv6 ::1)."""
+
+
+AdFrameType = Literal["none", "child", "root"]
+
+AdFrameExplanation = Literal["ParentIsAd", "CreatedByAdScript", "MatchedBlockingRule"]
+
+
+class AdFrameStatus(BaseModel, frozen=True):
+    """Indicates whether a frame has been identified as an ad and why."""
+
+    adFrameType: AdFrameType
+    explanations: tuple[AdFrameExplanation, ...] | None = None
+
+
+SecureContextType = Literal[
+    "Secure", "SecureLocalhost", "InsecureScheme", "InsecureAncestor"
+]
+
+
+CrossOriginIsolatedContextType = Literal[
+    "Isolated", "NotIsolated", "NotIsolatedFeatureDisabled"
+]
+
+
+GatedAPIFeatures = Literal[
+    "SharedArrayBuffers",
+    "SharedArrayBuffersTransferAllowed",
+    "PerformanceMeasureMemory",
+    "PerformanceProfile",
+]
+
+
+class Frame(BaseModel, frozen=True):
+    """Information about the Frame on the page."""
+
+    id: FrameId
+    """Frame unique identifier."""
+    parentId: FrameId | None = None
+    """Parent frame identifier."""
+    loaderId: object  # Network.LoaderId
+    """Identifier of the loader associated with this frame."""
+    name: str | None = None
+    """Frame's name as specified in the tag."""
+    url: str
+    """Frame document's URL without fragment."""
+    urlFragment: str | None = None
+    """Frame document's URL fragment including the '#'."""
+    domainAndRegistry: str
+    """Frame document's registered domain, taking the public suffixes list into account. Extracted from the Frame's url. Example URLs: http://www.google.com/file.html -> "google.com" http://a.b.co.uk/file.html -> "b.co.uk"""
+    securityOrigin: str
+    """Frame document's security origin."""
+    securityOriginDetails: SecurityOriginDetails | None = None
+    """Additional details about the frame document's security origin."""
+    mimeType: str
+    """Frame document's mimeType as determined by the browser."""
+    unreachableUrl: str | None = None
+    """If the frame failed to load, this contains the URL that could not be loaded. Note that unlike url above, this URL may contain a fragment."""
+    adFrameStatus: AdFrameStatus | None = None
+    """Indicates whether this frame was tagged as an ad and why."""
+    secureContextType: SecureContextType
+    """Indicates whether the main document is a secure context and explains why that is the case."""
+    crossOriginIsolatedContextType: CrossOriginIsolatedContextType
+    """Indicates whether this is a cross origin isolated context."""
+    gatedAPIFeatures: tuple[GatedAPIFeatures, ...]
+    """Indicated which gated APIs / features are available."""
+
+
+class FrameTree(BaseModel, frozen=True):
+    frame: Frame
+    """Frame information for this tree item."""
+    childFrames: tuple["FrameTree", ...] | None = None
+    """Child frames."""
+
+
+class FrameTrees(BaseModel, frozen=True):
+    frameTree: FrameTree

inspect_ai/tool/_tools/_web_browser/_resources/constants.py

@@ -0,0 +1,2 @@
+SERVER_PORT = 5555
+DEFAULT_SESSION_NAME = "WebBrowser"