data-olympus 0.3.2__tar.gz → 0.3.3__tar.gz

{data_olympus-0.3.2 → data_olympus-0.3.3}/CHANGELOG.md

@@ -12,6 +12,27 @@ This project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.3.3] - 2026-07-05
+
+### Fixed
+
+- **MCP streamable-HTTP session churn under long-lived clients.** A persistent
+  client (notably `opencode serve`) that holds the `GET /mcp` SSE stream open was
+  being forced to reconnect on a cycle, piling up abandoned transports on the
+  server and leaking event listeners on the client until it degraded. Two causes
+  addressed:
+  - The activity middleware now keeps a session non-idle for as long as its SSE
+    stream is actually open (re-stamping every `KB_SESSION_TOUCH_INTERVAL_SEC`,
+    default 30s, clamped to a third of the idle window), so the reaper evicts a
+    session only after its stream has genuinely closed. With that safety in
+    place, the idle-reap default (`KB_SESSION_IDLE_TIMEOUT_SEC`) drops from 1800s
+    to 300s, so an abandoned handshake is cleared in minutes instead of half an
+    hour.
+  - The shipped ingress manifest (`deploy/k8s/ingress.yaml`) now sets a long
+    `proxy-read-timeout`/`proxy-send-timeout` and disables buffering, so a proxy
+    with a short default idle timeout (nginx: 60s) no longer closes the SSE
+    stream and triggers the reconnect loop. See `docs/serving.md`.
+
 ## [0.3.2] - 2026-07-05
 
 ### Fixed
@@ -1029,7 +1050,8 @@ This project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - `docs/adoption.md`: bring-your-own-KB guide (author, lint, index, serve, wire an agent).
 - `docs/comparison.md`: how data-olympus relates to OKF, enterprise catalogs, markdown KB tools, agent-context conventions, RAG, and ADR tooling.
 
-[Unreleased]: https://github.com/knaisoma/data-olympus/compare/v0.3.2...HEAD
+[Unreleased]: https://github.com/knaisoma/data-olympus/compare/v0.3.3...HEAD
+[0.3.3]: https://github.com/knaisoma/data-olympus/compare/v0.3.2...v0.3.3
 [0.3.2]: https://github.com/knaisoma/data-olympus/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/knaisoma/data-olympus/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/knaisoma/data-olympus/compare/v0.2.0...v0.3.0

{data_olympus-0.3.2 → data_olympus-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: data-olympus
-Version: 0.3.2
+Version: 0.3.3
 Summary: Governance-grade knowledge-base format (OKF-compatible) plus CLI and single-writer MCP server
 Project-URL: Homepage, https://github.com/knaisoma/data-olympus
 Project-URL: Repository, https://github.com/knaisoma/data-olympus

{data_olympus-0.3.2 → data_olympus-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "data-olympus"
-version = "0.3.2"
+version = "0.3.3"
 description = "Governance-grade knowledge-base format (OKF-compatible) plus CLI and single-writer MCP server"
 readme = "README.md"
 requires-python = ">=3.13"

{data_olympus-0.3.2 → data_olympus-0.3.3}/src/data_olympus/config.py

@@ -65,8 +65,15 @@ class Config:
     # Streamable-http session reaping: terminate transports idle beyond this many
     # seconds to bound _server_instances (see session_metrics). 0 disables the
     # reaper (observability-only). The scan runs every session_reap_interval_sec.
-    session_idle_timeout_sec: int = 1800
+    # An in-flight GET SSE stream is kept non-idle by the activity middleware, so
+    # this window only clears sessions whose stream has actually closed (an
+    # abandoned handshake); 5 minutes keeps those from piling up.
+    session_idle_timeout_sec: int = 300
     session_reap_interval_sec: int = 60
+    # How often the activity middleware re-stamps a session while its GET SSE
+    # stream is open, so a quiet-but-connected client is never reaped. Clamped
+    # below session_idle_timeout_sec at wiring time.
+    session_touch_interval_sec: int = 30
     # Optional override for the status-aware reranker's status->weight map
     # (issue #37). None means "use the Index built-in default map". A negative
     # weight boosts an in-force status, a positive one penalizes a retired one.
@@ -191,8 +198,9 @@ def load_config() -> Config:
     auth_principals = parse_principals_env(os.getenv("KB_AUTH_PRINCIPALS", ""))
     consult_ttl_sec = int(os.getenv("KB_CONSULT_TTL_SEC", "300"))
     ledger_path = os.getenv("KB_LEDGER_PATH", "/state/ledger.json")
-    session_idle_timeout_sec = int(os.getenv("KB_SESSION_IDLE_TIMEOUT_SEC", "1800"))
+    session_idle_timeout_sec = int(os.getenv("KB_SESSION_IDLE_TIMEOUT_SEC", "300"))
     session_reap_interval_sec = int(os.getenv("KB_SESSION_REAP_INTERVAL_SEC", "60"))
+    session_touch_interval_sec = int(os.getenv("KB_SESSION_TOUCH_INTERVAL_SEC", "30"))
     status_weights = _load_status_weights(os.getenv("KB_STATUS_WEIGHTS", ""))
     read_only = _env_bool(os.getenv("KB_READ_ONLY", ""))
     from data_olympus.cooccurrence import (
@@ -254,6 +262,7 @@ def load_config() -> Config:
         ledger_path=ledger_path,
         session_idle_timeout_sec=session_idle_timeout_sec,
         session_reap_interval_sec=session_reap_interval_sec,
+        session_touch_interval_sec=session_touch_interval_sec,
         status_weights=status_weights,
         read_only=read_only,
         cooccurrence_enabled=cooc_enabled,

{data_olympus-0.3.2 → data_olympus-0.3.3}/src/data_olympus/server.py

@@ -251,8 +251,9 @@ def build_app(
     audit_hmac_key: str = "",
     audit_max_bytes: int = 0,
     ledger_path: str | None = None,
-    session_idle_timeout_sec: int = 1800,
+    session_idle_timeout_sec: int = 300,
     session_reap_interval_sec: int = 60,
+    session_touch_interval_sec: int = 30,
     status_weights: dict[str, float] | None = None,
     read_only: bool = False,
     embeddings_enabled: bool = False,
@@ -300,6 +301,7 @@ def build_app(
         audit_max_bytes=audit_max_bytes,
         session_idle_timeout_sec=session_idle_timeout_sec,
         session_reap_interval_sec=session_reap_interval_sec,
+        session_touch_interval_sec=session_touch_interval_sec,
         status_weights=status_weights,
         read_only=read_only,
         embeddings_enabled=embeddings_enabled,
@@ -888,6 +890,7 @@ def build_app_from_config(config: Config, *, bootstrap_now: bool = True) -> Fast
         ledger_path=config.ledger_path,
         session_idle_timeout_sec=config.session_idle_timeout_sec,
         session_reap_interval_sec=config.session_reap_interval_sec,
+        session_touch_interval_sec=config.session_touch_interval_sec,
         status_weights=config.status_weights,
         read_only=config.read_only,
         embeddings_enabled=config.embeddings_enabled,
@@ -983,9 +986,25 @@ def main() -> None:
     )
 
     tracker = SessionActivityTracker()
+    # Re-stamp an in-flight SSE session at least 3x per idle window, so a
+    # quiet-but-connected client is never reaped even if an operator sets a short
+    # idle timeout. Falls back to the configured interval when the idle window is
+    # generous.
+    _idle = config.session_idle_timeout_sec
+    _touch_interval = float(config.session_touch_interval_sec)
+    if _idle > 0:
+        # Always strictly below the idle window (>= 3 touches per window) even for
+        # a tiny idle value; a small positive floor avoids a zero/negative sleep.
+        _touch_interval = max(0.1, min(_touch_interval, _idle / 3))
     http_app = app.http_app(
         transport="streamable-http",
-        middleware=[StarletteMiddleware(SessionActivityMiddleware, tracker=tracker)],
+        middleware=[
+            StarletteMiddleware(
+                SessionActivityMiddleware,
+                tracker=tracker,
+                touch_interval_sec=_touch_interval,
+            )
+        ],
     )
     # Health surfaces the live session count; the manager is only reachable once
     # the lifespan has started, so this returns None before then (never raises).

{data_olympus-0.3.2 → data_olympus-0.3.3}/src/data_olympus/session_metrics.py

@@ -45,6 +45,7 @@ these internals, discovery returns ``None`` and the count is reported as
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
 import time
 from typing import TYPE_CHECKING, Any, Protocol
@@ -195,20 +196,61 @@ class SessionActivityTracker:
 
 class SessionActivityMiddleware:
     """ASGI middleware that stamps :class:`SessionActivityTracker` on each request
-    carrying an ``mcp-session-id`` header. Pure pass-through otherwise; adds no
-    latency beyond a header scan."""
+    carrying an ``mcp-session-id`` header.
+
+    The ``GET /mcp`` Server-Sent-Events stream is a *single* long-lived request
+    that emits no further ASGI events while the session is quiet. Stamping only
+    at request start would let the idle reaper evict a still-connected client
+    after the idle window (forcing a reconnect, the exact churn that piles up
+    transports server-side and leaks listeners in a persistent client like
+    ``opencode serve``). So for an in-flight GET stream this middleware re-stamps
+    the session every ``touch_interval_sec`` for as long as the stream stays open;
+    when the client disconnects the request completes, re-stamping stops, and only
+    then does the session go idle and become reap-eligible. Short GET/POST
+    requests finish before the first tick, so they pay only the initial stamp.
+    """
 
-    def __init__(self, app: ASGIApp, tracker: SessionActivityTracker) -> None:
+    def __init__(
+        self,
+        app: ASGIApp,
+        tracker: SessionActivityTracker,
+        *,
+        touch_interval_sec: float = 30.0,
+    ) -> None:
         self.app = app
         self._tracker = tracker
+        self._touch_interval = touch_interval_sec
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope.get("type") == "http":
-            for key, value in scope.get("headers", []):
-                if key.lower() == _MCP_SESSION_ID_HEADER and value:
-                    self._tracker.touch(value.decode("latin-1"))
-                    break
-        await self.app(scope, receive, send)
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+        session_id = ""
+        for key, value in scope.get("headers", []):
+            if key.lower() == _MCP_SESSION_ID_HEADER and value:
+                session_id = value.decode("latin-1")
+                break
+        if not session_id:
+            await self.app(scope, receive, send)
+            return
+        self._tracker.touch(session_id)
+        # Only the long-lived GET SSE stream needs keep-alive re-stamping.
+        if scope.get("method") != "GET":
+            await self.app(scope, receive, send)
+            return
+
+        async def _keep_active() -> None:
+            while True:
+                await asyncio.sleep(self._touch_interval)
+                self._tracker.touch(session_id)
+
+        task = asyncio.create_task(_keep_active())
+        try:
+            await self.app(scope, receive, send)
+        finally:
+            task.cancel()
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                await task
 
 
 async def reap_idle_sessions(