webbee 0.3.9__tar.gz → 0.3.10__tar.gz

{webbee-0.3.9 → webbee-0.3.10}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.3.10
+
+- Remote instructions picked up by an idle terminal now carry a dedup id, so
+  an at-least-once delivery can never run — or bill — the same instruction
+  twice.
+
 ## 0.3.9
 
 - Internal restructure: the session engine was split into focused modules

{webbee-0.3.9 → webbee-0.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.9
+Version: 0.3.10
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io

{webbee-0.3.9 → webbee-0.3.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.9"
+version = "0.3.10"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "MIT"

webbee-0.3.10/src/webbee/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.10"

{webbee-0.3.9 → webbee-0.3.10}/src/webbee/repl.py

@@ -214,14 +214,16 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         await _run_turn(line)
         return "continue"
 
-    async def _run_turn(line: str, surface: str = "") -> None:
+    async def _run_turn(line: str, surface: str = "", steer_iid: str = "") -> None:
         """ONE agent turn -- the SAME path for a typed line and an idle-steer
         pickup (liveness v2 §B), which threads the queued item's origin
-        `surface` into the turn so the kernel stamps provenance start-path.
-        Only the echo differs at the call sites: user_echo for a typed line,
-        foreign_turn for a remote one."""
+        `surface` (provenance) and dedup `steer_iid` (kernel dedup ring) into
+        the turn start-path. Only the echo differs at the call sites:
+        user_echo for a typed line, foreign_turn for a remote one."""
         _sink.begin_turn()
         kw = {"surface": surface} if surface else {}
+        if steer_iid:
+            kw["steer_iid"] = steer_iid
         try:
             text = await agent.run(line, _sink, marathon=not once,
                                    goal=(line if not once else ""), **kw)
@@ -236,11 +238,12 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
             return
         _sink.end_turn(text)
 
-    async def _steer_submit(text: str, surface: str) -> None:
+    async def _steer_submit(text: str, surface: str, steer_iid: str = "") -> None:
         """webbee.steer hands a drained remote instruction here: render it as
-        the remote user's own line, then run it as a normal turn."""
+        the remote user's own line, then run it as a normal turn (carrying the
+        item's dedup iid so the kernel can drop an at-least-once twin)."""
         _sink.foreign_turn(surface, "user", text)
-        await _run_turn(text, surface=surface)
+        await _run_turn(text, surface=surface, steer_iid=steer_iid)
 
     def _cancel_background() -> None:
         for _t in (watcher_task, steer_task):

{webbee-0.3.9 → webbee-0.3.10}/src/webbee/session.py

@@ -45,7 +45,7 @@ class AgentSession:
         return {"Authorization": f"Bearer {token}"}
 
     async def run(self, task: str, sink, *, marathon: bool = False, goal: str = "",
-                  surface: str = "") -> str:
+                  surface: str = "", steer_iid: str = "") -> str:
         import httpx
 
         from webbee.tools import LocalToolExecutor
@@ -72,6 +72,11 @@ class AgentSession:
             # [surface] tags). Additive-only -- a typed turn's body is
             # byte-identical to before.
             body["surface"] = surface
+        if steer_iid:
+            # steer-iid-dedup: a pickup also carries the queued item's dedup id
+            # so the kernel's ring can drop an at-least-once twin. Same
+            # additive-only contract -- a typed turn has none, key omitted.
+            body["steer_iid"] = steer_iid
         if marathon:
             body["marathon"] = True
             body["goal"] = goal

{webbee-0.3.9 → webbee-0.3.10}/src/webbee/steer.py

@@ -58,8 +58,9 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                           live_session_id=lambda: "",
                           interval: float = _POLL_INTERVAL) -> None:
     """Run forever (until cancelled): every ~`interval`s of idle time, drain
-    the pending-steer queue and hand the FIRST item to `submit(text, surface)`
-    -- the repl's normal turn path. Seams (all injected by the repl wiring):
+    the pending-steer queue and hand the FIRST item to
+    `submit(text, surface, steer_iid)` -- the repl's normal turn path. Seams
+    (all injected by the repl wiring):
       * is_busy()        -- sync; True while a turn is running. Checked BEFORE
                             the destructive fetch (never drain mid-turn) and
                             AGAIN right before submit (a locally-typed line
@@ -67,9 +68,12 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                             backlog instead of being lost).
       * live_session_id()-- sync; the agent's gateway-issued session id once a
                             turn has run ("" before). Wins over derivation.
-      * submit(text, surface) -- async; renders the remote line and runs the
-                            turn. Runs INSIDE this task, so polling is
-                            naturally paused for the turn's whole duration."""
+      * submit(text, surface, steer_iid) -- async; renders the remote line and
+                            runs the turn. Runs INSIDE this task, so polling
+                            is naturally paused for the turn's whole duration.
+                            steer_iid = the queued item's dedup id ("" on an
+                            older gateway), threaded into the turn POST so the
+                            kernel's dedup ring can drop an at-least-once twin."""
     from webbee.thread import fetch_pending_steer
     derived = ""
     backlog: deque = deque()
@@ -97,7 +101,8 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
             if is_busy():
                 backlog.appendleft(item)  # a local line won the race -- defer, don't drop
                 continue
-            await submit(text, str(item.get("surface") or "telegram"))
+            await submit(text, str(item.get("surface") or "telegram"),
+                         str(item.get("iid") or ""))
             if _cancel_absorbed():
                 raise asyncio.CancelledError
         except asyncio.CancelledError:

{webbee-0.3.9 → webbee-0.3.10}/tests/test_repl.py

@@ -590,10 +590,11 @@ class SurfaceAgent(FakeAgent):
     with a typed turn (the plain fallback read_line is sync)."""
     session_id = "marathon-user-1-rab12cd34ef56"
 
-    async def run(self, task, sink, *, marathon=False, goal="", surface=""):
+    async def run(self, task, sink, *, marathon=False, goal="", surface="",
+                  steer_iid=""):
         self.tasks.append(task)
         self.runs.append({"task": task, "marathon": marathon, "goal": goal,
-                          "surface": surface})
+                          "surface": surface, "steer_iid": steer_iid})
         await asyncio.sleep(0)
         return f"answer:{task}"
 
@@ -606,7 +607,7 @@ def test_steer_pickup_renders_remote_line_and_runs_tagged_turn(monkeypatch):
                          marathon=True, live_session_id=lambda: "", **kw):
         captured["marathon"] = marathon
         captured["live_sid"] = live_session_id()
-        await submit("push the fix", "telegram")
+        await submit("push the fix", "telegram", "iid-42")
 
     monkeypatch.setattr(SP, "poll_idle_steer", spy_poller)
 
@@ -617,9 +618,11 @@ def test_steer_pickup_renders_remote_line_and_runs_tagged_turn(monkeypatch):
     sink, agent = _run(read_line=_lines("hello", "again", "/exit"), agent=agent)
     # the remote user's line renders tagged with its origin surface...
     assert ("telegram", "user", "push the fix") in getattr(sink, "foreign", [])
-    # ...and the SAME turn path ran it, threading surface into the turn kwargs
+    # ...and the SAME turn path ran it, threading surface + the item's dedup
+    # iid into the turn kwargs (steer-iid-dedup pickup path)
     steer_runs = [r for r in agent.runs if r["task"] == "push the fix"]
     assert steer_runs and steer_runs[0]["surface"] == "telegram"
+    assert steer_runs[0]["steer_iid"] == "iid-42"
     assert steer_runs[0]["marathon"] is True          # normal marathon turn
     # a picked-up turn ends like any other -- end_turn fired, dock leaves busy
     assert "answer:push the fix" in sink.turns

{webbee-0.3.9 → webbee-0.3.10}/tests/test_session.py

@@ -961,3 +961,24 @@ def test_run_omits_surface_key_for_plain_typed_turns(monkeypatch):
     # to before -- no `surface` key at all.
     body = _run_turn_capture_body(monkeypatch)
     assert "surface" not in body
+
+
+def test_run_threads_steer_iid_into_session_post_body(monkeypatch):
+    # steer-iid-dedup pickup path: a picked-up remote instruction carries the
+    # queue entry's dedup id so the kernel ring can drop an at-least-once twin.
+    body = _run_turn_capture_body(monkeypatch, surface="telegram", steer_iid="iid-42")
+    assert body["steer_iid"] == "iid-42"
+    assert body["surface"] == "telegram"
+
+
+def test_run_omits_steer_iid_key_for_plain_typed_turns(monkeypatch):
+    # A typed turn has no dedup id -- key omitted, body byte-identical to today.
+    body = _run_turn_capture_body(monkeypatch)
+    assert "steer_iid" not in body
+
+
+def test_run_omits_steer_iid_key_when_pickup_item_had_none(monkeypatch):
+    # Older gateway: /pending-steer items without `iid` -> "" -> key omitted.
+    body = _run_turn_capture_body(monkeypatch, surface="telegram", steer_iid="")
+    assert "steer_iid" not in body
+    assert body["surface"] == "telegram"

{webbee-0.3.9 → webbee-0.3.10}/tests/test_steer.py

@@ -85,7 +85,7 @@ def test_poll_submits_first_item_with_surface(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     _drive(SP.poll_idle_steer(_Cfg(), _tp, workspace=".", is_busy=lambda: False,
@@ -97,6 +97,50 @@ def test_poll_submits_first_item_with_surface(monkeypatch):
     assert polled[0] == "marathon-user-1-rlive"
 
 
+def test_poll_passes_item_iid_to_submit(monkeypatch):
+    # steer-iid-dedup pickup path: /pending-steer items carry the queue entry's
+    # `iid`; the poller must hand it to submit so the turn POST carries
+    # steer_iid and the kernel's dedup ring can drop an at-least-once twin.
+    submitted = []
+
+    async def fake_fetch(cfg, tp, session_id):
+        return [{"text": "push the fix", "surface": "telegram", "ts": 1,
+                 "iid": "iid-42"}]
+
+    import webbee.thread as TH
+    monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
+
+    async def submit(text, surface, steer_iid=""):
+        submitted.append((text, surface, steer_iid))
+
+    _drive(SP.poll_idle_steer(_Cfg(), _tp, workspace=".", is_busy=lambda: False,
+                              submit=submit, live_session_id=lambda: "marathon-u-r1",
+                              interval=0.01),
+           until=lambda: submitted)
+    assert submitted[0] == ("push the fix", "telegram", "iid-42")
+
+
+def test_poll_item_without_iid_submits_empty_iid(monkeypatch):
+    # An older gateway's items carry no `iid` -- submit gets "" (the turn POST
+    # then omits steer_iid entirely), never a crash.
+    submitted = []
+
+    async def fake_fetch(cfg, tp, session_id):
+        return [{"text": "resume", "surface": "telegram", "ts": 2}]
+
+    import webbee.thread as TH
+    monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
+
+    async def submit(text, surface, steer_iid=""):
+        submitted.append((text, surface, steer_iid))
+
+    _drive(SP.poll_idle_steer(_Cfg(), _tp, workspace=".", is_busy=lambda: False,
+                              submit=submit, live_session_id=lambda: "marathon-u-r1",
+                              interval=0.01),
+           until=lambda: submitted)
+    assert submitted[0] == ("resume", "telegram", "")
+
+
 def test_poll_no_items_never_submits(monkeypatch):
     polled = []
     submitted = []
@@ -108,7 +152,7 @@ def test_poll_no_items_never_submits(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     _drive(SP.poll_idle_steer(_Cfg(), _tp, workspace=".", is_busy=lambda: False,
@@ -132,7 +176,7 @@ def test_poll_silent_on_network_error_and_recovers(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", flaky_fetch)
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     # No exception escapes the poller; the tick after the blip succeeds.
@@ -156,7 +200,7 @@ def test_poll_never_fetches_while_busy(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     ticks = {"n": 0}
@@ -192,7 +236,7 @@ def test_multi_item_drain_runs_in_order_one_per_tick_nothing_lost(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     # The gateway drain returns each item exactly ONCE -- items 2..n of a batch
@@ -221,7 +265,7 @@ def test_item_deferred_not_lost_when_turn_starts_mid_tick(monkeypatch):
     def is_busy():
         return busy_answers.pop(0) if busy_answers else False
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     _drive(SP.poll_idle_steer(_Cfg(), _tp, workspace=".", is_busy=is_busy,
@@ -245,7 +289,7 @@ def test_poller_exits_when_submitted_turn_absorbs_the_cancel(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
 
-    async def swallowing_submit(text, surface):
+    async def swallowing_submit(text, surface, steer_iid=""):
         in_submit.set()
         try:
             await asyncio.sleep(3600)

webbee-0.3.9/src/webbee/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.9"