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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.48.0
+Version: 2.48.2
 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.0 → geny_executor-2.48.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.48.0"
+version = "2.48.2"
 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.0 → geny_executor-2.48.2}/src/geny_executor/memory/_locks.py

@@ -28,6 +28,7 @@ provider stores.
 
 from __future__ import annotations
 
+import asyncio
 import threading
 from types import TracebackType
 from typing import Optional, Type
@@ -45,6 +46,16 @@ class LoopAgnosticLock:
     holds the lock and re-acquires from the same task will deadlock,
     so callers must never nest ``async with self._lock:`` for the
     same lock instance.
+
+    **Acquire must never block the event loop.** Store critical sections
+    hold this lock across ``await`` points (e.g. ``vector_store.index``
+    awaits the embedding HTTP call while holding it). If a second
+    coroutine on the SAME loop then acquired synchronously, it would
+    freeze the loop thread — the holder could never resume to release,
+    deadlocking the whole process. So the async acquire below yields to
+    the loop instead of blocking it: a fast non-blocking try first, and
+    only on contention does it offload the blocking wait to a worker
+    thread (keeping the loop free so the current holder can finish).
     """
 
     __slots__ = ("_lock",)
@@ -52,12 +63,17 @@ class LoopAgnosticLock:
     def __init__(self) -> None:
         self._lock = threading.Lock()
 
+    async def _acquire_without_blocking_loop(self) -> None:
+        # Uncontended fast path — no thread hop.
+        if self._lock.acquire(blocking=False):
+            return
+        # Contended: wait in a worker thread so the event loop keeps running
+        # (and the current holder — possibly a coroutine on THIS loop that
+        # yielded mid-critical-section — can make progress and release).
+        await asyncio.to_thread(self._lock.acquire)
+
     async def __aenter__(self) -> "LoopAgnosticLock":
-        # Synchronous acquire. Memory writes inside are short-lived
-        # disk ops; blocking the event loop here matches the cost of
-        # the I/O itself. If a future caller needs non-blocking
-        # acquire, swap to ``await asyncio.to_thread(self._lock.acquire)``.
-        self._lock.acquire()
+        await self._acquire_without_blocking_loop()
         return self
 
     async def __aexit__(
@@ -69,7 +85,7 @@ class LoopAgnosticLock:
         self._lock.release()
 
     async def acquire(self) -> bool:
-        self._lock.acquire()
+        await self._acquire_without_blocking_loop()
         return True
 
     def release(self) -> None:

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

@@ -14,6 +14,7 @@ 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 (
@@ -24,8 +25,41 @@ from geny_executor.memory.embedding.client import (
 from geny_executor.memory.provider import EmbeddingDescriptor
 
 
+logger = logging.getLogger(__name__)
+
 MAX_BATCH_SIZE = 2048
 
+# OpenAI's text-embedding-* models reject inputs over 8192 tokens with a
+# 400 that propagates as a hard EmbeddingError — a single over-long note
+# (a whole conversation memory, an un-chunked document) could take the
+# whole embedding path down. The BPE tokenizer never emits MORE tokens
+# than the input's UTF-8 byte count (every token is ≥1 byte), so bounding
+# a request's bytes bounds its tokens: ≤8192 bytes ⇒ ≤8192 tokens. We pass
+# anything within that budget untouched and defensively truncate only the
+# rare over-budget input (on a UTF-8 boundary), so embedding is crash-safe
+# for every caller regardless of language. Callers that want full coverage
+# of long text should chunk BEFORE embedding (the knowledge repository
+# does, via Contextifier); this is the last-resort guard, not a substitute.
+_MAX_EMBED_BYTES = 8192
+_TRUNCATE_TO_BYTES = 8000  # margin applied when a cut is unavoidable
+_truncation_warned = False
+
+
+def _bound_input(text: str) -> str:
+    global _truncation_warned
+    encoded = text.encode("utf-8")
+    if len(encoded) <= _MAX_EMBED_BYTES:
+        return text
+    if not _truncation_warned:
+        logger.warning(
+            "embedding input exceeds the 8192-token budget (%d bytes); "
+            "truncating to %d bytes for the vector. Chunk long text before "
+            "embedding to avoid losing coverage.",
+            len(encoded), _TRUNCATE_TO_BYTES,
+        )
+        _truncation_warned = True
+    return encoded[:_TRUNCATE_TO_BYTES].decode("utf-8", errors="ignore")
+
 
 # Reference dimensions for OpenAI's current embedding families.
 # Callers can override via `dimension=` kwarg to match a dedicated
@@ -73,6 +107,9 @@ class OpenAIEmbeddingClient(EmbeddingClient):
             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:

{geny_executor-2.48.0 → geny_executor-2.48.2}/tests/unit/test_embedding_error_classification.py

@@ -146,3 +146,54 @@ async def test_voyage_transport_stub_can_raise_classified_error() -> None:
     with pytest.raises(EmbeddingError) as excinfo:
         await client.embed(["hello"])
     assert excinfo.value.category == "auth"
+
+
+# ── input token-budget guard (crash-safety net) ──────────────────────
+
+import asyncio  # noqa: E402
+
+from geny_executor.memory.embedding import openai as _openai_mod  # noqa: E402
+
+
+def test_bound_input_passes_short_text():
+    from geny_executor.memory.embedding.openai import _bound_input, _MAX_EMBED_BYTES
+
+    t = "짧은 한글 노트 " * 10
+    assert len(t.encode("utf-8")) <= _MAX_EMBED_BYTES
+    assert _bound_input(t) == t  # untouched
+
+
+def test_bound_input_truncates_over_budget_on_utf8_boundary():
+    from geny_executor.memory.embedding.openai import (
+        _bound_input, _MAX_EMBED_BYTES, _TRUNCATE_TO_BYTES,
+    )
+
+    # A CJK note far over the byte budget (each char is 3 UTF-8 bytes).
+    huge = "가" * 10000  # 30000 bytes
+    assert len(huge.encode("utf-8")) > _MAX_EMBED_BYTES
+    out = _bound_input(huge)
+    encoded = out.encode("utf-8")
+    assert len(encoded) <= _TRUNCATE_TO_BYTES  # bounded → tokens ≤ bytes ≤ budget
+    assert "�" not in out  # clean UTF-8 boundary, no mojibake
+
+
+def test_embed_never_sends_over_budget_input():
+    """The whole-note memory path embeds un-chunked text; the client must
+    bound it so OpenAI never 400s ('maximum input length is 8192 tokens')."""
+    seen = {}
+
+    class _FakeEmbeddings:
+        async def create(self, *, input, model):
+            seen["input"] = input
+
+            class _R:
+                data = [type("E", (), {"embedding": [0.0, 0.1]})() for _ in input]
+
+            return _R()
+
+    class _FakeClient:
+        embeddings = _FakeEmbeddings()
+
+    client = OpenAIEmbeddingClient(model="text-embedding-3-large", api_key="k", client=_FakeClient())
+    asyncio.run(client.embed(["나" * 20000]))
+    assert len(seen["input"][0].encode("utf-8")) <= 8192

{geny_executor-2.48.0 → geny_executor-2.48.2}/tests/unit/test_loop_agnostic_lock.py

@@ -201,3 +201,52 @@ def test_concurrent_writes_serialize_correctly() -> None:
         assert len(lines) == N, (
             f"all {N} concurrent writes must be persisted, got {len(lines)}"
         )
+
+
+# ── Regression: acquire must not block the event loop (deadlock fix) ──
+#
+# vector_store.index/search hold this lock across `await` (the embedding
+# HTTP call). Before the fix, __aenter__ did a synchronous threading
+# acquire on the event-loop thread — so a second coroutine acquiring
+# while the first held-across-await froze the loop forever (the holder
+# could never resume to release). This reproduces that exact shape.
+
+import pytest
+from geny_executor.memory._locks import LoopAgnosticLock
+
+
+@pytest.mark.asyncio
+async def test_acquire_does_not_block_loop_when_holder_awaits():
+    lock = LoopAgnosticLock()
+    order: list[str] = []
+
+    async def holder():
+        async with lock:
+            order.append("holder-in")
+            # Yield to the loop WHILE holding the lock (like the embedding
+            # await inside vector_store.index).
+            await asyncio.sleep(0.1)
+            order.append("holder-out")
+
+    async def contender():
+        # Start slightly after the holder has taken the lock.
+        await asyncio.sleep(0.02)
+        order.append("contender-wait")
+        async with lock:
+            order.append("contender-in")
+
+    # If __aenter__ blocked the loop, holder's sleep could never resume and
+    # this would hang forever — the timeout turns a regression into a failure.
+    await asyncio.wait_for(asyncio.gather(holder(), contender()), timeout=3.0)
+
+    # Holder must fully finish (acquire → await → release) before the
+    # contender gets in — proving mutual exclusion held AND the loop stayed live.
+    assert order == ["holder-in", "contender-wait", "holder-out", "contender-in"]
+
+
+@pytest.mark.asyncio
+async def test_uncontended_acquire_is_fast_path_no_thread():
+    lock = LoopAgnosticLock()
+    async with lock:
+        assert lock.locked()
+    assert not lock.locked()