agentprobe-testing 0.8.3__tar.gz → 0.8.5__tar.gz

{agentprobe_testing-0.8.3 → agentprobe_testing-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentprobe-testing
-Version: 0.8.3
+Version: 0.8.5
 Summary: Adaptive chaos-testing for LLM agents: a live model-driven Injector that reads an agent's real trajectory and decides where to break something, instead of scripting perturbations in advance.
 License: Business Source License 1.1
         

{agentprobe_testing-0.8.3 → agentprobe_testing-0.8.5}/agentprobe/__init__.py

@@ -60,7 +60,7 @@ from agentprobe.scenario import CommitPattern, FactPattern, GoalSpec, Scenario
 from agentprobe.scenarios.registry import ALL_SCENARIOS as TICKET_SCENARIOS
 from agentprobe.scenarios.registry import BY_ID as TICKET_SCENARIOS_BY_ID
 
-__version__ = "0.8.3"
+__version__ = "0.8.5"
 
 __all__ = [
     "Agent",

{agentprobe_testing-0.8.3 → agentprobe_testing-0.8.5}/agentprobe/llm.py

@@ -15,9 +15,72 @@ from __future__ import annotations
 
 from typing import Any
 
+import anthropic._streaming as _anthropic_streaming
+
 _TEMPERATURE_SUPPORTED: dict[str, bool] = {}
 
 
+def _patch_sse_decoder_for_memoryview_chunks() -> None:
+    """anthropic._streaming.SSEDecoder calls `chunk.splitlines()` directly on
+    whatever the underlying HTTP iterator yields, assuming it's always
+    `bytes`. Under Cloudflare's Python Worker runtime (Pyodide/emscripten),
+    the httpx2-jsfetch transport that bridges JS's fetch API yields
+    `memoryview` chunks instead -- confirmed live: every single streamed
+    Injector call failed with AttributeError('memoryview' object has no
+    attribute 'splitlines') the moment create_deterministic() switched from
+    create() to stream() to dodge a separate idle-timeout bug. `bytes(chunk)`
+    is a no-op for already-bytes chunks and a cheap copy for memoryview, so
+    coercing at the one boundary where raw chunks enter the SSE decoder
+    fixes this without reimplementing SSE parsing ourselves. Wrapped in
+    try/except so an anthropic SDK upgrade that moves this internal method
+    fails quiet (falls back to the original, unpatched bug) rather than
+    breaking import entirely.
+    """
+    try:
+        decoder_cls = _anthropic_streaming.SSEDecoder
+        original_iter_chunks = decoder_cls._iter_chunks
+        original_aiter_chunks = decoder_cls._aiter_chunks
+
+        def _iter_chunks(self, iterator):
+            return original_iter_chunks(self, (bytes(chunk) for chunk in iterator))
+
+        async def _aiter_chunks(self, iterator):
+            async def _coerced():
+                async for chunk in iterator:
+                    yield bytes(chunk)
+
+            async for sse_chunk in original_aiter_chunks(self, _coerced()):
+                yield sse_chunk
+
+        decoder_cls._iter_chunks = _iter_chunks
+        decoder_cls._aiter_chunks = _aiter_chunks
+    except AttributeError:
+        pass
+
+
+_patch_sse_decoder_for_memoryview_chunks()
+
+
+_GIL_RACE_RETRIES = 3
+
+
+def _is_gil_race_error(e: BaseException) -> bool:
+    # "NoGilError: Attempted to use PyProxy when Python GIL not held" is a
+    # known Pyodide failure mode when a streamed JS fetch()'s reader
+    # callback fires from a browser/worker microtask where the GIL isn't
+    # currently held by the thread touching the Python-side proxy -- it
+    # lives inside httpx2-jsfetch's sync-over-async bridge (a pinned
+    # third-party wheel this codebase doesn't control), not in anything
+    # here. Confirmed live: worked for the first couple of scenarios on a
+    # fresh isolate, then failed consistently once the isolate warmed up
+    # and got reused -- a timing race, not a deterministic bug, so a retry
+    # is a legitimate mitigation even though it can't fix the bridge
+    # itself. String-matched (not `except NoGilError`) since that type
+    # only exists inside Pyodide -- importing it would break every
+    # non-Pyodide caller of this function, including the whole test suite.
+    return "nogilerror" in str(type(e).__name__).lower() or "gil not held" in str(e).lower()
+
+
 def create_deterministic(client: Any, **kwargs: Any) -> Any:
     # Streamed, not create(): a non-streaming call blocks with zero bytes on
     # the wire until the whole completion is ready, which under Cloudflare's
@@ -27,17 +90,24 @@ def create_deterministic(client: Any, **kwargs: Any) -> Any:
     # trivial first step) is what the same non-streaming pattern already
     # caused for domain generation, fixed there the same way.
     model = kwargs["model"]
-    if _TEMPERATURE_SUPPORTED.get(model, True):
+    for attempt in range(_GIL_RACE_RETRIES):
         try:
-            with client.messages.stream(**kwargs, extra_body={"temperature": 0}) as stream:
+            if _TEMPERATURE_SUPPORTED.get(model, True):
+                try:
+                    with client.messages.stream(**kwargs, extra_body={"temperature": 0}) as stream:
+                        return stream.get_final_message()
+                except Exception as e:
+                    if _is_gil_race_error(e):
+                        raise
+                    if "temperature" in str(e).lower():
+                        _TEMPERATURE_SUPPORTED[model] = False
+                    else:
+                        raise
+            with client.messages.stream(**kwargs) as stream:
                 return stream.get_final_message()
         except Exception as e:
-            if "temperature" in str(e).lower():
-                _TEMPERATURE_SUPPORTED[model] = False
-            else:
+            if not _is_gil_race_error(e) or attempt == _GIL_RACE_RETRIES - 1:
                 raise
-    with client.messages.stream(**kwargs) as stream:
-        return stream.get_final_message()
 
 
 _PRICE_PER_TOKEN: dict[str, tuple[float, float]] = {

{agentprobe_testing-0.8.3 → agentprobe_testing-0.8.5}/agentprobe_testing.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentprobe-testing
-Version: 0.8.3
+Version: 0.8.5
 Summary: Adaptive chaos-testing for LLM agents: a live model-driven Injector that reads an agent's real trajectory and decides where to break something, instead of scripting perturbations in advance.
 License: Business Source License 1.1
         

{agentprobe_testing-0.8.3 → agentprobe_testing-0.8.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentprobe-testing"
-version = "0.8.3"
+version = "0.8.5"
 description = "Adaptive chaos-testing for LLM agents: a live model-driven Injector that reads an agent's real trajectory and decides where to break something, instead of scripting perturbations in advance."
 requires-python = ">=3.11"
 dependencies = ["anthropic>=1.0.0", "python-dotenv>=1.0.0"]

{agentprobe_testing-0.8.3 → agentprobe_testing-0.8.5}/tests/test_llm.py

@@ -81,6 +81,69 @@ def test_unrelated_errors_are_not_swallowed():
         pass
 
 
+def test_retries_a_gil_race_error_and_succeeds_once_the_race_clears():
+    class FlakyStream:
+        def __init__(self, should_fail):
+            self.should_fail = should_fail
+
+        def __enter__(self):
+            if self.should_fail:
+                raise RuntimeError("NoGilError: Attempted to use PyProxy when Python GIL not held")
+            return self
+
+        def __exit__(self, *exc_info):
+            return False
+
+        def get_final_message(self):
+            return "ok"
+
+    class FlakyMessages:
+        def __init__(self):
+            self.calls = 0
+
+        def stream(self, **kwargs):
+            self.calls += 1
+            return FlakyStream(should_fail=self.calls < 3)
+
+    class FlakyClient:
+        def __init__(self):
+            self.messages = FlakyMessages()
+
+    client = FlakyClient()
+    result = create_deterministic(client, model="claude-sonnet-5", max_tokens=10)
+    assert result == "ok"
+    assert client.messages.calls == 3
+
+
+def test_gives_up_on_a_gil_race_error_after_the_retry_budget_is_exhausted():
+    class AlwaysFlakyStream:
+        def __enter__(self):
+            raise RuntimeError("NoGilError: Attempted to use PyProxy when Python GIL not held")
+
+        def __exit__(self, *exc_info):
+            return False
+
+    class AlwaysFlakyMessages:
+        def __init__(self):
+            self.calls = 0
+
+        def stream(self, **kwargs):
+            self.calls += 1
+            return AlwaysFlakyStream()
+
+    class AlwaysFlakyClient:
+        def __init__(self):
+            self.messages = AlwaysFlakyMessages()
+
+    client = AlwaysFlakyClient()
+    try:
+        create_deterministic(client, model="claude-sonnet-5", max_tokens=10)
+        assert False, "expected the GIL race error to propagate once retries are exhausted"
+    except RuntimeError as e:
+        assert "GIL" in str(e)
+    assert client.messages.calls == 3  # exactly the retry budget, not more
+
+
 def test_cacheable_system_wraps_text_with_ephemeral_cache_control():
     result = cacheable_system("some long system prompt")
     assert result == [