vis-agent 0.3.4.dev8082__tar.gz → 0.3.4.dev8092__tar.gz

{vis_agent-0.3.4.dev8082 → vis_agent-0.3.4.dev8092}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vis-agent
-Version: 0.3.4.dev8082
+Version: 0.3.4.dev8092
 Summary: The Vis Python SDK — author extensions and control local or remote engines.
 Project-URL: Homepage, https://vis.blockether.com
 Project-URL: Documentation, https://vis.blockether.com

{vis_agent-0.3.4.dev8082 → vis_agent-0.3.4.dev8092}/contracts/schema/gateway.json

@@ -1300,26 +1300,6 @@
       },
       "path": "/v1/sessions/:sid/views/live/:view-id/log"
     },
-    {
-      "audience": "sdk",
-      "operations": {
-        "get": {
-          "request": "none",
-          "response": "json"
-        }
-      },
-      "path": "/v1/views/live"
-    },
-    {
-      "audience": "sdk",
-      "operations": {
-        "post": {
-          "request": "json",
-          "response": "json"
-        }
-      },
-      "path": "/v1/views/:view-id/actions"
-    },
     {
       "audience": "sdk",
       "operations": {

{vis_agent-0.3.4.dev8082 → vis_agent-0.3.4.dev8092}/contracts/schema/view.json

@@ -1666,8 +1666,7 @@
       "type": "string",
       "enum": [
         "inline",
-        "panel",
-        "header"
+        "panel"
       ],
       "default": "inline"
     },
@@ -1702,12 +1701,12 @@
           "$ref": "common.json#/$defs/non_blank_string"
         },
         "extension": {
-          "description": "The extension that owns this panel or header view.",
+          "description": "The extension that owns this panel view.",
           "$ref": "common.json#/$defs/non_blank_string",
           "readOnly": true
         },
         "is_stale": {
-          "description": "True for the saved picture of an owned view after a gateway restart, until its extension opens the same key again.",
+          "description": "True for the saved picture of an owned view after a gateway restart, until its extension loads again.",
           "type": "boolean",
           "readOnly": true
         },

{vis_agent-0.3.4.dev8082 → vis_agent-0.3.4.dev8092}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vis-agent"
-version = "0.3.4.dev8082"
+version = "0.3.4.dev8092"
 description = "The Vis Python SDK — author extensions and control local or remote engines."
 readme = "README.md"
 requires-python = ">=3.12"

vis_agent-0.3.4.dev8092/release-tag

@@ -0,0 +1 @@
+beta-aada8f93cffb9c5de516bb8b02a25a9cdb281913

{vis_agent-0.3.4.dev8082 → vis_agent-0.3.4.dev8092}/src/blockether/vis/engine/_client.py

@@ -418,26 +418,6 @@ class ExecutionLayer(ABC):
         """
         return Session(self, sid)
 
-    def header_views(self) -> list[LiveView]:
-        """Read the header views of this machine as typed `LiveView` records.
-
-        A header view belongs to no session. Its events come on the fleet stream.
-        """
-        data = _field(self.get_views_live(), "views", list)
-        try:
-            return [LiveView.from_wire(item) for item in data]
-        except ValueError:
-            raise ProtocolError("invalid live View response") from None
-
-    def header_view_action(self, view_id: str, action: str, **values):
-        """Send an operator action to a header view and return the JSON response.
-
-        `values` supplies the action-specific fields of the operator action schema.
-        """
-        body = {**values, "action": action}
-        validate("view", "operator_action", body)
-        return self.post_view_actions(view_id, body=body)
-
     def create_session(
         self,
         *,
@@ -3002,34 +2982,6 @@ class ExecutionLayer(ABC):
         )
         return response.json()
 
-    def get_views_live(
-        self, *, query: Query | None = None, timeout: float | None = None
-    ) -> JSONValue:
-        """GET /v1/views/live — json response."""
-        response = self._request(
-            "GET", "/v1/views/live", path={}, query=query, timeout=timeout
-        )
-        return response.json()
-
-    def post_view_actions(
-        self,
-        view_id: str,
-        *,
-        query: Query | None = None,
-        timeout: float | None = None,
-        body: JSONValue = None,
-    ) -> JSONValue:
-        """POST /v1/views/:view-id/actions — json response."""
-        response = self._request(
-            "POST",
-            "/v1/views/:view-id/actions",
-            path={"view-id": view_id},
-            query=query,
-            timeout=timeout,
-            body=body,
-        )
-        return response.json()
-
     def post_voice(
         self,
         *,
@@ -3658,8 +3610,8 @@ class Session:
         """Read current live views as typed `blockether.vis.views.LiveView` records.
 
         This fetches a snapshot and does not subscribe to future updates. Use
-        `events` to follow view events. A `placement` (`inline`, `panel` or
-        `header`) keeps only those views. Malformed view data raises
+        `events` to follow view events. A `placement` (`inline` or `panel`)
+        keeps only those views. Malformed view data raises
         `ProtocolError`.
         """
         query = None if placement is None else {"placement": str(placement)}

{vis_agent-0.3.4.dev8082 → vis_agent-0.3.4.dev8092}/src/blockether/vis/engine/_local.py

@@ -4,7 +4,8 @@ Pass an executable, or keep the default `vis-agent`. The default runs the engine
 this SDK's release (see `ensure_installed`). There is no gateway discovery or
 user-server shutdown. Each engine gets a temporary database and stderr log, and
 closing discards them.
-Supports Linux and macOS. Instances use one calling thread, like GatewayClient.
+Supports Linux and macOS. Threads can share an instance: its requests take turns on
+the one stdio pipe.
 """
 
 from __future__ import annotations
@@ -17,6 +18,7 @@ import select
 import signal
 import subprocess
 import tempfile
+import threading
 import time
 from email.message import Message
 from pathlib import Path
@@ -150,6 +152,8 @@ class LocalEngine(ExecutionLayer):
         self._exit_status = None
         self._stderr_tail = ""
         self._cleanup_complete = False
+        # The stdio frames carry no request ids, so only one exchange can be in flight.
+        self._exchange = threading.RLock()
 
     def session_options(self, project=".") -> dict:
         """Resolve an existing local directory before the caller changes directory."""
@@ -197,6 +201,10 @@ class LocalEngine(ExecutionLayer):
         failure or close, create a new one. A startup failure cleans up the process and
         temporary database before the error propagates.
         """
+        with self._exchange:
+            return self._connect()
+
+    def _connect(self):
         if self._closed:
             raise TransportError("client is closed")
         if self._process is not None:
@@ -262,6 +270,17 @@ class LocalEngine(ExecutionLayer):
         data = (json.dumps(request, allow_nan=False) + "\n").encode()
         if len(data) > 67108864:
             raise ValueError("local request exceeds 64 MiB")
+        if not self._exchange.acquire(timeout=max(0.0, deadline - time.monotonic())):
+            raise VisTimeout("local engine request timed out")
+        try:
+            return self._exchange_frame(data, deadline)
+        finally:
+            self._exchange.release()
+
+    def _exchange_frame(self, data, deadline):
+        """Write one request frame and read its reply. The caller holds `_exchange`."""
+        if self._process is None or self._process.stdin is None:
+            raise TransportError("client is closed")
         try:
             offset = 0
             while offset < len(data):

{vis_agent-0.3.4.dev8082 → vis_agent-0.3.4.dev8092}/src/blockether/vis/extension.py

@@ -129,7 +129,7 @@ class Host(Protocol):
     def live(self, envelope_json: str, listener: Any = None) -> str:
         """Open, patch, read or close a live view.
 
-        On `open`, `listener(event)` gets each human event of a panel or header view.
+        On `open`, `listener(event)` gets each human event of a panel view.
 
         `state` accepts timeout_ms (0..86400000) and after_seq (nonnegative).
         A positive timeout blocks until the sequence differs or the view closes.
@@ -3914,12 +3914,12 @@ def ask(title, nodes, **options):
 # documents.
 #
 #   answer = vis.ask('Deploy', [
-#       vis.heading('Target'),
-#       vis.paragraph('Staging pages nobody.'),
-#       vis.row(vis.select('env', ['staging', 'prod'], label='Where',
+#       vis.ui.heading('Target'),
+#       vis.ui.paragraph('Staging pages nobody.'),
+#       vis.ui.row(vis.ui.select('env', ['staging', 'prod'], label='Where',
 #                          is_required=True),
-#               vis.slider('canary', min=0, max=100, step=5)),
-#       vis.password('token', label='Deploy token', is_required=True),
+#               vis.ui.slider('canary', min=0, max=100, step=5)),
+#       vis.ui.password('token', label='Deploy token', is_required=True),
 #   ])
 #
 # A builder is a plain dict, so a form stays printable and can be assembled in a
@@ -3934,56 +3934,56 @@ def _node(type_name, name, spec):
     return node
 
 
-def plaintext(name, **spec):
+def _ui_plaintext(name, **spec):
     # One typed line, answered as a string.
     return _node("plaintext", name, spec)
 
 
-def password(name, **spec):
+def _ui_password(name, **spec):
     # A masked line, answered as an opaque 'vis-secret:' handle: `reveal` it on
     # the trusted side, never log it.
     return _node("password", name, spec)
 
 
-def multiline(name, **spec):
+def _ui_multiline(name, **spec):
     # A text box, answered as a string that keeps its newlines.
     return _node("multiline", name, spec)
 
 
-def select(name, options, **spec):
-    # Choose exactly ONE of `options` (plain strings, or `vis.option(...)`
+def _ui_select(name, options, **spec):
+    # Choose exactly ONE of `options` (plain strings, or `vis.ui.option(...)`
     # pairs); answered as the chosen value.
     spec["options"] = list(options)
     return _node("select", name, spec)
 
 
-def multiselect(name, options, **spec):
+def _ui_multiselect(name, options, **spec):
     # Choose ANY of `options`; answered as a list, empty when nothing is ticked.
     spec["options"] = list(options)
     return _node("multiselect", name, spec)
 
 
-def checkbox(name, **spec):
+def _ui_checkbox(name, **spec):
     # One box, answered as a bool. `is_required=True` means it must end up
     # TICKED, not merely present.
     return _node("checkbox", name, spec)
 
 
-def slider(name, **spec):
+def _ui_slider(name, **spec):
     # A number on a track: min / max / step, 0 / 100 / 1 by default, answered as
     # a NUMBER. It is `range` on the wire; the builder is `slider` so it never
     # shadows the builtin.
     return _node("range", name, spec)
 
 
-def otp(name, **spec):
+def _ui_otp(name, **spec):
     # A one-time code in digit boxes: min_length / max_length say how many
     # (6 by default, 12 at most), digits only, paste fills the boxes. A code is a
     # credential, so it answers with a `vis-secret:` handle like a password.
     return _node("otp", name, spec)
 
 
-def option(value, label=None):
+def _ui_option(value, label=None):
     # One entry of a select / multiselect: the value that is ANSWERED and the
     # words shown for it. Given no label, the value shows itself.
     return {"value": value} if label is None else {"value": value, "label": label}
@@ -4016,20 +4016,20 @@ def _group(direction, fields):
     return group
 
 
-def row(*fields):
-    # Lay these nodes out side by side: `vis.row(vis.text("host"), vis.text("port"))`
-    # on a form, `vis.row("reading", vis.table("hosts", ...), vis.status("why"))`
+def _ui_row(*fields):
+    # Lay these nodes out side by side: `vis.ui.row(vis.text("host"), vis.text("port"))`
+    # on a form, `vis.ui.row("reading", vis.ui.table("hosts", ...), vis.ui.status("why"))`
     # in a live view.
     return _group("row", fields)
 
 
-def column(*fields):
+def _ui_column(*fields):
     # Stack these nodes, the default arrangement: worth saying out loud inside a
     # `row`.
     return _group("column", fields)
 
 
-def grid(*fields, max_columns=None):
+def _ui_grid(*fields, max_columns=None):
     """Lay ``fields`` out in equal columns that wrap into aligned rows.
 
     ``max_columns`` (1 to 12) caps the columns. A narrow surface shows fewer
@@ -4041,7 +4041,7 @@ def grid(*fields, max_columns=None):
     return node
 
 
-def wrap(*fields):
+def _ui_wrap(*fields):
     """Put ``fields`` side by side at their own width, wrapping onto new lines.
 
     Use it for buttons, stats, statuses and links that keep a natural width.
@@ -4049,7 +4049,7 @@ def wrap(*fields):
     return _group("wrap", fields)
 
 
-def group(*children, direction="column", **spec):
+def _ui_group(*children, direction="column", **spec):
     """Group ``children`` with optional ``label``, ``description`` and folding.
 
     A leading string is the group id. A submit button inside a group collects
@@ -4060,7 +4060,7 @@ def group(*children, direction="column", **spec):
     return node
 
 
-def card(node_id, title, **spec):
+def _ui_card(node_id, title, **spec):
     """A titled card with optional ``text``, ``tone`` and ``meta`` lines.
 
     With ``is_selectable=True`` the human can activate it like a button, and
@@ -4069,7 +4069,7 @@ def card(node_id, title, **spec):
     return _live_node("card", node_id, dict(spec, title=str(title)))
 
 
-def heading(text, live_text=None, **spec):
+def _ui_heading(text, live_text=None, **spec):
     """Form heading, or live ``heading(id, text, level=1..6)``."""
     if live_text is not None:
         return _live_node(
@@ -4080,7 +4080,7 @@ def heading(text, live_text=None, **spec):
     return {"type": "heading", "text": str(text)}
 
 
-def paragraph(text, live_text=None, **spec):
+def _ui_paragraph(text, live_text=None, **spec):
     """Form Markdown prose, or live ``paragraph(id, text)`` with inline Markdown."""
     if live_text is not None:
         return _live_node("paragraph", text, dict(spec, text=str(live_text)))
@@ -4280,9 +4280,9 @@ def list_sessions(search=None):
 # surface repaints, and the extension carries straight on. The human watches it
 # move and may stop it; the model reads the finished picture as DATA.
 #
-#   with vis.live('CI', [vis.status('now', 'Polling'),
-#                        vis.table('jobs', columns=[vis.table_column('job', 'Job'),
-#                                                   vis.table_column('state', 'State')])]) as view:
+#   with vis.live('CI', [vis.ui.status('now', 'Polling'),
+#                        vis.ui.table('jobs', columns=[vis.ui.table_column('job', 'Job'),
+#                                                   vis.ui.table_column('state', 'State')])]) as view:
 #       for job in poll():
 #           view['jobs'].upsert(job.id, [job.name, job.state], tone=job.tone)
 #       view['now'].set('Finished', tone='ok')
@@ -4692,7 +4692,7 @@ class LiveView:
         self._seq = 0
         self._cursor = 0
         self._listeners = []
-        # A panel or header view gets its events from the host, as callbacks.
+        # A panel view gets its events from the host, as callbacks.
         self._is_pushed = False
         if on_event is not None:
             self.on_event(on_event)
@@ -4986,7 +4986,7 @@ class LiveView:
     def on_event(self, callback):
         """Call `callback(event)` for each event that `events` or `sleep` reads.
 
-        A panel or header view opened with `vis.live(..., on_event=...)` gets its
+        A panel view opened with `vis.live(..., on_event=...)` gets its
         events from the host instead. Each one runs as an extension callback with
         the view session bound, also when no extension code waits on the view.
         Returns the callback, so you can use this method as a decorator.
@@ -5183,17 +5183,17 @@ def live(title, nodes, placement=None, key=None, on_event=None, **options):
     `vis.ask` documents. There is no cancellable flag: a human can always stop
     watching, and the verdict says they did (`is_from_human`) and why (`note`).
 
-    `placement` is `inline` (the default), `panel` (one session) or `header`
-    (this machine). Only extension code opens a panel or header view, and it
-    needs a `key`: the extension and the key own one view, so opening the same
-    key again replaces it. Such a view stays open after the call returns. It
+    `placement` is `inline` (the default) or `panel` (the side panel of one
+    session). Only extension code opens a panel view, and it needs a `key`:
+    the extension and the key own one view, so opening the same key again
+    replaces it. Such a view stays open after the call returns. It
     closes on `close()` or when the extension unloads. `on_event(event)` then
     runs for each human change, submit or activate, with the view session bound.
 
     The view is mounted at once and nothing blocks — use it as a context
     manager so it closes itself:
 
-        with vis.live('Deploy', [vis.steps('plan', steps=[...])]) as view:
+        with vis.live('Deploy', [vis.ui.steps('plan', steps=[...])]) as view:
             view['plan'].set('build', tone='running')
 
     Closing answers the verdict: `is_completed`, `reason`, the finished picture
@@ -5504,7 +5504,7 @@ class _LiveRecorder:
     def live(self, envelope_json, listener=None):
         """Record and apply one envelope emitted by the extension.
 
-        A `listener` gets each simulated event of a panel or header view, as the
+        A `listener` gets each simulated event of a panel view, as the
         host gives it to `on_event` callbacks.
         """
         import json
@@ -5801,8 +5801,8 @@ testing = _Testing()
 # here talks to the host, and `vis.live` is what carries it to the engine that
 # judges it.
 #
-# Layout is the FORM's own vocabulary, not a second one: `vis.row("reading",
-# table, status)` stands its nodes side by side and `vis.column(...)` stacks them,
+# Layout is the FORM's own vocabulary, not a second one: `vis.ui.row("reading",
+# table, status)` stands its nodes side by side and `vis.ui.column(...)` stacks them,
 # with a live group taking the id every op addresses. It is DECLARED once and no
 # op carries it, so a layout never rearranges itself while a human is reading it.
 
@@ -5814,7 +5814,7 @@ def _live_node(type_name, node_id, spec):
     return node
 
 
-def disclosure(node_id, label, *nodes, default_expanded=False):
+def _ui_disclosure(node_id, label, *nodes, default_expanded=False):
     """A collapsible column.
 
     Local choices survive updates, and receipts start collapsed.
@@ -5832,17 +5832,17 @@ def disclosure(node_id, label, *nodes, default_expanded=False):
     )
 
 
-def divider(node_id):
+def _ui_divider(node_id):
     """A static horizontal rule across its live container. Add or drop it by id."""
     return _live_node("divider", node_id, {})
 
 
-def code(node_id, text, *, language=None, **spec):
+def _ui_code(node_id, text, *, language=None, **spec):
     """Literal code. Whitespace is kept, and content is never executed."""
     return _live_node("code", node_id, dict(spec, text=str(text), language=language))
 
 
-def spinner(node_id, text="Working", *, variant="braille", is_active=True, **spec):
+def _ui_spinner(node_id, text="Working", *, variant="braille", is_active=True, **spec):
     """A braille, dots, line or pulse indicator. Receipts never animate."""
     return _live_node(
         "spinner",
@@ -5851,7 +5851,7 @@ def spinner(node_id, text="Working", *, variant="braille", is_active=True, **spe
     )
 
 
-def button(node_id, label, *, is_disabled=False, **spec):
+def _ui_button(node_id, label, *, is_disabled=False, **spec):
     """An operator action. Accepted presses increment ``clicks`` in ``view.state()``.
 
     No callback or code crosses the wire. The producer decides how to respond.
@@ -5862,27 +5862,27 @@ def button(node_id, label, *, is_disabled=False, **spec):
     )
 
 
-def status(node_id, text=None, **spec):
+def _ui_status(node_id, text=None, **spec):
     # One line saying what is happening right now: text, tone, detail, label.
     return _live_node("status", node_id, dict(spec, text=text))
 
 
-def progress(node_id, **spec):
+def _ui_progress(node_id, **spec):
     # A bar: value (0..1), or done/total. Neither is indeterminate.
     return _live_node("progress", node_id, spec)
 
 
-def stat(node_id, stats=None, **spec):
+def _ui_stat(node_id, stats=None, **spec):
     # A strip of counters, each `{'id': ..., 'label': ..., 'value_text': ...}`.
     return _live_node("stat", node_id, dict(spec, stats=stats))
 
 
-def steps(node_id, steps=None, **spec):
+def _ui_steps(node_id, steps=None, **spec):
     # A checklist, each `{'id': ..., 'label': ..., 'tone': ...}`.
     return _live_node("steps", node_id, dict(spec, steps=steps))
 
 
-def output(node_id, **spec):
+def _ui_output(node_id, **spec):
     """Durable output with an independent disclosure, collapsed by default.
 
     ``default_expanded=True`` opens an active log initially. Updates preserve the local
@@ -5896,7 +5896,7 @@ def output(node_id, **spec):
     return _live_node("log", node_id, spec)
 
 
-def table(node_id, columns=None, **spec):
+def _ui_table(node_id, columns=None, **spec):
     # Rows keyed by id. `order` declares how they paint — 'insertion' (the
     # default), 'newest-first', or {'by': 'duration', 'dir': 'desc'}.
     # `is_selectable=True` makes rows controls; `selected_ids` is shared state.
@@ -5905,17 +5905,17 @@ def table(node_id, columns=None, **spec):
     return _live_node("table", node_id, dict(spec, columns=columns))
 
 
-def table_column(column_id, label=None, **spec):
+def _ui_table_column(column_id, label=None, **spec):
     # One declared column: the id a cell sits under, its header, its align.
     return _live_item(column_id, dict(spec, label=label))
 
 
-def table_row(row_id, cells, **spec):
+def _ui_table_row(row_id, cells, **spec):
     # One declared row: the id every later upsert addresses, and its cells.
     return _live_item(row_id, dict(spec, cells=[_cell(c) for c in cells]))
 
 
-def table_group(group_id, label=None, **spec):
+def _ui_table_group(group_id, label=None, **spec):
     # One declared group of a table: the id a row's `parent` names, the `label`
     # painted over it instead of that id, and optionally `tone`, `order` and
     # `is_open`. Renaming the label never moves the group, because rows point at
@@ -5923,6 +5923,57 @@ def table_group(group_id, label=None, **spec):
     return _live_item(group_id, dict(spec, label=label))
 
 
-def link(node_id, links=None, **spec):
+def _ui_link(node_id, links=None, **spec):
     # Pointers a human can open: url, path or attachment.
     return _live_node("link", node_id, dict(spec, links=links))
+
+
+class _UI:
+    """Components for live views and forms.
+
+    `vis.live` and `vis.ask` take the same components, so one input or layout
+    works in both. Each builder returns plain data and talks to no host.
+    """
+
+    # Inputs
+    plaintext = staticmethod(_ui_plaintext)
+    password = staticmethod(_ui_password)
+    multiline = staticmethod(_ui_multiline)
+    select = staticmethod(_ui_select)
+    multiselect = staticmethod(_ui_multiselect)
+    checkbox = staticmethod(_ui_checkbox)
+    slider = staticmethod(_ui_slider)
+    otp = staticmethod(_ui_otp)
+    option = staticmethod(_ui_option)
+
+    # Layout
+    row = staticmethod(_ui_row)
+    column = staticmethod(_ui_column)
+    grid = staticmethod(_ui_grid)
+    wrap = staticmethod(_ui_wrap)
+    group = staticmethod(_ui_group)
+    card = staticmethod(_ui_card)
+    disclosure = staticmethod(_ui_disclosure)
+
+    # Text and links
+    heading = staticmethod(_ui_heading)
+    paragraph = staticmethod(_ui_paragraph)
+    divider = staticmethod(_ui_divider)
+    code = staticmethod(_ui_code)
+    link = staticmethod(_ui_link)
+
+    # Live state
+    spinner = staticmethod(_ui_spinner)
+    button = staticmethod(_ui_button)
+    status = staticmethod(_ui_status)
+    progress = staticmethod(_ui_progress)
+    stat = staticmethod(_ui_stat)
+    steps = staticmethod(_ui_steps)
+    output = staticmethod(_ui_output)
+    table = staticmethod(_ui_table)
+    table_column = staticmethod(_ui_table_column)
+    table_row = staticmethod(_ui_table_row)
+    table_group = staticmethod(_ui_table_group)
+
+
+ui = _UI()

{vis_agent-0.3.4.dev8082 → vis_agent-0.3.4.dev8092}/tests/test_client.py

@@ -954,54 +954,17 @@ def test_snapshot_info_reads_the_manifest_without_a_request():
         GatewayClient.snapshot_info(damaged)
 
 
-def test_header_views_read_and_act_through_the_machine_routes():
-    view = {
-        "id": "v1",
-        "title": "Build",
-        "placement": "header",
-        "key": "build",
-        "extension": "forge",
-        "nodes": [
-            {
-                "id": "go",
-                "type": "button",
-                "label": "Rerun",
-                "action": "activate",
-                "is_disabled": False,
-                "clicks": 0,
-            }
-        ],
-        "seq": 0,
-        "created_at": 1,
-        "timeout_ms": 0,
-        "channel_ids": ["app"],
-    }
-
+def test_live_views_filter_by_placement_on_the_session_route():
     def respond(method, path, body):
         if path.startswith(("/v1/capabilities", "/v1/clients")):
             return compatible(method, path, body)
-        if path == "/v1/views/live":
-            return 200, {"views": [view]}
-        if path.startswith("/v1/sessions/s1/views/live"):
-            return 200, {"views": []}
-        return 200, {"is_accepted": True}
+        return 200, {"views": []}
 
     with endpoint(respond) as (url, calls), GatewayClient(url) as client:
-        [header] = client.header_views()
-        assert (header.placement, header.key, header.extension) == (
-            "header",
-            "build",
-            "forge",
-        )
-        assert client.header_view_action("v1", "activate", node_id="go")["is_accepted"]
         assert client.session("s1").live_views(placement="panel") == []
     sent = [
-        (method, path, json.loads(body or b"null"))
-        for method, path, _, body in calls
+        (method, path)
+        for method, path, _, _ in calls
         if not path.startswith(("/v1/capabilities", "/v1/clients"))
     ]
-    assert sent == [
-        ("GET", "/v1/views/live", None),
-        ("POST", "/v1/views/v1/actions", {"node_id": "go", "action": "activate"}),
-        ("GET", "/v1/sessions/s1/views/live?placement=panel", None),
-    ]
+    assert sent == [("GET", "/v1/sessions/s1/views/live?placement=panel")]