mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/http_pool.py

@@ -0,0 +1,175 @@
+"""Warm model connections shared across runs in one process, each borrowed by one caller at a time."""
+
+import hashlib
+import threading
+import time
+
+from .transport import HTTP, peer_closed
+
+# Under each front end's own limit (2026-09-23: aiplatform.googleapis.com closed one at 240 s, api.typesafe.ai at 900+).
+MAX_IDLE_SECONDS = 120
+IDLE_LIMITS = {"https://aiplatform.googleapis.com": 180, "https://api.typesafe.ai/v1": 600}
+MAX_IDLE_PER_KEY = 4
+
+
+def _digest(key):
+    return hashlib.sha256((key or "").encode("utf-8")).hexdigest()
+
+
+class ConnectionPool:
+    def __init__(self, max_idle=None, per_key=MAX_IDLE_PER_KEY, factory=HTTP, clock=time.monotonic):
+        self.max_idle, self.per_key = max_idle, per_key
+        self._factory, self._clock = factory, clock
+        self._idle = {}
+        self._lock = threading.Lock()
+        self.stats = {"created": 0, "reused": 0, "discarded": 0, "released": 0}
+
+    def acquire(self, base_url, key=""):
+        pool_key = (base_url, _digest(key))
+        stale = []
+        client = None
+        reused = False
+        with self._lock:
+            idle = self._idle.get(pool_key, [])
+            while idle:
+                candidate, since = idle.pop()
+                limit = self.max_idle if self.max_idle is not None else IDLE_LIMITS.get(base_url, MAX_IDLE_SECONDS)
+                sock = getattr(candidate.connection, "sock", None)
+                if self._clock() - since <= limit and sock is not None and not peer_closed(sock):
+                    client = candidate
+                    reused = True
+                    self.stats["reused"] += 1
+                    break
+                stale.append(candidate)
+                self.stats["discarded"] += 1
+            if client is None:
+                self.stats["created"] += 1
+        for old in stale:
+            old.close()
+        if client is None:
+            client = self._factory(base_url, key)
+        client.key = key
+        # Read by PooledHTTP for the trace's ``reused`` flag on a fresh borrow.
+        client.pool_reused = reused
+        return client
+
+    def release(self, base_url, key, client):
+        inflight = getattr(client, "_inflight", None)
+        busy = inflight is not None and inflight.locked()
+        connected = getattr(client.connection, "sock", None) is not None
+        if busy or not connected:
+            client.close()
+            return False
+        client.key = key
+        pool_key = (base_url, _digest(key))
+        extra = None
+        with self._lock:
+            idle = self._idle.setdefault(pool_key, [])
+            idle.append((client, self._clock()))
+            self.stats["released"] += 1
+            if len(idle) > self.per_key:
+                extra, _ = idle.pop(0)
+        if extra is not None:
+            extra.close()
+        return True
+
+    def prewarm(self, base_url, key="", timeout=5.0):
+        def run():
+            try:
+                client = self._factory(base_url, key)
+                with self._lock:
+                    self.stats["created"] += 1
+                client.connection.timeout = timeout
+                client.connection.connect()
+                self.release(base_url, key, client)
+            except Exception:
+                pass  # Warming is an optimization; the first real call connects itself.
+        thread = threading.Thread(target=run, name="mobster-prewarm", daemon=True)
+        thread.start()
+        return thread
+
+    def clear(self):
+        with self._lock:
+            clients = [client for idle in self._idle.values() for client, _ in idle]
+            self._idle.clear()
+        for client in clients:
+            client.close()
+
+
+POOL = ConnectionPool()
+
+
+class PooledHTTP:
+    def __init__(self, base_url, key="", pool=None):
+        self.base_url, self._key = base_url, key
+        self._pool = POOL if pool is None else pool
+        self._client = None
+        self._active = 0
+        self._fresh_borrow = False
+        self._lock = threading.Lock()
+        self.last_reused = None
+
+    def _borrow(self):
+        # Caller holds self._lock.
+        if self._client is None:
+            self._client = self._pool.acquire(self.base_url, self._key)
+            self._fresh_borrow = True
+        return self._client
+
+    @property
+    def connection(self):
+        with self._lock:
+            return self._borrow().connection
+
+    @property
+    def key(self):
+        return self._key
+
+    @key.setter
+    def key(self, value):
+        # Vertex sets a short-lived bearer token per request; the pool key stays the construction-time credential.
+        with self._lock:
+            self._borrow().key = value
+
+    def request(self, method, path, body=None, timeout=20):
+        with self._lock:
+            if self._active > 0:
+                # The borrower's connection carries a request already (24 Sep): a second one serves this, then returns.
+                extra = self._pool.acquire(self.base_url, self._key)
+                if self._client is not None:
+                    extra.key = self._client.key  # Carry a per-request bearer token (Vertex).
+                # last_reused stays the in-flight request's.
+            else:
+                extra = None
+                client = self._borrow()
+                if self._fresh_borrow:
+                    self._fresh_borrow = False
+                    self.last_reused = bool(getattr(client, "pool_reused", False))
+                else:
+                    self.last_reused = getattr(client.connection, "sock", None) is not None
+                self._active += 1
+        if extra is not None:
+            try:
+                return extra.request(method, path, body, timeout)
+            finally:
+                self._pool.release(self.base_url, self._key, extra)
+        try:
+            return client.request(method, path, body, timeout)
+        finally:
+            with self._lock:
+                self._active -= 1
+
+    def close(self):
+        with self._lock:
+            client, self._client = self._client, None
+            busy = self._active > 0
+        if client is None:
+            return
+        if busy:
+            client.close()  # Abort the in-flight request, exactly like HTTP.close.
+        else:
+            self._pool.release(self.base_url, self._key, client)
+
+
+def pooled_http(base_url, key=""):
+    return PooledHTTP(base_url, key)

mobile_agent/image_policy.py

@@ -0,0 +1,139 @@
+"""When a Smart turn needs the screenshot: only when the accessibility tree can't carry the screen.
+
+The rows the model reads (frontier.screen_rows)
+say what is on most screens: every label, value, switch state, the selected tab, where each control sits. The picture
+adds what rows can't say. ``decide`` keeps it exactly then, and drops it on the turns where the rows are the whole
+screen:
+
+- the first turn, a new app in front, or ``MAX_BLIND`` turns without one (the picture never goes stale for long);
+- the turn after a miss: the last action got feedback, or its outcome is unproven (the screen may not be what the
+  model thinks it is);
+- a skill's pictures waiting to be shown, or a driver that reads pixels (its rows come from the picture already);
+- a request about how something looks (a colour, an icon, a photo, a layout);
+- a screen the rows can't describe (``tree_gap``): too few rows, a control with no label, a web view, a map or a
+  video, a large picture or unnamed area, a switch-like control that shows no state (a segmented control, a date
+  picker, a tab bar with no selected tab), a text field with no label.
+
+Every reason is a word in ``REASONS`` that goes on the turn's ``frontier_prompt`` event, so a run says why each turn
+had its picture or went without. ``MOBSTER_IMAGE_POLICY=tree`` turns the policy on; the default is ``always``, a
+picture every turn as before, until the paired A/B on real phones passes (tuning/PLAN.md).
+
+Code only: it reads rows and counters, calls no model, and fails toward sending the picture.
+"""
+
+import os
+import re
+from dataclasses import dataclass
+
+MODES = ("always", "tree")
+MAX_BLIND = 3                   # turns in a row that may go without a picture
+MIN_ROWS = 5                    # a screen with fewer rows than this isn't described by them
+HERO_AREA = 30.0                # percent of the screen: a picture or unnamed area this big is content, not chrome
+CHROME = re.compile(r"overlay|dimming|background|shadow|separator|scrim|backdrop|divider", re.I)
+HERO_ROLES = frozenset({"Image", "Other"})
+OPAQUE_ROLES = frozenset({"WebView", "Map", "Video", "Canvas", "MapView", "WebKit"})
+# Controls whose state the rows show as ``value=`` or ``selected``; one that shows neither can't be read from rows.
+STATE_ROLES = frozenset({"SegmentedControl", "DatePicker", "TabBar"})
+GROUPS = frozenset({"Toolbar", "TabBar"})
+VISUAL = re.compile(r"\b(colou?rs?|icons?|logos?|images?|photos?|pictures?|screenshots?|look(?:s|ing)? like|appears?|"
+                    r"shapes?|draw(?:ing)?|sketch|designs?|layouts?|pixels?|emoji|videos?|maps?|charts?|graphs?|"
+                    r"badges?|animations?|wallpapers?|fonts?|brightness|dark mode|themes?|stickers?|memes?|gifs?)\b",
+                    re.I)
+ROW = re.compile(r'^(e\d+) (\S+) (?:"((?:[^"\\]|\\.)*)"|\(no label[^)]*\))(.*?)@(-?\d+),(-?\d+)(?:,(\d+),(\d+))?\s*$')
+VALUE = re.compile(r'\bvalue="')
+
+REASONS = ("off", "first turn", "new app", "refresh", "after a miss", "skill pictures", "pixel read", "visual request",
+           "long task", "too few rows", "unlabeled control", "opaque view", "large picture", "state not in the rows",
+           "tree carries the screen")
+
+
+@dataclass(frozen=True)
+class Row:
+    alias: str
+    role: str
+    label: str                  # "" when the row has no label
+    labeled: bool
+    flags: str                  # what follows the label: value="...", selected, editable, disabled
+    x: int
+    y: int
+    w: int
+    h: int
+
+    @property
+    def area(self):
+        return self.w * self.h / 100.0
+
+    @property
+    def has_value(self):
+        return bool(VALUE.search(self.flags))
+
+    @property
+    def selected(self):
+        return bool(re.search(r"\bselected\b", self.flags))
+
+
+@dataclass(frozen=True)
+class Turn:
+    """What the loop knows about this turn besides the rows."""
+    first: bool = False
+    new_app: bool = False
+    blind: int = 0                  # turns in a row without a picture before this one
+    missed: bool = False            # the last action got feedback, or its outcome is unproven
+    skill_pictures: bool = False
+    pixel_read: bool = False
+    long_task: bool = False
+    request: str = ""
+
+
+def mode():
+    value = os.environ.get("MOBSTER_IMAGE_POLICY", "always").strip().lower()
+    return value if value in MODES else "always"
+
+
+def parse_rows(lines):
+    """``Row``s from the "Screen elements" lines of a prompt; a line that isn't a row is skipped."""
+    rows = []
+    for line in lines:
+        found = ROW.match(str(line).strip())
+        if not found:
+            if re.match(r"^e\d+\s", str(line).strip()):
+                rows.append(Row(str(line).split()[0], "Unknown", "", False, "", 0, 0, 0, 0))
+            continue
+        alias, role, label, rest, x, y, w, h = found.groups()
+        rows.append(Row(alias, role, (label or "").replace('\\"', '"'), bool(label and label.strip()), rest.strip(),
+                        int(x), int(y),
+                        int(w or 0), int(h or 0)))
+    return rows
+
+
+def tree_gap(rows):
+    """Why the rows can't carry this screen (one of ``REASONS``), or None when they can."""
+    if len(rows) < MIN_ROWS:
+        return "too few rows"
+    if any(row.role in OPAQUE_ROLES for row in rows):
+        return "opaque view"
+    for row in rows:
+        if not row.labeled and row.role != "StaticText":
+            return "unlabeled control"     # the rows say "find it by position in the screenshot"
+        if row.role in HERO_ROLES and row.area >= HERO_AREA and not CHROME.search(row.label):
+            return "large picture"
+    for row in rows:
+        if row.role in STATE_ROLES and not row.has_value and not row.selected:
+            return "state not in the rows"
+    if any(row.role in GROUPS for row in rows) and not any(row.selected for row in rows):
+        return "state not in the rows"
+    return None
+
+
+def decide(rows, turn):
+    """(send the picture?, the reason) for a Smart turn showing ``rows``. Fails toward sending it."""
+    for flag, why in ((turn.long_task, "long task"), (turn.first, "first turn"), (turn.new_app, "new app"),
+                      (turn.pixel_read, "pixel read"), (turn.skill_pictures, "skill pictures"),
+                      (turn.missed, "after a miss"), (turn.blind >= MAX_BLIND, "refresh"),
+                      (bool(VISUAL.search(turn.request or "")), "visual request")):
+        if flag:
+            return True, why
+    gap = tree_gap(rows)
+    if gap is not None:
+        return True, gap
+    return False, "tree carries the screen"

mobile_agent/inbox.py

@@ -0,0 +1,148 @@
+"""Needs you (GET /api/inbox): approvals, questions, results to review, repairs and unsent drafts; never history."""
+
+from __future__ import annotations
+
+import time
+
+from .workflows.health import run_outcome
+
+REVIEW_DAYS = 7
+# A draft stays as long as a result to look at: then its conversation has moved on without it.
+DRAFT_DAYS = REVIEW_DAYS
+DRAFT_FIELDS = ("to", "handle", "app", "bundleId", "account", "context", "lastMessage", "draft", "decision", "frameId",
+                "yourWords")
+QUESTION_KINDS = frozenset({"clarify", "question"})
+ACTIVE = frozenset({"queued", "running"})
+WORKFLOW_ORIGINS = frozenset({"workflow", "schedule"})
+
+
+def _ms(seconds):
+    return round(seconds * 1000) if isinstance(seconds, (int, float)) else None
+
+
+def _text(value, limit):
+    return " ".join(value.split())[:limit] if isinstance(value, str) and value.strip() else None
+
+
+def _same_task(run):
+    return ((run.app or {}).get("id"), " ".join(str(run.goal or "").casefold().split()))
+
+
+def _base(run):
+    extras = run.extras if isinstance(run.extras, dict) else {}
+    app = run.app or {}
+    return {"runId": run.id, "goal": run.goal or "", "app": app.get("name") or "", "appId": app.get("id"),
+            "device": run.device_id, "deviceName": run.device_name,
+            "threadId": extras.get("threadId") if isinstance(extras.get("threadId"), str) else None}
+
+
+def _result(run):
+    summary = run.summary if isinstance(run.summary, dict) else {}
+    return {"status": run.status, "answer": _text(summary.get("answer"), 300),
+            "reason": _text(summary.get("reason"), 300)}
+
+
+def collect(runs, workflows, now=None):
+    now = time.time() if now is None else now
+    waiting, later = [], []
+    by_id = {run.id: run for run in runs}
+    # When each task last ended Done: anything older of the same task is history.
+    done_at = {}
+    for run in runs:
+        if run_outcome(run) == "done":
+            done_at[_same_task(run)] = max(done_at.get(_same_task(run), 0), run.created_at)
+    last_runs = {workflow.get("lastRunId"): workflow for workflow in workflows if workflow.get("lastRunId")}
+    drafts = []
+
+    for run in runs:
+        if run.status not in ACTIVE and now - (run.finished_at or run.created_at) <= DRAFT_DAYS * 86_400:
+            drafts.extend(_drafts(run, by_id))
+        if run.status in ACTIVE:
+            with run.condition:
+                approval = dict(run.approval) if run.approval else None
+            if approval and approval.get("id") and (approval.get("expiresAt") or 0) > now * 1000:
+                kind = "question" if approval.get("kind") in QUESTION_KINDS else "approval"
+                waiting.append({"id": f"{kind}:{approval['id']}", "kind": kind, "at": approval.get("requestedAt"),
+                                **_base(run), "approval": approval})
+            continue
+        if run_outcome(run) != "check":
+            continue
+        workflow = last_runs.get(run.id)
+        if run.origin in WORKFLOW_ORIGINS and workflow is None:
+            continue  # its workflow ran again since
+        finished = run.finished_at or run.created_at
+        if now - finished > REVIEW_DAYS * 86_400 or done_at.get(_same_task(run), 0) > run.created_at:
+            continue
+        later.append({"id": f"review:{run.id}", "kind": "review", "at": _ms(finished), **_base(run),
+                      "result": _result(run),
+                      **({"workflow": {"id": workflow["id"], "name": workflow.get("name")}} if workflow else {})})
+
+    for workflow in workflows:
+        item = _repair(workflow, by_id)
+        if item:
+            later.append(item)
+
+    # One draft per person a profile writes to: a later task's draft to the same person replaces an earlier one.
+    drafts.sort(key=lambda item: item.get("at") or 0, reverse=True)
+    seen = set()
+    for item in drafts:
+        draft = item["draft"]
+        recipient = ("handle", draft["handle"]) if draft.get("handle") else ("name", draft.get("to"))
+        person = (draft.get("bundleId") or draft.get("app") or item["app"], draft.get("account"),
+                  recipient[0], " ".join(str(recipient[1]).casefold().split()))
+        if person not in seen:
+            seen.add(person)
+            later.append(item)
+
+    waiting.sort(key=lambda item: item["approval"].get("expiresAt") or 0)
+    later.sort(key=lambda item: item.get("at") or 0, reverse=True)
+    return waiting + later
+
+
+def _drafts(run, runs):
+    summary = run.summary if isinstance(run.summary, dict) else {}
+    blocks = summary.get("blocks") if isinstance(summary.get("blocks"), list) else []
+    brief = summary.get("brief") if isinstance(summary.get("brief"), dict) else {}
+    sources = brief.get("sources") if isinstance(brief.get("sources"), dict) else {}
+    with run.condition:
+        decided = dict(run.block_state)
+    items = []
+    for block in blocks:
+        if not isinstance(block, dict) or block.get("type") != "review_queue" or not isinstance(block.get("id"), str):
+            continue
+        source = sources.get(block["id"])
+        if isinstance(source, list) and len(source) == 2 and source[0] != run.id and source[0] in runs:
+            continue  # a brief's copy of another task's queue is that task's while it is here: listed once
+        for item in block.get("items") or ():
+            if not isinstance(item, dict) or not isinstance(item.get("id"), str) or not isinstance(item.get("to"), str):
+                continue
+            if not item.get("draft") and item.get("yourWords") is not True:
+                continue  # nothing to send: an opener to someone who asked for no DMs, a conversation that can wait
+            if (decided.get(f"{block['id']}/{item['id']}") or {}).get("state") in ("approved", "skipped"):
+                continue
+            items.append({"id": f"draft:{run.id}/{block['id']}/{item['id']}", "kind": "draft",
+                          "at": _ms(run.finished_at or run.created_at), **_base(run),
+                          "draft": {"blockId": block["id"], "itemId": item["id"],
+                                    "action": block.get("action") or "send_message",
+                                    **{key: item[key] for key in DRAFT_FIELDS if item.get(key) is not None}}})
+    return items
+
+
+def _repair(workflow, runs):
+    health = workflow.get("health") if isinstance(workflow.get("health"), dict) else {}
+    attention = health.get("attention") if isinstance(health.get("attention"), dict) else None
+    if not attention or attention.get("kind") != "failed":
+        return None
+    run = runs.get(attention.get("runId")) if isinstance(attention.get("runId"), str) else None
+    item = {"id": f"repair:{workflow['id']}", "kind": "repair",
+            "workflow": {"id": workflow["id"], "name": workflow.get("name"), "enabled": workflow.get("enabled") is True,
+                         "nextAt": workflow.get("nextAt")}}
+    reason = _text(attention.get("detail"), 300) or _text(attention.get("words"), 300)
+    if run is not None:
+        result = _result(run)
+        return {**item, **_base(run), "at": _ms(run.finished_at or run.created_at),
+                "result": {**result, "reason": result["reason"] or reason}}
+    return {**item, "runId": None, "goal": workflow.get("goal") or "", "app": workflow.get("appName") or "",
+            "appId": workflow.get("appId"), "device": workflow.get("device"), "deviceName": None, "threadId": None,
+            "at": attention.get("at"),
+            "result": {"status": workflow.get("lastOutcome"), "answer": None, "reason": reason}}