geny-executor 2.48.2__tar.gz → 2.48.3__tar.gz

{geny_executor-2.48.2 → geny_executor-2.48.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.48.2
+Version: 2.48.3
 Summary: Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor

{geny_executor-2.48.2 → geny_executor-2.48.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.48.2"
+version = "2.48.3"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "Apache-2.0"

{geny_executor-2.48.2 → geny_executor-2.48.3}/src/geny_executor/memory/embedding/client.py

@@ -34,9 +34,10 @@ re-attempted the call and logged a full traceback, forever.
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import os
-from typing import List, Protocol, Sequence, runtime_checkable
+from typing import List, Optional, Protocol, Sequence, runtime_checkable
 
 from geny_executor.memory.provider import CostEvent, EmbeddingDescriptor
 
@@ -148,6 +149,93 @@ def _resolve_env_api_key(provider: str, *env_vars: str) -> str:
     return ""
 
 
+class _LoopBoundClientMixin:
+    """Loop-safe caching for httpx-backed embedding SDK clients.
+
+    An httpx-based SDK client (``AsyncOpenAI``, ``genai.Client``) binds its
+    transport/connection-pool to the event loop that first drives it and
+    cannot be reused from another loop — a later call on a different loop
+    raises ``RuntimeError: Event loop is closed`` / "Future attached to a
+    different loop". Hosts that drive memory writes through a sync→async
+    bridge (Geny's ``run_coro_sync``) spin a fresh, short-lived event loop
+    **per call**, so a single cached client would (a) fail cross-loop on
+    every bridged embed and (b), never being closed, leak its socket pool
+    once per session.
+
+    Strategy:
+      * Cache ONE client on the loop that first uses it — almost always the
+        stable server loop, where the vast majority of embeds happen
+        (search, the memory stage). That loop's calls reuse it, so
+        connection pooling is preserved.
+      * If the cached client's loop is found dead, drop the reference (its
+        transport is finalized by GC) and rebind to the current loop. An
+        all-bridge caller (only ever ephemeral loops) therefore rebinds
+        each call instead of accumulating clients.
+      * Any OTHER still-live loop gets a short-lived client that the caller
+        closes within the same call (``ephemeral=True``) — never drive one
+        client's transport from two loops.
+
+    Subclasses set ``self._client`` / ``self._client_loop`` /
+    ``self._injected_client`` in ``__init__`` and implement
+    ``_build_client()``. A test-injected client (``_injected_client``) is
+    used verbatim and never rebuilt or auto-closed — the caller owns it.
+    """
+
+    _client: Optional[object] = None
+    _client_loop: Optional[asyncio.AbstractEventLoop] = None
+    _injected_client: bool = False
+
+    def _build_client(self) -> object:
+        raise NotImplementedError
+
+    def _acquire_client(self):
+        """Return ``(client, ephemeral)`` bound to the CURRENT running loop.
+
+        ``ephemeral`` clients MUST be closed by the caller (see
+        ``_aclose_client``) before the coroutine returns.
+        """
+        if self._injected_client:
+            return self._client, False
+        loop = asyncio.get_running_loop()
+        cached = self._client
+        if cached is not None:
+            if self._client_loop is loop and not loop.is_closed():
+                return cached, False  # hot path: pooled client on its loop
+            if self._client_loop is None or self._client_loop.is_closed():
+                # Cached loop is dead — drop so GC finalizes its transport,
+                # then rebind to this loop below.
+                self._client = None
+                self._client_loop = None
+                cached = None
+        if cached is None:
+            self._client = self._build_client()
+            self._client_loop = loop
+            return self._client, False
+        # Cache valid but bound to a different, still-live loop → ephemeral.
+        return self._build_client(), True
+
+    async def _aclose_client(self, client: object) -> None:
+        closer = getattr(client, "close", None)
+        if closer is None:
+            return
+        try:
+            result = closer()
+            if asyncio.iscoroutine(result):
+                await result
+        except Exception:  # noqa: BLE001 — close is best-effort
+            logger.debug("embedding client close failed", exc_info=True)
+
+    async def _close_cached_client(self) -> None:
+        """Release the cached client (``close()`` surface). No-op for an
+        injected client — its lifetime belongs to the caller."""
+        client = self._client
+        self._client = None
+        self._client_loop = None
+        if client is None or self._injected_client:
+            return
+        await self._aclose_client(client)
+
+
 __all__ = [
     "EmbeddingClient",
     "EmbeddingError",

{geny_executor-2.48.2 → geny_executor-2.48.3}/src/geny_executor/memory/embedding/google.py

@@ -15,6 +15,7 @@ from typing import Any, List, Optional, Sequence
 from geny_executor.memory.embedding.client import (
     EmbeddingClient,
     EmbeddingError,
+    _LoopBoundClientMixin,
     _resolve_env_api_key,
 )
 from geny_executor.memory.provider import EmbeddingDescriptor
@@ -27,7 +28,7 @@ _GOOGLE_DIMS = {
 }
 
 
-class GoogleEmbeddingClient(EmbeddingClient):
+class GoogleEmbeddingClient(_LoopBoundClientMixin, EmbeddingClient):
     """Google Generative AI embeddings."""
 
     def __init__(
@@ -45,7 +46,10 @@ class GoogleEmbeddingClient(EmbeddingClient):
             "google", "GOOGLE_API_KEY", "GEMINI_API_KEY"
         )
         self._dimension = dimension or _GOOGLE_DIMS.get(model, 0)
+        # Loop-safe client cache (see _LoopBoundClientMixin).
         self._client = client
+        self._client_loop = None
+        self._injected_client = client is not None
         self._descriptor = EmbeddingDescriptor(
             provider="google",
             model=model,
@@ -61,43 +65,47 @@ class GoogleEmbeddingClient(EmbeddingClient):
     async def embed(self, texts: Sequence[str]) -> List[List[float]]:
         if not texts:
             return []
-        client = self._ensure_client()
+        # Loop-safe: pooled client on the stable loop, ephemeral (closed
+        # below) on a sync-bridge loop.
+        client, ephemeral = self._acquire_client()
         try:
-            # google-genai v1: `client.aio.models.embed_content(...)`
-            resp = await client.aio.models.embed_content(
-                model=self._model,
-                contents=list(texts),
-            )
-        except Exception as exc:
-            raise EmbeddingError(f"google embed failed: {exc}") from exc
-        embeds = getattr(resp, "embeddings", None)
-        if embeds is None:
-            raise EmbeddingError(f"google embed: missing 'embeddings' in {resp!r}")
-        vectors: List[List[float]] = []
-        for item in embeds:
-            values = getattr(item, "values", None)
-            if values is None:
-                raise EmbeddingError(f"google embed: bad row: {item!r}")
-            vectors.append([float(x) for x in values])
-        if self._dimension == 0 and vectors:
-            self._dimension = len(vectors[0])
-            self._descriptor = EmbeddingDescriptor(
-                provider="google",
-                model=self._model,
-                dimension=self._dimension,
-                metric="cosine",
-                api_key_present=bool(self._api_key),
-            )
-        return vectors
+            try:
+                # google-genai v1: `client.aio.models.embed_content(...)`
+                resp = await client.aio.models.embed_content(
+                    model=self._model,
+                    contents=list(texts),
+                )
+            except Exception as exc:
+                raise EmbeddingError(f"google embed failed: {exc}") from exc
+            embeds = getattr(resp, "embeddings", None)
+            if embeds is None:
+                raise EmbeddingError(f"google embed: missing 'embeddings' in {resp!r}")
+            vectors: List[List[float]] = []
+            for item in embeds:
+                values = getattr(item, "values", None)
+                if values is None:
+                    raise EmbeddingError(f"google embed: bad row: {item!r}")
+                vectors.append([float(x) for x in values])
+            if self._dimension == 0 and vectors:
+                self._dimension = len(vectors[0])
+                self._descriptor = EmbeddingDescriptor(
+                    provider="google",
+                    model=self._model,
+                    dimension=self._dimension,
+                    metric="cosine",
+                    api_key_present=bool(self._api_key),
+                )
+            return vectors
+        finally:
+            if ephemeral:
+                await self._aclose_client(client)
 
     async def close(self) -> None:
-        return None
+        await self._close_cached_client()
 
     # ── internal ────────────────────────────────────────────────────
 
-    def _ensure_client(self):
-        if self._client is not None:
-            return self._client
+    def _build_client(self) -> object:
         try:
             from google import genai  # type: ignore
         except ImportError as exc:
@@ -105,8 +113,7 @@ class GoogleEmbeddingClient(EmbeddingClient):
                 "GoogleEmbeddingClient requires `google-genai`. "
                 "Install via `pip install geny-executor[google]`."
             ) from exc
-        self._client = genai.Client(api_key=self._api_key or None)
-        return self._client
+        return genai.Client(api_key=self._api_key or None)
 
 
 __all__ = ["GoogleEmbeddingClient"]

{geny_executor-2.48.2 → geny_executor-2.48.3}/src/geny_executor/memory/embedding/openai.py

@@ -13,13 +13,13 @@ keep request bodies reasonable and allow resume on partial failures.
 
 from __future__ import annotations
 
-import asyncio
 import logging
 from typing import List, Optional, Sequence
 
 from geny_executor.memory.embedding.client import (
     EmbeddingClient,
     EmbeddingError,
+    _LoopBoundClientMixin,
     _resolve_env_api_key,
 )
 from geny_executor.memory.provider import EmbeddingDescriptor
@@ -71,7 +71,7 @@ _OPENAI_DIMS = {
 }
 
 
-class OpenAIEmbeddingClient(EmbeddingClient):
+class OpenAIEmbeddingClient(_LoopBoundClientMixin, EmbeddingClient):
     """OpenAI embeddings via the official SDK."""
 
     def __init__(
@@ -89,7 +89,12 @@ class OpenAIEmbeddingClient(EmbeddingClient):
         # it logs a one-time migration warning (audit §2.6).
         self._api_key = api_key or _resolve_env_api_key("openai", "OPENAI_API_KEY")
         self._dimension = dimension or _OPENAI_DIMS.get(model, 0)
+        # Loop-safe client cache (see _LoopBoundClientMixin). A caller-
+        # supplied client is used verbatim (tests); otherwise lazily built
+        # per-loop by _build_client below.
         self._client = client
+        self._client_loop = None
+        self._injected_client = client is not None
         self._descriptor = EmbeddingDescriptor(
             provider="openai",
             model=model,
@@ -105,51 +110,47 @@ class OpenAIEmbeddingClient(EmbeddingClient):
     async def embed(self, texts: Sequence[str]) -> List[List[float]]:
         if not texts:
             return []
-        client = self._ensure_client()
-        out: List[List[float]] = []
-        # Bound each input to the model's token budget so one over-long
-        # text can never 400 the whole batch (crash-safety net).
-        texts = [_bound_input(t) for t in texts]
-        for i in range(0, len(texts), MAX_BATCH_SIZE):
-            batch = list(texts[i : i + MAX_BATCH_SIZE])
-            try:
-                # `openai>=1.x` exposes `await client.embeddings.create(...)`
-                resp = await client.embeddings.create(input=batch, model=self._model)
-            except Exception as exc:  # narrow is SDK-dependent
-                raise EmbeddingError(
-                    f"openai embed failed: {exc}",
-                    category=_classify_openai_error(exc),
-                ) from exc
-            # SDK response: `data: List[Embedding(embedding: List[float])]`
-            out.extend(item.embedding for item in resp.data)
-        # Update descriptor dimension if we learned it at runtime
-        if self._dimension == 0 and out:
-            self._dimension = len(out[0])
-            self._descriptor = EmbeddingDescriptor(
-                provider="openai",
-                model=self._model,
-                dimension=self._dimension,
-                metric="cosine",
-                api_key_present=bool(self._api_key),
-            )
-        return out
+        # Loop-safe: a pooled client on the stable loop, or a short-lived
+        # client on an ephemeral (sync-bridge) loop that we close below.
+        client, ephemeral = self._acquire_client()
+        try:
+            out: List[List[float]] = []
+            # Bound each input to the model's token budget so one over-long
+            # text can never 400 the whole batch (crash-safety net).
+            texts = [_bound_input(t) for t in texts]
+            for i in range(0, len(texts), MAX_BATCH_SIZE):
+                batch = list(texts[i : i + MAX_BATCH_SIZE])
+                try:
+                    # `openai>=1.x` exposes `await client.embeddings.create(...)`
+                    resp = await client.embeddings.create(input=batch, model=self._model)
+                except Exception as exc:  # narrow is SDK-dependent
+                    raise EmbeddingError(
+                        f"openai embed failed: {exc}",
+                        category=_classify_openai_error(exc),
+                    ) from exc
+                # SDK response: `data: List[Embedding(embedding: List[float])]`
+                out.extend(item.embedding for item in resp.data)
+            # Update descriptor dimension if we learned it at runtime
+            if self._dimension == 0 and out:
+                self._dimension = len(out[0])
+                self._descriptor = EmbeddingDescriptor(
+                    provider="openai",
+                    model=self._model,
+                    dimension=self._dimension,
+                    metric="cosine",
+                    api_key_present=bool(self._api_key),
+                )
+            return out
+        finally:
+            if ephemeral:
+                await self._aclose_client(client)
 
     async def close(self) -> None:
-        client = self._client
-        if client is None:
-            return
-        closer = getattr(client, "close", None)
-        if closer is None:
-            return
-        result = closer()
-        if asyncio.iscoroutine(result):
-            await result
+        await self._close_cached_client()
 
     # ── internal ────────────────────────────────────────────────────
 
-    def _ensure_client(self):
-        if self._client is not None:
-            return self._client
+    def _build_client(self) -> object:
         try:
             from openai import AsyncOpenAI  # type: ignore
         except ImportError as exc:
@@ -157,8 +158,7 @@ class OpenAIEmbeddingClient(EmbeddingClient):
                 "OpenAIEmbeddingClient requires the `openai` package. "
                 "Install via `pip install geny-executor[openai]`."
             ) from exc
-        self._client = AsyncOpenAI(api_key=self._api_key or None)
-        return self._client
+        return AsyncOpenAI(api_key=self._api_key or None)
 
 
 def _classify_openai_error(exc: Exception) -> str:

{geny_executor-2.48.2 → geny_executor-2.48.3}/src/geny_executor/memory/providers/file/provider.py

@@ -185,8 +185,21 @@ class FileMemoryProvider(MemoryProvider):
         self._initialized = True
 
     async def close(self) -> None:
-        # All writes are flushed at op time; nothing to do.
-        return None
+        # Writes are flushed at op time, so the stores need no teardown —
+        # but the embedding client owns an httpx connection pool (sockets)
+        # that must be released, or every session/restore leaks one client.
+        # The vector store shares THIS exact client instance (built with
+        # ``client=self._embedding_client``), so this is the single release
+        # point. Best-effort: a broken/cross-loop client must not turn
+        # session teardown into an error.
+        client = self._embedding_client
+        self._embedding_client = None
+        if client is None:
+            return
+        try:
+            await client.close()
+        except Exception:  # noqa: BLE001
+            logger.debug("embedding client close failed during provider close", exc_info=True)
 
     # ── layer handles ───────────────────────────────────────────────
 

geny_executor-2.48.3/tests/unit/test_embedding_loop_safety.py

@@ -0,0 +1,167 @@
+"""Regression: embedding clients must be loop-safe.
+
+An httpx-backed SDK client (AsyncOpenAI / genai.Client) binds its transport
+to the event loop that first drives it and cannot be reused from another
+loop. Hosts that drive memory writes through a sync->async bridge spin a
+fresh event loop PER CALL, so a naively-cached client (a) fails cross-loop
+on every bridged embed with "Event loop is closed" and (b), never being
+closed, leaks its socket pool once per session.
+
+``_LoopBoundClientMixin`` fixes this: it caches one client on the stable
+loop (pooled/reused), hands any other live loop a short-lived client it
+closes within the call, and drops a dead-loop cache so an all-bridge caller
+never accumulates references. These tests pin that behaviour without needing
+the real SDKs or a network — a fake SDK client asserts it is only ever
+driven on the loop it was built on.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+
+from geny_executor.memory.embedding.client import _LoopBoundClientMixin
+
+
+class _FakeSDKClient:
+    """Stand-in for AsyncOpenAI: records its build loop and asserts it is
+    never driven from a different loop (the exact cross-loop failure the
+    mixin exists to prevent)."""
+
+    def __init__(self, registry: dict) -> None:
+        self.build_loop = asyncio.get_running_loop()
+        self.closed = False
+        registry["built"] += 1
+
+    async def do_call(self) -> None:
+        assert asyncio.get_running_loop() is self.build_loop, (
+            "embedding client driven on a different loop than it was built on"
+        )
+
+    async def close(self) -> None:
+        self.closed = True
+
+
+class _FakeLoopBoundClient(_LoopBoundClientMixin):
+    """Minimal client using the mixin, with a counting fake SDK client."""
+
+    def __init__(self, injected: object | None = None) -> None:
+        self._client = injected
+        self._client_loop = None
+        self._injected_client = injected is not None
+        self._registry = {"built": 0}
+
+    def _build_client(self) -> object:
+        return _FakeSDKClient(self._registry)
+
+    async def embed(self, texts):
+        client, ephemeral = self._acquire_client()
+        try:
+            await client.do_call()  # asserts same-loop use
+            return [[0.0]] * len(texts)
+        finally:
+            if ephemeral:
+                await self._aclose_client(client)
+
+    async def close(self) -> None:
+        # Same delegation the real OpenAI/Google clients use.
+        await self._close_cached_client()
+
+    @property
+    def build_count(self) -> int:
+        return self._registry["built"]
+
+
+async def test_stable_loop_reuses_cached_client():
+    """Repeated embeds on the same (stable) loop reuse one pooled client."""
+    c = _FakeLoopBoundClient()
+    await c.embed(["a"])
+    await c.embed(["b"])
+    await c.embed(["c"])
+    assert c.build_count == 1  # built once, reused — connection pooling kept
+
+
+async def test_other_live_loop_gets_ephemeral_closed_client():
+    """A call on a DIFFERENT still-live loop must get its own short-lived
+    client, closed within the call, without disturbing the cache."""
+    c = _FakeLoopBoundClient()
+    await c.embed(["main"])              # caches on this (test) loop
+    assert c.build_count == 1
+    cached = c._client
+
+    captured: dict = {}
+
+    def worker() -> None:
+        loop = asyncio.new_event_loop()
+        try:
+            # This loop != the cached loop, and the cached loop is still
+            # alive (test thread is blocked in join), so → ephemeral.
+            loop.run_until_complete(c.embed(["worker"]))
+            captured["ok"] = True
+        except Exception as exc:  # noqa: BLE001
+            captured["err"] = repr(exc)
+        finally:
+            loop.close()
+
+    t = threading.Thread(target=worker)
+    t.start()
+    t.join()
+
+    assert captured.get("ok"), captured.get("err")
+    assert c.build_count == 2          # cached + one ephemeral
+    assert c._client is cached         # cache untouched
+    # The cached (test-loop) client keeps being reused afterwards:
+    await c.embed(["main2"])
+    assert c.build_count == 2
+
+
+def test_ephemeral_loops_never_cross_loop_and_do_not_accumulate():
+    """All-bridge caller: every call on a fresh, then-dead loop. The mixin
+    rebinds each round (dead-loop cache dropped, not reused → no cross-loop
+    error) and never retains more than the single current client."""
+    c = _FakeLoopBoundClient()
+    for _ in range(4):
+        loop = asyncio.new_event_loop()
+        try:
+            loop.run_until_complete(c.embed(["x"]))  # do_call asserts same-loop
+        finally:
+            loop.close()
+    # Rebuilt each round (previous loop was dead) rather than reusing a
+    # dead-loop client, and only ONE reference is held now (old ones were
+    # dereferenced → GC finalizes their transports; no growing retention).
+    assert c.build_count == 4
+    held = c._client
+    assert held is not None
+    # A fifth call on yet another fresh loop still holds exactly one.
+    loop = asyncio.new_event_loop()
+    try:
+        loop.run_until_complete(c.embed(["y"]))
+    finally:
+        loop.close()
+    assert c.build_count == 5
+    assert c._client is not held  # rebound, previous reference released
+
+
+async def test_injected_client_is_used_verbatim_and_not_auto_closed():
+    """A test-injected client is used as-is, never rebuilt, and close()
+    leaves it to the caller."""
+    reg = {"built": 0}
+    injected = _FakeSDKClient(reg)  # built on this loop
+    c = _FakeLoopBoundClient(injected=injected)
+    await c.embed(["z"])
+    assert c.build_count == 0          # never called _build_client
+    assert c._client is injected
+    await c.close()
+    assert injected.closed is False    # caller owns injected client's lifetime
+
+
+async def test_close_releases_cached_client():
+    """close() closes the lazily-built cached client (the per-session leak
+    fix) and clears the cache."""
+    c = _FakeLoopBoundClient()
+    await c.embed(["a"])
+    cached = c._client
+    assert cached is not None
+    await c.close()
+    assert cached.closed is True
+    assert c._client is None