soliplex 0.85.4__tar.gz → 0.86__tar.gz

{soliplex-0.85.4/src/soliplex.egg-info → soliplex-0.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soliplex
-Version: 0.85.4
+Version: 0.86
 Summary: An AI-powered Retrieval-Augmented Generation (RAG) system with a modern web interface.
 Author-email: Enfold <info@enfoldsystems.net>
 Classifier: Programming Language :: Python :: 3
@@ -20,7 +20,7 @@ Requires-Dist: fastapi
 Requires-Dist: fastmcp<5.0,>=4.0.2
 Requires-Dist: fakeredis!=2.35.0
 Requires-Dist: greenlet
-Requires-Dist: haiku.rag-slim<0.98,>=0.97.0
+Requires-Dist: haiku.rag-slim<0.99,>=0.98.0
 Requires-Dist: idna>=3.15
 Requires-Dist: itsdangerous
 Requires-Dist: joserfc<1.7,>=1.6.7

{soliplex-0.85.4 → soliplex-0.86}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "soliplex"
-version = "0.85.4"
+version = "0.86"
 description = "An AI-powered Retrieval-Augmented Generation (RAG) system with a modern web interface."
 authors = [{ name = "Enfold", email = "info@enfoldsystems.net" }]
 readme = "README.md"
@@ -26,7 +26,7 @@ dependencies = [
     "fastmcp >= 4.0.2, < 5.0",
     "fakeredis != 2.35.0",  # brownbag
     "greenlet",
-    "haiku.rag-slim >= 0.97.0, < 0.98",
+    "haiku.rag-slim >= 0.98.0, < 0.99",
     "idna >= 3.15",
     "itsdangerous",
     "joserfc >= 1.6.7, < 1.7",  # CVE-2026-48990
@@ -111,6 +111,7 @@ filterwarnings = [
 ]
 markers = [
     "needs_llm: functest requiring an LLM",
+    "sse_timing: functest asserting loopback SSE delivery timing",
 ]
 
 [tool.coverage.run]

{soliplex-0.85.4 → soliplex-0.86}/src/soliplex/agui/__init__.py

@@ -1,39 +1,19 @@
 from __future__ import annotations
 
 import abc
-import collections.abc
+import collections
 import datetime
 import enum
 import typing
 
 import fastapi
 from ag_ui import core as agui_core
-from pydantic_ai import ui as ai_ui
 from sqlalchemy.ext import asyncio as sqla_asyncio
 
 AGUI_Events = list[agui_core.Event]
-AGUI_EventStream = collections.abc.AsyncIterator[agui_core.Event]
 AGUI_State = dict[str, typing.Any]
 
 
-_COMPACTIBLE_TYPES = {  # event_type: compacting_attr
-    agui_core.EventType.TEXT_MESSAGE_CONTENT: "message_id",
-    agui_core.EventType.THINKING_TEXT_MESSAGE_CONTENT: "message_id",
-    agui_core.EventType.REASONING_MESSAGE_CONTENT: "message_id",
-    agui_core.EventType.TOOL_CALL_ARGS: "tool_call_id",
-}
-
-#
-#   Events which terminate a run's event stream
-#
-TERMINAL_EVENT_TYPES = frozenset(
-    [
-        agui_core.EventType.RUN_FINISHED,
-        agui_core.EventType.RUN_ERROR,
-    ]
-)
-
-
 class AGUI_Exception(ValueError):
     status_code = 400
 
@@ -617,48 +597,6 @@ class ThreadStorage(abc.ABC):
     ) -> RunFeedbackReviewEntry: ...
 
 
-async def compact_event_stream(stream: AGUI_EventStream):
-    compacting: agui_core.Event = None
-    compacting_id: str = None
-    compacting_attr: str = None
-
-    async for event in stream:
-        if compacting is not None:
-            event_id = getattr(event, compacting_attr, None)
-            if event.type == compacting.type and event_id == compacting_id:
-                compacting.delta += event.delta
-            else:
-                to_yield, compacting = compacting, None
-                yield to_yield
-                yield event
-
-        else:
-            compacting_attr = _COMPACTIBLE_TYPES.get(event.type)
-            if compacting_attr is not None:
-                compacting = event.model_copy()
-                compacting_id = getattr(event, compacting_attr, None)
-            else:
-                yield event
-
-
-async def with_final_state(
-    *,
-    stream: AGUI_EventStream,
-    deps: ai_ui.StateHandler | None,
-) -> AGUI_EventStream:
-    """Yield events from 'stream', adding a final AG-UI state snapshot.
-
-    The snapshot precedes the run's terminal event: AG-UI clients may stop
-    reading after a terminal event, and on replay the parser only accepts a
-    snapshot while the run is still in the RUNNING state.
-    """
-    async for event in stream:
-        if deps is not None and event.type in TERMINAL_EVENT_TYPES:
-            yield agui_core.StateSnapshotEvent(snapshot=deps.state)
-
-        yield event
-
-
 async def get_the_threads(request: fastapi.Request) -> ThreadStorage:
     from . import persistence
 

{soliplex-0.85.4 → soliplex-0.86}/src/soliplex/agui/persistence.py

@@ -14,6 +14,7 @@ from sqlalchemy.ext import asyncio as sqla_asyncio
 from soliplex import agui
 from soliplex.agui import persistence as agui_persistence
 from soliplex.agui import schema as agui_schema
+from soliplex.agui import sse_delivery as agui_sse_delivery
 from soliplex.agui import util as agui_util
 
 FeedbackReviewStatus = agui.FeedbackReviewStatus
@@ -341,6 +342,7 @@ class ThreadStorage(agui.ThreadStorage):
             await run.awaitable_attrs.events
             await run.awaitable_attrs.run_agent_input
             await run.awaitable_attrs.run_metadata
+            await run.awaitable_attrs.parent
 
         return run
 
@@ -1025,11 +1027,11 @@ async def drive_agui_turn(
     ``run_stream_kwargs`` is forwarded verbatim to the Pydantic AI adapter.
     """
     stream_kwargs = run_stream_kwargs or {}
-    event_stream = agui.with_final_state(
+    event_stream = agui_sse_delivery.with_final_state(
         stream=adapter.run_stream(**stream_kwargs),
         deps=stream_kwargs.get("deps"),
     )
-    compacted = agui.compact_event_stream(event_stream)
+    compacted = agui_sse_delivery.compact_event_stream(event_stream)
     async for event in compacted:
         try:
             await save_single_event(

soliplex-0.86/src/soliplex/agui/sse_delivery.py

@@ -0,0 +1,287 @@
+# ============================================================================
+#   AG-UI event-stream delivery shaping machinery
+# ============================================================================
+
+import asyncio
+import collections.abc
+import time
+
+import logfire
+from ag_ui import core as agui_core
+from pydantic_ai import ui as ai_ui
+
+from soliplex.config import sse_delivery as config_sse_delivery
+
+AGUI_EventStream = collections.abc.AsyncIterator[agui_core.Event]
+
+
+_COMPACTIBLE_TYPES = {  # event_type: compacting_attr
+    agui_core.EventType.TEXT_MESSAGE_CONTENT: "message_id",
+    agui_core.EventType.THINKING_TEXT_MESSAGE_CONTENT: "message_id",
+    agui_core.EventType.REASONING_MESSAGE_CONTENT: "message_id",
+    agui_core.EventType.TOOL_CALL_ARGS: "tool_call_id",
+}
+
+#
+#   Events which terminate a run's event stream
+#
+TERMINAL_EVENT_TYPES = frozenset(
+    [
+        agui_core.EventType.RUN_FINISHED,
+        agui_core.EventType.RUN_ERROR,
+    ]
+)
+
+
+async def compact_event_stream(stream: AGUI_EventStream):
+    compacting: agui_core.Event = None
+    compacting_id: str = None
+    compacting_attr: str = None
+
+    async for event in stream:
+        if compacting is not None:
+            event_id = getattr(event, compacting_attr, None)
+            if event.type == compacting.type and event_id == compacting_id:
+                compacting.delta += event.delta
+            else:
+                to_yield, compacting = compacting, None
+                yield to_yield
+                yield event
+
+        else:
+            compacting_attr = _COMPACTIBLE_TYPES.get(event.type)
+            if compacting_attr is not None:
+                compacting = event.model_copy()
+                compacting_id = getattr(event, compacting_attr, None)
+            else:
+                yield event
+
+
+_hold_clock = time.monotonic
+_wait = asyncio.wait
+_TIMEOUT = object()
+_BACKGROUND_PUMPS: set[asyncio.Task] = set()
+
+
+class _PumpState:
+    def __init__(self):
+        self.closing = False
+        self.error: Exception | None = None
+
+
+async def _pump(
+    stream: AGUI_EventStream,
+    queue: asyncio.Queue,
+    state: _PumpState,
+) -> _PumpState:
+    """Iterate and close 'stream' in this one task, putting events on 'queue'
+
+    Returns 'state', holding any error from iterating or closing the
+    stream.  'state.closing' is set before closing, after which the task is
+    no longer cancelled.  If the task is cancelled, the error is logged, as
+    nobody will read it.
+    """
+    cancelled = False
+
+    try:
+        async for event in stream:
+            await queue.put(event)
+    except asyncio.CancelledError:
+        cancelled = True
+    except Exception as exc:
+        state.error = exc
+
+    state.closing = True
+    aclose = getattr(stream, "aclose", None)
+    if aclose is not None:
+        try:
+            await aclose()
+        except Exception as close_exc:
+            if state.error is None:
+                state.error = close_exc
+            else:
+                state.error.add_note(
+                    f"Closing the stream also failed: {close_exc!r}"
+                )
+
+    if cancelled or asyncio.current_task().cancelling():
+        if state.error is not None:
+            logfire.error(
+                "AG-UI event stream failed after cancellation: {error!r}",
+                error=state.error,
+            )
+        raise asyncio.CancelledError
+
+    return state
+
+
+def _log_undelivered(error: Exception):
+    logfire.error(
+        "AG-UI event stream failed after its consumer closed: {error!r}",
+        error=error,
+    )
+
+
+def _forget_background_pump(pump: asyncio.Task):
+    """Drop a pump left closing by a cancelled consumer, logging its error"""
+    _BACKGROUND_PUMPS.discard(pump)
+    if not pump.cancelled() and pump.exception() is None:
+        error = pump.result().error
+        if error is not None:
+            _log_undelivered(error)
+
+
+async def _next_item(queue: asyncio.Queue, pump: asyncio.Future, timeout):
+    """Return the next queued event, else the pump's result once it is done
+
+    Returns '_TIMEOUT' if neither arrives within 'timeout' seconds.
+    """
+    if queue.empty() and not pump.done():
+        getter = asyncio.ensure_future(queue.get())
+        try:
+            await _wait(
+                {getter, pump},
+                timeout=timeout,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+        finally:
+            if not getter.done():
+                getter.cancel()
+                await asyncio.wait({getter})
+
+        if not getter.cancelled():
+            return getter.result()
+
+    if not queue.empty():
+        return queue.get_nowait()
+
+    if pump.done():
+        if pump.cancelled():
+            raise asyncio.CancelledError
+        return pump.result()
+
+    return _TIMEOUT
+
+
+async def coalesce_event_stream(
+    stream: AGUI_EventStream,
+    *,
+    max_deltas: int,
+    max_bytes: int,
+    max_ms: int,
+) -> AGUI_EventStream:
+    """Merge deltas as 'compact_event_stream' does, within bounds
+
+    The merged event is yielded once it holds 'max_deltas' deltas, or
+    'max_bytes' bytes of UTF-8 text, or has been held about 'max_ms'
+    milliseconds (a target, checked when the event loop runs this
+    generator), or when any other event arrives.  The upstream is
+    iterated and closed in a separate task, so the time bound applies
+    while the upstream is quiet.
+    """
+    queue = asyncio.Queue(maxsize=1)
+    state = _PumpState()
+    pump = asyncio.create_task(_pump(stream, queue, state))
+    delivered = False
+    held = held_attr = held_id = None
+    held_count = 0
+    deadline = 0.0
+
+    try:
+        while True:
+            timeout = None
+            if held is not None:
+                timeout = max(0.0, deadline - _hold_clock())
+
+            item = await _next_item(queue, pump, timeout)
+
+            if held is not None and _hold_clock() >= deadline:
+                to_yield, held = held, None
+                yield to_yield
+
+            if item is _TIMEOUT:
+                continue
+
+            if item is state:
+                if held is not None:
+                    yield held
+                delivered = True
+                if state.error is not None:
+                    raise state.error
+                return
+
+            if (
+                held is not None
+                and item.type == held.type
+                and getattr(item, held_attr, None) == held_id
+            ):
+                held.delta += item.delta
+                held_count += 1
+            else:
+                if held is not None:
+                    to_yield, held = held, None
+                    yield to_yield
+
+                held_attr = _COMPACTIBLE_TYPES.get(item.type)
+                if held_attr is None:
+                    yield item
+                    continue
+
+                held = item.model_copy()
+                held_id = getattr(item, held_attr, None)
+                held_count = 1
+                deadline = _hold_clock() + max_ms / 1000
+
+            if (
+                held_count >= max_deltas
+                or len(held.delta.encode("utf-8")) >= max_bytes
+            ):
+                to_yield, held = held, None
+                yield to_yield
+
+    finally:
+        if not state.closing:
+            pump.cancel()
+        try:
+            await asyncio.shield(pump)
+        except asyncio.CancelledError:
+            if asyncio.current_task().cancelling():
+                _BACKGROUND_PUMPS.add(pump)
+                pump.add_done_callback(_forget_background_pump)
+                raise
+        else:
+            if not delivered and state.error is not None:
+                _log_undelivered(state.error)
+
+
+def apply_delivery_strategy(
+    stream: AGUI_EventStream,
+    delivery: config_sse_delivery.SSEDeliveryConfig,
+) -> AGUI_EventStream:
+    if delivery.strategy == config_sse_delivery.SSEDeliveryStrategy.BOUNDED:
+        return coalesce_event_stream(
+            stream,
+            max_deltas=delivery.max_deltas,
+            max_bytes=delivery.max_bytes,
+            max_ms=delivery.max_ms,
+        )
+
+    return compact_event_stream(stream)
+
+
+async def with_final_state(
+    *,
+    stream: AGUI_EventStream,
+    deps: ai_ui.StateHandler | None,
+) -> AGUI_EventStream:
+    """Yield events from 'stream', adding a final AG-UI state snapshot.
+
+    The snapshot precedes the run's terminal event: AG-UI clients may stop
+    reading after a terminal event, and on replay the parser only accepts a
+    snapshot while the run is still in the RUNNING state.
+    """
+    async for event in stream:
+        if deps is not None and event.type in TERMINAL_EVENT_TYPES:
+            yield agui_core.StateSnapshotEvent(snapshot=deps.state)
+
+        yield event

soliplex-0.86/src/soliplex/alembic_migrations/versions/f13fea6c1953_soliplex_v0_86.py

@@ -0,0 +1,64 @@
+"""soliplex-v0.86
+
+Authz: add 'ACLEntry.permission', with new type 'Permission'
+
+Revision ID: f13fea6c1953
+Revises: b7e2f41c9d05
+Create Date: 2026-10-20 12:04:57.539891
+
+"""
+
+import typing
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "f13fea6c1953"
+down_revision: str | typing.Sequence[str] | None = "b7e2f41c9d05"
+branch_labels: str | typing.Sequence[str] | None = None
+depends_on: str | typing.Sequence[str] | None = None
+
+
+def upgrade(engine_name: str) -> None:
+    """Upgrade schema."""
+    globals()[f"upgrade_{engine_name}"]()
+
+
+def downgrade(engine_name: str) -> None:
+    """Downgrade schema."""
+    globals()[f"downgrade_{engine_name}"]()
+
+
+def upgrade_agui() -> None:
+    """Upgrade agui schema."""
+    pass
+
+
+def downgrade_agui() -> None:
+    """Downgrade agui schema."""
+    pass
+
+
+def upgrade_authz() -> None:
+    """Upgrade authz schema."""
+    # Postgres: 'add_column' does not emit 'CREATE TYPE' the way
+    # 'create_table' does
+    if op.get_context().dialect.name == "postgresql":
+        op.execute("CREATE TYPE permission AS ENUM ('READ', 'WRITE', 'ADMIN')")
+    op.add_column(
+        "room_acl_entries",
+        sa.Column(
+            "permission",
+            sa.Enum("READ", "WRITE", "ADMIN", name="permission"),
+            server_default="READ",
+            nullable=False,
+        ),
+    )
+
+
+def downgrade_authz() -> None:
+    """Downgrade authz schema."""
+    op.drop_column("room_acl_entries", "permission")
+    if op.get_context().dialect.name == "postgresql":
+        op.execute("DROP TYPE permission")

{soliplex-0.85.4 → soliplex-0.86}/src/soliplex/authn.py

@@ -1,8 +1,11 @@
 """Soliplex authentication support"""
 
+import os
+import time
 import typing
 
 import fastapi
+import itsdangerous
 import jwt
 import starlette.config
 from authlib.integrations import starlette_client
@@ -26,6 +29,18 @@ _oauth = None
 JWT_VALIDATION_NO_TOKEN = "JWT validation failed (no token)"
 JWT_VALIDATION_INVALID_TOKEN = "JWT validation failed (invalid token)"
 
+INSECURE_COOKIES_ENV_VAR = "_SOLIPLEX_INSECURE_SESSION_COOKIE"
+
+AUTHN_COOKIE_NAME = "soliplex_authn"
+AUTHN_COOKIE_SALT = "soliplex.authn.cookie"
+AUTHN_COOKIE_SECRET_NAME = "SESSION_MIDDLEWARE_TOKEN"
+AUTHN_COOKIE_ALWAYS_CLAIMS = ("sub",)
+# Browsers reject cookies whose name+value exceeds 4096 bytes (RFC 6265bis;
+# enforced by Chrome and Firefox, and no more generous in Safari in
+# practice).  'soliplex_authn' consumes 14 of them, leaving the round 4000
+# as the budget for the serialized value alone.
+AUTHN_COOKIE_MAX_SIZE = 4000
+
 
 def _get_authsystem_config(
     *,
@@ -153,3 +168,111 @@ def validate_access_token(
             return None, f"{loggers.AUTHN_JWT_BIND_CLAIM}:{claim}"
 
     return payload, None
+
+
+def secure_cookies() -> bool:
+    """Should Soliplex's cookies carry the 'Secure' attribute?
+
+    'True' unless the '_SOLIPLEX_INSECURE_SESSION_COOKIE' environment
+    variable is 'Y'.
+    """
+    return os.environ.get(INSECURE_COOKIES_ENV_VAR) != "Y"
+
+
+def _authn_cookie_serializer(
+    the_installation: installation.Installation,
+) -> itsdangerous.URLSafeSerializer:
+    secret_key = the_installation.get_secret(AUTHN_COOKIE_SECRET_NAME)
+    return itsdangerous.URLSafeSerializer(secret_key, salt=AUTHN_COOKIE_SALT)
+
+
+def set_authn_cookie(
+    response: fastapi.Response,
+    *,
+    the_installation: installation.Installation,
+    auth_system: config_authsystem.OIDCAuthSystemConfig,
+    claims: UserClaims,
+    logger: loggers.LogWrapper,
+) -> bool:
+    """Set the signed authn cookie on 'response'
+
+    The cookie holds the claims named in 'AUTHN_COOKIE_ALWAYS_CLAIMS' and
+    in 'auth_system.cookie_claims' (those present in 'claims'), and
+    expires at 'claims["exp"]'.  Returns True when the cookie was set.
+
+    A value larger than 'AUTHN_COOKIE_MAX_SIZE' is logged as an error,
+    and the cookie is cleared from the response rather than set:  the
+    browser ignores an oversized 'Set-Cookie' entirely (see
+    'AUTHN_COOKIE_MAX_SIZE'), so merely not setting it would leave
+    whatever 'soliplex_authn' cookie the browser already holds --
+    possibly left by a different visitor's sign-in -- authorizing the
+    wrong person until it expires.
+    """
+    names = (*AUTHN_COOKIE_ALWAYS_CLAIMS, *auth_system.cookie_claims)
+    selected = {name: claims[name] for name in names if name in claims}
+    envelope = (auth_system.id, claims["exp"], selected)
+    value = _authn_cookie_serializer(the_installation).dumps(envelope)
+
+    cookie_set = len(value) <= AUTHN_COOKIE_MAX_SIZE
+
+    if cookie_set:
+        response.set_cookie(
+            AUTHN_COOKIE_NAME,
+            value,
+            max_age=max(int(claims["exp"] - time.time()), 0),
+            path="/",
+            secure=secure_cookies(),
+            httponly=True,
+            samesite="lax",
+        )
+    else:
+        logger.error(loggers.AUTHN_COOKIE_TOO_LARGE, size=len(value))
+        clear_authn_cookie(response)
+
+    return cookie_set
+
+
+def clear_authn_cookie(response: fastapi.Response):
+    """Remove the authn cookie via 'response'"""
+    response.delete_cookie(
+        AUTHN_COOKIE_NAME,
+        path="/",
+        secure=secure_cookies(),
+        httponly=True,
+        samesite="lax",
+    )
+
+
+def load_authn_cookie(
+    the_installation: installation.Installation,
+    value: str,
+) -> tuple[UserClaims | None, None | str]:
+    """Return '(claims, None)' from authn cookie's 'value' if valid.
+
+    Return '(None, reason)' if not:
+    - the signature does not verify;
+    - 'value' is not a well formed '(authsystem_id, exp, claims)' envelope;
+    - the unpacked 'exp' has expired;
+    - the unpacked 'authsystem_id' matches no configured auth system.
+    """
+    try:
+        envelope = _authn_cookie_serializer(the_installation).loads(value)
+    except itsdangerous.BadSignature:
+        return None, loggers.AUTHN_COOKIE_BAD_SIGNATURE
+
+    try:
+        authsystem_id, exp, claims = envelope
+    except ValueError:
+        return None, loggers.AUTHN_COOKIE_BAD_ENVELOPE
+
+    if exp <= time.time():
+        return None, loggers.AUTHN_COOKIE_EXPIRED
+
+    authsystem_map = {
+        auth_system.id
+        for auth_system in the_installation.oidc_auth_system_configs
+    }
+    if authsystem_id not in authsystem_map:
+        return None, loggers.AUTHN_COOKIE_UNKNOWN_IDP
+
+    return claims, None