geny-executor 2.69.0__tar.gz → 2.70.0__tar.gz

{geny_executor-2.69.0 → geny_executor-2.70.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: geny-executor
-Version: 2.69.0
+Version: 2.70.0
 Summary: Harness-engineered agent pipeline library — one 21-stage architecture, many model accounts behind one conversation
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor

{geny_executor-2.69.0 → geny_executor-2.70.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.69.0"
+version = "2.70.0"
 description = "Harness-engineered agent pipeline library — one 21-stage architecture, many model accounts behind one conversation"
 readme = "README.md"
 license = "Apache-2.0"

{geny_executor-2.69.0 → geny_executor-2.70.0}/src/geny_executor/llm_client/_failover.py

@@ -46,6 +46,29 @@ def clear_cooldown(account_id: str) -> None:
     _COOLDOWN.pop(account_id, None)
 
 
+# ── load (process-wide, keyed by account) ─────────────────────────────
+# Cooldowns answer "who is broken". This answers "whose turn is it".
+# A route of several healthy accounts used to send EVERY turn to the
+# first one until it hit its cap — failover, which only reacts once an
+# account is already exhausted. For subscription plans that is backwards:
+# the point of holding two logins is that neither reaches its limit.
+#
+# Process-wide for the same reason cooldowns are: sibling agents share
+# the accounts, so a per-client counter would let three agents each
+# "balance" onto the same first account.
+_LAST_USED: dict[str, float] = {}
+
+
+def mark_used(account_id: str) -> None:
+    if account_id:
+        _LAST_USED[account_id] = time.time()
+
+
+def last_used(account_id: str) -> float:
+    """When this account last answered; 0.0 if never (so it goes first)."""
+    return _LAST_USED.get(account_id, 0.0)
+
+
 def snapshot() -> dict[str, dict[str, Any]]:
     now = time.time()
     return {

{geny_executor-2.69.0 → geny_executor-2.70.0}/src/geny_executor/llm_client/router.py

@@ -59,6 +59,7 @@ class RouterClient(BaseClient):
         timeout_s: Optional[float] = None,
         event_sink: Any = None,
         client_factory: Any = None,
+        balance: bool = False,
         **_ignored: Any,
     ) -> None:
         super().__init__(
@@ -78,6 +79,12 @@ class RouterClient(BaseClient):
         self._timeout_s = timeout_s
         self._children: dict[int, BaseClient] = {}
         self._factory = client_factory
+        # Spread turns across healthy hops instead of always asking the
+        # first one. Off by default: a route's order is a choice the user
+        # made, and silently round-robining it would be a different
+        # product. Geny turns it on for a route of interchangeable
+        # subscription accounts.
+        self._balance = bool(balance)
         self.last_target: Optional[dict[str, Any]] = None
 
     @property
@@ -138,10 +145,44 @@ class RouterClient(BaseClient):
         return client
 
     def _order(self) -> list[int]:
+        """Who to ask, in order: healthy hops first, cooling ones last.
+
+        With ``balance`` on, hops that are INTERCHANGEABLE — same provider
+        and same model, i.e. two logins to the same thing — take turns
+        least-recently-used instead of the first one answering until it
+        hits its cap. That is the difference between failover and load
+        balancing: failover only reacts once an account is already
+        exhausted, which for subscription plans is backwards, since the
+        reason to hold two logins is that neither should reach its limit.
+
+        Balancing deliberately does NOT reach across different providers
+        or models. A route is a preference — a primary and its fallbacks —
+        so spreading turns over it would make one conversation answer as
+        Claude, then as GPT, then as Claude again. Equivalent hops are a
+        pool; the route between pools is still an order.
+        """
         ready: list[int] = []
         cooling: list[int] = []
         for i, target in enumerate(self._targets):
             (cooling if failover.cooling(str(target.get("accountId") or "")) else ready).append(i)
+        if self._balance:
+
+            def group(i: int) -> tuple[str, str]:
+                t = self._targets[i]
+                return (str(t.get("engineProvider") or ""), str(t.get("model") or ""))
+
+            # the pool's place in the route is its best member's place, so
+            # a primary pool stays ahead of a fallback pool
+            rank = {}
+            for i in ready:
+                rank.setdefault(group(i), i)
+            ready.sort(
+                key=lambda i: (
+                    rank[group(i)],
+                    failover.last_used(str(self._targets[i].get("accountId") or "")),
+                    i,
+                )
+            )
         # everything cooling: still try, earliest recovery first — refusing
         # outright would turn a stale cooldown into an outage
         cooling.sort(
@@ -189,7 +230,11 @@ class RouterClient(BaseClient):
     def _chosen(self, index: int) -> None:
         target = self._targets[index]
         self.last_target = target
-        failover.clear_cooldown(str(target.get("accountId") or ""))
+        account = str(target.get("accountId") or "")
+        failover.clear_cooldown(account)
+        # Only the hop that actually answered counts as used — a hop that
+        # was tried and failed over is not "its turn taken".
+        failover.mark_used(account)
         self._notify_host(
             {
                 "kind": "route",

{geny_executor-2.69.0 → geny_executor-2.70.0}/src/geny_executor/llm_client/translators/_canonical.py

@@ -295,6 +295,20 @@ _ANTHROPIC_INTERNAL_KEYS = ("_meta",)
 def _sanitize_anthropic_block(block: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     """Strip executor-internal keys and lower unsupported block types."""
     btype = block.get("type")
+    if btype in ("thinking", "redacted_thinking"):
+        # A thinking block belongs to the model that produced it: its
+        # signature is bound to that model, and replaying it to a
+        # different one is at best ignored and at worst a 400. In THIS
+        # library the model can change between any two turns — a route
+        # failing over to another account, a user swapping the model
+        # mid-conversation, a sub-agent on a cheaper model reading its
+        # parent's history — so a thinking block is never portable and
+        # is dropped, exactly as every other translator here drops it.
+        #
+        # The cost is thinking continuity within one model; the cost of
+        # keeping it is a session that dies the moment its model changes.
+        return None
+
     if btype == "file":
         # TODO: Anthropic ``document`` block 으로 매핑 (PDF/text 직접 지원).
         # 지금은 metadata 텍스트로 fallback.

geny_executor-2.70.0/tests/unit/test_account_load_balancing.py

@@ -0,0 +1,153 @@
+"""Two accounts should share the work, not take turns being exhausted.
+
+Failover is a reaction: it moves off an account once that account has
+already hit its wall. For subscription plans that is backwards — the whole
+reason to hold two Claude logins is that neither should reach its cap. A
+route of healthy accounts sent EVERY turn to the first one until it 429'd,
+and the second sat idle until then.
+
+``balance`` orders the healthy hops least-recently-used. It is opt-in: a
+route's order is a choice someone made, and silently round-robining it
+would be a different product.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from geny_executor.llm_client import _failover as failover
+from geny_executor.llm_client.router import RouterClient
+
+
+def _targets(*ids: str) -> list[dict]:
+    return [
+        {"accountId": i, "engineProvider": "anthropic", "model": "claude-sonnet-5", "label": i}
+        for i in ids
+    ]
+
+
+@pytest.fixture(autouse=True)
+def _clean():
+    for acct in ("a", "b", "c"):
+        failover.clear_cooldown(acct)
+        failover._LAST_USED.pop(acct, None)
+    yield
+    for acct in ("a", "b", "c"):
+        failover.clear_cooldown(acct)
+        failover._LAST_USED.pop(acct, None)
+
+
+def _order(client: RouterClient) -> list[str]:
+    return [client.targets[i]["accountId"] for i in client._order()]
+
+
+class TestWithoutBalancing:
+    def test_the_route_order_is_kept(self) -> None:
+        """The default is unchanged: hop 0 answers until it cannot."""
+        client = RouterClient(targets=_targets("a", "b", "c"))
+        assert _order(client) == ["a", "b", "c"]
+        client._chosen(0)
+        assert _order(client) == ["a", "b", "c"], "a used account must not move"
+
+
+class TestWithBalancing:
+    def test_a_never_used_account_goes_first(self) -> None:
+        client = RouterClient(targets=_targets("a", "b"), balance=True)
+        client._chosen(0)
+        assert _order(client)[0] == "b", "the idle account should take the next turn"
+
+    def test_turns_alternate_instead_of_piling_onto_one_account(self) -> None:
+        client = RouterClient(targets=_targets("a", "b"), balance=True)
+        answered = []
+        for _ in range(6):
+            first = client._order()[0]
+            client._chosen(first)
+            answered.append(client.targets[first]["accountId"])
+        assert answered.count("a") == 3 and answered.count("b") == 3, answered
+
+    def test_route_position_breaks_ties(self) -> None:
+        """Equal load is not a reason to shuffle: a deliberate ordering
+        still holds among accounts that have done the same amount."""
+        client = RouterClient(targets=_targets("a", "b", "c"), balance=True)
+        assert _order(client) == ["a", "b", "c"]
+
+    def test_a_cooling_account_is_still_last(self) -> None:
+        """Balancing changes who is asked first among the healthy; it does
+        not promote an account that is rate-limited."""
+        client = RouterClient(targets=_targets("a", "b"), balance=True)
+        failover.cool_down("b", 300, "usage limit")
+        client._chosen(0)  # a is now the most recently used
+        assert _order(client) == ["a", "b"], "a cooling hop must not be preferred"
+
+    def test_a_failed_hop_does_not_count_as_its_turn(self) -> None:
+        """Only the account that actually answered has taken a turn — a hop
+        that was tried and failed over has not."""
+        client = RouterClient(targets=_targets("a", "b"), balance=True)
+        client._failed(0, RuntimeError("429 usage limit"), remaining=1)
+        client._chosen(1)
+        failover.clear_cooldown("a")
+        assert _order(client)[0] == "a", "the hop that never answered should be next"
+
+
+class TestTheLoadRecordIsShared:
+    def test_two_agents_on_the_same_accounts_do_not_both_pick_first(self) -> None:
+        """Sibling agents share the accounts, so the record has to be
+        process-wide — a per-client counter would let every agent
+        'balance' onto the same account."""
+        one = RouterClient(targets=_targets("a", "b"), balance=True)
+        two = RouterClient(targets=_targets("a", "b"), balance=True)
+        one._chosen(one._order()[0])
+        assert _order(two)[0] == "b", "the second agent repeated the first one's choice"
+
+
+class TestPoolsNotTheWholeRoute:
+    """A route is a preference; only interchangeable hops are a pool."""
+
+    def _mixed(self) -> list[dict]:
+        return [
+            {"accountId": "claude1", "engineProvider": "geny_claude_code",
+             "model": "sonnet", "label": "Claude 1"},
+            {"accountId": "claude2", "engineProvider": "geny_claude_code",
+             "model": "sonnet", "label": "Claude 2"},
+            {"accountId": "codex1", "engineProvider": "geny_codex",
+             "model": "gpt-5.6-terra", "label": "Codex"},
+        ]
+
+    def test_a_conversation_does_not_ping_pong_between_providers(self) -> None:
+        """The failure this guards: blind round-robin over a route would
+        answer as Claude, then as GPT, then as Claude — one agent visibly
+        changing who it is every turn."""
+        client = RouterClient(targets=self._mixed(), balance=True)
+        answered = []
+        try:
+            for _ in range(6):
+                first = client._order()[0]
+                client._chosen(first)
+                answered.append(client.targets[first]["engineProvider"])
+        finally:
+            for acct in ("claude1", "claude2", "codex1"):
+                failover._LAST_USED.pop(acct, None)
+        assert set(answered) == {"geny_claude_code"}, answered
+
+    def test_the_two_equivalent_logins_still_share(self) -> None:
+        client = RouterClient(targets=self._mixed(), balance=True)
+        answered = []
+        try:
+            for _ in range(4):
+                first = client._order()[0]
+                client._chosen(first)
+                answered.append(client.targets[first]["accountId"])
+        finally:
+            for acct in ("claude1", "claude2", "codex1"):
+                failover._LAST_USED.pop(acct, None)
+        assert answered.count("claude1") == 2 and answered.count("claude2") == 2, answered
+
+    def test_the_fallback_pool_is_reached_when_the_primary_pool_is_cooling(self) -> None:
+        client = RouterClient(targets=self._mixed(), balance=True)
+        try:
+            failover.cool_down("claude1", 300, "usage limit")
+            failover.cool_down("claude2", 300, "usage limit")
+            assert client.targets[client._order()[0]]["engineProvider"] == "geny_codex"
+        finally:
+            failover.clear_cooldown("claude1")
+            failover.clear_cooldown("claude2")

geny_executor-2.70.0/tests/unit/test_conversation_is_portable.py

@@ -0,0 +1,162 @@
+"""One conversation, any provider, at any point — the invariant behind
+mid-conversation model switching.
+
+An agent session outlives the model answering it. A user swaps Opus for a
+ChatGPT plan mid-thread; a route fails over from a rate-limited Claude
+account to a second one; a sub-agent runs on a cheaper model than its
+parent. In every case the SAME canonical history is handed to a DIFFERENT
+translator, and it has to survive the trip.
+
+Three properties make that work, and each has broken in some harness
+somewhere:
+
+  1. No vendor session handle. Nothing carries ``previous_response_id`` or
+     a thread id, so history is rebuilt from our own record every call and
+     no provider owns the conversation.
+  2. No cross-model thinking. Reasoning blocks are bound to the model that
+     produced them; replaying one to another model is at best ignored and
+     at worst a 400. Every translator drops them.
+  3. Our tool ids, round-tripped. A ``tool_use`` emitted on one provider
+     and its ``tool_result`` executed here must still pair when the NEXT
+     turn runs somewhere else.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+# A history with every shape that has to survive: text, an image, a tool
+# call made by one provider, its result from our Stage 10, and a thinking
+# block from whichever model produced it.
+HISTORY = [
+    {"role": "user", "content": "look at this and list /tmp"},
+    {
+        "role": "assistant",
+        "content": [
+            {"type": "thinking", "thinking": "I should list it.", "signature": "sig-from-opus"},
+            {"type": "text", "text": "Listing."},
+            {
+                "type": "tool_use",
+                "id": "toolu_geny_abc123",
+                "name": "ListDir",
+                "input": {"path": "/tmp"},
+            },
+        ],
+    },
+    {
+        "role": "user",
+        "content": [
+            {"type": "tool_result", "tool_use_id": "toolu_geny_abc123", "content": "a.txt"}
+        ],
+    },
+    {"role": "user", "content": "thanks"},
+]
+
+
+def _dumped(obj) -> str:
+    return json.dumps(obj, ensure_ascii=False, default=str)
+
+
+class TestNoVendorSessionHandle:
+    def test_the_responses_wire_sends_no_previous_response_id(self) -> None:
+        """Codex rebuilds the thread from OUR history every call. A vendor
+        session handle would mean a conversation could not leave Codex and
+        come back — and could not be replayed on a second account."""
+        from geny_executor.llm_client.responses_wire import to_input
+
+        blob = _dumped(to_input(HISTORY))
+        assert "previous_response_id" not in blob
+        assert "thread_id" not in blob
+
+
+class TestNoCrossModelThinking:
+    def test_the_responses_wire_drops_thinking(self) -> None:
+        from geny_executor.llm_client.responses_wire import to_input
+
+        blob = _dumped(to_input(HISTORY))
+        assert "sig-from-opus" not in blob, "a signature from another model was replayed"
+        assert "I should list it." not in blob
+
+    def test_the_anthropic_translator_drops_thinking(self) -> None:
+        from geny_executor.llm_client.translators import canonical_messages_to_anthropic
+
+        blob = _dumped(canonical_messages_to_anthropic(HISTORY))
+        assert "sig-from-opus" not in blob, "a signature from another model was replayed"
+
+    def test_the_openai_translator_drops_thinking(self) -> None:
+        from geny_executor.llm_client.translators import canonical_messages_to_openai
+
+        blob = _dumped(canonical_messages_to_openai(HISTORY))
+        assert "sig-from-opus" not in blob
+
+    def test_the_google_translator_drops_thinking(self) -> None:
+        from geny_executor.llm_client.translators import canonical_messages_to_google
+
+        blob = _dumped(canonical_messages_to_google(HISTORY))
+        assert "sig-from-opus" not in blob
+
+    def test_the_claude_code_protocol_drops_thinking(self) -> None:
+        from geny_executor.llm_client import text_tool_protocol as tp
+
+        blob = _dumped(tp.render_transcript(HISTORY))
+        assert "sig-from-opus" not in blob
+
+
+class TestOurToolIdsRoundTrip:
+    """The call and its result must still refer to each other after the
+    conversation moves to a provider that never issued the id."""
+
+    def test_the_responses_wire_pairs_them(self) -> None:
+        from geny_executor.llm_client.responses_wire import to_input
+
+        items = to_input(HISTORY)
+        calls = [i for i in items if i.get("type") == "function_call"]
+        outs = [i for i in items if i.get("type") == "function_call_output"]
+        assert [c["call_id"] for c in calls] == ["toolu_geny_abc123"]
+        assert [o["call_id"] for o in outs] == ["toolu_geny_abc123"]
+
+    def test_the_anthropic_translator_pairs_them(self) -> None:
+        from geny_executor.llm_client.translators import canonical_messages_to_anthropic
+
+        blob = _dumped(canonical_messages_to_anthropic(HISTORY))
+        assert blob.count("toolu_geny_abc123") >= 2, "the call and its result came apart"
+
+    def test_the_openai_translator_pairs_them(self) -> None:
+        from geny_executor.llm_client.translators import canonical_messages_to_openai
+
+        blob = _dumped(canonical_messages_to_openai(HISTORY))
+        assert blob.count("toolu_geny_abc123") >= 2
+
+
+class TestEveryProviderAcceptsTheSameHistory:
+    @pytest.mark.parametrize(
+        "translate",
+        [
+            pytest.param("responses", id="geny_codex / openai-responses"),
+            pytest.param("anthropic", id="anthropic / geny_claude_code family"),
+            pytest.param("openai", id="openai / vllm / ollama / lmstudio"),
+            pytest.param("google", id="google"),
+            pytest.param("claude_code", id="geny_claude_code text protocol"),
+        ],
+    )
+    def test_it_renders_without_raising_and_keeps_the_user_text(self, translate: str) -> None:
+        """A translator that raises on a history another provider produced
+        is a session that dies the moment its model changes."""
+        if translate == "responses":
+            from geny_executor.llm_client.responses_wire import to_input as fn
+        elif translate == "anthropic":
+            from geny_executor.llm_client.translators import canonical_messages_to_anthropic as fn
+        elif translate == "openai":
+            from geny_executor.llm_client.translators import canonical_messages_to_openai as fn
+        elif translate == "google":
+            from geny_executor.llm_client.translators import canonical_messages_to_google as fn
+        else:
+            from geny_executor.llm_client import text_tool_protocol as tp
+
+            fn = tp.render_transcript
+
+        blob = _dumped(fn(HISTORY))
+        assert "look at this and list /tmp" in blob
+        assert "a.txt" in blob