dispatchbox 0.1.2__tar.gz → 0.1.3__tar.gz

{dispatchbox-0.1.2/dispatchbox.egg-info → dispatchbox-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dispatchbox
-Version: 0.1.2
+Version: 0.1.3
 Summary: Route events to Claude Code and Codex running on your own machines, and ask you only when it matters.
 Author: Xixian Yang
 License-Expression: MIT

{dispatchbox-0.1.2 → dispatchbox-0.1.3}/dispatchbox/__init__.py

@@ -1,3 +1,3 @@
 """dispatchbox: a thin event router that hands work to coding agents on your own machines."""
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"

{dispatchbox-0.1.2 → dispatchbox-0.1.3}/dispatchbox/hub.py

@@ -231,7 +231,7 @@ class Hub:
 
     def finish(self, run_id: int, worker: str, result: dict[str, Any]) -> dict[str, Any]:
         with self.lock:
-            self._running(run_id, worker)
+            row = self._running(run_id, worker)
             exit_code = int(result.get("exit_code", 1))
             output = str(result.get("output", ""))
             summary = result.get("summary") or extract_summary(output)
@@ -246,19 +246,50 @@ class Hub:
                 status = "failed"
             else:
                 status = "succeeded"
+            usage = (_num(result.get("cost_usd"), float), _num(result.get("input_tokens"), int),
+                     _num(result.get("output_tokens"), int))
+            if row["parent_run"] and result.get("session_id"):
+                usage = self._own_share(row, str(result["session_id"]), *usage)
             self.db.execute(
                 "UPDATE runs SET status=?, finished_at=?, exit_code=?, summary=?, session_id=?, output_tail=?, "
                 "decision_request=?, cost_usd=?, input_tokens=?, output_tokens=? WHERE id=?",
                 (status, self.clock(), exit_code, (summary or "")[:2000], result.get("session_id"),
                  output[-8000:], json.dumps(decision_req, ensure_ascii=False) if decision_req else None,
-                 _num(result.get("cost_usd"), float), _num(result.get("input_tokens"), int),
-                 _num(result.get("output_tokens"), int), run_id),
+                 *usage, run_id),
             )
             self.cv.notify_all()
             run = self.get_run(run_id)
         self._maybe_notify(run)
         return {"run_id": run_id, "status": status}
 
+    def _own_share(self, row: Any, session_id: str, cost: float | None, tokens_in: int | None,
+                   tokens_out: int | None) -> tuple[float | None, int | None, int | None]:
+        """A continued session reports running totals: claude's total_cost_usd covers every call of the session so
+        far (its token counts cover the call alone), and codex's token counts do the same. Verified with claude 2.1.310
+        and codex 0.166. Take off what earlier runs of the same session recorded, so each run holds only its own share.
+        A figure below that total is a per-call one and is kept as reported."""
+        prev_cost, prev_in, prev_out = 0.0, 0, 0
+        rid = row["parent_run"]
+        while rid:
+            earlier = self.db.execute(
+                "SELECT parent_run, session_id, cost_usd, input_tokens, output_tokens FROM runs WHERE id=?", (rid,)
+            ).fetchone()
+            if earlier is None or earlier["session_id"] != session_id:
+                break
+            prev_cost += earlier["cost_usd"] or 0
+            prev_in += earlier["input_tokens"] or 0
+            prev_out += earlier["output_tokens"] or 0
+            rid = earlier["parent_run"]
+        runner = json.loads(row["spec"]).get("runner")
+        if runner == "claude" and cost is not None and cost >= prev_cost:
+            cost -= prev_cost
+        if runner == "codex":
+            if tokens_in is not None and tokens_in >= prev_in:
+                tokens_in -= prev_in
+            if tokens_out is not None and tokens_out >= prev_out:
+                tokens_out -= prev_out
+        return cost, tokens_in, tokens_out
+
     def decide(self, run_id: int, choice: str, note: str = "", by: str = "human") -> dict[str, Any]:
         with self.lock:
             run = self.get_run(run_id)

{dispatchbox-0.1.2 → dispatchbox-0.1.3}/dispatchbox/worker.py

@@ -167,6 +167,9 @@ def parse_output(runner: str, stdout: str, stderr: str, tmpdir: str) -> dict[str
             data = json.loads(stdout.strip().splitlines()[-1]) if stdout.strip() else {}
         except (json.JSONDecodeError, IndexError):
             data = {}
+        if isinstance(data, list):
+            # With verbose on, by flag or in its settings, Claude prints every message as one JSON array on one line.
+            data = next((m for m in reversed(data) if isinstance(m, dict) and m.get("type") == "result"), {})
         if isinstance(data, dict) and "result" in data:
             out = {"output": str(data.get("result") or ""), "session_id": data.get("session_id")}
             if data.get("is_error"):

{dispatchbox-0.1.2 → dispatchbox-0.1.3/dispatchbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dispatchbox
-Version: 0.1.2
+Version: 0.1.3
 Summary: Route events to Claude Code and Codex running on your own machines, and ask you only when it matters.
 Author: Xixian Yang
 License-Expression: MIT

{dispatchbox-0.1.2 → dispatchbox-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dispatchbox"
-version = "0.1.2"
+version = "0.1.3"
 description = "Route events to Claude Code and Codex running on your own machines, and ask you only when it matters."
 readme = "README.md"
 requires-python = ">=3.10"

{dispatchbox-0.1.2 → dispatchbox-0.1.3}/tests/test_e2e.py

@@ -34,8 +34,9 @@ elif "DELETE" in prompt:
 else:
     text = "did the work\nDISPATCHBOX_SUMMARY: reviewed " + os.environ["DISPATCHBOX_RULE"]
 assert "DISPATCHBOX_TOKEN" not in os.environ, "token leaked to agent"
+cost = 0.03 if "--resume" in args else 0.01   # like the real CLI, a resumed session reports its running total
 print(json.dumps({"type": "result", "result": text, "session_id": "sess-42", "is_error": False,
-                  "total_cost_usd": 0.01, "usage": {"input_tokens": 10, "cache_read_input_tokens": 90,
+                  "total_cost_usd": cost, "usage": {"input_tokens": 10, "cache_read_input_tokens": 90,
                                                     "output_tokens": 7}}))
 """
 
@@ -171,6 +172,8 @@ class E2ETest(unittest.TestCase):
         follow = [r for r in self.hub.list_runs() if r.get("parent_run") == rid][0]
         run = self.wait_status(follow["id"], {"succeeded", "failed"})
         self.assertEqual(run["summary"], "resumed sess-42")
+        self.assertAlmostEqual(run["cost_usd"], 0.02, msg="only this run's share of the session total")
+        self.assertEqual((run["input_tokens"], run["output_tokens"]), (100, 7))
 
     def test_agent_reported_failure(self):
         self.start_worker()

{dispatchbox-0.1.2 → dispatchbox-0.1.3}/tests/test_step0.py

@@ -16,8 +16,16 @@ RULES = {
     "rules": [
         {"name": "job", "when": {"source": "s"}, "prompt": "do {subject}", "group": "{subject}"},
         {"name": "retry-job", "when": {"source": "r"}, "prompt": "do {subject}", "retries": 1, "notify": "on_failure"},
+        {"name": "after", "when": {"source": "dispatchbox", "type": "decision.made"}, "prompt": "go on"},
     ]
 }
+CODEX_RULES = {
+    "rules": [
+        {"name": "job", "when": {"source": "s"}, "runner": "codex", "prompt": "do {subject}"},
+        {"name": "after", "when": {"source": "dispatchbox", "type": "decision.made"}, "runner": "codex", "prompt": "go on"},
+    ]
+}
+ASK = 'DISPATCHBOX_DECISION: {"question": "Go on?", "options": ["yes", "no"]}'
 
 # Shapes copied from real `claude -p --output-format json` and `codex exec --json` output.
 CLAUDE_OUT = json.dumps({"type": "result", "is_error": False, "session_id": "s-1", "total_cost_usd": 0.0024359,
@@ -104,6 +112,44 @@ class Step0Hub(unittest.TestCase):
         self.hub.finish(task["run_id"], "w", {"exit_code": exit_code, "output": output, **extra})
         return self.hub.get_run(task["run_id"])
 
+    def continue_session(self, run_id, output="done", **extra):
+        """Answer the decision run_id waits for, then finish the follow-up run with the given result."""
+        follow = self.hub.decide(run_id, "yes")["follow_up"]["runs"][0]
+        task = self.hub.claim("w")
+        self.assertEqual((task["run_id"], task["resume_session"]), (follow, self.hub.get_run(run_id)["session_id"]))
+        self.hub.finish(follow, "w", {"exit_code": 0, "output": output, **extra})
+        return self.hub.get_run(follow)
+
+    def test_continued_claude_session_records_only_its_own_cost(self):
+        # Figures from a real claude 2.1.310 session: the resumed call reports the session's running total cost,
+        # while its token counts cover that call alone.
+        first = self.run_once(ASK, session_id="s-1", cost_usd=0.72866, input_tokens=36424, output_tokens=4)
+        second = self.continue_session(first["id"], ASK, session_id="s-1", cost_usd=0.895048,
+                                       input_tokens=36466, output_tokens=4)
+        self.assertAlmostEqual(second["cost_usd"], 0.166388)
+        self.assertEqual((second["input_tokens"], second["output_tokens"]), (36466, 4))
+        third = self.continue_session(second["id"], session_id="s-1", cost_usd=1.0, input_tokens=100, output_tokens=2)
+        self.assertAlmostEqual(third["cost_usd"], 0.104952, msg="the whole chain counts, not just the parent")
+        self.assertAlmostEqual(first["cost_usd"], 0.72866, msg="the first run is left alone")
+
+    def test_continued_codex_session_records_only_its_own_tokens(self):
+        # Figures from a real codex 0.166 session: the resumed call reports the session's running token totals.
+        self.hub.close()
+        self.hub = Hub(write_rules(self.tmp.name, CODEX_RULES), str(Path(self.tmp.name, "c.db")), lost_after=60,
+                       clock=self.clock)
+        first = self.run_once(ASK, session_id="t-1", input_tokens=23372, output_tokens=5)
+        second = self.continue_session(first["id"], session_id="t-1", input_tokens=50928, output_tokens=10)
+        self.assertEqual((second["input_tokens"], second["output_tokens"]), (27556, 5))
+        self.assertIsNone(second["cost_usd"])
+
+    def test_usage_of_a_new_session_or_below_the_total_is_kept(self):
+        first = self.run_once(ASK, session_id="s-1", cost_usd=0.5)
+        fresh = self.continue_session(first["id"], session_id="s-2", cost_usd=0.4)
+        self.assertAlmostEqual(fresh["cost_usd"], 0.4, msg="a new session owes nothing to the old one")
+        first = self.run_once(ASK, session_id="s-3", cost_usd=0.5)
+        same = self.continue_session(first["id"], session_id="s-3", cost_usd=0.1)
+        self.assertAlmostEqual(same["cost_usd"], 0.1, msg="a figure below the running total is per call")
+
     def test_agent_failed_verdict_beats_clean_exit(self):
         run = self.run_once("tried\nDISPATCHBOX_STATUS: failed\nDISPATCHBOX_SUMMARY: permission denied, file kept")
         self.assertEqual(run["status"], "failed")
@@ -178,6 +224,17 @@ class Step0Units(unittest.TestCase):
         self.assertEqual(out["output_tokens"], 4)
         self.assertEqual(out["session_id"], "s-1")
 
+    def test_parse_claude_verbose_array(self):
+        # With verbose on, claude 2.1.310 prints every message as one JSON array on a single line.
+        line = json.dumps([{"type": "system", "subtype": "init"}, {"type": "assistant"}, {"type": "rate_limit_event"},
+                           json.loads(CLAUDE_OUT)])
+        with tempfile.TemporaryDirectory() as d:
+            out = parse_output("claude", line + "\n", "", d)
+        self.assertEqual((out["output"], out["session_id"], out["cost_usd"]), ("ok", "s-1", 0.0024359))
+        with tempfile.TemporaryDirectory() as d:
+            none = parse_output("claude", '[{"type": "system"}]\n', "", d)
+        self.assertNotIn("session_id", none, "an array without a result is read as raw output")
+
     def test_parse_codex_success_and_failure(self):
         with tempfile.TemporaryDirectory() as d:
             Path(d, "last_message.txt").write_text("ok\n")