agentbyte 0.32.0__tar.gz → 0.32.2__tar.gz

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

@@ -6,6 +6,19 @@ The format follows Keep a Changelog principles and semantic versioning.
 
 ## [Unreleased]
 
+## [0.32.2] - 2026-10-01
+
+### Fixed
+
+- `import agentbyte` no longer requires the `openai` package. OpenAI and Azure OpenAI clients in `agentbyte.llm` are imported on first use; without the extra, using them raises `ModuleNotFoundError` naming the extra to install (`pip install 'agentbyte[openai]'` or `'agentbyte[azureopenai]'`). `agentbyte.presets.build_chat_client` imports the provider client it needs at call time.
+
+## [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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentbyte
-Version: 0.32.0
+Version: 0.32.2
 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.2**
 
 ## Building an Agent
 

{agentbyte-0.32.0 → agentbyte-0.32.2}/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.2**
 
 ## Building an Agent
 

{agentbyte-0.32.0 → agentbyte-0.32.2}/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.2/src/agentbyte/__about__.py

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

{agentbyte-0.32.0 → agentbyte-0.32.2}/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.2}/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.2}/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.2}/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.2}/src/agentbyte/llm/__init__.py

@@ -33,23 +33,6 @@ from .base import (
 )
 from .retry_policy import RetryPolicy
 from .embeddings_base import BaseEmbeddingClient, BaseEmbeddingClientConfig
-from .openai import OpenAIChatCompletionClient, OpenAIChatCompletionClientConfig
-from .openai import OpenAIEmbeddingClient, OpenAIEmbeddingClientConfig
-from .openai import OpenAISettings
-from .azure import (
-    AzureOpenAIChatCompletionClient,
-    AzureOpenAIChatCompletionClientConfig,
-)
-from .azure import (
-    AzureOpenAIEmbeddingClient,
-    AzureOpenAIEmbeddingClientConfig,
-)
-from .azure import (
-    get_default_token_provider,
-    get_certificate_token_provider,
-    create_token_provider_from_string,
-)
-from .azure import AzureOpenAISettings, AzureServicePrincipalSettings
 # Import message types and usage from root module (picoagents-aligned)
 from agentbyte.messages import (
     BaseMessage,
@@ -117,3 +100,63 @@ __all__ = [
     "EmbeddingResult",
     "ModelPricing",
 ]
+
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:  # editors and type checkers see the provider classes eagerly
+    from .azure import (
+        AzureOpenAIChatCompletionClient,
+        AzureOpenAIChatCompletionClientConfig,
+        AzureOpenAIEmbeddingClient,
+        AzureOpenAIEmbeddingClientConfig,
+        AzureOpenAISettings,
+        AzureServicePrincipalSettings,
+        create_token_provider_from_string,
+        get_certificate_token_provider,
+        get_default_token_provider,
+    )
+    from .openai import (
+        OpenAIChatCompletionClient,
+        OpenAIChatCompletionClientConfig,
+        OpenAIEmbeddingClient,
+        OpenAIEmbeddingClientConfig,
+        OpenAISettings,
+    )
+
+# Provider clients need optional extras (``openai``, ``azureopenai``); they are
+# imported on first access so ``import agentbyte`` works with core dependencies only.
+_PROVIDER_EXPORTS = {
+    "OpenAIChatCompletionClient": ".openai",
+    "OpenAIChatCompletionClientConfig": ".openai",
+    "OpenAIEmbeddingClient": ".openai",
+    "OpenAIEmbeddingClientConfig": ".openai",
+    "OpenAISettings": ".openai",
+    "AzureOpenAIChatCompletionClient": ".azure",
+    "AzureOpenAIChatCompletionClientConfig": ".azure",
+    "AzureOpenAIEmbeddingClient": ".azure",
+    "AzureOpenAIEmbeddingClientConfig": ".azure",
+    "get_default_token_provider": ".azure",
+    "get_certificate_token_provider": ".azure",
+    "create_token_provider_from_string": ".azure",
+    "AzureOpenAISettings": ".azure",
+    "AzureServicePrincipalSettings": ".azure",
+}
+
+
+def __getattr__(name: str):
+    module_name = _PROVIDER_EXPORTS.get(name)
+    if module_name is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    from importlib import import_module
+
+    try:
+        module = import_module(module_name, __name__)
+    except ModuleNotFoundError as exc:
+        extra = "openai" if module_name == ".openai" else "azureopenai"
+        raise ModuleNotFoundError(
+            f"{name} needs the '{extra}' extra: pip install 'agentbyte[{extra}]'", name=exc.name
+        ) from exc
+    value = getattr(module, name)
+    globals()[name] = value
+    return value

{agentbyte-0.32.0 → agentbyte-0.32.2}/src/agentbyte/presets/clients.py

@@ -5,11 +5,7 @@ from __future__ import annotations
 import os
 from typing import Any
 
-from agentbyte.llm import (
-    AzureOpenAIChatCompletionClient,
-    BaseChatCompletionClient,
-    OpenAIChatCompletionClient,
-)
+from agentbyte.llm import BaseChatCompletionClient
 
 DEFAULT_OPENAI_MODEL = "gpt-4.1-mini"
 DEFAULT_CLIENT_CONFIG = {"temperature": 0.2}
@@ -53,11 +49,15 @@ def build_chat_client(
     )
 
     if resolved_provider == "openai":
+        from agentbyte.llm import OpenAIChatCompletionClient
+
         return OpenAIChatCompletionClient.from_api_key(
             model=model or DEFAULT_OPENAI_MODEL,
             config=resolved_config,
         )
 
+    from agentbyte.llm import AzureOpenAIChatCompletionClient
+
     if os.getenv("AZURE_TENANT_ID"):
         return AzureOpenAIChatCompletionClient.from_certificate(
             model=resolved_model,

{agentbyte-0.32.0 → agentbyte-0.32.2}/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 → agentbyte-0.32.2}/tests/presets/test_clients.py

@@ -4,6 +4,7 @@ from types import SimpleNamespace
 
 import pytest
 
+import agentbyte.llm as llm
 from agentbyte.presets import clients as preset_clients
 
 
@@ -43,7 +44,7 @@ class DummyAzureClient:
 
 
 def test_build_chat_client_explicit_openai(monkeypatch):
-    monkeypatch.setattr(preset_clients, "OpenAIChatCompletionClient", DummyOpenAIClient)
+    monkeypatch.setattr(llm, "OpenAIChatCompletionClient", DummyOpenAIClient)
 
     client = preset_clients.build_chat_client(provider="openai", model="gpt-test")
 
@@ -53,8 +54,7 @@ def test_build_chat_client_explicit_openai(monkeypatch):
 
 
 def test_build_chat_client_explicit_azure_with_api_key(monkeypatch):
-    monkeypatch.setattr(
-        preset_clients, "AzureOpenAIChatCompletionClient", DummyAzureClient
+    monkeypatch.setattr(llm, "AzureOpenAIChatCompletionClient", DummyAzureClient
     )
     monkeypatch.setenv("AZURE_OPENAI_API_KEY", "secret")
 
@@ -69,8 +69,7 @@ def test_build_chat_client_explicit_azure_with_api_key(monkeypatch):
 
 
 def test_build_chat_client_prefers_azure_certificate_over_api_key(monkeypatch):
-    monkeypatch.setattr(
-        preset_clients, "AzureOpenAIChatCompletionClient", DummyAzureClient
+    monkeypatch.setattr(llm, "AzureOpenAIChatCompletionClient", DummyAzureClient
     )
     monkeypatch.setenv("AZURE_OPENAI_ENDPOINT", "https://example.openai.azure.com/")
     monkeypatch.setenv("AZURE_OPENAI_API_KEY", "secret")
@@ -83,8 +82,7 @@ def test_build_chat_client_prefers_azure_certificate_over_api_key(monkeypatch):
 
 
 def test_build_chat_client_uses_azure_env_model_name_when_present(monkeypatch):
-    monkeypatch.setattr(
-        preset_clients, "AzureOpenAIChatCompletionClient", DummyAzureClient
+    monkeypatch.setattr(llm, "AzureOpenAIChatCompletionClient", DummyAzureClient
     )
     monkeypatch.delenv("OPENAI_API_KEY", raising=False)
     monkeypatch.delenv("AZURE_OPENAI_API_KEY", raising=False)
@@ -98,7 +96,7 @@ def test_build_chat_client_uses_azure_env_model_name_when_present(monkeypatch):
 
 
 def test_build_chat_client_infers_openai_from_env(monkeypatch):
-    monkeypatch.setattr(preset_clients, "OpenAIChatCompletionClient", DummyOpenAIClient)
+    monkeypatch.setattr(llm, "OpenAIChatCompletionClient", DummyOpenAIClient)
     monkeypatch.setenv("OPENAI_API_KEY", "secret")
 
     client = preset_clients.build_chat_client()
@@ -108,8 +106,7 @@ def test_build_chat_client_infers_openai_from_env(monkeypatch):
 
 
 def test_build_chat_client_uses_azure_default_credential_when_no_key(monkeypatch):
-    monkeypatch.setattr(
-        preset_clients, "AzureOpenAIChatCompletionClient", DummyAzureClient
+    monkeypatch.setattr(llm, "AzureOpenAIChatCompletionClient", DummyAzureClient
     )
     monkeypatch.delenv("OPENAI_API_KEY", raising=False)
     monkeypatch.delenv("AZURE_OPENAI_API_KEY", raising=False)

{agentbyte-0.32.0 → agentbyte-0.32.2}/tests/test_package_api.py

@@ -512,3 +512,26 @@ def test_package_root_otel_bootstrap_instruments_agent_init(
         assert getattr(AgentClass.__init__, "__agentbyte_otel_instrumented__", False) is True
     finally:
         AgentClass.__init__ = original_init
+
+
+OPTIONAL_MODULES = [
+    "openai", "azure", "azure.identity", "aiosqlite", "sqlalchemy", "sqlmodel", "asyncpg",
+    "aioboto3", "fastapi", "uvicorn", "opentelemetry", "graphviz", "gepa",
+]
+
+
+def test_core_import_works_without_optional_extras() -> None:
+    """`import agentbyte` and the CLI must not need any optional extra (regression for 0.32.1)."""
+    import subprocess
+
+    blocked = "\n".join(f"sys.modules[{name!r}] = None" for name in OPTIONAL_MODULES)
+    script = (
+        f"import sys\n{blocked}\n"
+        "import agentbyte, agentbyte.llm, agentbyte.presets, agentbyte.cli.main\n"
+        "from agentbyte.llm import BaseChatCompletionClient\n"
+        "try:\n    agentbyte.llm.OpenAIChatCompletionClient\n"
+        "except ModuleNotFoundError as exc:\n    print(exc)\n"
+    )
+    result = subprocess.run([sys.executable, "-c", script], capture_output=True, text=True, timeout=120)
+    assert result.returncode == 0, result.stderr
+    assert "pip install 'agentbyte[openai]'" in result.stdout

agentbyte-0.32.0/src/agentbyte/__about__.py

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