soliplex 0.70.2__tar.gz → 0.72__tar.gz

{soliplex-0.70.2/src/soliplex.egg-info → soliplex-0.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soliplex
-Version: 0.70.2
+Version: 0.72
 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
@@ -19,7 +19,7 @@ Requires-Dist: fastapi
 Requires-Dist: fastmcp<3.4,>=3.3.0
 Requires-Dist: fakeredis!=2.35.0
 Requires-Dist: greenlet
-Requires-Dist: haiku.rag-slim<0.64,>=0.63.1
+Requires-Dist: haiku.rag-slim<0.66,>=0.65
 Requires-Dist: haiku-skills<0.19,>=0.18.0
 Requires-Dist: idna>=3.15
 Requires-Dist: itsdangerous

{soliplex-0.70.2 → soliplex-0.72}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "soliplex"
-version = "0.70.2"
+version = "0.72"
 description = "An AI-powered Retrieval-Augmented Generation (RAG) system with a modern web interface."
 authors = [{ name = "Enfold", email = "info@enfoldsystems.net" }]
 readme = "README.md"
@@ -25,7 +25,7 @@ dependencies = [
     "fastmcp >= 3.3.0, < 3.4",
     "fakeredis != 2.35.0",  # brownbag
     "greenlet",
-    "haiku.rag-slim >= 0.63.1, < 0.64",
+    "haiku.rag-slim >= 0.65, < 0.66",
     "haiku-skills >= 0.18.0, < 0.19",
     "idna >= 3.15",
     "itsdangerous",
@@ -92,9 +92,6 @@ markers = [
 [tool.coverage.run]
 omit = [
     "src/soliplex/cli/__init__.py",
-    "src/soliplex/cli/serve.py",
-
-    "src/soliplex/examples.py",
     "src/soliplex/tui.py",
 ]
 

{soliplex-0.70.2 → soliplex-0.72}/src/soliplex/agents.py

@@ -11,7 +11,7 @@ from pydantic_ai import agent as ai_agent
 from pydantic_ai import tools as ai_tools
 from pydantic_ai import toolsets as ai_toolsets
 
-from soliplex import agui as agui_package
+from soliplex import agui
 from soliplex import mcp_client
 from soliplex import models
 from soliplex.config import agents as config_agents
@@ -41,8 +41,8 @@ class AgentDependencies:
     """
 
     the_installation: typing.Any  # installation.Installation
-    the_threads: agui_package.ThreadStorage = None
-    state: agui_package.AGUI_State = dataclasses.field(default_factory=dict)
+    the_threads: agui.ThreadStorage = None
+    state: agui.AGUI_State = dataclasses.field(default_factory=dict)
     room_id: str | None = None
     thread_id: str | None = None
     run_id: str | None = None
@@ -150,3 +150,12 @@ def get_agent_from_configs(
             mcp_client_toolset_configs=mcp_client_toolset_configs,
             skill_toolset_config=skill_toolset_config,
         )
+
+
+def find_skill_toolset(
+    agent: pydantic_ai.Agent,
+) -> hs_agent.SkillToolset | None:
+    for toolset in getattr(agent, "toolsets", ()):
+        if isinstance(toolset, hs_agent.SkillToolset):
+            return toolset
+    return None

{soliplex-0.70.2 → soliplex-0.72}/src/soliplex/agui/__init__.py

@@ -587,7 +587,11 @@ async def get_the_threads(request: fastapi.Request) -> ThreadStorage:
 
     engine = request.state.threads_engine
     async with sqla_asyncio.AsyncSession(bind=engine) as session:
-        yield persistence.ThreadStorage(session)
+        # One transaction per request: the storage methods no longer
+        # commit, so the request owns the unit of work -- committed on a
+        # clean response, rolled back if the handler raises.
+        async with session.begin():
+            yield persistence.ThreadStorage(session)
 
 
 depend_the_threads = fastapi.Depends(get_the_threads)

{soliplex-0.70.2 → soliplex-0.72}/src/soliplex/agui/parser.py

@@ -10,7 +10,7 @@ from collections import abc
 import jsonpatch
 from ag_ui import core as agui_core
 
-from soliplex import agui as agui_package
+from soliplex import agui
 
 AGUI_EventIterator = abc.AsyncIterator[agui_core.Event]
 AGUI_EventDictIterator = abc.AsyncIterator[agui_core.Event]
@@ -230,12 +230,12 @@ DEFAULT_STRIPPED_MESSAGE_TYPES: StrippedMessageTypes = None
 @dataclasses.dataclass
 class EventStreamParser:
     run_agent_input: dataclasses.InitVar[agui_core.RunAgentInput] = None
-    run: dataclasses.InitVar[agui_package.Run] = None
+    run: dataclasses.InitVar[agui.Run] = None
 
     _ = dataclasses.KW_ONLY
 
     _run_input: agui_core.RunAgentInput = None
-    _the_run: agui_package.Run = None
+    _the_run: agui.Run = None
 
     run_status: RunStatus = RunStatus.INITIALIZED
     active_steps: set[str] = dataclasses.field(default_factory=set)
@@ -282,7 +282,7 @@ class EventStreamParser:
         self.messages_by_id = {msg.id: msg for msg in value.messages}
 
     @property
-    def the_run(self) -> agui_package.Run:
+    def the_run(self) -> agui.Run:
         return self._the_run
 
     def _assert_running(self, event):

{soliplex-0.70.2 → soliplex-0.72}/src/soliplex/agui/persistence.py

@@ -1,14 +1,20 @@
 from __future__ import annotations
 
+import collections.abc
 import contextlib
 import datetime
 import typing
 
+import logfire
 from ag_ui import core as agui_core
+from haiku.skills import agent as hs_agent
+from sqlalchemy import exc as sqla_exc
 from sqlalchemy import sql as sqla_sql
 from sqlalchemy.ext import asyncio as sqla_asyncio
 
-from soliplex import agui as agui_package
+from soliplex import agui
+from soliplex import loggers
+from soliplex import rag_audit
 from soliplex.agui import persistence as agui_persistence
 from soliplex.agui import schema as agui_schema
 from soliplex.agui import util as agui_util
@@ -16,7 +22,7 @@ from soliplex.agui import util as agui_util
 # Temporary backward-compatibility:  to be removed in 'v0.45'
 from soliplex.agui.schema import *  # noqa F403
 
-FeedbackReviewStatus = agui_package.FeedbackReviewStatus
+FeedbackReviewStatus = agui.FeedbackReviewStatus
 
 
 class NoFeedbackFound(ValueError):
@@ -48,15 +54,19 @@ _LAST_ACTIVITY = sqla_sql.func.max(
 )
 
 
-class ThreadStorage(agui_package.ThreadStorage):
+class ThreadStorage(agui.ThreadStorage):
     def __init__(self, session: sqla_asyncio.AsyncSession):
         self._session = session
 
     @property
     @contextlib.asynccontextmanager
     async def session(self):
-        async with self._session.begin():
-            yield self._session
+        # Yield the caller-owned session as-is: the session owner (a
+        # FastAPI dependency, CLI context manager, or streaming helper)
+        # owns the transaction boundary and commits the unit of work
+        # exactly once. Methods here never open their own transaction or
+        # commit, so callers -- and tests -- need no interleaved commits.
+        yield self._session
 
     async def _find_user_thread(
         self,
@@ -74,12 +84,12 @@ class ThreadStorage(agui_package.ThreadStorage):
         thread = (await session.scalars(query)).first()
 
         if thread is None:
-            raise agui_package.UnknownThread(user_name, thread_id)
+            raise agui.UnknownThread(user_name, thread_id)
 
         t_room_id = await thread.awaitable_attrs.room_id
 
         if t_room_id != room_id:
-            raise agui_package.ThreadRoomMismatch(room_id, t_room_id)
+            raise agui.ThreadRoomMismatch(room_id, t_room_id)
 
         return thread
 
@@ -91,7 +101,7 @@ class ThreadStorage(agui_package.ThreadStorage):
         thread_id: str,
         run_id: str,
         session,
-        exc_type=agui_package.UnknownRun,
+        exc_type=agui.UnknownRun,
     ):
         thread = await self._find_user_thread(
             user_name=user_name,
@@ -294,7 +304,7 @@ class ThreadStorage(agui_package.ThreadStorage):
                     thread_id=thread_id,
                     run_id=parent_run_id,
                     session=session,
-                    exc_type=agui_package.MissingParentRun,
+                    exc_type=agui.MissingParentRun,
                 )
             else:
                 parent = None
@@ -362,7 +372,7 @@ class ThreadStorage(agui_package.ThreadStorage):
             already = await run.awaitable_attrs.run_agent_input
 
             if already is not None:
-                raise agui_package.RunAlreadyStarted(
+                raise agui.RunAlreadyStarted(
                     user_name,
                     thread_id,
                     run_id,
@@ -420,8 +430,6 @@ class ThreadStorage(agui_package.ThreadStorage):
         event: agui_core.Event,
     ) -> None:
         """Save a single event for a run (incremental persistence)"""
-        await self._session.commit()
-
         async with self.session as session:
             run = await self._find_thread_run(
                 user_name=user_name,
@@ -448,8 +456,6 @@ class ThreadStorage(agui_package.ThreadStorage):
         run_id: str,
     ) -> None:
         """Mark a run as finished"""
-        await self._session.commit()
-
         async with self.session as session:
             run = await self._find_thread_run(
                 user_name=user_name,
@@ -475,8 +481,6 @@ class ThreadStorage(agui_package.ThreadStorage):
 
         Each element is a (event_index, event) tuple.
         """
-        await self._session.commit()
-
         async with self.session as session:
             run = await self._find_thread_run(
                 user_name=user_name,
@@ -504,8 +508,6 @@ class ThreadStorage(agui_package.ThreadStorage):
         run_id: str,
     ) -> bool:
         """Return True if the run has a 'finished' timestamp"""
-        await self._session.commit()
-
         async with self.session as session:
             run = await self._find_thread_run(
                 user_name=user_name,
@@ -524,11 +526,9 @@ class ThreadStorage(agui_package.ThreadStorage):
         room_id: str,
         thread_id: str,
         run_id: str,
-        events: agui_package.AGUI_Events,
-    ) -> agui_package.AGUI_Events:
+        events: agui.AGUI_Events,
+    ) -> agui.AGUI_Events:
         """Save the events for a gven run"""
-        await self._session.commit()
-
         async with self.session as session:
             run = await self._find_thread_run(
                 user_name=user_name,
@@ -560,8 +560,6 @@ class ThreadStorage(agui_package.ThreadStorage):
         tool_calls: int,
     ):
         """Save the run usage statistics"""
-        await self._session.commit()
-
         async with self.session as session:
             run = await self._find_thread_run(
                 user_name=user_name,
@@ -591,8 +589,6 @@ class ThreadStorage(agui_package.ThreadStorage):
         reason: str,
     ):
         """Save the run feedback"""
-        await self._session.commit()
-
         async with self.session as session:
             run = await self._find_thread_run(
                 user_name=user_name,
@@ -624,10 +620,8 @@ class ThreadStorage(agui_package.ThreadStorage):
         room_id: str,
         thread_id: str,
         run_id: str,
-    ) -> agui_package.RunFeedbackType | None:
+    ) -> agui.RunFeedbackType | None:
         """Get the run feedback"""
-        await self._session.commit()
-
         async with self.session as session:
             run = await self._find_thread_run(
                 user_name=user_name,
@@ -658,8 +652,6 @@ class ThreadStorage(agui_package.ThreadStorage):
         if limit is None and since is None:
             limit = 20
 
-        await self._session.commit()
-
         async with self.session as session:
             query = (
                 sqla_sql.Select(
@@ -869,3 +861,148 @@ class ThreadStorage(agui_package.ThreadStorage):
             )
 
             return history_entry
+
+
+# --------------------------------------------------------------------------
+# Engine-owning run-persistence helpers
+#
+# Each builds its own short-lived session (the one bound to a request's
+# lifetime may already be closed, e.g. after an early connection reset) and
+# owns its commit: 'ThreadStorage' methods no longer commit on their own.
+# Committing per event is what lets a reconnecting client's poll observe
+# events incrementally.
+# --------------------------------------------------------------------------
+
+
+async def capture_usage_after_stream(
+    result,
+    *,
+    sqla_engine,
+    user_name: str,
+    room_id: str,
+    thread_id: str,
+    run_id: str,
+):
+    """Save the run usage to the database."""
+    usage = getattr(result, "usage", None)
+
+    if usage is not None:
+        async with sqla_asyncio.AsyncSession(bind=sqla_engine) as session:
+            the_threads = ThreadStorage(session)
+
+            async with session.begin():
+                await the_threads.save_run_usage(
+                    user_name=user_name,
+                    room_id=room_id,
+                    thread_id=thread_id,
+                    run_id=run_id,
+                    input_tokens=usage.input_tokens,
+                    output_tokens=usage.output_tokens,
+                    requests=usage.requests,
+                    tool_calls=usage.tool_calls,
+                )
+
+
+async def save_single_event(
+    sqla_engine,
+    user_name: str,
+    room_id: str,
+    thread_id: str,
+    run_id: str,
+    event,
+):
+    """Save a single run event to the database (incremental persistence)."""
+    async with sqla_asyncio.AsyncSession(bind=sqla_engine) as session:
+        the_threads = ThreadStorage(session)
+
+        async with session.begin():
+            await the_threads.save_single_event(
+                user_name=user_name,
+                room_id=room_id,
+                thread_id=thread_id,
+                run_id=run_id,
+                event=event,
+            )
+
+
+async def finish_run(
+    sqla_engine,
+    user_name: str,
+    room_id: str,
+    thread_id: str,
+    run_id: str,
+):
+    """Mark a run as finished in the database."""
+    async with sqla_asyncio.AsyncSession(bind=sqla_engine) as session:
+        the_threads = ThreadStorage(session)
+
+        async with session.begin():
+            await the_threads.finish_run(
+                user_name=user_name,
+                room_id=room_id,
+                thread_id=thread_id,
+                run_id=run_id,
+            )
+
+
+async def drive_agui_turn(
+    *,
+    adapter,
+    skill_toolset: hs_agent.SkillToolset | None,
+    engine,
+    user_name: str,
+    room_id: str,
+    thread_id: str,
+    run_id: str,
+    claims: dict | None = None,
+    rag_db_paths: dict[str, str] | None = None,
+    run_stream_kwargs: dict | None = None,
+) -> collections.abc.AsyncIterator:
+    """Drive one room-agent turn as an AG-UI event stream.
+
+    An async generator: for each event it records any RAG access (skill
+    retrievals surface as AG-UI activity events) and persists the event
+    (via :func:`save_single_event`), then yields it. Callers own
+    presentation (an SSE queue, or collecting the assistant text) and any
+    post-run work such as :func:`finish_run`, usage capture, or title
+    generation.
+
+    ``run_stream_kwargs`` is forwarded verbatim to
+    ``haiku.skills.agent.run_agui_stream`` (``deps``, ``conversation_id``,
+    ``on_complete``).
+    """
+    auditor = rag_audit.RagAccessAuditor(
+        loggers.RAGAccessAuditLog(
+            claims=claims or {},
+            room_id=room_id,
+            thread_id=thread_id,
+            run_id=run_id,
+        ),
+        (rag_db_paths or {}).get,
+    )
+
+    async with hs_agent.run_agui_stream(
+        adapter,
+        toolset=skill_toolset,
+        **(run_stream_kwargs or {}),
+    ) as event_stream:
+        compacted = agui.compact_event_stream(event_stream)
+        async for event in compacted:
+            auditor.handle(event)
+
+            try:
+                await save_single_event(
+                    engine,
+                    user_name=user_name,
+                    room_id=room_id,
+                    thread_id=thread_id,
+                    run_id=run_id,
+                    event=event,
+                )
+            except sqla_exc.SQLAlchemyError as sa_exc:
+                logfire.error(
+                    "Error saving event: {error_message}",
+                    error_message=str(sa_exc),
+                )
+
+            yield event

{soliplex-0.70.2 → soliplex-0.72}/src/soliplex/agui/schema.py

@@ -12,7 +12,7 @@ from sqlalchemy import schema as sqla_schema
 from sqlalchemy.ext import asyncio as sqla_asyncio
 from sqlalchemy.sql import sqltypes as sqla_sqltypes
 
-from soliplex import agui as agui_package
+from soliplex import agui
 from soliplex import util
 from soliplex.agui import util as agui_util
 from soliplex.config import installation as config_installation
@@ -42,7 +42,7 @@ JSON_Mapped_From = dict[str, typing.Any]
 
 metadata = sqla_schema.MetaData(naming_convention=NAMING_CONVENTION)
 
-FeedbackReviewStatus = agui_package.FeedbackReviewStatus
+FeedbackReviewStatus = agui.FeedbackReviewStatus
 
 
 class Base(AsyncAttrs, DeclarativeBase):
@@ -447,8 +447,8 @@ class RunUsage(Base):
     requests: Mapped[int] = mapped_column()
     tool_calls: Mapped[int] = mapped_column()
 
-    def as_tuple(self) -> agui_package.RunUsageStats:
-        return agui_package.RunUsageStats(
+    def as_tuple(self) -> agui.RunUsageStats:
+        return agui.RunUsageStats(
             self.input_tokens,
             self.output_tokens,
             self.requests,