soliplex 0.78__tar.gz → 0.78.2__tar.gz

{soliplex-0.78/src/soliplex.egg-info → soliplex-0.78.2}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "soliplex"
-version = "0.78"
+version = "0.78.2"
 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.78 → soliplex-0.78.2}/src/soliplex/cli/audit.py

@@ -568,22 +568,39 @@ async def _list_admin_discriminators(dburi):
         return await policy.list_admin_user_discriminators()
 
 
-def _room_authz_groups(the_installation):
-    """Bucket configured rooms by authorization state; collect stale rows."""
-    configured = sorted(the_installation._config.room_configs)
+def _room_policies(the_installation) -> tuple[list, str | None]:
+    """Return ``(policies, error)`` for the stored room policies.
+
+    ``policies`` holds the unchecked policy models read via
+    'RoomAuthorizationPolicy.list_room_policies' and ``error`` is ``None``
+    on success. A RAM-based authz DB can hold no persisted rows, so it
+    short-circuits to ``([], None)`` without touching the database.
+
+    When the database itself cannot be reached -- e.g. its DBURI names a
+    Postgres server that isn't listening -- ``policies`` is empty and
+    ``error`` carries the exception message, so the audit can report the
+    unreachable DB instead of dying on the traceback.
+    """
     dburi = the_installation.authorization_dburi_async
 
     if dburi in cli_util._RAM_DBURIS:
-        return {
-            "default": list(configured),
-            "public": [],
-            "private": [],
-            "stale": [],
-        }
+        return [], None
+
+    try:
+        return list(asyncio.run(_list_room_policies(dburi))), None
+    except Exception as exc:
+        return [], f"{type(exc).__name__}: {exc}"
+
+
+def _room_authz_groups(the_installation, room_policies):
+    """Bucket configured rooms by authorization state; collect stale rows.
+
+    ``room_policies`` is the policy list from '_room_policies'.
+    """
+    configured = sorted(the_installation._config.room_configs)
 
     policies = {
-        policy.room_id: policy.default_allow_deny
-        for policy in asyncio.run(_list_room_policies(dburi))
+        policy.room_id: policy.default_allow_deny for policy in room_policies
     }
 
     configured_set = set(configured)
@@ -606,26 +623,21 @@ def _room_authz_groups(the_installation):
     }
 
 
-def _invalid_acl_json_paths(the_installation) -> dict:
+def _invalid_acl_json_paths(room_policies) -> dict:
     """Collect ACL entries whose stored 'json_path' fails to validate.
 
-    Reads every room policy via 'RoomAuthorizationPolicy.list_room_policies'
-    -- which returns the unchecked models, tolerating entries that would
-    fail 'policy.as_model' -- and re-validates each surfaced 'json_path'
-    against the currently-loaded JSONPath environment. Typically an
-    entry lands here when it was authored under a meta-config that
-    registered filter functions which are no longer present.
+    ``room_policies`` is the policy list from '_room_policies' -- the
+    unchecked models, which tolerate entries that would fail
+    'policy.as_model'. Each surfaced 'json_path' is re-validated against
+    the currently-loaded JSONPath environment. Typically an entry lands
+    here when it was authored under a meta-config that registered filter
+    functions which are no longer present.
 
     Returns a dict mapping 'room_id' to a list of '(json_path, error)'
-    pairs. A RAM-based authz DB has no persisted rows and returns '{}'.
+    pairs.
     """
-    dburi = the_installation.authorization_dburi_async
-
-    if dburi in cli_util._RAM_DBURIS:
-        return {}
-
     invalid: dict = {}
-    for policy in asyncio.run(_list_room_policies(dburi)):
+    for policy in room_policies:
         for entry in policy.acl_entries:
             if entry.json_path is None:
                 continue
@@ -651,7 +663,13 @@ def _audit_room_authz_section(
     tc_rule("Configured rooms by authorization state")
     tc_line()
 
-    groups = _room_authz_groups(the_installation)
+    room_policies, db_error = _room_policies(the_installation)
+    if db_error is not None:
+        tc_print(f"ERROR: authorization database unreachable: {db_error}")
+        tc_line()
+        return {"room_authz": {"unreachable": db_error}}
+
+    groups = _room_authz_groups(the_installation, room_policies)
 
     for label, room_ids in (
         (
@@ -677,7 +695,7 @@ def _audit_room_authz_section(
         tc_print("  (none)")
     tc_line()
 
-    invalid_acls = _invalid_acl_json_paths(the_installation)
+    invalid_acls = _invalid_acl_json_paths(room_policies)
     tc_print("ACL entries with invalid JSONPath:")
     if invalid_acls:
         for room_id in sorted(invalid_acls):
@@ -699,36 +717,47 @@ def _audit_room_authz_section(
     return errors
 
 
-def _admin_user_json_paths(the_installation) -> list[str]:
-    """Return every stored 'AdminUser.json_path', in insertion order.
-
-    Reads them via
-    'AdminUserPolicy.list_admin_user_discriminators'. Returns an
-    empty list when the authz DB is RAM-based (no persisted rows can
-    exist).
+def _admin_user_json_paths(
+    the_installation,
+) -> tuple[list[str], str | None]:
+    """Return ``(json_paths, error)`` for the stored admin rows.
+
+    ``json_paths`` holds every stored 'AdminUser.json_path', in insertion
+    order, read via 'AdminUserPolicy.list_admin_user_discriminators';
+    ``error`` is ``None`` on success. A RAM-based authz DB can hold no
+    persisted rows, so it short-circuits to ``([], None)`` without
+    touching the database.
+
+    When the database itself cannot be reached -- e.g. its DBURI names a
+    Postgres server that isn't listening -- ``json_paths`` is empty and
+    ``error`` carries the exception message, so the audit can report the
+    unreachable DB instead of dying on the traceback.
     """
     dburi = the_installation.authorization_dburi_async
 
     if dburi in cli_util._RAM_DBURIS:
-        return []
+        return [], None
 
-    return asyncio.run(_list_admin_discriminators(dburi))
+    try:
+        return list(asyncio.run(_list_admin_discriminators(dburi))), None
+    except Exception as exc:
+        return [], f"{type(exc).__name__}: {exc}"
 
 
 def _invalid_admin_user_json_paths(
-    the_installation,
+    json_paths,
 ) -> list[tuple[str, str]]:
     """Collect admin entries whose 'json_path' fails to validate.
 
     Same intent as '_invalid_acl_json_paths' but for the 'AdminUser'
     table: a row typically lands here when it was authored under a
     meta-config that registered filter functions which are no longer
-    present.
+    present. ``json_paths`` is the list from '_admin_user_json_paths'.
 
     Returns a list of '(json_path, error)' pairs.
     """
     invalid: list[tuple[str, str]] = []
-    for json_path in _admin_user_json_paths(the_installation):
+    for json_path in json_paths:
         try:
             authz.validate_json_path(json_path)
         except authz.InvalidJSONPath as exc:
@@ -749,7 +778,12 @@ def _audit_admin_users_section(
     tc_rule("Configured admin users")
     tc_line()
 
-    json_paths = _admin_user_json_paths(the_installation)
+    json_paths, db_error = _admin_user_json_paths(the_installation)
+    if db_error is not None:
+        tc_print(f"ERROR: authorization database unreachable: {db_error}")
+        tc_line()
+        return {"admin_users": {"unreachable": db_error}}
+
     tc_print(f"Admin users ({len(json_paths)}):")
     if json_paths:
         for json_path in json_paths:
@@ -763,7 +797,7 @@ def _audit_admin_users_section(
         tc_print("  (none)")
     tc_line()
 
-    invalid = _invalid_admin_user_json_paths(the_installation)
+    invalid = _invalid_admin_user_json_paths(json_paths)
     tc_print("Admin users with invalid JSONPath:")
     if invalid:
         for json_path, error in invalid:

{soliplex-0.78 → soliplex-0.78.2}/src/soliplex/config/rag.py

@@ -177,10 +177,13 @@ class _RAGDatabaseBase:
         try:
             rag_lancedb_path = self.rag_lancedb_path
         except RagDbFileNotFound as exc:
-            rag_lancedb_path = f"MISSING: {exc.rag_db_filename}"
+            missing = exc.rag_db_filename
+            db_name = f"MISSING: {missing.stem}"
+        else:
+            db_name = rag_lancedb_path.stem
 
         return {
-            "rag_lancedb_path": rag_lancedb_path,
+            "database_names": [db_name],
         }
 
 

{soliplex-0.78 → soliplex-0.78.2}/src/soliplex/config/skills.py

@@ -177,7 +177,7 @@ class FilesystemSkillConfig:
 
     @property
     def extra_parameters(self) -> dict[str, pathlib.Path]:
-        return {"path": self.path}
+        return {}
 
     def with_defer_loading(self, defer_loading: bool) -> FilesystemSkillConfig:
         """A copy whose capability loads as a room asked.

{soliplex-0.78 → soliplex-0.78.2}/src/soliplex/config/tools.py

@@ -315,6 +315,10 @@ class ToolConfig:
     def get_extra_parameters(self) -> dict:
         return {}
 
+    @property
+    def extra_parameters(self) -> dict:
+        return self.get_extra_parameters()
+
 
 SDTC_TOOL_NAME = "soliplex.tools.rag.search_documents"
 _, SDTC_TOOL_KIND = SDTC_TOOL_NAME.rsplit(".", 1)

{soliplex-0.78 → soliplex-0.78.2}/src/soliplex/models.py

@@ -111,7 +111,7 @@ class Tool(pydantic.BaseModel):
             tool_requires=tool_config.tool_requires,
             allow_mcp=tool_config.allow_mcp,
             agui_feature_names=list(tool_config.agui_feature_names),
-            extra_parameters=tool_config.get_extra_parameters(),
+            extra_parameters=tool_config.extra_parameters,
         )
 
 

{soliplex-0.78 → soliplex-0.78.2}/src/soliplex/skills/bwrap_sandbox/__init__.py

@@ -419,63 +419,102 @@ async def skill_run_python(
     return str(output)
 
 
+class InvalidSubdir(ValueError):
+    def __init__(self, path, expected_parent):
+        self.path = path
+        self.expected_parent = expected_parent
+        super().__init__(f"{path} not a subdir of {expected_parent}")
+
+
+def _check_is_subdir(path: pathlib.Path, expected_parent: pathlib.Path):
+    ep_resolved = expected_parent.resolve()
+
+    try:
+        resolved = path.resolve()
+    except ValueError as exc:
+        raise InvalidSubdir(path, ep_resolved) from exc
+    else:
+        if resolved.parent == ep_resolved:
+            return
+
+    raise InvalidSubdir(path, ep_resolved)
+
+
+def _check_subdirs(base: pathlib.Path, paths: list[str]) -> pathlib.Path:
+    current = base
+    for path in paths:
+        on_deck = current / path
+        _check_is_subdir(on_deck, current)
+        current = on_deck
+    return current.resolve()
+
+
 def get_workdir(
     workdirs_path: pathlib.Path | None,
-    room_id: str,
-    thread_id: str,
-    run_id: str,
+    room_id: str | None,
+    thread_id: str | None,
+    run_id: str | None,
 ):
-    if workdirs_path is not None:
-        workdir = workdirs_path / room_id / str(thread_id) / str(run_id)
+    if (
+        workdirs_path is not None
+        and room_id is not None
+        and thread_id is not None
+        and run_id is not None
+    ):
+        workdir = _check_subdirs(
+            workdirs_path,
+            [room_id, str(thread_id), str(run_id)],
+        )
         workdir.mkdir(parents=True, exist_ok=True)
+        return workdir
     else:
-        workdir = None
-
-    return workdir
+        return None
 
 
-def get_extra_volumes(
-    rooms_upload_path: pathlib.Path | None,
-    threads_upload_path: pathlib.Path | None,
-    room_id: str,
-    thread_id: str,
+def _get_upload_volume(
+    upload_path: pathlib.Path | None,
+    volume_id: str | None,
 ):
-    result = {}
-
-    if rooms_upload_path is not None:
-        room_dir = rooms_upload_path / room_id
-        if room_dir.exists():
-            result["room"] = bs_models.VolumeInfo(
-                host_path=room_dir,
+    if upload_path is not None and volume_id is not None:
+        volume_dir = _check_subdirs(upload_path, [str(volume_id)])
+        if volume_dir.exists():
+            return bs_models.VolumeInfo(
+                host_path=volume_dir,
                 writable=False,
             )
         else:
-            result["room"] = bs_models.VolumeInfo(
+            return bs_models.VolumeInfo(
                 host_path=None,
                 writable=False,
             )
 
-    if threads_upload_path is not None:
-        thread_dir = threads_upload_path / str(thread_id)
-        if thread_dir.exists():
-            result["thread"] = bs_models.VolumeInfo(
-                host_path=thread_dir,
-                writable=False,
-            )
-        else:
-            result["thread"] = bs_models.VolumeInfo(
-                host_path=None,
-                writable=False,
-            )
+
+def get_extra_volumes(
+    rooms_upload_path: pathlib.Path | None,
+    threads_upload_path: pathlib.Path | None,
+    room_id: str | None,
+    thread_id: str | None,
+):
+    result = {}
+
+    room_volume = _get_upload_volume(rooms_upload_path, room_id)
+
+    if room_volume is not None:
+        result["room"] = room_volume
+
+    thread_volume = _get_upload_volume(threads_upload_path, str(thread_id))
+
+    if thread_volume is not None:
+        result["thread"] = thread_volume
 
     return result
 
 
 def write_transcript(
     transcripts_path: pathlib.Path | None,
-    room_id: str,
-    thread_id: str,
-    run_id: str,
+    room_id: str | None,
+    thread_id: str | None,
+    run_id: str | None,
     *,
     content: str,
     suffix: str,
@@ -488,16 +527,24 @@ def write_transcript(
     with the saved transcript. Returns 'None' (writing nothing) when no
     'transcripts_path' is configured.
     """
-    if transcripts_path is None:
-        return None
-
-    run_dir = transcripts_path / room_id / str(thread_id) / str(run_id)
-    run_dir.mkdir(parents=True, exist_ok=True)
-    target = run_dir / f"{uuid.uuid4()}{suffix}"
-    target.write_text(content, encoding="utf-8")
-    target.chmod(0o600)
+    if (
+        transcripts_path is not None
+        and room_id is not None
+        and thread_id is not None
+        and run_id is not None
+    ):
+        run_dir = _check_subdirs(
+            transcripts_path,
+            [room_id, str(thread_id), str(run_id)],
+        )
+        run_dir.mkdir(parents=True, exist_ok=True)
+        target = run_dir / f"{uuid.uuid4()}{suffix}"
+        target.write_text(content, encoding="utf-8")
+        target.chmod(0o600)
 
-    return str(target)
+        return str(target)
+    else:
+        return None
 
 
 def create_sandbox_toolset(
@@ -581,19 +628,22 @@ def create_sandbox_toolset(
 
         else:
             deps = ctx.deps
-            room_id = deps.room_id or ""
-            thread_id = deps.thread_id or ""
+            room_id = deps.room_id
+            thread_id = deps.thread_id
 
             return await skill_list_volume_files(
                 volume=volume,
                 room_upload_path=(
-                    rooms_upload_path / room_id
-                    if rooms_upload_path is not None
+                    _check_subdirs(rooms_upload_path, [room_id])
+                    if (rooms_upload_path is not None and room_id is not None)
                     else None
                 ),
                 thread_upload_path=(
-                    threads_upload_path / thread_id
-                    if threads_upload_path is not None
+                    _check_subdirs(threads_upload_path, [thread_id])
+                    if (
+                        threads_upload_path is not None
+                        and thread_id is not None
+                    )
                     else None
                 ),
             )
@@ -614,16 +664,16 @@ def create_sandbox_toolset(
         deps = ctx.deps
         workdir = get_workdir(
             workdirs_path,
-            deps.room_id or "",
-            deps.thread_id or "",
-            deps.run_id or "",
+            deps.room_id,
+            deps.thread_id,
+            deps.run_id,
         )
 
         extra_volumes = get_extra_volumes(
             rooms_upload_path,
             threads_upload_path,
-            deps.room_id or "",
-            deps.thread_id or "",
+            deps.room_id,
+            deps.thread_id,
         )
 
         with sandbox_audit.audit_sandbox_exec(
@@ -634,9 +684,9 @@ def create_sandbox_toolset(
         ) as access:
             ref = write_transcript(
                 transcripts_path,
-                deps.room_id or "",
-                deps.thread_id or "",
-                deps.run_id or "",
+                deps.room_id,
+                deps.thread_id,
+                deps.run_id,
                 content=(
                     command
                     if isinstance(command, str)
@@ -672,16 +722,16 @@ def create_sandbox_toolset(
         deps = ctx.deps
         workdir = get_workdir(
             workdirs_path,
-            deps.room_id or "",
-            deps.thread_id or "",
-            deps.run_id or "",
+            deps.room_id,
+            deps.thread_id,
+            deps.run_id,
         )
 
         extra_volumes = get_extra_volumes(
             rooms_upload_path,
             threads_upload_path,
-            deps.room_id or "",
-            deps.thread_id or "",
+            deps.room_id,
+            deps.thread_id,
         )
 
         with sandbox_audit.audit_sandbox_exec(
@@ -692,9 +742,9 @@ def create_sandbox_toolset(
         ) as access:
             ref = write_transcript(
                 transcripts_path,
-                deps.room_id or "",
-                deps.thread_id or "",
-                deps.run_id or "",
+                deps.room_id,
+                deps.thread_id,
+                deps.run_id,
                 content=script,
                 suffix=".py",
             )

{soliplex-0.78 → soliplex-0.78.2}/src/soliplex/views/agui.py

@@ -99,6 +99,61 @@ async def _check_user_room_agent(
     return user_profile, agent
 
 
+async def _check_thread_ownership(
+    *,
+    room_id: str,
+    thread_id: str,
+    run_id: str | None = None,
+    the_installation: installation.Installation,
+    the_threads: agui.ThreadStorage,
+    the_room_authz: authz.RoomAuthorizationPolicy,
+    the_user_claims: authn.UserClaims,
+    the_logger: loggers.LogWrapper,
+) -> config_rooms.RoomConfig:
+    """Raise if user is not the owner of the thread
+
+    If 'run_id' is passed, also check that it is a valid member of the thread.
+    """
+    user_name = the_user_claims.get("preferred_username", "<unknown>")
+
+    _room_config = await _check_user_in_room(  # raises
+        room_id=room_id,
+        the_installation=the_installation,
+        the_room_authz=the_room_authz,
+        the_user_claims=the_user_claims,
+        the_logger=the_logger,
+    )
+
+    try:  # verify user's ownership of the thread
+        await the_threads.get_thread(
+            user_name=user_name,
+            room_id=room_id,
+            thread_id=thread_id,
+        )
+    except agui.AGUI_Exception:
+        raise fastapi.HTTPException(
+            status_code=404,
+            detail="No such thread",
+        ) from None
+
+    if run_id is not None:
+        try:
+            await the_threads.get_run(
+                user_name=user_name,
+                room_id=room_id,
+                thread_id=thread_id,
+                run_id=run_id,
+            )
+
+        except agui.AGUI_Exception:
+            raise fastapi.HTTPException(
+                status_code=404,
+                detail="No such run",
+            ) from None
+
+    return _room_config
+
+
 @util.logfire_span("GET /v1/rooms/{room_id}/agui")
 @router.get("/v1/rooms/{room_id}/agui")
 async def get_room_agui(
@@ -732,16 +787,12 @@ async def post_room_agui_thread_id_run_id(
             the_logger=the_logger,
         )
 
-        agui_adapter = await ai_ag_ui.AGUIAdapter.from_request(
-            request=request,
-            agent=(
-                await the_installation.get_agent_for_room(
-                    room_id=room_id,
-                    user=the_user_claims,
-                    the_room_authz=the_room_authz,
-                    the_logger=the_logger,
-                )
-            ),
+        # This adapter is only used to encode the stream from the database:
+        # it doesn't need an 'agent' or a 'run_input' for that job.
+        agui_adapter = ai_ag_ui.AGUIAdapter(
+            agent=None,
+            run_input=None,
+            accept=request.headers.get("accept"),
         )
 
         db_event_stream = streaming_views.stream_from_db(
@@ -787,6 +838,17 @@ async def post_room_agui_thread_id_run_id(
         agent=agent,
     )
 
+    # Ensure IDs in request body match the checked URL path IDs.
+    # The values must match the ones minted / serialized earlier
+    # by us *exactly*: client must return them verbatim.  See #1325.
+    run_input = agui_adapter.run_input
+
+    if thread_id != run_input.thread_id or run_id != run_input.run_id:
+        raise fastapi.HTTPException(
+            status_code=400,
+            detail="Invalid run input",
+        )
+
     try:
         async with sqla_asyncio.AsyncSession(
             bind=request.state.threads_engine,

{soliplex-0.78 → soliplex-0.78.2}/src/soliplex/views/room_file_uploads.py

@@ -110,7 +110,13 @@ async def get_uploads_room_filename(
     the_user_claims: authn_package.UserClaims = depend_the_user_claims,
     the_logger: loggers.LogWrapper = depend_the_logger,
 ) -> str:  # file path, converted to file response by FastAPI
-    """Download a file from the room uploads directory"""
+    """Download a file from the room uploads directory
+
+    Unlike sandbox workdir files, which are created by a possibly-
+    hallucinating or mischievous agent, files in the room-uploads tree
+    are under purview of the admin / operator:  symlinks to share e.g.
+    large datasets between rooms may be intentional and appropriate.
+    """
     the_logger.debug(loggers.UPLOADS_GET_ROOM_FILE)
 
     _room_config = await soliplex_views_agui._check_user_in_room(
@@ -134,7 +140,7 @@ async def get_uploads_room_filename(
     if not room_dir.is_dir():
         raise fastapi.HTTPException(
             status_code=404,
-            detail="No uploads in room: {room_id}",
+            detail=f"No uploads in room: {room_id}",
         )
 
     file_path = room_dir / filename