soliplex 0.81__tar.gz → 0.82__tar.gz

{soliplex-0.81/src/soliplex.egg-info → soliplex-0.82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soliplex
-Version: 0.81
+Version: 0.82
 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

{soliplex-0.81 → soliplex-0.82}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "soliplex"
-version = "0.81"
+version = "0.82"
 description = "An AI-powered Retrieval-Augmented Generation (RAG) system with a modern web interface."
 authors = [{ name = "Enfold", email = "info@enfoldsystems.net" }]
 readme = "README.md"
@@ -50,13 +50,13 @@ dependencies = [
 ]
 
 [project.scripts]
-soliplex-cli = "soliplex.cli.main:the_cli"
+soliplex-cli = "soliplex.cli.main:main"
 soliplex-tui = "soliplex.tui.cli:the_cli"
 soliplex-tui-serve = "soliplex.tui.serve:the_cli"
 
 [dependency-groups]
 dev = [
-    "anyio >= 4.12.1, < 4.13",
+    "anyio >= 4.14.2, < 4.15",
     "coverage >= 7.13.5, < 7.14",
     "pytest >= 9.0.2, < 9.1",
     "pytest-cov >= 7.0.0, < 7.1",
@@ -102,7 +102,15 @@ markers = [
 omit = [
     "scripts/lint_textio.py",   # runs its own '--self-test' during lint
     "scripts/lint_interpolation.py",  # ditto
+    "scripts/lint_alembic_chain.py",  # ditto
+    # Run-once deployment repair (issue #1367), applied by hand against a
+    # live database and verified there; like a migration script, it is not
+    # exercised by the unit suite.
+    "scripts/bootstrap_alembic_version.py",
     "src/soliplex/tui/*",       # the TUI is deliberately untested
+    # Generated revision scripts. The package's '__init__.py' and
+    # 'env.py' are hand-written, and are held to the 100% bar.
+    "src/soliplex/alembic_migrations/versions/*",
 ]
 
 [tool.coverage.report]
@@ -141,6 +149,7 @@ ignore = [
 
 [tool.ruff.lint.isort]
 force-single-line = true
+known-third-party = ["alembic"]
 
 [tool.ruff.lint.flake8-pytest-style]
 parametrize-names-type = "csv"
@@ -171,7 +180,7 @@ rolling_prefix = "docs"
 
 
 [tool.alembic]
-
+script_location = "%(here)s/src/soliplex/alembic_migrations"
 
 # template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
 # Uncomment the line below if you want the files to be prepended with date and time

{soliplex-0.81 → soliplex-0.82}/src/soliplex/agui/__init__.py

@@ -104,10 +104,11 @@ RunUsageStats = collections.namedtuple(
         "tool_calls",
         "final_input_tokens",
         "resolved_model_name",
+        "final_output_tokens",
     ],
     # Rows written before these columns existed deserialize with them
-    # unset, so both stay optional at the tuple boundary too.
-    defaults=(None, None),
+    # unset, so they stay optional at the tuple boundary too.
+    defaults=(None, None, None),
 )
 
 
@@ -142,6 +143,21 @@ class RunUsage(abc.ABC):
     tokenizer from it in preference to the configured string.
     """
 
+    final_output_tokens: int | None
+    """Output tokens of the run's *last* model request.
+
+    That response is the reply the thread now ends with, and it is part of
+    the next request's input. 'final_input_tokens' alone therefore reads
+    one reply short of what the window holds; the sum of the two is the
+    thread's occupancy. None when the run produced no model response.
+
+    The provider's own count, as reported: on a reasoning model it includes
+    the reasoning, which providers generally do not carry into the next
+    request, so the sum reads high there by the last reply's reasoning --
+    never low -- until the next run measures. Ollama itemises no reasoning
+    count, so nothing more exact is available for it.
+    """
+
     @abc.abstractmethod
     def as_tuple(self) -> RunUsageStats:
         """Return values as a tuple."""

{soliplex-0.81 → soliplex-0.82}/src/soliplex/agui/persistence.py

@@ -554,6 +554,7 @@ class ThreadStorage(agui.ThreadStorage):
         tool_calls: int,
         final_input_tokens: int | None = None,
         resolved_model_name: str | None = None,
+        final_output_tokens: int | None = None,
     ):
         """Save the run usage statistics"""
         async with self.session as session:
@@ -573,6 +574,7 @@ class ThreadStorage(agui.ThreadStorage):
                     tool_calls=tool_calls,
                     final_input_tokens=final_input_tokens,
                     resolved_model_name=resolved_model_name,
+                    final_output_tokens=final_output_tokens,
                 )
             )
 
@@ -893,20 +895,22 @@ class ThreadStorage(agui.ThreadStorage):
 
 
 def _final_request_usage(result):
-    """Usage and model name of the run's last model response.
+    """Input and output tokens, and model name, of the run's last response.
 
     'RunUsage.input_tokens' accumulates across every request a run makes, so
     it answers "what did this run cost", not "how full was the window". The
-    last response's own 'RequestUsage' answers the second question, and its
+    last response's own 'RequestUsage' answers the second question: its
+    input is what the window held when the request went out, and its output
+    is the reply that joins that input in the *next* request. The response's
     'model_name' is what the provider actually served -- a better tokenizer
     key than the configured name, which may be an alias.
 
-    Returns '(None, None)' for a run that never reached the model.
+    Returns '(None, None, None)' for a run that never reached the model.
     """
     all_messages = getattr(result, "all_messages", None)
 
     if all_messages is None:  # pragma: NO COVER - defensive
-        return None, None
+        return None, None, None
 
     for message in reversed(all_messages()):
         message_usage = getattr(message, "usage", None)
@@ -916,10 +920,11 @@ def _final_request_usage(result):
 
         return (
             getattr(message_usage, "input_tokens", None),
+            getattr(message_usage, "output_tokens", None),
             getattr(message, "model_name", None),
         )
 
-    return None, None
+    return None, None, None
 
 
 async def capture_usage_after_stream(
@@ -935,7 +940,9 @@ async def capture_usage_after_stream(
     usage = getattr(result, "usage", None)
 
     if usage is not None:
-        final_input_tokens, resolved_model_name = _final_request_usage(result)
+        final_input_tokens, final_output_tokens, resolved_model_name = (
+            _final_request_usage(result)
+        )
         async with sqla_asyncio.AsyncSession(bind=sqla_engine) as session:
             the_threads = ThreadStorage(session)
 
@@ -951,6 +958,7 @@ async def capture_usage_after_stream(
                     tool_calls=usage.tool_calls,
                     final_input_tokens=final_input_tokens,
                     resolved_model_name=resolved_model_name,
+                    final_output_tokens=final_output_tokens,
                 )
 
 

{soliplex-0.81 → soliplex-0.82}/src/soliplex/agui/schema.py

@@ -429,6 +429,7 @@ class RunUsage(Base):
     'tool_calls', int, required
     'final_input_tokens', int, optional
     'resolved_model_name', str, optional
+    'final_output_tokens', int, optional
     """
 
     __tablename__ = "run_usage"
@@ -453,6 +454,7 @@ class RunUsage(Base):
     # the model has no final request to measure.
     final_input_tokens: Mapped[int | None] = mapped_column(default=None)
     resolved_model_name: Mapped[str | None] = mapped_column(default=None)
+    final_output_tokens: Mapped[int | None] = mapped_column(default=None)
 
     def as_tuple(self) -> agui.RunUsageStats:
         return agui.RunUsageStats(
@@ -462,6 +464,7 @@ class RunUsage(Base):
             self.tool_calls,
             self.final_input_tokens,
             self.resolved_model_name,
+            self.final_output_tokens,
         )
 
 
@@ -532,7 +535,6 @@ class RunFeedbackReviewEntry(Base):
 
 def get_engine(
     engine_url=config_installation.SYNC_MEMORY_ENGINE_URL,
-    init_schema=False,
     **engine_kwargs,
 ) -> sqlalchemy.Engine:
     engine = sqlalchemy.create_engine(
@@ -557,21 +559,15 @@ def get_engine(
         cursor_fk.execute("PRAGMA foreign_keys=ON")
         cursor_fk.close()
 
-    if init_schema:
-        with engine.connect() as connection:
-            Base.metadata.create_all(connection)
-
     return engine
 
 
 def get_session(
     engine_url=config_installation.SYNC_MEMORY_ENGINE_URL,
-    init_schema=False,
     **engine_kwargs,
 ) -> sqla_orm.Session:
     engine = get_engine(
         engine_url=engine_url,
-        init_schema=init_schema,
         **engine_kwargs,
     )
     return sqla_orm.Session(bind=engine)
@@ -579,7 +575,6 @@ def get_session(
 
 async def get_async_engine(
     engine_url=config_installation.ASYNC_MEMORY_ENGINE_URL,
-    init_schema=False,
     **engine_kwargs,
 ) -> sqla_asyncio.AsyncEngine:
     engine = sqla_asyncio.create_async_engine(
@@ -588,21 +583,15 @@ async def get_async_engine(
         **engine_kwargs,
     )
 
-    if init_schema:
-        async with engine.begin() as connection:
-            await connection.run_sync(Base.metadata.create_all)
-
     return engine
 
 
 async def get_async_session(
     engine_url=config_installation.ASYNC_MEMORY_ENGINE_URL,
-    init_schema=False,
     **engine_kwargs,
 ):
     engine = await get_async_engine(
         engine_url=engine_url,
-        init_schema=init_schema,
         **engine_kwargs,
     )
     return sqla_asyncio.AsyncSession(bind=engine)