soliplex 0.76__tar.gz → 0.76.1__tar.gz

{soliplex-0.76/src/soliplex.egg-info → soliplex-0.76.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soliplex
-Version: 0.76
+Version: 0.76.1
 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.76 → soliplex-0.76.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "soliplex"
-version = "0.76"
+version = "0.76.1"
 description = "An AI-powered Retrieval-Augmented Generation (RAG) system with a modern web interface."
 authors = [{ name = "Enfold", email = "info@enfoldsystems.net" }]
 readme = "README.md"

{soliplex-0.76 → soliplex-0.76.1}/src/soliplex/agents.py

@@ -5,13 +5,12 @@ import typing
 
 import pydantic_ai
 from haiku.rag.capabilities import analysis as hr_caps_analysis
-from haiku.rag.capabilities import compaction as hr_caps_compaction
-from haiku.rag.capabilities import policy as hr_caps_policy
 from haiku.rag.capabilities import rag as hr_caps_rag
 from pydantic_ai import agent as ai_agent
 from pydantic_ai import capabilities as ai_capabilities
 from pydantic_ai import tools as ai_tools
 from pydantic_ai import toolsets as ai_toolsets
+from sqlalchemy.ext import asyncio as sqla_asyncio
 
 from soliplex import agui
 from soliplex import mcp_client
@@ -27,13 +26,6 @@ HR_VisionCapabilities = (
     hr_caps_rag.RAGCapability | hr_caps_analysis.AnalysisCapability
 )
 
-# Capabilities which can always be eagerly loaded
-HookOnlyCapabilities = (
-    hr_caps_compaction.EvidenceCompactionCapability
-    | hr_caps_policy.CitationPolicyCapability
-    | cap_rag_audit.RAGAccessAuditCapability
-)
-
 
 class CapabilityConfig(typing.Protocol):
     """Room-specific native capabilities and their audit targets."""
@@ -54,7 +46,7 @@ class AgentDependencies:
     """
 
     the_installation: typing.Any  # installation.Installation
-    the_threads: agui.ThreadStorage = None
+    thread_persistence_engine: sqla_asyncio.AsyncEngine = None
     state: agui.AGUI_State = dataclasses.field(default_factory=dict)
     room_id: str | None = None
     thread_id: str | None = None
@@ -94,6 +86,27 @@ def make_mcp_client_toolset(
     return factory(**toolset_config.tool_kwargs)
 
 
+def _is_routing_capability(
+    capability: ai_capabilities.AbstractCapability,
+) -> bool:
+    """Whether the model has anything to load from this capability.
+
+    Tools or instructions are what there is to route between; a hook-only
+    capability offers neither.
+    """
+    if capability.get_instructions() or capability.get_native_tools():
+        return True
+
+    toolset = capability.get_toolset()
+
+    if toolset is None:
+        return False
+
+    # A capability registering no tools of its own still gets an empty
+    # 'FunctionToolset', so ask whether it is empty, not whether it exists.
+    return bool(getattr(toolset, "tools", True))
+
+
 def get_default_agent_from_configs(
     *,
     agent_config: config_agents.AgentConfig,
@@ -135,13 +148,10 @@ def get_default_agent_from_configs(
     #
     # Multiple stay deferred so the model routes between them via
     # 'load_capability'.
-    #
-    # Hook-only capabilities expose no tools to route
-    # between, so they neither defer nor count.
     routing_capabilities = [
         capability
         for capability in capabilities
-        if not isinstance(capability, HookOnlyCapabilities)
+        if _is_routing_capability(capability)
     ]
     defer_loading = len(routing_capabilities) > 1
     for capability in routing_capabilities:

{soliplex-0.76 → soliplex-0.76.1}/src/soliplex/config/authsystem.py

@@ -9,7 +9,6 @@ from . import _utils
 from . import exceptions as config_exc
 
 _no_repr_no_compare_none = _utils._no_repr_no_compare_none
-_default_list_field = _utils._default_list_field
 
 
 # ============================================================================
@@ -62,6 +61,29 @@ class OIDCAuthSystemConfig:
                 config_dict,
             ) from exc
 
+    @property
+    def as_yaml(self) -> dict:
+        result = {
+            "id": self.id,
+            "title": self.title,
+            "server_url": self.server_url,
+            "token_validation_pem": self.token_validation_pem,
+            "client_id": self.client_id,
+        }
+
+        if self.scope is not None:
+            result["scope"] = self.scope
+
+        if self.client_secret:
+            # Dumped raw: 'env:'/'secret:' interpolations are not resolved.
+            result["client_secret"] = self.client_secret
+
+        if self.oidc_client_pem_path is not None:
+            # Absolutized against the config dir on load.  See #1228.
+            result["oidc_client_pem_path"] = str(self.oidc_client_pem_path)
+
+        return result
+
     @property
     def server_metadata_url(self):
         return f"{self.server_url}/{WELL_KNOWN_OPENID_CONFIGURATION}"
@@ -94,8 +116,3 @@ class OIDCAuthSystemConfig:
             # added by the auth setup
             # "authorize_state": main.SESSION_SECRET_KEY,
         }
-
-
-@dataclasses.dataclass(kw_only=True)
-class AvailableOIDCAuthSystemConfigs:
-    systems: list[OIDCAuthSystemConfig] = _default_list_field()

{soliplex-0.76 → soliplex-0.76.1}/src/soliplex/config/completions.py

@@ -81,5 +81,26 @@ class CompletionConfig:
 
         return cls(**config_dict)
 
+    @property
+    def as_yaml(self) -> dict:
+        result = {
+            "id": self.id,
+            "agent": self.agent_config.as_yaml,
+        }
+
+        if self.name is not None:
+            result["name"] = self.name
+
+        if self.tool_configs:
+            result["tools"] = [tc.as_yaml for tc in self.tool_configs.values()]
+
+        if self.mcp_client_toolset_configs:
+            result["mcp_client_toolsets"] = {
+                key: mctc.as_yaml
+                for key, mctc in self.mcp_client_toolset_configs.items()
+            }
+
+        return result
+
 
 CompletionConfigMap = dict[str, CompletionConfig]

{soliplex-0.76 → soliplex-0.76.1}/src/soliplex/config/quizzes.py

@@ -145,12 +145,9 @@ class QuizConfig:
             kwargs = {
                 "id": f"quiz-{self.id}-judge",
                 "model_name": "gpt-oss:20b",
+                "_installation_config": self._installation_config,
+                "_config_path": self._config_path,
             }
-            if self._installation_config is not None:
-                i_config = self._installation_config
-                kwargs["provider_base_url"] = i_config.get_environment(
-                    "OLLAMA_BASE_URL",
-                )
             self.judge_agent = agents.AgentConfig(**kwargs)
 
     @property

{soliplex-0.76 → soliplex-0.76.1}/src/soliplex/config/skills.py

@@ -175,22 +175,6 @@ class FilesystemSkillConfig:
     def errors(self) -> list[str]:
         return self._validation_errors
 
-    @property
-    def license(self) -> None:
-        return None
-
-    @property
-    def compatibility(self) -> None:
-        return None
-
-    @property
-    def allowed_tools(self) -> list[str]:
-        return []
-
-    @property
-    def metadata(self) -> dict[str, str]:
-        return {}
-
     @property
     def extra_parameters(self) -> dict[str, pathlib.Path]:
         return {"path": self.path}
@@ -264,22 +248,6 @@ class _HaikuRAGCapabilityConfig(
             )
         return result
 
-    @property
-    def license(self) -> None:
-        return None
-
-    @property
-    def compatibility(self) -> None:
-        return None
-
-    @property
-    def allowed_tools(self) -> list[str]:
-        return []
-
-    @property
-    def metadata(self) -> dict[str, str]:
-        return {}
-
     @property
     def extra_parameters(self) -> dict[str, typing.Any]:
         return self.get_extra_parameters()
@@ -364,22 +332,6 @@ class _HaikuRAGEvidenceSkillConfig:
     def as_yaml(self) -> dict:
         return {"kind": self.kind}
 
-    @property
-    def license(self) -> None:
-        return None
-
-    @property
-    def compatibility(self) -> None:
-        return None
-
-    @property
-    def allowed_tools(self) -> list[str]:
-        return []
-
-    @property
-    def metadata(self) -> dict[str, str]:
-        return {}
-
     @property
     def extra_parameters(self) -> dict[str, typing.Any]:
         return {}
@@ -499,22 +451,6 @@ class BwrapSandboxSkillConfig:
             }
         return result
 
-    @property
-    def license(self) -> None:
-        return None
-
-    @property
-    def compatibility(self) -> None:
-        return None
-
-    @property
-    def allowed_tools(self) -> list[str]:
-        return []
-
-    @property
-    def metadata(self) -> dict[str, str]:
-        return {}
-
     @property
     def extra_parameters(self) -> dict[str, typing.Any]:
         result = {"default_environment": self.default_environment}
@@ -609,22 +545,6 @@ class EntrypointCapabilityConfig:
     def as_yaml(self) -> dict:
         return {"kind": self.kind, "name": self.name, **self.params}
 
-    @property
-    def license(self) -> None:
-        return None
-
-    @property
-    def compatibility(self) -> None:
-        return None
-
-    @property
-    def allowed_tools(self) -> list[str]:
-        return []
-
-    @property
-    def metadata(self) -> dict[str, str]:
-        return {}
-
     @property
     def extra_parameters(self) -> dict[str, typing.Any]:
         return dict(self.params)

{soliplex-0.76 → soliplex-0.76.1}/src/soliplex/installation.py

@@ -16,7 +16,6 @@ from sqlalchemy.ext import asyncio as sqla_asyncio
 from sqlalchemy.pool import NullPool
 
 from soliplex import agents
-from soliplex import agui
 from soliplex import authz
 from soliplex import loggers
 from soliplex import mcp_server
@@ -405,7 +404,7 @@ class Installation:
         *,
         room_id: str,
         user: dict,
-        the_threads: agui.ThreadStorage = None,
+        thread_persistence_engine: sqla_asyncio.AsyncEngine = None,
         the_room_authz: authz.RoomAuthorizationPolicy = None,
         run_agent_input: agui_core.RunAgentInput = None,
         the_logger: loggers.LogWrapper = None,
@@ -424,8 +423,8 @@ class Installation:
             thread_id = run_agent_input.thread_id
             run_id = run_agent_input.run_id
 
-        if the_threads is not None:
-            kwargs["the_threads"] = the_threads
+        if thread_persistence_engine is not None:
+            kwargs["thread_persistence_engine"] = thread_persistence_engine
 
         return agents.AgentDependencies(
             the_installation=self,

{soliplex-0.76 → soliplex-0.76.1}/src/soliplex/models.py

@@ -143,10 +143,6 @@ class Skill(pydantic.BaseModel):
     source: config_skills.SkillKind | None = None
     name: str
     description: str
-    license: str | None
-    compatibility: str | None
-    allowed_tools: SkillAllowedTools = None
-    metadata: SkillMetadata = None
     state_type_schema: dict[str, typing.Any] | None = None
     state_namespace: str | None = None
     extra_parameters: dict[str, typing.Any] = {}
@@ -168,10 +164,6 @@ class Skill(pydantic.BaseModel):
             source=skill_config.source,
             name=skill_config.name,
             description=skill_config.description,
-            license=skill_config.license,
-            compatibility=skill_config.compatibility,
-            allowed_tools=" ".join(skill_config.allowed_tools),
-            metadata=skill_config.metadata,
             state_namespace=skill_config.state_namespace,
             **kwargs,
         )

{soliplex-0.76 → soliplex-0.76.1}/src/soliplex/tools/agui_run_feedback.py

@@ -4,6 +4,7 @@
 - Allow privileged users to mark feedback a as "reviewed", "resolved".
 """
 
+import contextlib
 import datetime
 import enum
 import typing
@@ -12,10 +13,12 @@ import jsonpatch
 import pydantic
 import pydantic_ai
 from ag_ui import core as agui_core
+from sqlalchemy.ext import asyncio as sqla_asyncio
 
 from soliplex import agents
 from soliplex import agui
 from soliplex.agui import parser as agui_parser
+from soliplex.agui import persistence as agui_persistence
 
 FRS = agui.FeedbackReviewStatus
 STATE_NAMESPACE = "soliplex-agui-run-feedback"
@@ -241,11 +244,28 @@ class FeedbackResolution(pydantic.BaseModel):
     note: str | None = None
 
 
-async def _do_query(
+@contextlib.asynccontextmanager
+async def _get_threads_storage(
     ctx: pydantic_ai.RunContext[agents.AgentDependencies],
+):
+    """Context manager for tool-call local thread storage / session
+
+    Cannot be derived from the FastAPI request dependency, because
+    tool calls must run / complete in their own boundaries.
+    """
+    engine = ctx.deps.thread_persistence_engine
+    async with sqla_asyncio.AsyncSession(bind=engine) as session:
+        # One transaction per tool call: the storage methods no longer
+        # commit, so the tool call owns the unit of work -- committed on a
+        # clean response, rolled back if the handler raises.
+        async with session.begin():
+            yield agui_persistence.ThreadStorage(session)
+
+
+async def _do_query(
+    the_threads: agui_persistence.ThreadStorage,
     query: RecentRunFeedbackQuery,
 ) -> RecentRunFeedback:
-    the_threads = ctx.deps.the_threads
     runs_w_recent_fb = await the_threads.list_recent_run_feedback(
         **query.as_kwargs,
     )
@@ -328,7 +348,8 @@ async def query_recent_feedback(
     )
     before_state = {} if raw_state is None else {STATE_NAMESPACE: raw_state}
 
-    entries = await _do_query(ctx, query)
+    async with _get_threads_storage(ctx) as the_threads:
+        entries = await _do_query(the_threads, query)
     our_state.query = query
     our_state.entries = entries
 
@@ -390,29 +411,29 @@ async def get_feedback_run_info(
 
     to_query, _ = _find_feedback_by_run_id(our_state, run_id)
 
-    the_threads = ctx.deps.the_threads
-    run = await the_threads.get_run(
-        user_name=to_query.user_name,
-        room_id=to_query.room_id,
-        thread_id=to_query.thread_id,
-        run_id=to_query.run_id,
-    )
+    async with _get_threads_storage(ctx) as the_threads:
+        run = await the_threads.get_run(
+            user_name=to_query.user_name,
+            room_id=to_query.room_id,
+            thread_id=to_query.thread_id,
+            run_id=to_query.run_id,
+        )
 
-    thread = await run.awaitable_attrs.thread
-    email = await thread.awaitable_attrs.email
-    run_input = await run.awaitable_attrs.run_agent_input
-    parent_run_id = await run.awaitable_attrs.parent_run_id
-    events = await run.awaitable_attrs.events
+        thread = await run.awaitable_attrs.thread
+        email = await thread.awaitable_attrs.email
+        run_input = await run.awaitable_attrs.run_agent_input
+        parent_run_id = await run.awaitable_attrs.parent_run_id
+        events = await run.awaitable_attrs.events
 
-    esp = agui_parser.EventStreamParser(run_input)
+        esp = agui_parser.EventStreamParser(run_input)
 
-    for event in events:
-        try:
-            e_model = event.to_agui_model()
-        # agui_core.events.Event is not all-inclusive :<
-        except pydantic.ValidationError:  # pragma: NO COVER
-            continue
-        esp(e_model)
+        for event in events:
+            try:
+                e_model = event.to_agui_model()
+            # agui_core.events.Event is not all-inclusive :<
+            except pydantic.ValidationError:  # pragma: NO COVER
+                continue
+            esp(e_model)
 
     user_prompts = [
         message.content for message in esp.messages if message.role == "user"
@@ -471,17 +492,17 @@ async def review_recent_feedback(
         our_state, review.run_id, [FromWhichAttrs.OPENED]
     )
 
-    the_threads = ctx.deps.the_threads
     user = ctx.deps.user
-    await the_threads.review_run_feedback(
-        reviewer_user_name=user.preferred_username,
-        reviewer_email=user.email,
-        note=review.note,
-        user_name=to_review.user_name,
-        room_id=to_review.room_id,
-        thread_id=to_review.thread_id,
-        run_id=to_review.run_id,
-    )
+    async with _get_threads_storage(ctx) as the_threads:
+        await the_threads.review_run_feedback(
+            reviewer_user_name=user.preferred_username,
+            reviewer_email=user.email,
+            note=review.note,
+            user_name=to_review.user_name,
+            room_id=to_review.room_id,
+            thread_id=to_review.thread_id,
+            run_id=to_review.run_id,
+        )
 
     to_review.status = FRS.REVIEWED
     to_review.note = review.note
@@ -515,17 +536,17 @@ async def resolve_recent_feedback(
         [FromWhichAttrs.OPENED, FromWhichAttrs.REVIEWED],
     )
 
-    the_threads = ctx.deps.the_threads
     user = ctx.deps.user
-    await the_threads.resolve_run_feedback(
-        resolver_user_name=user.preferred_username,
-        resolver_email=user.email,
-        note=resolution.note,
-        user_name=to_resolve.user_name,
-        room_id=to_resolve.room_id,
-        thread_id=to_resolve.thread_id,
-        run_id=to_resolve.run_id,
-    )
+    async with _get_threads_storage(ctx) as the_threads:
+        await the_threads.resolve_run_feedback(
+            resolver_user_name=user.preferred_username,
+            resolver_email=user.email,
+            note=resolution.note,
+            user_name=to_resolve.user_name,
+            room_id=to_resolve.room_id,
+            thread_id=to_resolve.thread_id,
+            run_id=to_resolve.run_id,
+        )
 
     to_resolve.status = FRS.RESOLVED
     to_resolve.note = resolution.note

{soliplex-0.76 → soliplex-0.76.1}/src/soliplex/views/agui.py

@@ -698,7 +698,6 @@ async def post_room_agui_thread_id_run_id(
     thread_id: pydantic.UUID4,
     run_id: pydantic.UUID4,
     the_installation: installation.Installation = depend_the_installation,
-    the_threads: agui.ThreadStorage = depend_the_threads,
     the_room_authz: authz.RoomAuthorizationPolicy = depend_the_room_authz,
     the_user_claims: authn.UserClaims = depend_the_user_claims,
     the_logger: loggers.LogWrapper = depend_the_logger,
@@ -788,13 +787,6 @@ async def post_room_agui_thread_id_run_id(
         agent=agent,
     )
 
-    # Persist the run input in its own short-lived, committed session
-    # rather than via the request-scoped 'the_threads'. This handler
-    # returns a long-lived StreamingResponse, so the request session's
-    # transaction stays open for the whole stream; committing the input
-    # write here releases its lock immediately (and keeps the request
-    # transaction from holding a writer lock behind the incremental
-    # per-event background saves).
     try:
         async with sqla_asyncio.AsyncSession(
             bind=request.state.threads_engine,
@@ -818,7 +810,7 @@ async def post_room_agui_thread_id_run_id(
         room_id=room_id,
         user=user,
         run_agent_input=agui_adapter.run_input,
-        the_threads=the_threads,
+        thread_persistence_engine=request.state.threads_engine,
         the_logger=the_logger,
     )
 

{soliplex-0.76 → soliplex-0.76.1/src/soliplex.egg-info}/PKG-INFO

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