geny-executor 2.61.2__tar.gz → 2.63.0__tar.gz

{geny_executor-2.61.2 → geny_executor-2.63.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.61.2
+Version: 2.63.0
 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
@@ -10,7 +10,7 @@ Author-email: CocoRoF <cocorof@users.noreply.github.com>
 License-Expression: Apache-2.0
 License-File: LICENSE
 License-File: NOTICE
-Keywords: agent,ai,anthropic,claude,harness,llm,mcp,orchestration,pipeline
+Keywords: agent,ai,anthropic,claude,harness,llm,mcp>=1.0.0,<2,orchestration,pipeline
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
@@ -29,7 +29,7 @@ Requires-Dist: ddgs>=9.11
 Requires-Dist: google-genai>=1.0.0
 Requires-Dist: httpx>=0.27
 Requires-Dist: jsonschema>=4.0
-Requires-Dist: mcp>=1.0.0
+Requires-Dist: mcp<2,>=1.0.0
 Requires-Dist: numpy>=1.24
 Requires-Dist: openai>=1.50.0
 Requires-Dist: pgvector>=0.3.0

{geny_executor-2.61.2 → geny_executor-2.63.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.61.2"
+version = "2.63.0"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "Apache-2.0"
@@ -20,7 +20,7 @@ keywords = [
     "harness",
     "ai",
     "llm",
-    "mcp",
+    "mcp>=1.0.0,<2",
     "orchestration",
 ]
 classifiers = [
@@ -39,7 +39,7 @@ classifiers = [
 dependencies = [
     # Core runtime
     "anthropic>=0.52.0",
-    "mcp>=1.0.0",
+    "mcp>=1.0.0,<2",
     "pydantic>=2.0",
     "jsonschema>=4.0",
     # httpx — declared explicitly because WebFetch imports it directly

{geny_executor-2.61.2 → geny_executor-2.63.0}/src/geny_executor/core/compaction.py

@@ -114,6 +114,22 @@ async def run_compaction(
     before_msgs = len(before_list)
     before_tokens = estimate_prompt_tokens(state)
 
+    # Deterministic pre-pass BEFORE the (expensive, lossy) compactor: dedup
+    # repeated tool outputs, strip stale base64 images, trim oversized stale
+    # results. In-place, count/order-preserving, pair-safe — so the watermark
+    # reconcile below and the compactor itself see a normal message list. The
+    # token-estimate memo keys on list length + head/tail ids, which this
+    # pass preserves, so it must be dropped for after_tokens to be honest.
+    try:
+        from geny_executor.core.context_prune import prune_messages
+
+        prune_metrics = prune_messages(state.messages or [])
+        if any(prune_metrics.get(k) for k in ("deduped", "images_stripped", "trimmed")):
+            state.shared.pop("_prompt_tokens_memo", None)
+            state.add_event("context.pruned", dict(prune_metrics))
+    except Exception:  # noqa: BLE001 — relief, never a gate
+        logger.debug("deterministic prune pass failed", exc_info=True)
+
     try:
         await compactor.compact(state)
     except Exception as exc:  # noqa: BLE001 — best effort

geny_executor-2.63.0/src/geny_executor/core/context_prune.py

@@ -0,0 +1,201 @@
+"""Deterministic tool-output pruning — the no-LLM pass that runs BEFORE
+summary compaction.
+
+LLM summarization is expensive and lossy; a large share of context pressure
+is mechanical redundancy that a deterministic pass can reclaim first:
+
+* **Duplicate tool outputs** — the same file read five times keeps five full
+  copies in history. Only the NEWEST copy carries information; older ones are
+  rewritten to a one-line back-reference (hash-matched, exact).
+* **Stale image payloads** — a base64 screenshot in an old tool result rides
+  every subsequent request forever (and survives summary compaction whenever
+  the compactor keeps that message verbatim).
+* **Oversized stale outputs** — a 10k-char terminal dump from twenty turns ago
+  is almost never load-bearing; the head plus an explicit trim marker is.
+
+Invariants (why this is safe to run on any history):
+
+* Message COUNT and ORDER never change — STM watermarks and compaction
+  bookkeeping stay valid.
+* ``tool_use`` blocks and every ``tool_use_id`` are untouched — pruning can
+  never orphan a tool call (pair repair stays a no-op).
+* Blocks are rewritten in place, never removed; only ``tool_result`` content
+  and image blocks shrink.
+* The newest ``protect_last`` messages are never touched — recent context is
+  exactly what the model is working from.
+
+Everything here is pure function + stdlib; no model, no network.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any, Dict, List
+
+__all__ = ["prune_messages", "PruneMetrics"]
+
+#: Messages within this tail window are never modified.
+DEFAULT_PROTECT_LAST = 6
+#: Tool-result text shorter than this is never considered for dedup — tiny
+#: results ("ok", exit codes) legitimately repeat and cost nothing.
+DEFAULT_MIN_DUP_CHARS = 512
+#: Stale tool-result text longer than this is trimmed to its head.
+DEFAULT_TRIM_OVER_CHARS = 4000
+#: How much head text a trimmed output keeps.
+DEFAULT_TRIM_KEEP_CHARS = 600
+
+_DUP_NOTE = "[duplicate tool output — identical to a more recent result]"
+_IMAGE_NOTE = "[image removed during context compaction]"
+
+
+class PruneMetrics(Dict[str, int]):
+    """Plain dict of counters; a class only so callers can type it."""
+
+
+def _iter_tool_results(message: Dict[str, Any]):
+    content = message.get("content")
+    if not isinstance(content, list):
+        return
+    for block in content:
+        if isinstance(block, dict) and block.get("type") == "tool_result":
+            yield block
+
+
+def _result_text_parts(block: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """The text sub-blocks of a tool_result whose content is a block list."""
+    content = block.get("content")
+    if not isinstance(content, list):
+        return []
+    return [b for b in content
+            if isinstance(b, dict) and b.get("type") == "text"]
+
+
+def _content_hash(block: Dict[str, Any]) -> str:
+    """Stable digest of a tool_result's content (str or block list)."""
+    content = block.get("content")
+    try:
+        payload = json.dumps(content, ensure_ascii=False, sort_keys=True,
+                             default=str)
+    except Exception:  # noqa: BLE001 — unhashable exotic content: skip dedup
+        return ""
+    return hashlib.sha1(payload.encode("utf-8", "replace")).hexdigest()
+
+
+def _content_size(block: Dict[str, Any]) -> int:
+    content = block.get("content")
+    if isinstance(content, str):
+        return len(content)
+    if isinstance(content, list):
+        return sum(len(b.get("text", "")) for b in content
+                   if isinstance(b, dict) and b.get("type") == "text")
+    return 0
+
+
+def _strip_images_in(blocks: List[Any]) -> int:
+    """Replace base64 image blocks with a small text marker, recursing into
+    tool_result content lists. Returns the number of images removed."""
+    removed = 0
+    for i, b in enumerate(blocks):
+        if not isinstance(b, dict):
+            continue
+        if (b.get("type") == "image"
+                and isinstance(b.get("source"), dict)
+                and b["source"].get("type") == "base64"):
+            blocks[i] = {"type": "text", "text": _IMAGE_NOTE}
+            removed += 1
+        elif b.get("type") == "tool_result" and isinstance(b.get("content"), list):
+            removed += _strip_images_in(b["content"])
+    return removed
+
+
+def _trim_result(block: Dict[str, Any], keep: int) -> int:
+    """Trim an oversized tool_result to its head + explicit marker. Returns
+    chars removed."""
+    content = block.get("content")
+    if isinstance(content, str):
+        dropped = len(content) - keep
+        block["content"] = (content[:keep]
+                            + f"\n… [{dropped} chars trimmed during context compaction]")
+        return dropped
+    if isinstance(content, list):
+        dropped = 0
+        budget = keep
+        for sub in _result_text_parts(block):
+            text = sub.get("text", "")
+            if budget <= 0:
+                dropped += len(text)
+                sub["text"] = ""
+            elif len(text) > budget:
+                dropped += len(text) - budget
+                sub["text"] = text[:budget]
+                budget = 0
+            else:
+                budget -= len(text)
+        if dropped > 0:
+            parts = _result_text_parts(block)
+            if parts:
+                parts[-1]["text"] += (
+                    f"\n… [{dropped} chars trimmed during context compaction]")
+        return dropped
+    return 0
+
+
+def prune_messages(
+    messages: List[Dict[str, Any]],
+    *,
+    protect_last: int = DEFAULT_PROTECT_LAST,
+    min_dup_chars: int = DEFAULT_MIN_DUP_CHARS,
+    trim_over_chars: int = DEFAULT_TRIM_OVER_CHARS,
+    trim_keep_chars: int = DEFAULT_TRIM_KEEP_CHARS,
+) -> PruneMetrics:
+    """Run the deterministic prune over *messages* in place.
+
+    Returns metrics: ``deduped`` (results back-referenced), ``images_stripped``,
+    ``trimmed`` (oversized results shortened), ``chars_saved`` (text chars
+    removed, images excluded).
+    """
+    metrics = PruneMetrics(deduped=0, images_stripped=0, trimmed=0,
+                           chars_saved=0)
+    if not messages:
+        return metrics
+    cutoff = max(0, len(messages) - max(0, protect_last))
+
+    # Pass 1 — hashes of every PROTECTED/newer occurrence win. Walk from the
+    # end so the newest copy of any repeated output is the one kept.
+    seen: set = set()
+    for mi in range(len(messages) - 1, -1, -1):
+        msg = messages[mi]
+        if not isinstance(msg, dict):
+            continue
+        protected = mi >= cutoff
+        for block in _iter_tool_results(msg):
+            if _content_size(block) < min_dup_chars:
+                continue
+            digest = _content_hash(block)
+            if not digest:
+                continue
+            if digest in seen and not protected:
+                old = _content_size(block)
+                block["content"] = _DUP_NOTE
+                metrics["deduped"] += 1
+                metrics["chars_saved"] += max(0, old - len(_DUP_NOTE))
+            else:
+                seen.add(digest)
+
+    # Pass 2 — stale-region cleanup: image stripping + oversize trimming.
+    for mi in range(cutoff):
+        msg = messages[mi]
+        if not isinstance(msg, dict):
+            continue
+        content = msg.get("content")
+        if isinstance(content, list):
+            metrics["images_stripped"] += _strip_images_in(content)
+        for block in _iter_tool_results(msg):
+            size = _content_size(block)
+            if size > trim_over_chars:
+                saved = _trim_result(block, trim_keep_chars)
+                if saved > 0:
+                    metrics["trimmed"] += 1
+                    metrics["chars_saved"] += saved
+    return metrics

{geny_executor-2.61.2 → geny_executor-2.63.0}/src/geny_executor/events/catalog.py

@@ -97,6 +97,10 @@ class EventTypes(str, Enum):
     # ── Stage 2: Context ──
     CONTEXT_BUILT = "context.built"
     CONTEXT_COMPACTED = "context.compacted"
+    #: Deterministic (no-LLM) prune pass that runs before the compactor:
+    #: dedup repeated tool outputs, strip stale base64 images, trim
+    #: oversized stale results.
+    CONTEXT_PRUNED = "context.pruned"
     CONTEXT_COMPACTION_FAILED = "context.compaction_failed"
     CONTEXT_COMPACTION_RECORD_FAILED = "context.compaction_record_failed"
     # TTFT program (2.50.0): retrieval bounded / LLM compaction moved
@@ -356,6 +360,12 @@ PAYLOADS: Dict[EventTypes, Dict[str, str]] = {
         "messages_after": "int?",
         "saved_tokens_estimate": "int?",
     },
+    EventTypes.CONTEXT_PRUNED: {
+        "deduped": "int — duplicate tool results rewritten to a back-reference",
+        "images_stripped": "int — stale base64 images replaced with a marker",
+        "trimmed": "int — oversized stale tool results shortened",
+        "chars_saved": "int — text chars removed (images excluded)",
+    },
     EventTypes.CONTEXT_RETRIEVAL_TIMEOUT: {
         "timeout_s": "float — the retrieval_timeout_s bound that fired; the turn proceeds without memory",
     },

{geny_executor-2.61.2 → geny_executor-2.63.0}/src/geny_executor/memory/providers/file/stm_store.py

@@ -31,11 +31,44 @@ from geny_executor.memory.providers.file.timezone import now_in
 logger = logging.getLogger(__name__)
 
 MAX_STM_LINES = 2000
+#: Byte budget for the whole jsonl. The line cap alone let a session grow to
+#: 270 MB in production — 2,000 lines is no bound when single event lines
+#: carry hundreds of KB (inlined observation frames, giant tool results).
+#: recent()/search() and the transcripts UI re-read the WHOLE file, so the
+#: byte budget is what actually keeps those O(file) paths sane.
+MAX_STM_BYTES = 16 * 1024 * 1024
+#: A single record longer than this is truncated at append time (its
+#: ``content`` tail replaced with a marker). Applies to turns AND events —
+#: nothing conversational needs half a megabyte of inline payload.
+MAX_RECORD_BYTES = 64 * 1024
 #: Enforce the line cap every N appends (not every append — the cap
 #: re-reads the whole jsonl). Bounds the file to MAX_STM_LINES + this.
 _CAP_CHECK_EVERY = 200
 
 
+def _bound_record_line(line: str) -> str:
+    """Truncate an oversized serialized record to MAX_RECORD_BYTES.
+
+    The cut happens on the record's ``content`` field (the only place
+    multi-hundred-KB payloads ride), preserving valid JSON and stamping an
+    explicit marker so downstream readers know bytes were dropped."""
+    if len(line.encode("utf-8", "ignore")) <= MAX_RECORD_BYTES:
+        return line
+    try:
+        rec = json.loads(line)
+        content = rec.get("content")
+        if isinstance(content, str) and len(content) > 4096:
+            overshoot = len(line.encode("utf-8", "ignore")) - MAX_RECORD_BYTES
+            keep = max(4096, len(content) - overshoot - 256)
+            dropped = len(content) - keep
+            rec["content"] = (content[:keep]
+                              + f"\n… [{dropped} chars truncated at record cap]")
+            return json.dumps(rec, ensure_ascii=False)
+    except Exception:  # noqa: BLE001 — malformed record: hard-cut the line
+        pass
+    return line[: MAX_RECORD_BYTES // 2]
+
+
 class _JSONLSTMStore:
     """Append-only JSONL file backed STM.
 
@@ -68,7 +101,7 @@ class _JSONLSTMStore:
 
     async def append(self, turn: Turn) -> None:
         rec = _turn_to_record(turn, self._tz)
-        line = json.dumps(rec, ensure_ascii=False)
+        line = _bound_record_line(json.dumps(rec, ensure_ascii=False))
         async with self._lock:
             self._path.parent.mkdir(parents=True, exist_ok=True)
             with self._path.open("a", encoding="utf-8") as fh:
@@ -90,6 +123,7 @@ class _JSONLSTMStore:
             self._appends_since_cap = 0
             try:
                 await self.enforce_line_cap()
+                await self.enforce_byte_cap()
             except Exception:  # noqa: BLE001 — capping is best-effort
                 logger.debug("stm: enforce_line_cap failed", exc_info=True)
 
@@ -118,6 +152,14 @@ class _JSONLSTMStore:
         if metadata:
             rec["metadata"] = dict(metadata)
         line = json.dumps(rec, ensure_ascii=False)
+        if len(line.encode("utf-8", "ignore")) > MAX_RECORD_BYTES:
+            # Event payloads (observation frames, giant tool results) were the
+            # production 270 MB transcript's fat lines. Keep the envelope,
+            # drop the payload with an explicit marker.
+            rec["data"] = {"truncated": True,
+                           "reason": f"event payload over {MAX_RECORD_BYTES} bytes"}
+            rec.pop("metadata", None)
+            line = json.dumps(rec, ensure_ascii=False)
         async with self._lock:
             self._path.parent.mkdir(parents=True, exist_ok=True)
             with self._path.open("a", encoding="utf-8") as fh:
@@ -146,6 +188,36 @@ class _JSONLSTMStore:
                     break
         return out
 
+    async def enforce_byte_cap(self) -> int:
+        """Drop OLDEST lines until the file fits MAX_STM_BYTES. Returns
+        dropped-line count. Line cap alone is no bound when individual lines
+        are hundreds of KB — this is the bound that keeps the whole-file
+        readers (recent/search/transcripts UI) usable."""
+        async with self._lock:
+            try:
+                if (not self._path.exists()
+                        or self._path.stat().st_size <= MAX_STM_BYTES):
+                    return 0
+            except OSError:
+                return 0
+            lines = self._read_lines_sync()
+            sizes = [len(ln.encode("utf-8", "ignore")) + 1 for ln in lines]
+            total = sum(sizes)
+            drop = 0
+            while drop < len(lines) and total > MAX_STM_BYTES:
+                total -= sizes[drop]
+                drop += 1
+            if drop == 0:
+                return 0
+            tail = lines[drop:]
+            self._path.parent.mkdir(parents=True, exist_ok=True)
+            tmp = self._path.with_suffix(self._path.suffix + ".tmp")
+            with tmp.open("w", encoding="utf-8") as fh:
+                for line in tail:
+                    fh.write(line + "\n")
+            tmp.replace(self._path)
+            return drop
+
     async def truncate(self, *, keep_last: int) -> int:
         """Rewrite the file to keep only the last `keep_last` lines.
         Returns the number of dropped lines.

{geny_executor-2.61.2 → geny_executor-2.63.0}/src/geny_executor/stages/s03_system/artifact/default/stage.py

@@ -322,7 +322,23 @@ class SystemStage(Stage[Any, Any]):
             catalog = self._catalog_cache
             if catalog:
                 if isinstance(system, str):
-                    system = (system + "\n\n" + catalog) if system else catalog
+                    parts_rec = state.shared.get("system_parts")
+                    if (isinstance(parts_rec, dict)
+                            and parts_rec.get("stable_text")
+                            and parts_rec.get("volatile_text")):
+                        # volatile_placement="system": the catalog is
+                        # CACHE-STABLE, so it belongs in the stable region —
+                        # BEFORE the volatile tail. Appending it after the
+                        # joined string used to break the Stage-5 split
+                        # (`system == stable + "\n\n" + volatile` no longer
+                        # held), which silently caching the volatile tail too
+                        # → a full system re-prefill every turn.
+                        stable = parts_rec["stable_text"]
+                        stable = f"{stable}\n\n{catalog}" if stable else catalog
+                        parts_rec["stable_text"] = stable
+                        system = f"{stable}\n\n{parts_rec['volatile_text']}"
+                    else:
+                        system = (system + "\n\n" + catalog) if system else catalog
                 elif isinstance(system, list):
                     system = [*system, {"type": "text", "text": catalog}]
 

{geny_executor-2.61.2 → geny_executor-2.63.0}/src/geny_executor/stages/s05_cache/artifact/default/strategies.py

@@ -91,10 +91,20 @@ def _cache_system(state: PipelineState) -> None:
         parts = state.shared.get("system_parts")
         stable = parts.get("stable_text") if isinstance(parts, dict) else None
         volatile = parts.get("volatile_text") if isinstance(parts, dict) else None
-        if stable and volatile and system == f"{stable}\n\n{volatile}":
+        # Tolerant split: locate the volatile tail by POSITION instead of
+        # requiring the whole string to equal stable+"\n\n"+volatile exactly.
+        # Text appended between/after by later stages (e.g. the deferred-tool
+        # catalog) used to break that equality, silently pulling the volatile
+        # tail INSIDE the cached prefix — a full system re-prefill every turn.
+        # Splitting at the tail keeps concatenation byte-identical.
+        idx = -1
+        if stable and volatile and system.startswith(stable):
+            idx = system.rfind(volatile)
+        if idx > 0:
             state.system = [
-                {"type": "text", "text": stable, "cache_control": EPHEMERAL_CACHE},
-                {"type": "text", "text": f"\n\n{volatile}"},
+                {"type": "text", "text": system[:idx],
+                 "cache_control": EPHEMERAL_CACHE},
+                {"type": "text", "text": system[idx:]},
             ]
         else:
             state.system = [{"type": "text", "text": system, "cache_control": EPHEMERAL_CACHE}]

{geny_executor-2.61.2 → geny_executor-2.63.0}/src/geny_executor/stages/s20_persist/artifact/default/persisters.py

@@ -99,6 +99,12 @@ class FilePersister(Persister):
         # Run blocking IO in a thread so we don't stall the event loop.
         await asyncio.to_thread(self._write_sync, record)
 
+    #: Retention: keep at most this many checkpoint files per session. A
+    #: long-lived session accumulated 1,482 files (367 MB) in production —
+    #: checkpoints are resume points, not an archive; the recent tail is all
+    #: recovery ever needs.
+    KEEP_LAST = 100
+
     def _write_sync(self, record: CheckpointRecord) -> None:
         path = self._path_for(record.session_id, record.checkpoint_id)
         with self._lock:
@@ -109,6 +115,24 @@ class FilePersister(Persister):
                 fh.flush()
                 os.fsync(fh.fileno())
             os.replace(tmp, path)
+            self._prune_sync(path.parent)
+
+    def _prune_sync(self, session_dir: Path) -> None:
+        """Drop the oldest checkpoints beyond KEEP_LAST (by mtime). Called
+        under the lock, right after a successful write, so retention rides
+        the write path — no background job, no unbounded growth."""
+        try:
+            files = sorted(
+                session_dir.glob("*.json"),
+                key=lambda q: q.stat().st_mtime,
+            )
+            for stale in files[: max(0, len(files) - self.KEEP_LAST)]:
+                try:
+                    stale.unlink()
+                except OSError:
+                    continue
+        except OSError:
+            pass  # retention is best-effort; the write itself succeeded
 
     async def read(self, checkpoint_id: str) -> Optional[CheckpointRecord]:
         return await asyncio.to_thread(self._read_sync, checkpoint_id)