agentbyte 0.32.0__tar.gz → 0.32.1__tar.gz

{agentbyte-0.32.0 → agentbyte-0.32.1}/CHANGELOG.md

@@ -6,6 +6,13 @@ The format follows Keep a Changelog principles and semantic versioning.
 
 ## [Unreleased]
 
+## [0.32.1] - 2026-09-30
+
+### Fixed
+
+- Evaluation history stores (`SQLiteEvalRunStore`, `SqlEvalRunStore`): a write that has started now commits or rolls back before a cancellation is delivered. Previously, cancelling a worker mid-write (for example by closing `evaluate_stream()` early) could leave the store lock held and hang `finish_run` on slow machines.
+- CI: pytest dumps thread stacks after 60 s without progress (`faulthandler_timeout`), and the test job times out after 20 minutes instead of 1 hour.
+
 ## [0.32.0] - 2026-09-30
 
 Upgrade notes (breaking):

{agentbyte-0.32.0 → agentbyte-0.32.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentbyte
-Version: 0.32.0
+Version: 0.32.1
 Summary: A toolkit for designing multiagent systems
 Author-email: MrDataPsycho <mr.data.psycho@gmail.com>
 License-Expression: LicenseRef-Proprietary
@@ -90,7 +90,7 @@ Description-Content-Type: text/markdown
 
 Agentbyte is an observability-first agentic AI framework for building and studying multiagent systems with a learning-first, implementation-oriented workflow.
 
-Current release: **0.32.0**
+Current release: **0.32.1**
 
 ## Building an Agent
 

{agentbyte-0.32.0 → agentbyte-0.32.1}/README.md

@@ -2,7 +2,7 @@
 
 Agentbyte is an observability-first agentic AI framework for building and studying multiagent systems with a learning-first, implementation-oriented workflow.
 
-Current release: **0.32.0**
+Current release: **0.32.1**
 
 ## Building an Agent
 

{agentbyte-0.32.0 → agentbyte-0.32.1}/pyproject.toml

@@ -220,3 +220,5 @@ experiment = [
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 norecursedirs = ["external_lib"]
+# Dump every thread's stack if a test stalls, instead of hanging silently.
+faulthandler_timeout = 60

agentbyte-0.32.1/src/agentbyte/__about__.py

@@ -0,0 +1,2 @@
+__version__ = "0.32.1"
+VERSION = __version__

{agentbyte-0.32.0 → agentbyte-0.32.1}/src/agentbyte/eval/history/recorder.py

@@ -4,8 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
-from collections.abc import AsyncIterator, Awaitable, Sequence
-from typing import TypeVar
+from collections.abc import AsyncIterator, Sequence
 
 from agentbyte.cancellation_token import CancellationToken
 from agentbyte.eval.base import BaseEvalTarget
@@ -28,30 +27,11 @@ from .models import (
     task_type,
     utc_now,
 )
-from .store import EvalRunStore
-
-T = TypeVar("T")
+from .store import EvalRunStore, _uninterrupted
 
 _DONE = object()
 
 
-async def _settle(awaitable: Awaitable[T]) -> T:
-    """Finish a cleanup write even if the caller is cancelled meanwhile."""
-    task = asyncio.ensure_future(awaitable)
-    cancelled = False
-    while not task.done():
-        try:
-            await asyncio.shield(task)
-        except asyncio.CancelledError:
-            if task.done():
-                break
-            cancelled = True
-    if cancelled:
-        task.result()
-        raise asyncio.CancelledError()
-    return task.result()
-
-
 def _error_code(exc: BaseException) -> str:
     if isinstance(exc, EvalRedactionError):
         return "redaction_error"
@@ -258,10 +238,10 @@ class EvalRunRecorder:
         finally:
             if not driver.done():
                 driver.cancel()
-                await _settle(asyncio.wait([driver]))
+                await _uninterrupted(asyncio.wait([driver]))
             code = _error_code(error) if error is not None else None
             try:
-                await _settle(self.store.finish_run(run.id, status, error=code))
+                await _uninterrupted(self.store.finish_run(run.id, status, error=code))
             except Exception as finish_error:
                 if error is None:
                     raise

{agentbyte-0.32.0 → agentbyte-0.32.1}/src/agentbyte/eval/history/sql.py

@@ -50,7 +50,7 @@ from .models import (
     deserialize_evidence,
     serialize_evidence,
 )
-from .store import EvalRunStore
+from .store import EvalRunStore, _uninterrupted
 from .transitions import (
     admit,
     admitted_duplicate,
@@ -300,19 +300,26 @@ class SqlEvalRunStore(EvalRunStore):
             raise EvalHistoryError("History store was opened read-only")
         async with self._lock:
             self._check_open()
-            try:
-                async with self._session() as session:
-                    try:
-                        result = await body(session)
-                        await session.commit()
-                        return result
-                    except BaseException:
-                        await _settle(session.rollback())
-                        raise
-            except (EvalHistoryError, ValueError):
-                raise
-            except Exception as exc:
-                raise EvalPersistenceError(f"Could not {action}", run_id=run_id) from exc
+            # A started transaction commits or rolls back before cancellation is
+            # delivered, so a cancelled caller never leaves the lock held mid-write.
+            return await _uninterrupted(self._transaction(run_id, action, body))
+
+    async def _transaction(
+        self, run_id: str | None, action: str, body: Callable[[AsyncSession], Awaitable[T]]
+    ) -> T:
+        try:
+            async with self._session() as session:
+                try:
+                    result = await body(session)
+                    await session.commit()
+                    return result
+                except BaseException:
+                    await _settle(session.rollback())
+                    raise
+        except (EvalHistoryError, ValueError):
+            raise
+        except Exception as exc:
+            raise EvalPersistenceError(f"Could not {action}", run_id=run_id) from exc
 
     async def _read(self, run_id: str | None, statement: Any) -> list[Any]:
         self._check_open()

{agentbyte-0.32.0 → agentbyte-0.32.1}/src/agentbyte/eval/history/sqlite.py

@@ -28,7 +28,7 @@ from .models import (
     deserialize_evidence,
     serialize_evidence,
 )
-from .store import EvalRunStore
+from .store import EvalRunStore, _uninterrupted
 from .transitions import (
     admit,
     admitted_duplicate,
@@ -209,17 +209,23 @@ class SQLiteEvalRunStore(EvalRunStore):
         if not self.writer:
             raise EvalHistoryError("History store was opened read-only")
         async with self._lock:
-            connection = self._db()
-            try:
-                await connection.execute("BEGIN IMMEDIATE")
-                result = await body(connection)
-                await connection.commit()
-                return result
-            except BaseException as exc:
-                await self._rollback(connection)
-                if isinstance(exc, (EvalHistoryError, ValueError)) or not isinstance(exc, Exception):
-                    raise
-                raise EvalPersistenceError(f"Could not {action}", run_id=run_id) from exc
+            # A started transaction commits or rolls back before cancellation is
+            # delivered, so a cancelled caller never leaves the lock held mid-write.
+            return await _uninterrupted(self._transaction(self._db(), run_id, action, body))
+
+    async def _transaction(
+        self, connection: Any, run_id: str | None, action: str, body: Callable[[Any], Awaitable[T]]
+    ) -> T:
+        try:
+            await connection.execute("BEGIN IMMEDIATE")
+            result = await body(connection)
+            await connection.commit()
+            return result
+        except BaseException as exc:
+            await self._rollback(connection)
+            if isinstance(exc, (EvalHistoryError, ValueError)) or not isinstance(exc, Exception):
+                raise
+            raise EvalPersistenceError(f"Could not {action}", run_id=run_id) from exc
 
     async def _read(self, run_id: str | None, sql: str, params: tuple = ()) -> list:
         async with self._lock:

{agentbyte-0.32.0 → agentbyte-0.32.1}/src/agentbyte/eval/history/store.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import asyncio
 from abc import ABC, abstractmethod
+from collections.abc import Awaitable
+from typing import TypeVar
 
 from .errors import EvalHistoryConflictError, EvalRunNotFoundError
 from .models import (
@@ -26,6 +28,25 @@ from .transitions import (
     start,
 )
 
+T = TypeVar("T")
+
+
+async def _uninterrupted(awaitable: Awaitable[T]) -> T:
+    """Run ``awaitable`` to completion, then deliver any cancellation received meanwhile."""
+    task = asyncio.ensure_future(awaitable)
+    cancelled = False
+    while not task.done():
+        try:
+            await asyncio.shield(task)
+        except asyncio.CancelledError:
+            if task.done():
+                break
+            cancelled = True
+    if cancelled:
+        task.result()
+        raise asyncio.CancelledError()
+    return task.result()
+
 
 class EvalRunStore(ABC):
     """Durable ledger of evaluation runs and their planned items.

{agentbyte-0.32.0 → agentbyte-0.32.1}/tests/eval/test_eval_history.py

@@ -233,6 +233,41 @@ async def test_closing_stream_cancels_active_work_and_closes_run(kind, tmp_path)
     assert run.finished_count + run.cancelled_count + run.not_started_count == run.planned_count
 
 
+@pytest.mark.parametrize("kind", ["sqlite", "sql"])
+@pytest.mark.asyncio
+async def test_cancelled_write_commits_before_cancellation_is_delivered(kind, tmp_path) -> None:
+    async with open_store(kind, tmp_path) as store:
+        run = EvalRunRecord(dataset_id="d", target_id="t", judge_name="j", judge_type="J")
+        items = [EvalItemRecord(run_id=run.id, item_index=i, task_name="x", task_type="task") for i in range(2)]
+        await store.create_run(run, items)
+        await store.start_run(run.id)
+
+        entered, release = asyncio.Event(), asyncio.Event()
+        put_item = store._put_item
+
+        async def slow_put_item(*args, **kwargs):
+            entered.set()
+            await release.wait()
+            await put_item(*args, **kwargs)
+
+        store._put_item = slow_put_item
+        write = asyncio.create_task(store.mark_item_running(run.id, 0))
+        await entered.wait()
+        write.cancel()
+        await asyncio.sleep(0.05)
+        assert not write.done()  # the transaction is not abandoned while holding the store lock
+
+        release.set()
+        with pytest.raises(asyncio.CancelledError):
+            await write
+        del store._put_item
+
+        assert (await store.get_item(run.id, 0)).state == "running"
+        final = await asyncio.wait_for(store.finish_run(run.id, "cancelled"), 5)
+    assert final.status == "cancelled"
+    assert final.cancelled_count == 1 and final.not_started_count == 1
+
+
 @pytest.mark.asyncio
 async def test_task_cancellation_closes_run_as_cancelled(tmp_path) -> None:
     gate = asyncio.Event()

agentbyte-0.32.0/src/agentbyte/__about__.py

@@ -1,2 +0,0 @@
-__version__ = "0.32.0"
-VERSION = __version__